DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 18 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.
1461 Commits
7 Branches
146MB
Tree: 4ab933a073
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4ab933a073'
${ noResults }
Cardinal/src/override/diffs/MenuBar.cpp.diff

895 lines
25KB
Raw Blame History 

  1. --- ../Rack/src/app/MenuBar.cpp	2022-09-21 19:49:12.198540676 +0100

  2. +++ MenuBar.cpp	2022-12-30 14:50:06.801891005 +0000

  3. @@ -1,8 +1,33 @@

  4. +/*

  5. + * DISTRHO Cardinal Plugin

  6. + * Copyright (C) 2021-2022 Filipe Coelho <falktx@falktx.com>

  7. + *

  8. + * This program is free software; you can redistribute it and/or

  9. + * modify it under the terms of the GNU General Public License as

  10. + * published by the Free Software Foundation; either version 3 of

  11. + * the License, or any later version.

  12. + *

  13. + * This program is distributed in the hope that it will be useful,

  14. + * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  16. + * GNU General Public License for more details.

  17. + *

  18. + * For a full copy of the GNU General Public License see the LICENSE file.

  19. + */

  20. +

  21. +/**

  22. + * This file is an edited version of VCVRack's app/MenuBar.cpp

  23. + * Copyright (C) 2016-2021 VCV.

  24. + *

  25. + * This program is free software: you can redistribute it and/or

  26. + * modify it under the terms of the GNU General Public License as

  27. + * published by the Free Software Foundation; either version 3 of

  28. + * the License, or (at your option) any later version.

  29. + */

  30. +

  31.  #include <thread>

  32.  #include <utility>

  33.  

  34. -#include <osdialog.h>

  35. -

  36.  #include <app/MenuBar.hpp>

  37.  #include <app/TipWindow.hpp>

  38.  #include <widget/OpaqueWidget.hpp>

  39. @@ -15,6 +40,7 @@

  40.  #include <ui/ProgressBar.hpp>

  41.  #include <ui/Label.hpp>

  42.  #include <engine/Engine.hpp>

  43. +#include <widget/FramebufferWidget.hpp>

  44.  #include <window/Window.hpp>

  45.  #include <asset.hpp>

  46.  #include <context.hpp>

  47. @@ -25,8 +51,28 @@

  48.  #include <patch.hpp>

  49.  #include <library.hpp>

  50.  

  51. +#include "../CardinalCommon.hpp"

  52. +#include "../CardinalRemote.hpp"

  53. +#include "DistrhoPlugin.hpp"

  54. +#include "DistrhoStandaloneUtils.hpp"

  55. +

  56. +#ifdef HAVE_LIBLO

  57. +# include <lo/lo.h>

  58. +#endif

  59. +

  60. +void switchDarkMode(bool darkMode);

  61.  

  62.  namespace rack {

  63. +namespace asset {

  64. +std::string patchesPath();

  65. +}

  66. +namespace engine {

  67. +void Engine_setRemoteDetails(Engine*, remoteUtils::RemoteDetails*);

  68. +}

  69. +namespace plugin {

  70. +void updateStaticPluginsDarkMode();

  71. +}

  72. +

  73.  namespace app {

  74.  namespace menuBar {

  75.  

  76. @@ -48,79 +94,160 @@

  77.  };

  78.  

  79.  

  80. -struct NotificationIcon : widget::Widget {

  81. -	void draw(const DrawArgs& args) override {

  82. -		nvgBeginPath(args.vg);

  83. -		float radius = 4;

  84. -		nvgCircle(args.vg, radius, radius, radius);

  85. -		nvgFillColor(args.vg, nvgRGBf(1.0, 0.0, 0.0));

  86. -		nvgFill(args.vg);

  87. -		nvgStrokeColor(args.vg, nvgRGBf(0.5, 0.0, 0.0));

  88. -		nvgStroke(args.vg);

  89. -	}

  90. -};

  91. -

  92. -

  93.  ////////////////////

  94.  // File

  95.  ////////////////////

  96.  

  97.  

  98.  struct FileButton : MenuButton {

  99. +	const bool isStandalone;

  100. +#if ! CARDINAL_VARIANT_MINI

  101. +	std::vector<std::string> demoPatches;

  102. +#endif

  103. +

  104. +	FileButton(const bool standalone)

  105. +		: MenuButton(),  isStandalone(standalone)

  106. +	{

  107. +#if ! CARDINAL_VARIANT_MINI

  108. +		const std::string patchesDir = asset::patchesPath() + DISTRHO_OS_SEP_STR "examples";

  109. +

  110. +		if (system::isDirectory(patchesDir))

  111. +		{

  112. +			demoPatches = system::getEntries(patchesDir);

  113. +			std::sort(demoPatches.begin(), demoPatches.end(), [](const std::string& a, const std::string& b){

  114. +				return string::lowercase(a) < string::lowercase(b);

  115. +			});

  116. +		}

  117. +#endif

  118. +	}

  119. +

  120.  	void onAction(const ActionEvent& e) override {

  121.  		ui::Menu* menu = createMenu();

  122.  		menu->cornerFlags = BND_CORNER_TOP;

  123.  		menu->box.pos = getAbsoluteOffset(math::Vec(0, box.size.y));

  124.  

  125. -		menu->addChild(createMenuItem("New", RACK_MOD_CTRL_NAME "+N", []() {

  126. -			APP->patch->loadTemplateDialog();

  127. +#ifndef DISTRHO_OS_WASM

  128. +		const char* const NewShortcut = RACK_MOD_CTRL_NAME "+N";

  129. +#else

  130. +		const char* const NewShortcut = "";

  131. +#endif

  132. +		menu->addChild(createMenuItem("New", NewShortcut, []() {

  133. +			patchUtils::loadTemplateDialog();

  134.  		}));

  135.  

  136. -		menu->addChild(createMenuItem("Open", RACK_MOD_CTRL_NAME "+O", []() {

  137. -			APP->patch->loadDialog();

  138. +#if ! CARDINAL_VARIANT_MINI

  139. +#ifndef DISTRHO_OS_WASM

  140. +		menu->addChild(createMenuItem("Open / Import...", RACK_MOD_CTRL_NAME "+O", []() {

  141. +			patchUtils::loadDialog();

  142.  		}));

  143.  

  144. -		menu->addChild(createSubmenuItem("Open recent", "", [](ui::Menu* menu) {

  145. -			for (const std::string& path : settings::recentPatchPaths) {

  146. -				std::string name = system::getStem(path);

  147. -				menu->addChild(createMenuItem(name, "", [=]() {

  148. -					APP->patch->loadPathDialog(path);

  149. -				}));

  150. -			}

  151. -		}, settings::recentPatchPaths.empty()));

  152. -

  153.  		menu->addChild(createMenuItem("Save", RACK_MOD_CTRL_NAME "+S", []() {

  154. -			APP->patch->saveDialog();

  155. +			// NOTE: will do nothing if path is empty, intentionally

  156. +			patchUtils::saveDialog(APP->patch->path);

  157. +		}, APP->patch->path.empty()));

  158. +

  159. +		menu->addChild(createMenuItem("Save as / Export...", RACK_MOD_CTRL_NAME "+Shift+S", []() {

  160. +			patchUtils::saveAsDialog();

  161. +		}));

  162. +#else

  163. +		menu->addChild(createMenuItem("Import patch...", RACK_MOD_CTRL_NAME "+O", []() {

  164. +			patchUtils::loadDialog();

  165.  		}));

  166.  

  167. -		menu->addChild(createMenuItem("Save as", RACK_MOD_CTRL_NAME "+Shift+S", []() {

  168. -			APP->patch->saveAsDialog();

  169. +		menu->addChild(createMenuItem("Import selection...", "", [=]() {

  170. +			patchUtils::loadSelectionDialog();

  171. +		}, false, true));

  172. +

  173. +		menu->addChild(createMenuItem("Save and download compressed", RACK_MOD_CTRL_NAME "+Shift+S", []() {

  174. +			patchUtils::saveAsDialog();

  175.  		}));

  176.  

  177. -		menu->addChild(createMenuItem("Save a copy", "", []() {

  178. -			APP->patch->saveAsDialog(false);

  179. +		menu->addChild(createMenuItem("Save and download uncompressed", "", []() {

  180. +			patchUtils::saveAsDialogUncompressed();

  181.  		}));

  182. +#endif

  183. +#endif

  184.  

  185.  		menu->addChild(createMenuItem("Revert", RACK_MOD_CTRL_NAME "+" RACK_MOD_SHIFT_NAME "+O", []() {

  186. -			APP->patch->revertDialog();

  187. -		}, APP->patch->path == ""));

  188. +			patchUtils::revertDialog();

  189. +		}, APP->patch->path.empty()));

  190.  

  191. -		menu->addChild(createMenuItem("Overwrite template", "", []() {

  192. -			APP->patch->saveTemplateDialog();

  193. -		}));

  194. +#if defined(HAVE_LIBLO) && ! CARDINAL_VARIANT_MINI

  195. +		menu->addChild(new ui::MenuSeparator);

  196. +

  197. +		remoteUtils::RemoteDetails* const remoteDetails = remoteUtils::getRemote();

  198. +

  199. +		if (remoteDetails != nullptr && remoteDetails->connected) {

  200. +			menu->addChild(createMenuItem("Deploy to MOD", "F7", [remoteDetails]() {

  201. +				remoteUtils::sendFullPatchToRemote(remoteDetails);

  202. +			}));

  203.  

  204. +			menu->addChild(createCheckMenuItem("Auto deploy to MOD", "",

  205. +				[remoteDetails]() {return remoteDetails->autoDeploy;},

  206. +				[remoteDetails]() {

  207. +					remoteDetails->autoDeploy = !remoteDetails->autoDeploy;

  208. +					Engine_setRemoteDetails(APP->engine, remoteDetails->autoDeploy ? remoteDetails : nullptr);

  209. +				}

  210. +			));

  211. +		} else {

  212. +			menu->addChild(createMenuItem("Connect to MOD", "", []() {

  213. +				DISTRHO_SAFE_ASSERT(remoteUtils::connectToRemote());

  214. +			}));

  215. +		}

  216. +#endif

  217. +

  218. +#if ! CARDINAL_VARIANT_MINI

  219. +#ifndef DISTRHO_OS_WASM

  220.  		menu->addChild(new ui::MenuSeparator);

  221.  

  222.  		// Load selection

  223. -		menu->addChild(createMenuItem("Import selection", "", [=]() {

  224. -			APP->scene->rack->loadSelectionDialog();

  225. +		menu->addChild(createMenuItem("Import selection...", "", [=]() {

  226. +			patchUtils::loadSelectionDialog();

  227.  		}, false, true));

  228.  

  229. -		menu->addChild(new ui::MenuSeparator);

  230. -

  231. -		menu->addChild(createMenuItem("Quit", RACK_MOD_CTRL_NAME "+Q", []() {

  232. -			APP->window->close();

  233. +		menu->addChild(createMenuItem("Export uncompressed json...", "", []() {

  234. +			patchUtils::saveAsDialogUncompressed();

  235.  		}));

  236. +#endif

  237. +#endif

  238. +

  239. +#if ! CARDINAL_VARIANT_MINI

  240. +		if (!demoPatches.empty())

  241. +		{

  242. +			menu->addChild(new ui::MenuSeparator);

  243. +

  244. +			menu->addChild(createSubmenuItem("Open Demo / Example project", "", [=](ui::Menu* const menu) {

  245. +				for (std::string path : demoPatches) {

  246. +					std::string label = system::getStem(path);

  247. +

  248. +					for (size_t i=0, len=label.size(); i<len; ++i) {

  249. +						if (label[i] == '_')

  250. +							label[i] = ' ';

  251. +					}

  252. +

  253. +					menu->addChild(createMenuItem(label, "", [path]() {

  254. +						patchUtils::loadPathDialog(path, true);

  255. +					}));

  256. +				}

  257. +

  258. +				menu->addChild(new ui::MenuSeparator);

  259. +

  260. +				menu->addChild(createMenuItem("Open PatchStorage.com for more patches", "", []() {

  261. +					patchUtils::openBrowser("https://patchstorage.com/platform/cardinal/");

  262. +				}));

  263. +			}));

  264. +		}

  265. +#endif

  266. +

  267. +#ifndef DISTRHO_OS_WASM

  268. +		if (isStandalone) {

  269. +			menu->addChild(new ui::MenuSeparator);

  270. +

  271. +			menu->addChild(createMenuItem("Quit", RACK_MOD_CTRL_NAME "+Q", []() {

  272. +				APP->window->close();

  273. +			}));

  274. +		}

  275. +#endif

  276.  	}

  277.  };

  278.  

  279. @@ -166,7 +293,7 @@

  280.  

  281.  		menu->addChild(new ui::MenuSeparator);

  282.  

  283. -		APP->scene->rack->appendSelectionContextMenu(menu);

  284. +		patchUtils::appendSelectionContextMenu(menu);

  285.  	}

  286.  };

  287.  

  288. @@ -256,7 +383,7 @@

  289.  		return settings::cableTension;

  290.  	}

  291.  	float getDefaultValue() override {

  292. -		return 0.5;

  293. +		return 0.75;

  294.  	}

  295.  	float getDisplayValue() override {

  296.  		return getValue() * 100;

  297. @@ -393,36 +520,37 @@

  298.  };

  299.  

  300.  

  301. +static void setAllFramebufferWidgetsDirty(widget::Widget* const widget)

  302. +{

  303. +	for (widget::Widget* child : widget->children)

  304. +	{

  305. +		if (widget::FramebufferWidget* const fbw = dynamic_cast<widget::FramebufferWidget*>(child))

  306. +		{

  307. +			fbw->setDirty();

  308. +			break;

  309. +		}

  310. +		setAllFramebufferWidgetsDirty(child);

  311. +	}

  312. +}

  313. +

  314. +

  315.  struct ViewButton : MenuButton {

  316.  	void onAction(const ActionEvent& e) override {

  317.  		ui::Menu* menu = createMenu();

  318.  		menu->cornerFlags = BND_CORNER_TOP;

  319.  		menu->box.pos = getAbsoluteOffset(math::Vec(0, box.size.y));

  320.  

  321. -		menu->addChild(createMenuLabel("Window"));

  322. -

  323. -		bool fullscreen = APP->window->isFullScreen();

  324. -		std::string fullscreenText = "F11";

  325. -		if (fullscreen)

  326. -			fullscreenText += " " CHECKMARK_STRING;

  327. -		menu->addChild(createMenuItem("Fullscreen", fullscreenText, [=]() {

  328. -			APP->window->setFullScreen(!fullscreen);

  329. -		}));

  330. +		menu->addChild(createMenuLabel("Appearance"));

  331.  

  332. -		double frameRate = APP->window->getMonitorRefreshRate() / settings::frameSwapInterval;

  333. -		menu->addChild(createSubmenuItem("Frame rate", string::f("%.0f Hz", frameRate), [=](ui::Menu* menu) {

  334. -			for (int i = 1; i <= 6; i++) {

  335. -				double frameRate = APP->window->getMonitorRefreshRate() / i;

  336. -				menu->addChild(createCheckMenuItem(string::f("%.0f Hz", frameRate), "",

  337. -					[=]() {return settings::frameSwapInterval == i;},

  338. -					[=]() {settings::frameSwapInterval = i;}

  339. -				));

  340. -			}

  341. +		std::string darkModeText;

  342. +		if (settings::darkMode)

  343. +			darkModeText = CHECKMARK_STRING;

  344. +		menu->addChild(createMenuItem("Dark Mode", darkModeText, []() {

  345. +			switchDarkMode(!settings::darkMode);

  346. +			plugin::updateStaticPluginsDarkMode();

  347. +			setAllFramebufferWidgetsDirty(APP->scene);

  348.  		}));

  349.  

  350. -		menu->addChild(new ui::MenuSeparator);

  351. -		menu->addChild(createMenuLabel("Appearance"));

  352. -

  353.  		menu->addChild(createBoolPtrMenuItem("Show tooltips", "", &settings::tooltips));

  354.  

  355.  		ZoomSlider* zoomSlider = new ZoomSlider;

  356. @@ -446,9 +574,18 @@

  357.  		menu->addChild(haloBrightnessSlider);

  358.  

  359.  		menu->addChild(new ui::MenuSeparator);

  360. +		menu->addChild(createMenuLabel("Module dragging"));

  361. +

  362. +		menu->addChild(createBoolPtrMenuItem("Lock module positions", "", &settings::lockModules));

  363. +

  364. +		menu->addChild(createBoolPtrMenuItem("Auto-squeeze modules when dragging", "", &settings::squeezeModules));

  365. +

  366. +		menu->addChild(new ui::MenuSeparator);

  367.  		menu->addChild(createMenuLabel("Parameters"));

  368.  

  369. +#ifdef DISTRHO_OS_WASM

  370.  		menu->addChild(createBoolPtrMenuItem("Lock cursor while dragging", "", &settings::allowCursorLock));

  371. +#endif

  372.  

  373.  		static const std::vector<std::string> knobModeLabels = {

  374.  			"Linear",

  375. @@ -473,11 +610,34 @@

  376.  		menu->addChild(knobScrollSensitivitySlider);

  377.  

  378.  		menu->addChild(new ui::MenuSeparator);

  379. -		menu->addChild(createMenuLabel("Module dragging"));

  380. +		menu->addChild(createMenuLabel("Window"));

  381. +

  382. +#ifdef DISTRHO_OS_WASM

  383. +		const bool fullscreen = APP->window->isFullScreen();

  384. +		std::string rightText = "F11";

  385. +		if (fullscreen)

  386. +			rightText += " " CHECKMARK_STRING;

  387. +		menu->addChild(createMenuItem("Fullscreen", rightText, [=]() {

  388. +			APP->window->setFullScreen(!fullscreen);

  389. +		}));

  390. +#endif

  391.  

  392. -		menu->addChild(createBoolPtrMenuItem("Lock positions", "", &settings::lockModules));

  393. +		menu->addChild(createBoolPtrMenuItem("Invert zoom", "", &settings::invertZoom));

  394.  

  395. -		menu->addChild(createBoolPtrMenuItem("Auto-squeeze algorithm (experimental)", "", &settings::squeezeModules));

  396. +		static const std::vector<std::string> rateLimitLabels = {

  397. +			"None",

  398. +			"2x",

  399. +			"4x",

  400. +		};

  401. +		static const std::vector<int> rateLimits = {0, 1, 2};

  402. +		menu->addChild(createSubmenuItem("Update rate limit", rateLimitLabels[settings::rateLimit], [=](ui::Menu* menu) {

  403. +			for (int rateLimit : rateLimits) {

  404. +				menu->addChild(createCheckMenuItem(rateLimitLabels[rateLimit], "",

  405. +					[=]() {return settings::rateLimit == rateLimit;},

  406. +					[=]() {settings::rateLimit = rateLimit;}

  407. +				));

  408. +			}

  409. +		}));

  410.  	}

  411.  };

  412.  

  413. @@ -487,47 +647,6 @@

  414.  ////////////////////

  415.  

  416.  

  417. -struct SampleRateItem : ui::MenuItem {

  418. -	ui::Menu* createChildMenu() override {

  419. -		ui::Menu* menu = new ui::Menu;

  420. -

  421. -		// Auto sample rate

  422. -		std::string rightText;

  423. -		if (settings::sampleRate == 0) {

  424. -			float sampleRate = APP->engine->getSampleRate();

  425. -			rightText += string::f("(%g kHz) ", sampleRate / 1000.f);

  426. -		}

  427. -		menu->addChild(createCheckMenuItem("Auto", rightText,

  428. -			[=]() {return settings::sampleRate == 0;},

  429. -			[=]() {settings::sampleRate = 0;}

  430. -		));

  431. -

  432. -		// Power-of-2 oversample times 44.1kHz or 48kHz

  433. -		for (int i = -2; i <= 4; i++) {

  434. -			for (int j = 0; j < 2; j++) {

  435. -				float oversample = std::pow(2.f, i);

  436. -				float sampleRate = (j == 0) ? 44100.f : 48000.f;

  437. -				sampleRate *= oversample;

  438. -

  439. -				std::string text = string::f("%g kHz", sampleRate / 1000.f);

  440. -				std::string rightText;

  441. -				if (oversample > 1.f) {

  442. -					rightText += string::f("(%.0fx)", oversample);

  443. -				}

  444. -				else if (oversample < 1.f) {

  445. -					rightText += string::f("(1/%.0fx)", 1.f / oversample);

  446. -				}

  447. -				menu->addChild(createCheckMenuItem(text, rightText,

  448. -					[=]() {return settings::sampleRate == sampleRate;},

  449. -					[=]() {settings::sampleRate = sampleRate;}

  450. -				));

  451. -			}

  452. -		}

  453. -		return menu;

  454. -	}

  455. -};

  456. -

  457. -

  458.  struct EngineButton : MenuButton {

  459.  	void onAction(const ActionEvent& e) override {

  460.  		ui::Menu* menu = createMenu();

  461. @@ -541,268 +660,46 @@

  462.  			settings::cpuMeter ^= true;

  463.  		}));

  464.  

  465. -		menu->addChild(createMenuItem<SampleRateItem>("Sample rate", RIGHT_ARROW));

  466. -

  467. -		menu->addChild(createSubmenuItem("Threads", string::f("%d", settings::threadCount), [=](ui::Menu* menu) {

  468. -			// BUG This assumes SMT is enabled.

  469. -			int cores = system::getLogicalCoreCount() / 2;

  470. -

  471. -			for (int i = 1; i <= 2 * cores; i++) {

  472. +		if (isUsingNativeAudio()) {

  473. +			if (supportsAudioInput()) {

  474. +				const bool enabled = isAudioInputEnabled();

  475.  				std::string rightText;

  476. -				if (i == cores)

  477. -					rightText += "(most modules)";

  478. -				else if (i == 1)

  479. -					rightText += "(lowest CPU usage)";

  480. -				menu->addChild(createCheckMenuItem(string::f("%d", i), rightText,

  481. -					[=]() {return settings::threadCount == i;},

  482. -					[=]() {settings::threadCount = i;}

  483. -				));

  484. -			}

  485. -		}));

  486. -	}

  487. -};

  488. -

  489. -

  490. -////////////////////

  491. -// Plugins

  492. -////////////////////

  493. -

  494. -

  495. -struct AccountPasswordField : ui::PasswordField {

  496. -	ui::MenuItem* logInItem;

  497. -	void onAction(const ActionEvent& e) override {

  498. -		logInItem->doAction();

  499. -	}

  500. -};

  501. -

  502. -

  503. -struct LogInItem : ui::MenuItem {

  504. -	ui::TextField* emailField;

  505. -	ui::TextField* passwordField;

  506. -

  507. -	void onAction(const ActionEvent& e) override {

  508. -		std::string email = emailField->text;

  509. -		std::string password = passwordField->text;

  510. -		std::thread t([=] {

  511. -			library::logIn(email, password);

  512. -			library::checkUpdates();

  513. -		});

  514. -		t.detach();

  515. -		e.unconsume();

  516. -	}

  517. -

  518. -	void step() override {

  519. -		text = "Log in";

  520. -		rightText = library::loginStatus;

  521. -		MenuItem::step();

  522. -	}

  523. -};

  524. -

  525. -

  526. -struct SyncUpdatesItem : ui::MenuItem {

  527. -	void step() override {

  528. -		if (library::updateStatus != "") {

  529. -			text = library::updateStatus;

  530. -		}

  531. -		else if (library::isSyncing) {

  532. -			text = "Updating...";

  533. -		}

  534. -		else if (!library::hasUpdates()) {

  535. -			text = "Up-to-date";

  536. -		}

  537. -		else {

  538. -			text = "Update all";

  539. -		}

  540. -

  541. -		disabled = library::isSyncing || !library::hasUpdates();

  542. -		MenuItem::step();

  543. -	}

  544. -

  545. -	void onAction(const ActionEvent& e) override {

  546. -		std::thread t([=] {

  547. -			library::syncUpdates();

  548. -		});

  549. -		t.detach();

  550. -		e.unconsume();

  551. -	}

  552. -};

  553. -

  554. -

  555. -struct SyncUpdateItem : ui::MenuItem {

  556. -	std::string slug;

  557. -

  558. -	void setUpdate(const std::string& slug) {

  559. -		this->slug = slug;

  560. -

  561. -		auto it = library::updateInfos.find(slug);

  562. -		if (it == library::updateInfos.end())

  563. -			return;

  564. -		library::UpdateInfo update = it->second;

  565. -

  566. -		text = update.name;

  567. -	}

  568. -

  569. -	ui::Menu* createChildMenu() override {

  570. -		auto it = library::updateInfos.find(slug);

  571. -		if (it == library::updateInfos.end())

  572. -			return NULL;

  573. -		library::UpdateInfo update = it->second;

  574. -

  575. -		if (update.changelogUrl == "")

  576. -			return NULL;

  577. -

  578. -		ui::Menu* menu = new ui::Menu;

  579. -

  580. -		std::string changelogUrl = update.changelogUrl;

  581. -		menu->addChild(createMenuItem("Changelog", "", [=]() {

  582. -			system::openBrowser(changelogUrl);

  583. -		}));

  584. -

  585. -		return menu;

  586. -	}

  587. -

  588. -	void step() override {

  589. -		disabled = library::isSyncing;

  590. -

  591. -		auto it = library::updateInfos.find(slug);

  592. -		if (it != library::updateInfos.end()) {

  593. -			library::UpdateInfo update = it->second;

  594. -

  595. -			if (update.downloaded) {

  596. -				rightText = CHECKMARK_STRING;

  597. -				disabled = true;

  598. -			}

  599. -			else if (slug == library::updateSlug) {

  600. -				rightText = string::f("%.0f%%", library::updateProgress * 100.f);

  601. -			}

  602. -			else {

  603. -				rightText = "";

  604. -				plugin::Plugin* p = plugin::getPlugin(slug);

  605. -				if (p) {

  606. -					rightText += p->version + " → ";

  607. -				}

  608. -				rightText += update.version;

  609. +				if (enabled)

  610. +					rightText = CHECKMARK_STRING;

  611. +				menu->addChild(createMenuItem("Enable Audio Input", rightText, [enabled]() {

  612. +					if (!enabled)

  613. +						requestAudioInput();

  614. +				}));

  615.  			}

  616. -		}

  617.  

  618. -		MenuItem::step();

  619. -	}

  620. -

  621. -	void onAction(const ActionEvent& e) override {

  622. -		std::thread t([=] {

  623. -			library::syncUpdate(slug);

  624. -		});

  625. -		t.detach();

  626. -		e.unconsume();

  627. -	}

  628. -};

  629. -

  630. -

  631. -struct LibraryMenu : ui::Menu {

  632. -	LibraryMenu() {

  633. -		refresh();

  634. -	}

  635. -

  636. -	void step() override {

  637. -		// Refresh menu when appropriate

  638. -		if (library::refreshRequested) {

  639. -			library::refreshRequested = false;

  640. -			refresh();

  641. -		}

  642. -		Menu::step();

  643. -	}

  644. -

  645. -	void refresh() {

  646. -		setChildMenu(NULL);

  647. -		clearChildren();

  648. -

  649. -		if (settings::devMode) {

  650. -			addChild(createMenuLabel("Disabled in development mode"));

  651. -		}

  652. -		else if (!library::isLoggedIn()) {

  653. -			addChild(createMenuItem("Register VCV account", "", [=]() {

  654. -				system::openBrowser("https://vcvrack.com/login");

  655. -			}));

  656. -

  657. -			ui::TextField* emailField = new ui::TextField;

  658. -			emailField->placeholder = "Email";

  659. -			emailField->box.size.x = 240.0;

  660. -			addChild(emailField);

  661. -

  662. -			AccountPasswordField* passwordField = new AccountPasswordField;

  663. -			passwordField->placeholder = "Password";

  664. -			passwordField->box.size.x = 240.0;

  665. -			passwordField->nextField = emailField;

  666. -			emailField->nextField = passwordField;

  667. -			addChild(passwordField);

  668. -

  669. -			LogInItem* logInItem = new LogInItem;

  670. -			logInItem->emailField = emailField;

  671. -			logInItem->passwordField = passwordField;

  672. -			passwordField->logInItem = logInItem;

  673. -			addChild(logInItem);

  674. -		}

  675. -		else {

  676. -			addChild(createMenuItem("Log out", "", [=]() {

  677. -				library::logOut();

  678. -			}));

  679. -

  680. -			addChild(createMenuItem("Browse VCV Library", "", [=]() {

  681. -				system::openBrowser("https://library.vcvrack.com/");

  682. -			}));

  683. -

  684. -			SyncUpdatesItem* syncItem = new SyncUpdatesItem;

  685. -			syncItem->text = "Update all";

  686. -			addChild(syncItem);

  687. -

  688. -			if (!library::updateInfos.empty()) {

  689. -				addChild(new ui::MenuSeparator);

  690. -				addChild(createMenuLabel("Updates"));

  691. -

  692. -				for (auto& pair : library::updateInfos) {

  693. -					SyncUpdateItem* updateItem = new SyncUpdateItem;

  694. -					updateItem->setUpdate(pair.first);

  695. -					addChild(updateItem);

  696. -				}

  697. +			if (supportsMIDI()) {

  698. +				std::string rightText;

  699. +				if (isMIDIEnabled())

  700. +					rightText = CHECKMARK_STRING;

  701. +				menu->addChild(createMenuItem("Enable/Reconnect MIDI", rightText, []() {

  702. +					requestMIDI();

  703. +				}));

  704.  			}

  705. -		}

  706. -	}

  707. -};

  708. -

  709. -

  710. -struct LibraryButton : MenuButton {

  711. -	NotificationIcon* notification;

  712. -

  713. -	LibraryButton() {

  714. -		notification = new NotificationIcon;

  715. -		addChild(notification);

  716. -	}

  717. -

  718. -	void onAction(const ActionEvent& e) override {

  719. -		ui::Menu* menu = createMenu<LibraryMenu>();

  720. -		menu->cornerFlags = BND_CORNER_TOP;

  721. -		menu->box.pos = getAbsoluteOffset(math::Vec(0, box.size.y));

  722. -		// Check for updates when menu is opened

  723. -		std::thread t([&]() {

  724. -			system::setThreadName("Library");

  725. -			library::checkUpdates();

  726. -		});

  727. -		t.detach();

  728. -	}

  729. -

  730. -	void step() override {

  731. -		notification->box.pos = math::Vec(0, 0);

  732. -		notification->visible = library::hasUpdates();

  733.  

  734. -		// Popup when updates finish downloading

  735. -		if (library::restartRequested) {

  736. -			library::restartRequested = false;

  737. -			if (osdialog_message(OSDIALOG_INFO, OSDIALOG_OK_CANCEL, "All plugins have been downloaded. Close and re-launch Rack to load new updates.")) {

  738. -				APP->window->close();

  739. +			if (supportsBufferSizeChanges()) {

  740. +				static const std::vector<uint32_t> bufferSizes = {

  741. +					#ifdef DISTRHO_OS_WASM

  742. +					256, 512, 1024, 2048, 4096, 8192, 16384

  743. +					#else

  744. +					128, 256, 512, 1024, 2048, 4096, 8192

  745. +					#endif

  746. +				};

  747. +				const uint32_t currentBufferSize = getBufferSize();

  748. +				menu->addChild(createSubmenuItem("Buffer Size", std::to_string(currentBufferSize), [=](ui::Menu* menu) {

  749. +					for (uint32_t bufferSize : bufferSizes) {

  750. +						menu->addChild(createCheckMenuItem(std::to_string(bufferSize), "",

  751. +							[=]() {return currentBufferSize == bufferSize;},

  752. +							[=]() {requestBufferSizeChange(bufferSize);}

  753. +						));

  754. +					}

  755. +				}));

  756.  			}

  757.  		}

  758. -

  759. -		MenuButton::step();

  760.  	}

  761.  };

  762.  

  763. @@ -813,65 +710,23 @@

  764.  

  765.  

  766.  struct HelpButton : MenuButton {

  767. -	NotificationIcon* notification;

  768. -

  769. -	HelpButton() {

  770. -		notification = new NotificationIcon;

  771. -		addChild(notification);

  772. -	}

  773. -

  774.  	void onAction(const ActionEvent& e) override {

  775.  		ui::Menu* menu = createMenu();

  776.  		menu->cornerFlags = BND_CORNER_TOP;

  777.  		menu->box.pos = getAbsoluteOffset(math::Vec(0, box.size.y));

  778.  

  779. -		menu->addChild(createMenuItem("Tips", "", [=]() {

  780. -			APP->scene->addChild(tipWindowCreate());

  781. -		}));

  782. -

  783. -		menu->addChild(createMenuItem("User manual", "F1", [=]() {

  784. -			system::openBrowser("https://vcvrack.com/manual");

  785. -		}));

  786. -

  787. -		menu->addChild(createMenuItem("Support", "", [=]() {

  788. -			system::openBrowser("https://vcvrack.com/support");

  789. +		menu->addChild(createMenuItem("Rack User manual", "F1", [=]() {

  790. +			patchUtils::openBrowser("https://vcvrack.com/manual");

  791.  		}));

  792.  

  793. -		menu->addChild(createMenuItem("VCVRack.com", "", [=]() {

  794. -			system::openBrowser("https://vcvrack.com/");

  795. +		menu->addChild(createMenuItem("Cardinal Project page", "", [=]() {

  796. +			patchUtils::openBrowser("https://github.com/DISTRHO/Cardinal/");

  797.  		}));

  798.  

  799.  		menu->addChild(new ui::MenuSeparator);

  800.  

  801. -		menu->addChild(createMenuLabel(APP_NAME + " " + APP_EDITION_NAME + " " + APP_VERSION));

  802. -

  803. -		menu->addChild(createMenuItem("Open user folder", "", [=]() {

  804. -			system::openDirectory(asset::user(""));

  805. -		}));

  806. -

  807. -		menu->addChild(createMenuItem("Changelog", "", [=]() {

  808. -			system::openBrowser("https://github.com/VCVRack/Rack/blob/v2/CHANGELOG.md");

  809. -		}));

  810. -

  811. -		if (library::isAppUpdateAvailable()) {

  812. -			menu->addChild(createMenuItem("Update " + APP_NAME, APP_VERSION + " → " + library::appVersion, [=]() {

  813. -				system::openBrowser(library::appDownloadUrl);

  814. -			}));

  815. -		}

  816. -		else if (!settings::autoCheckUpdates && !settings::devMode) {

  817. -			menu->addChild(createMenuItem("Check for " + APP_NAME + " update", "", [=]() {

  818. -				std::thread t([&]() {

  819. -					library::checkAppUpdate();

  820. -				});

  821. -				t.detach();

  822. -			}, false, true));

  823. -		}

  824. -	}

  825. -

  826. -	void step() override {

  827. -		notification->box.pos = math::Vec(0, 0);

  828. -		notification->visible = library::isAppUpdateAvailable();

  829. -		MenuButton::step();

  830. +		menu->addChild(createMenuLabel("Cardinal " + APP_EDITION + " " + CARDINAL_VERSION));

  831. +		menu->addChild(createMenuLabel("Rack " + APP_VERSION + " Compatible"));

  832.  	}

  833.  };

  834.  

  835. @@ -910,9 +765,14 @@

  836.  		// 	uiLastTime = time;

  837.  		// }

  838.  

  839. +#if CARDINAL_VARIANT_MINI

  840. +		text = string::f("%.1f fps", 1.0 / frameDurationAvg);

  841. +#else

  842.  		double meterAverage = APP->engine->getMeterAverage();

  843.  		double meterMax = APP->engine->getMeterMax();

  844.  		text = string::f("%.1f fps  %.1f%% avg  %.1f%% max", 1.0 / frameDurationAvg, meterAverage * 100, meterMax * 100);

  845. +#endif

  846. +

  847.  		Label::step();

  848.  	}

  849.  };

  850. @@ -921,7 +781,9 @@

  851.  struct MenuBar : widget::OpaqueWidget {

  852.  	MeterLabel* meterLabel;

  853.  

  854. -	MenuBar() {

  855. +	MenuBar(const bool isStandalone)

  856. +		: widget::OpaqueWidget()

  857. +	{

  858.  		const float margin = 5;

  859.  		box.size.y = BND_WIDGET_HEIGHT + 2 * margin;

  860.  

  861. @@ -930,7 +792,7 @@

  862.  		layout->spacing = math::Vec(0, 0);

  863.  		addChild(layout);

  864.  

  865. -		FileButton* fileButton = new FileButton;

  866. +		FileButton* fileButton = new FileButton(isStandalone);

  867.  		fileButton->text = "File";

  868.  		layout->addChild(fileButton);

  869.  

  870. @@ -942,13 +804,11 @@

  871.  		viewButton->text = "View";

  872.  		layout->addChild(viewButton);

  873.  

  874. +#if ! CARDINAL_VARIANT_MINI

  875.  		EngineButton* engineButton = new EngineButton;

  876.  		engineButton->text = "Engine";

  877.  		layout->addChild(engineButton);

  878. -

  879. -		LibraryButton* libraryButton = new LibraryButton;

  880. -		libraryButton->text = "Library";

  881. -		layout->addChild(libraryButton);

  882. +#endif

  883.  

  884.  		HelpButton* helpButton = new HelpButton;

  885.  		helpButton->text = "Help";

  886. @@ -984,7 +844,7 @@

  887.  

  888.  

  889.  widget::Widget* createMenuBar() {

  890. -	menuBar::MenuBar* menuBar = new menuBar::MenuBar;

  891. +	menuBar::MenuBar* menuBar = new menuBar::MenuBar(isStandalone());

  892.  	return menuBar;

  893.  }

  894.