VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1355 Commits
4 Branches
540MB
Tree: 45b884d5f1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '45b884d5f1'
${ noResults }
Rack/plugins/community/repos/SubmarineUtility/src/ModBrowser.cpp

722 lines
20KB
Raw Blame History 

  1. #include "SubControls.hpp"

  2. #include <map>

  3. #include <algorithm>

  4. #include "global_pre.hpp"

  5. #include "global_ui.hpp"

  6. #include "app.hpp"

  7. #include "window.hpp"

  8. #include "osdialog.h"

  9. #include "util/common.hpp"

  10. 

  11. namespace rack_plugin_SubmarineUtility {

  12. 

  13. struct ModBrowserWidget;

  14. 

  15. struct ListElement {

  16. 	ModBrowserWidget *mbw;

  17. 	virtual void onAction(EventAction &e) { debug ("Not Implemented"); }

  18. 	virtual std::string GetLabelOne() { return std::string("Label 1"); };

  19. 	virtual std::string GetLabelTwo() { return std::string("Label 2"); };

  20. };

  21. 

  22. struct TextButton : SubControls::ButtonBase {

  23. 	std::string label1;

  24. 	std::string label2;

  25. 	std::shared_ptr<ListElement> element;

  26. 	float label1Width = 0;

  27. 	float label2Width = 0;	

  28. 	void CalculateSizes(NVGcontext *vg, float zoom) {

  29. 		nvgFontFaceId(vg, rack::global_ui->window.gGuiFont->handle);

  30. 		nvgFontSize(vg, 13 * zoom);

  31. 		float bounds[4];

  32. 		nvgTextBounds(vg, zoom, box.size.y / 2, label1.c_str(), NULL, bounds);

  33. 		label1Width = bounds[2] - bounds[0];

  34. 		nvgTextBounds(vg, zoom, box.size.y / 2, label2.c_str(), NULL, bounds);

  35. 		label2Width = bounds[2] - bounds[0];	

  36. 	}

  37. 	void draw (NVGcontext *vg) override {

  38. 		float zoom = 1.0f / clamp(RACK_PLUGIN_UI_RACKSCENE->zoomWidget->zoom, 0.25f, 1.0f);

  39. 		//if (label1Width == 0.0f)

  40. 			CalculateSizes(vg, zoom);

  41. 		if (RACK_PLUGIN_UI_DRAGGED_WIDGET == this) {

  42. 			nvgBeginPath(vg);

  43. 			nvgRect(vg, 0, 0, box.size.x - 2, box.size.y);

  44. 			nvgFillColor(vg, nvgRGB(0x40, 0x40, 0x40));

  45. 			nvgFill(vg);

  46. 		}

  47. 		nvgFontFaceId(vg, rack::global_ui->window.gGuiFont->handle);

  48. 		nvgFontSize(vg, 13 * zoom);

  49. 	// Draw secondary text

  50. 		nvgFillColor(vg, nvgRGB(0x80, 0x80, 0x80));

  51. 		nvgTextAlign(vg, NVG_ALIGN_MIDDLE | NVG_ALIGN_RIGHT);

  52. 		nvgText(vg, box.size.x - zoom, box.size.y / 2, label2.c_str(), NULL);

  53. 	// If text overlaps, feather out overlap

  54. 		if (label1Width + label2Width > box.size.x) {

  55. 			NVGpaint grad;

  56. 			if (RACK_PLUGIN_UI_DRAGGED_WIDGET == this) {

  57. 				nvgFillColor(vg, nvgRGB(0x40, 0x40, 0x40));

  58. 				grad = nvgLinearGradient(vg, label1Width, 0, label1Width + 10, 0, nvgRGBA(0x20, 0x20, 0x20, 0xff), nvgRGBA(0x20, 0x20, 0x20, 0));

  59. 			}

  60. 			else {

  61. 				nvgFillColor(vg, nvgRGB(0, 0, 0));

  62. 				grad = nvgLinearGradient(vg, label1Width, 0, label1Width + 10, 0, nvgRGBA(0, 0, 0, 0xff), nvgRGBA(0, 0, 0, 0));

  63. 			}

  64. 			nvgBeginPath(vg);

  65. 			nvgRect(vg, box.size.x - label2Width, 0, label1Width - box.size.x + label2Width, box.size.y);

  66. 			nvgFill(vg);

  67. 			nvgBeginPath(vg);

  68. 			nvgRect(vg, label1Width, 0, 10, box.size.y);

  69. 			nvgFillPaint(vg, grad);

  70. 			nvgFill(vg); 

  71. 		}

  72. 	// Draw primary text

  73. 		nvgFillColor(vg, nvgRGB(0xff, 0xff, 0xff));

  74. 		nvgTextAlign(vg, NVG_ALIGN_MIDDLE);

  75. 		nvgText(vg, zoom, box.size.y / 2, label1.c_str(), NULL);

  76. 		Component::draw(vg);

  77. 	}

  78. 	void GetLabels() {

  79. 		label1 = element->GetLabelOne();

  80. 		label2 = element->GetLabelTwo();

  81. 	}

  82. 	void onAction(EventAction &e) override {

  83. 		element->onAction(e);

  84. 	}

  85. };

  86. 

  87. // Icons

  88. 

  89. 

  90. struct MBIconWidget : SubControls::ButtonBase,SVGWidget {

  91. 	ModBrowserWidget *mbw;

  92. };

  93. 

  94. struct PluginIcon : MBIconWidget {

  95. 	int selected = 0;

  96. 	PluginIcon() {

  97. 		box.size.x = 30;

  98. 		box.size.y = 30;

  99. 	}

  100. 	void onAction(EventAction &e) override;

  101. };

  102. 

  103. struct TagIcon : MBIconWidget {

  104. 	int selected = 0;

  105. 	TagIcon() {

  106. 		box.size.x = 30;

  107. 		box.size.y = 30;

  108. 	}

  109. 	void onAction(EventAction &e) override;

  110. };

  111. 

  112. struct FavIcon : MBIconWidget {

  113. 	int selected = 0;

  114. 	FavIcon() {

  115. 		box.size.x = 30;

  116. 		box.size.y = 30;

  117. 	}

  118. 	void onAction(EventAction &e) override;

  119. };

  120. 

  121. struct LoadIcon : MBIconWidget {

  122. 	int selected = 0;

  123. 	LoadIcon() {

  124. 		box.size.x = 30;

  125. 		box.size.y = 30;

  126. 	}

  127. 	void onAction(EventAction &e) override;

  128. };

  129. 

  130. struct MinimizeIcon : MBIconWidget {

  131. 	MinimizeIcon() {

  132. 		box.size.x = 30;

  133. 		box.size.y = 30;

  134. 	}

  135. 	void onAction(EventAction &e) override;

  136. };

  137. 

  138. // Elements

  139. 

  140. struct ModelElement : ListElement {

  141. 	Model *model;

  142. 	std::string GetLabelOne() override {

  143. 		return model->name;

  144. 	}

  145. 	std::string GetLabelTwo() override {

  146. #undef plugin

  147. 		return model->plugin->slug;

  148. #define plugin "SubmarineUtility"

  149. 	}

  150. 	void onAction(EventAction &e) override;

  151. };

  152. 

  153. struct PluginElement : ListElement {

  154. 	std::string label;

  155. 	std::string GetLabelOne() override {

  156. 		return label;

  157. 	}

  158. 	std::string GetLabelTwo() override;

  159. 	void onAction(EventAction &e) override;

  160. };

  161. 

  162. struct TagElement : ListElement {

  163. 	unsigned int tag;

  164. 	std::string GetLabelOne() override {

  165. 		return gTagNames[tag];

  166. 	}

  167. 	std::string GetLabelTwo() override;

  168. 	void onAction(EventAction &e) override;

  169. };

  170. 

  171. struct PluginBackElement : ListElement {

  172. 	std::string label2;

  173. 	std::string GetLabelOne() override {

  174. 		return std::string("\xe2\x86\x90 Back");

  175. 	}

  176. 	std::string GetLabelTwo() override {

  177. 		return label2;

  178. 	}

  179. 	void onAction(EventAction &e) override;

  180. };

  181. 

  182. struct TagBackElement : ListElement {

  183. 	std::string label2;

  184. 	std::string GetLabelOne() override {

  185. 		return std::string("\xe2\x86\x90 Back");

  186. 	}

  187. 	std::string GetLabelTwo() override {

  188. 		return label2;

  189. 	}

  190. 	void onAction(EventAction &e) override;

  191. };

  192. 

  193. struct ModBrowserWidget : SubControls::SizeableModuleWidget {

  194. 	Widget *scrollContainer;

  195. 	ScrollWidget *scrollWidget;

  196. 	PluginIcon *pluginIcon;

  197. 	TagIcon *tagIcon;

  198. 	FavIcon *favIcon;

  199. 	LoadIcon *loadIcon;

  200. 	MinimizeIcon *minimizeIcon;

  201. 	float width;

  202. 	float zoom = 1.0f;

  203. 	std::list<std::shared_ptr<PluginElement>> pluginList;

  204. 	std::list<std::shared_ptr<TagElement>> tagList;

  205. 	std::list<std::shared_ptr<ModelElement>> modelList;

  206. 	std::string allfilters;

  207. 	std::string lastPath;

  208. 	ModBrowserWidget(Module *module) : SubControls::SizeableModuleWidget(module) {

  209. 		moduleName = "Module Browser";

  210. 		zoom = clamp(RACK_PLUGIN_UI_RACKSCENE->zoomWidget->zoom, 0.25f, 1.0f);

  211. 		allfilters.assign(PATCH_FILTERS);

  212. 		allfilters.append(";");

  213. 		allfilters.append(PRESET_FILTERS);

  214. 

  215. 		pluginIcon = Widget::create<PluginIcon>(Vec(2, 2));

  216. 		pluginIcon->selected = 1;

  217. 		pluginIcon->mbw = this;

  218. 		pluginIcon->setSVG(SVG::load(assetPlugin(plugin, "res/plugin.svg")));

  219. 		backPanel->addChild(pluginIcon);

  220. 

  221. 		tagIcon = Widget::create<TagIcon>(Vec(34, 2));

  222. 		tagIcon->mbw = this;

  223. 		tagIcon->setSVG(SVG::load(assetPlugin(plugin, "res/tag.svg")));

  224. 		backPanel->addChild(tagIcon);

  225. 

  226. 		favIcon = Widget::create<FavIcon>(Vec(66, 2));

  227. 		favIcon->mbw = this;

  228. 		favIcon->setSVG(SVG::load(assetPlugin(plugin, "res/favorite.svg")));

  229. 		backPanel->addChild(favIcon);

  230. 	

  231. 		loadIcon = Widget::create<LoadIcon>(Vec(98, 2));

  232. 		loadIcon->mbw = this;

  233. 		loadIcon->setSVG(SVG::load(assetPlugin(plugin, "res/load.svg")));

  234. 		backPanel->addChild(loadIcon);

  235. 	

  236. 		minimizeIcon = Widget::create<MinimizeIcon>(Vec(130, 2));

  237. 		minimizeIcon->mbw = this;

  238. 		minimizeIcon->setSVG(SVG::load(assetPlugin(plugin, "res/min.svg")));

  239. 		backPanel->addChild(minimizeIcon);	

  240. 

  241. 		scrollWidget = Widget::create<ScrollWidget>(Vec(0, 35));

  242. 		scrollWidget->box.size.x = box.size.x - 20;

  243. 		scrollWidget->box.size.y = box.size.y - 65;

  244. 		width = scrollWidget->box.size.x - 20;

  245. 		backPanel->addChild(scrollWidget);

  246. 

  247. 		scrollContainer = scrollWidget->container;

  248. 		for (unsigned int i = 1; i < NUM_TAGS; i++) {

  249. 			std::shared_ptr<TagElement> te = std::make_shared<TagElement>();

  250. 			te->mbw = this;

  251. 			te->tag = i;

  252. 			tagList.push_back(te);

  253. 		}

  254. 		// Sort Tags (probably already sorted)

  255. 		tagList.sort([](std::shared_ptr<TagElement> te1, std::shared_ptr<TagElement> te2) { return gTagNames[te1->tag].compare(gTagNames[te2->tag]) < 0;  } );

  256. 

  257. #undef plugin

  258. 		for (Plugin *plugin : rack::global->plugin.gPlugins) {

  259. 			for (Model *model : plugin->models) {

  260. 				std::shared_ptr<ModelElement> me = std::make_shared<ModelElement>();

  261. 				me->mbw = this;

  262. 				me->model = model;

  263. 				modelList.push_back(me);

  264. 				int found = false;

  265. 				for (std::shared_ptr<PluginElement> pe : pluginList) {

  266. 					if (!pe->label.compare(me->model->author)) {

  267. 						found = true;

  268. 						break;

  269. 					}

  270. 				}

  271. 				if (!found) {

  272. 					std::shared_ptr<PluginElement> pe = std::make_shared<PluginElement>();

  273. 					pe->mbw = this;

  274. 					pe->label.assign(me->model->author);

  275. 					pluginList.push_back(pe);

  276. 				}

  277. 			}

  278. 		}

  279. 		// Sort Plugins/Authors

  280. 		pluginList.sort([](std::shared_ptr<PluginElement> pe1, std::shared_ptr<PluginElement> pe2) { return stringLowercase(pe1->label).compare(stringLowercase(pe2->label)) < 0; } );

  281. 		

  282. 		AddPlugins();

  283. 	}

  284. 	void ResetIcons() {

  285. 		pluginIcon->selected = 0;

  286. 		tagIcon->selected = 0;

  287. 		favIcon->selected = 0;

  288. 	}

  289. 

  290. 	void onResize() override {

  291. 		scrollWidget->box.size.x = box.size.x - 20;

  292. 		SetListWidth();

  293. 	} 

  294. 

  295. 	void SetListWidth() {

  296. 		float width = scrollContainer->parent->box.size.x;

  297. 		float size = 15.0f / zoom;

  298. 		if (scrollContainer->children.size() * size > scrollContainer->parent->box.size.y)

  299. 			width -= 13;

  300. 		float position = 0;

  301. 		for (Widget *w : scrollContainer->children) {

  302. 			w->box.pos.y = position;

  303. 			w->box.size.x = width;

  304. 			position += w->box.size.y = size;

  305. 		}

  306. 	}

  307. 	void AddElement(std::shared_ptr<ListElement> le, float y) {

  308. 		TextButton *tb = Widget::create<TextButton>(Vec(0, y));

  309. 		tb->element = le;

  310. 		tb->GetLabels();

  311. 		tb->box.size.x = width;

  312. 		tb->box.size.y = 15;

  313. 		scrollContainer->addChild(tb);

  314. 	}

  315. 	void AddPlugins() {

  316. 		scrollContainer->clearChildren();

  317. 		unsigned int y = 0;

  318. 		for (std::shared_ptr<PluginElement> pe : pluginList) {

  319. 			AddElement(pe, y);			

  320. 			y += 15;

  321. 		}

  322. 		SetListWidth();

  323. 	}

  324. 	void AddTags() {

  325. 		scrollContainer->clearChildren();

  326. 		unsigned int y = 0;

  327. 		for (std::shared_ptr<TagElement> te : tagList) {

  328. 			AddElement(te, y);

  329. 			y += 15;

  330. 		}

  331. 		SetListWidth();

  332. 	}

  333. 	void AddFavorites() {

  334. 		scrollContainer->clearChildren();

  335. 		unsigned int y = 0;

  336. 		FILE *file = fopen(assetLocal("settings.json").c_str(), "r");

  337. 		if (!file)

  338. 			return;

  339. 		json_error_t error;

  340. 		json_t *rootJ = json_loadf(file, 0, &error);

  341. 		if (!rootJ) {

  342. 			warn("JSON parsing error at %s %d:%d %s", error.source, error.line, error.column, error.text);

  343. 			fclose(file);

  344. 			return;

  345. 		}

  346. 		json_t *modb = json_object_get(rootJ, "moduleBrowser");

  347. 		if (modb) {

  348. 			json_t *favoritesJ = json_object_get(modb, "favorites");

  349. 			if (favoritesJ) {

  350. 				size_t i;

  351. 				json_t *favoriteJ;

  352. 				json_array_foreach(favoritesJ, i, favoriteJ) {

  353. 					json_t *pluginJ = json_object_get(favoriteJ, "plugin");

  354. 					json_t *modelJ = json_object_get(favoriteJ, "model");

  355. 					if (!pluginJ || !modelJ)

  356. 						continue;

  357. 					std::string pluginSlug = json_string_value(pluginJ);

  358. 					std::string modelSlug = json_string_value(modelJ);

  359. 					Model *model = pluginGetModel(pluginSlug, modelSlug);

  360. 					if (!model)

  361. 						continue;

  362. 					for (std::shared_ptr<ModelElement> me : modelList) {

  363. 						if (me->model == model) {

  364. 							AddElement(me, y);

  365. 							y += 15;

  366. 						}

  367. 					}

  368. 				}

  369. 			}

  370. 		}

  371. 		json_decref(rootJ);

  372. 		fclose(file);

  373. 		SetListWidth();

  374. 	}

  375. 	void AddModels(std::string author) {

  376. 		scrollContainer->clearChildren();

  377. 		std::shared_ptr<PluginBackElement> pbe = std::make_shared<PluginBackElement>();	

  378. 		pbe->mbw = this;

  379. 		pbe->label2 = author;

  380. 		AddElement(pbe, 0);

  381. 		unsigned int y = 15;

  382. 		for (std::shared_ptr<ModelElement> me : modelList) {

  383. 			if (!me->model->author.compare(author)) {

  384. 				AddElement(me, y);

  385. 				y += 15;

  386. 			}

  387. 		}

  388. 		SetListWidth();

  389. 	}

  390. 	void AddModels(unsigned int tag) {

  391. 		scrollContainer->clearChildren();

  392. 		std::shared_ptr<TagBackElement> tbe = std::make_shared<TagBackElement>();

  393. 		tbe->mbw = this;

  394. 		tbe->label2 = gTagNames[tag];

  395. 		AddElement(tbe, 0);

  396. 		unsigned int y = 15;

  397. 		for (std::shared_ptr<ModelElement> me : modelList) {

  398. 			for (ModelTag mt : me->model->tags) {

  399. 				if (mt == tag) {

  400. 					AddElement(me, y);

  401. 					y += 15;

  402. 				}

  403. 			}

  404. 		}	

  405. 		SetListWidth();

  406. 	}

  407. 	void Load() {

  408. 		if (lastPath.empty()) {

  409. 			if (RACK_PLUGIN_UI_RACKWIDGET->lastPath.empty()) {

  410. 				lastPath = assetLocal("patches");

  411. 				systemCreateDirectory(lastPath);

  412. 			}

  413. 			else {

  414. 				lastPath = stringDirectory(RACK_PLUGIN_UI_RACKWIDGET->lastPath);

  415. 			}

  416. 		}

  417. 		osdialog_filters *filters = osdialog_filters_parse(allfilters.c_str());

  418. 		char *path = osdialog_file(OSDIALOG_OPEN, lastPath.c_str(), NULL, filters);

  419. 			

  420. 		if (path) {

  421. 			Load(path);

  422. 			lastPath = stringDirectory(path);

  423. 			free(path);

  424. 		}

  425. 		osdialog_filters_free(filters);

  426. 	}

  427. 	void Load(std::string filename) {

  428. 		FILE *file = fopen(filename.c_str(), "r");

  429. 		if (!file) {	

  430. 			debug("Unable to open patch %s", filename.c_str());

  431. 			return;

  432. 		}

  433. 

  434. 		json_error_t error;

  435. 		json_t *rootJ = json_loadf(file, 0, &error);

  436. 		if (rootJ) {

  437. 			Load(rootJ);

  438. 			json_decref(rootJ);

  439. 		}

  440. 		else {

  441. 			std::string message = stringf("JSON parsing error at %s %d:%d %s", error.source, error.line, error.column, error.text);

  442. 			osdialog_message(OSDIALOG_WARNING, OSDIALOG_OK, message.c_str());

  443. 		}		

  444. 		fclose(file);

  445. 	}

  446. 	void LoadPreset(json_t *rootJ) {

  447.  		ModuleWidget *moduleWidget = RACK_PLUGIN_UI_RACKWIDGET->moduleFromJson(rootJ);

  448. 		if (moduleWidget) {

  449. 			moduleWidget->box.pos = RACK_PLUGIN_UI_RACKWIDGET->lastMousePos.minus(moduleWidget->box.size.div(2));

  450. 			RACK_PLUGIN_UI_RACKWIDGET->requestModuleBoxNearest(moduleWidget, moduleWidget->box);

  451. 		}

  452. 	}

  453. 	void Load(json_t *rootJ) {

  454. 		std::string message;

  455. 		Rect newBox;

  456. 		newBox.pos.x = -1;

  457. 		//load modules

  458. 		std::map<int, ModuleWidget *> moduleWidgets;

  459. 		json_t *modulesJ = json_object_get(rootJ, "modules");

  460. 		if (!modulesJ) {

  461. 			LoadPreset(rootJ);

  462. 			return;

  463. 		}

  464. 		std::vector<Widget *> existingWidgets;

  465. 		for (Widget *child : RACK_PLUGIN_UI_RACKWIDGET->moduleContainer->children) {

  466. 			existingWidgets.push_back(child);

  467. 		} 

  468. 		size_t moduleId;

  469. 		json_t *moduleJ;

  470. 		json_array_foreach(modulesJ, moduleId, moduleJ) {

  471. 			ModuleWidget *moduleWidget = RACK_PLUGIN_UI_RACKWIDGET->moduleFromJson(moduleJ);

  472. 			if (moduleWidget) {

  473. 				json_t *posJ = json_object_get(moduleJ, "pos");

  474. 				double x, y;

  475. 				json_unpack(posJ, "[F, F]", &x, &y);

  476. 				Vec pos = Vec(x,y);

  477. 				moduleWidget->box.pos = pos.mult(RACK_GRID_SIZE);

  478. 				moduleWidgets[moduleId] = moduleWidget;

  479. 				if (newBox.pos.x == -1) {

  480. 					newBox.pos.x = moduleWidget->box.pos.x;

  481. 					newBox.pos.y = moduleWidget->box.pos.y;

  482. 					newBox.size.x = moduleWidget->box.size.x;

  483. 					newBox.size.y = moduleWidget->box.size.y;

  484. 				}

  485. 				else {

  486. 					Rect mbox = moduleWidget->box;

  487. 					if (mbox.pos.x < newBox.pos.x) {

  488. 						newBox.size.x += newBox.pos.x - mbox.pos.x;

  489. 						newBox.pos.x = mbox.pos.x;

  490. 					}

  491. 					if (mbox.pos.y < newBox.pos.y) {

  492. 						newBox.size.y += newBox.pos.y - mbox.pos.y;

  493. 						newBox.pos.y = mbox.pos.y;

  494. 					}

  495. 					if ((mbox.pos.x + mbox.size.x) > (newBox.pos.x + newBox.size.x)) {

  496. 						newBox.size.x = mbox.pos.x + mbox.size.x - newBox.pos.x;

  497. 					}

  498. 					if ((mbox.pos.y + mbox.size.y) > (newBox.pos.y + newBox.size.y)) {

  499. 						newBox.size.y = mbox.pos.y + mbox.size.y - newBox.pos.y;

  500. 					}

  501. 				}

  502. 			}

  503. 		}

  504.  

  505. 		//find space for modules and arrange

  506. 		Rect space = FindSpace(existingWidgets, newBox);

  507. 		if (space.pos.x == -1) {

  508. 			// oooh noes!!! couldn't find space for these widgets

  509. 			warn("Module browser could not find space to load patch");

  510. 			for (const auto& kvp : moduleWidgets) {

  511. 				RACK_PLUGIN_UI_RACKWIDGET->deleteModule(kvp.second);

  512. 				kvp.second->finalizeEvents();

  513. 				delete kvp.second;

  514. 			}

  515. 			return;

  516. 		}

  517. 		// Move modules into space

  518. 		float dx = space.pos.x - newBox.pos.x;

  519. 		float dy = space.pos.y - newBox.pos.y;

  520. 		for (const auto& kvp : moduleWidgets) {

  521. 			kvp.second->box.pos.x += dx;

  522. 			kvp.second->box.pos.y += dy;

  523. 		}

  524. 		//wires

  525. 		json_t *wiresJ = json_object_get(rootJ, "wires");

  526. 		if (!wiresJ) return;

  527. 		size_t wireId;

  528. 		json_t *wireJ;

  529. 		json_array_foreach(wiresJ, wireId, wireJ) {

  530. 			int outputModuleId = json_integer_value(json_object_get(wireJ, "outputModuleId"));

  531. 			int outputId = json_integer_value(json_object_get(wireJ, "outputId"));

  532. 			int inputModuleId = json_integer_value(json_object_get(wireJ, "inputModuleId"));

  533. 			int inputId = json_integer_value(json_object_get(wireJ, "inputId"));

  534. 			ModuleWidget *outputModuleWidget = moduleWidgets[outputModuleId];

  535. 			if (!outputModuleWidget) continue;

  536. 			ModuleWidget *inputModuleWidget = moduleWidgets[inputModuleId];

  537. 			if (!inputModuleWidget) continue;

  538. 			Port *outputPort = NULL;

  539. 			Port *inputPort = NULL;

  540. 			for (Port *port : outputModuleWidget->outputs) {

  541. 				if (port->portId == outputId) {

  542. 					outputPort = port;

  543. 					break;

  544. 				}

  545. 			}

  546. 			for (Port *port : inputModuleWidget->inputs) {

  547. 				if (port->portId == inputId) {

  548. 					inputPort = port;

  549. 					break;

  550. 				}

  551. 			}

  552. 			if (!outputPort || !inputPort)

  553. 				continue;

  554. 			WireWidget *wireWidget = new WireWidget();

  555. 			wireWidget->fromJson(wireJ);

  556. 			wireWidget->outputPort = outputPort;

  557. 			wireWidget->inputPort = inputPort;

  558. 			wireWidget->updateWire();

  559. 			RACK_PLUGIN_UI_RACKWIDGET->wireContainer->addChild(wireWidget);

  560. 		}

  561. 

  562. 	}

  563. 	Rect FindSpace(std::vector<Widget *> existingWidgets, Rect box) {

  564. 		int x0 = roundf(box.pos.x / RACK_GRID_WIDTH);

  565. 		int y0 = roundf(box.pos.y / RACK_GRID_HEIGHT);

  566. 		std::vector<Vec> positions;

  567. 		for (int y = max(0, y0 - 8); y < y0 + 8; y++) {

  568. 			for (int x = max(0, x0 - 400); x < x0 + 400; x++) {

  569. 				positions.push_back(Vec(x * RACK_GRID_WIDTH, y * RACK_GRID_HEIGHT));

  570. 			}

  571. 		}

  572. 		std::sort(positions.begin(), positions.end(), [box](Vec a, Vec b) {

  573. 			return a.minus(box.pos).norm() < b.minus(box.pos).norm();

  574. 		});

  575. 		for (Vec position : positions) {

  576. 			Rect newBox = box;

  577. 			newBox.pos = position;

  578. 			int collide = false;

  579. 			for (Widget *child : existingWidgets) {

  580. 				if (newBox.intersects(child->box)) {

  581. 					collide = true;

  582. 					break;

  583. 				}		

  584. 			}

  585. 			if (!collide) {

  586. 				return newBox;

  587. 			}

  588. 		}

  589. 		Rect failed;

  590. 		failed.pos.x = -1;

  591. 		return failed;

  592. 	}

  593. 	void step() override {

  594. 		float thisZoom = clamp(RACK_PLUGIN_UI_RACKSCENE->zoomWidget->zoom, 0.25f, 1.0f);

  595. 		if (thisZoom != zoom) {

  596. 			zoom = thisZoom;

  597. 			SetListWidth();

  598. 		}

  599. 		stabilized = true;

  600. 		ModuleWidget::step();

  601. 	} 

  602. 

  603. };

  604. 

  605. // Icon onAction

  606. 

  607. void PluginIcon::onAction(EventAction &e) {

  608. 	mbw->ResetIcons();

  609. 	mbw->pluginIcon->selected = 1;

  610. 	mbw->AddPlugins();

  611. }

  612. 

  613. void TagIcon::onAction(EventAction &e) {

  614. 	mbw->ResetIcons();

  615. 	mbw->tagIcon->selected = 1;

  616. 	mbw->AddTags();

  617. }

  618. 

  619. void FavIcon::onAction(EventAction &e) {

  620. 	mbw->pluginIcon->selected = 0;

  621. 	mbw->favIcon->selected = 1;

  622. 	mbw->AddFavorites();

  623. }

  624. 

  625. void LoadIcon::onAction(EventAction &e) {

  626. 	mbw->Load();

  627. }

  628. 

  629. void MinimizeIcon::onAction(EventAction &e) {

  630. 	mbw->Minimize(true);

  631. }

  632. 

  633. // Element onAction

  634. 

  635. void PluginElement::onAction(EventAction &e) {

  636. 	mbw->AddModels(label);

  637. }

  638. 

  639. std::string PluginElement::GetLabelTwo() {

  640. 	unsigned int count = 0;

  641. 	for (std::shared_ptr<ModelElement> me : mbw->modelList) {

  642. 		if (!label.compare(me->model->author))

  643. 			count++;

  644. 	}

  645. 	return std::to_string(count).append(" Modules");

  646. } 

  647. 

  648. void TagElement::onAction(EventAction &e) {

  649. 	mbw->AddModels(tag);

  650. }

  651. 

  652. std::string TagElement::GetLabelTwo() {

  653. 	unsigned int count = 0;

  654. 	for (std::shared_ptr<ModelElement> me : mbw->modelList) {

  655. 		for (ModelTag mt : me->model->tags) {

  656. 			if (mt == tag) {

  657. 				count++;

  658. 			}

  659. 		}

  660. 	}

  661. 	return std::to_string(count).append(" Modules");

  662. }

  663. 

  664. void ModelElement::onAction(EventAction &e) {

  665. 	ModuleWidget *moduleWidget = model->createModuleWidget();

  666. 	if (!moduleWidget)

  667. 		return;

  668. 	RACK_PLUGIN_UI_RACKWIDGET->addModule(moduleWidget);

  669. 	moduleWidget->box.pos = RACK_PLUGIN_UI_RACKWIDGET->lastMousePos.minus(moduleWidget->box.size.div(2));

  670. 	RACK_PLUGIN_UI_RACKWIDGET->requestModuleBoxNearest(moduleWidget, moduleWidget->box);

  671. }

  672. 

  673. void PluginBackElement::onAction(EventAction &e) {

  674. 	mbw->AddPlugins();

  675. }

  676. 

  677. void TagBackElement::onAction(EventAction &e) {

  678. 	mbw->AddTags();

  679. }

  680. 

  681. struct Blank2 : ModuleWidget {

  682. 	Blank2(Module *module) : ModuleWidget(module) {

  683. 		box.size = Vec(RACK_GRID_WIDTH * 5, RACK_GRID_HEIGHT * 2);

  684. 		{

  685. 			Panel *panel = new LightPanel();

  686. 			panel->box.size = box.size;

  687. 			addChild(panel);

  688. 		}

  689. 	}

  690. };

  691. 

  692. struct Blank3 : ModuleWidget {

  693. 	Blank3(Module *module) : ModuleWidget(module) {

  694. 		box.size = Vec(RACK_GRID_WIDTH * 5, RACK_GRID_HEIGHT * 3);

  695. 		{

  696. 			Panel *panel = new LightPanel();

  697. 			panel->box.size = box.size;

  698. 			addChild(panel);

  699. 		}

  700. 	}

  701. };

  702. 

  703. struct Blank5 : ModuleWidget {

  704. 	Blank5(Module *module) : ModuleWidget(module) {

  705. 		box.size = Vec(RACK_GRID_WIDTH * 5, RACK_GRID_HEIGHT * 5);

  706. 		{

  707. 			Panel *panel = new LightPanel();

  708. 			panel->box.size = box.size;

  709. 			addChild(panel);

  710. 		}

  711. 	}

  712. };

  713. 

  714. } // namespace rack_plugin_SubmarineUtility

  715. 

  716. using namespace rack_plugin_SubmarineUtility;

  717. 

  718. RACK_PLUGIN_MODEL_INIT(SubmarineUtility, ModBrowser) {

  719.    Model *modelModBrowser = Model::create<Module, ModBrowserWidget>("Submarine (Utilities)", "ModBrowser", "Module Browser", UTILITY_TAG);

  720.    return modelModBrowser;

  721. }