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.
1276 Commits
4 Branches
540MB
Tree: bb9e211c03
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bb9e211c03'
${ noResults }
Rack/plugins/community/repos/ImpromptuModular/src/Foundry.cpp

2039 lines
78KB
Raw Blame History 

  1. //***********************************************************************************************

  2. //Multi-track sequencer module for VCV Rack by Marc Boulé

  3. //

  4. //Based on code from the Fundamental and AudibleInstruments plugins by Andrew Belt 

  5. //and graphics from the Component Library by Wes Milholen 

  6. //See ./LICENSE.txt for all licenses

  7. //See ./res/fonts/ for font licenses

  8. //

  9. //Acknowledgements: please see README.md

  10. //***********************************************************************************************

  11. 

  12. #include <algorithm>

  13. #include "FoundrySequencer.hpp"

  14. 

  15. namespace rack_plugin_ImpromptuModular {

  16. 

  17. struct Foundry : Module {	

  18. 	enum ParamIds {

  19. 		EDIT_PARAM,

  20. 		PHRASE_PARAM,

  21. 		SEQUENCE_PARAM,

  22. 		RUN_PARAM,

  23. 		COPY_PARAM,

  24. 		PASTE_PARAM,

  25. 		RESET_PARAM,

  26. 		ENUMS(OCTAVE_PARAM, 7),

  27. 		GATE_PARAM,

  28. 		SLIDE_BTN_PARAM,

  29. 		AUTOSTEP_PARAM,

  30. 		ENUMS(KEY_PARAMS, 12),

  31. 		MODE_PARAM,

  32. 		CLKRES_PARAM,

  33. 		TRAN_ROT_PARAM,

  34. 		GATE_PROB_PARAM,

  35. 		TIE_PARAM,// Legato

  36. 		CPMODE_PARAM,

  37. 		ENUMS(STEP_PHRASE_PARAMS, SequencerKernel::MAX_STEPS),

  38. 		TRACKDOWN_PARAM,

  39. 		TRACKUP_PARAM,

  40. 		VEL_KNOB_PARAM,

  41. 		SEL_PARAM,

  42. 		ALLTRACKS_PARAM,

  43. 		REP_LEN_PARAM,

  44. 		BEGIN_PARAM,

  45. 		END_PARAM,

  46. 		KEY_GATE_PARAM,

  47. 		ATTACH_PARAM,

  48. 		VEL_EDIT_PARAM,

  49. 		WRITEMODE_PARAM,

  50. 		NUM_PARAMS

  51. 	};

  52. 	enum InputIds {

  53. 		WRITE_INPUT,

  54. 		ENUMS(CV_INPUTS, Sequencer::NUM_TRACKS),

  55. 		RESET_INPUT,

  56. 		ENUMS(CLOCK_INPUTS, Sequencer::NUM_TRACKS),

  57. 		LEFTCV_INPUT,

  58. 		RIGHTCV_INPUT,

  59. 		RUNCV_INPUT,

  60. 		GATECV_INPUT,

  61. 		GATEPCV_INPUT,

  62. 		TIEDCV_INPUT,

  63. 		SLIDECV_INPUT,

  64. 		ENUMS(VEL_INPUTS, Sequencer::NUM_TRACKS),

  65. 		SEQCV_INPUT,

  66. 		TRKCV_INPUT,

  67. 		NUM_INPUTS

  68. 	};

  69. 	enum OutputIds {

  70. 		ENUMS(CV_OUTPUTS, Sequencer::NUM_TRACKS),

  71. 		ENUMS(VEL_OUTPUTS, Sequencer::NUM_TRACKS),

  72. 		ENUMS(GATE_OUTPUTS, Sequencer::NUM_TRACKS),

  73. 		NUM_OUTPUTS

  74. 	};

  75. 	enum LightIds {

  76. 		ENUMS(STEP_PHRASE_LIGHTS, SequencerKernel::MAX_STEPS * 3),// room for GreenRedWhite

  77. 		ENUMS(OCTAVE_LIGHTS, 7),// octaves 1 to 7

  78. 		ENUMS(KEY_LIGHTS, 12 * 2),// room for GreenRed

  79. 		RUN_LIGHT,

  80. 		RESET_LIGHT,

  81. 		ENUMS(GATE_LIGHT, 2),// room for GreenRed

  82. 		SLIDE_LIGHT,

  83. 		ENUMS(GATE_PROB_LIGHT, 2),// room for GreenRed

  84. 		TIE_LIGHT,

  85. 		ATTACH_LIGHT,

  86. 		ENUMS(VEL_PROB_LIGHT, 2),// room for GreenRed

  87. 		VEL_SLIDE_LIGHT,

  88. 		ENUMS(WRITECV_LIGHTS, Sequencer::NUM_TRACKS),

  89. 		ENUMS(WRITECV2_LIGHTS, Sequencer::NUM_TRACKS),

  90. 		NUM_LIGHTS

  91. 	};

  92. 	

  93. 	// Constants

  94. 	enum EditPSDisplayStateIds {DISP_NORMAL, DISP_MODE_SEQ, DISP_MODE_SONG, DISP_LEN, DISP_REPS, DISP_TRANSPOSE, DISP_ROTATE, DISP_PPQN, DISP_DELAY, DISP_COPY_SEQ, DISP_PASTE_SEQ, DISP_COPY_SONG, DISP_PASTE_SONG, DISP_COPY_SONG_CUST};

  95. 	static constexpr float warningTime = 0.7f;// seconds

  96. 

  97. 	// Need to save

  98. 	int panelTheme = 0;

  99. 	int expansion = 0;

  100. 	int velocityMode;

  101. 	bool velocityBipol;

  102. 	bool holdTiedNotes;

  103. 	bool autoseq;

  104. 	bool autostepLen;

  105. 	bool showSharp;

  106. 	bool multiTracks;

  107. 	int seqCVmethod;// 0 is 0-10V, 1 is C2-D7#, 2 is TrigIncr

  108. 	bool running;

  109. 	bool resetOnRun;

  110. 	bool attached;

  111. 	int velEditMode;// 0 is velocity, 1 is gate-prob, 2 is slide-rate

  112. 	int writeMode;// 0 is both, 1 is CV only, 2 is CV2 only

  113. 	Sequencer seq;

  114. 

  115. 	// No need to save

  116. 	int displayState;

  117. 	long clockIgnoreOnReset;

  118. 	long tiedWarning;// 0 when no warning, positive downward step counter timer when warning

  119. 	long attachedWarning;// 0 when no warning, positive downward step counter timer when warning

  120. 	long revertDisplay;

  121. 	long showLenInSteps;

  122. 	bool multiSteps;

  123. 	int clkInSources[Sequencer::NUM_TRACKS];// first index is always 0 and will never change

  124. 	int cpSeqLength;

  125. 	int cpSongStart;// no need to initialize

  126. 	

  127. 	

  128. 

  129. 	unsigned int lightRefreshCounter = 0;

  130. 	float resetLight = 0.0f;

  131. 	int sequenceKnob = 0;

  132. 	int velocityKnob = 0;

  133. 	int phraseKnob = 0;

  134. 	Trigger resetTrigger;

  135. 	Trigger leftTrigger;

  136. 	Trigger rightTrigger;

  137. 	Trigger runningTrigger;

  138. 	Trigger clockTriggers[SequencerKernel::MAX_STEPS];

  139. 	Trigger keyTriggers[12];

  140. 	Trigger octTriggers[7];

  141. 	Trigger gate1Trigger;

  142. 	Trigger tiedTrigger;

  143. 	Trigger gateProbTrigger;

  144. 	Trigger slideTrigger;

  145. 	Trigger writeTrigger;

  146. 	Trigger copyTrigger;

  147. 	Trigger pasteTrigger;

  148. 	Trigger modeTrigger;

  149. 	Trigger rotateTrigger;

  150. 	Trigger transposeTrigger;

  151. 	Trigger stepTriggers[SequencerKernel::MAX_STEPS];

  152. 	Trigger clkResTrigger;

  153. 	Trigger trackIncTrigger;

  154. 	Trigger trackDeccTrigger;	

  155. 	Trigger beginTrigger;

  156. 	Trigger endTrigger;

  157. 	Trigger repLenTrigger;

  158. 	Trigger attachedTrigger;

  159. 	Trigger seqCVTrigger;

  160. 	Trigger selTrigger;

  161. 	Trigger allTrigger;

  162. 	Trigger velEditTrigger;

  163. 	Trigger writeModeTrigger;

  164. 

  165. 	

  166. 	inline bool isEditingSequence(void) {return params[EDIT_PARAM].value < 0.5f;}

  167. 	inline bool isEditingGates(void) {return params[KEY_GATE_PARAM].value < 0.5f;}

  168. 	inline int getCPMode(void) {

  169. 		if (params[CPMODE_PARAM].value > 1.5f) return 2000;// this means end, and code should never loop up to this count. This value should be bigger than max(MAX_STEPS, MAX_PHRASES)

  170. 		if (params[CPMODE_PARAM].value < 0.5f) return 4;

  171. 		return 8;

  172. 	}

  173. 

  174. 	

  175. 	Foundry() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  176. 		seq.construct(&holdTiedNotes, &velocityMode);

  177. 		onReset();

  178. 	}

  179. 

  180. 	

  181. 	// widgets are not yet created when module is created (and when onReset() is called by constructor)

  182. 	// onReset() is also called when right-click initialization of module

  183. 	void onReset() override {

  184. 		autoseq = false;

  185. 		autostepLen = false;

  186. 		showSharp = true;

  187. 		running = true;

  188. 		velocityMode = 0;

  189. 		velocityBipol = false;

  190. 		holdTiedNotes = true;

  191. 		displayState = DISP_NORMAL;

  192. 		tiedWarning = 0l;

  193. 		attachedWarning = 0l;

  194. 		revertDisplay = 0l;

  195. 		showLenInSteps = 0l;

  196. 		resetOnRun = false;

  197. 		attached = false;

  198. 		multiSteps = false;

  199. 		multiTracks = false;

  200. 		seqCVmethod = 0;

  201. 		cpSeqLength = getCPMode();

  202. 		for (int trkn = 0; trkn < Sequencer::NUM_TRACKS; trkn++) {

  203. 			clkInSources[trkn] = 0;

  204. 		}

  205. 		velEditMode = 0;

  206. 		writeMode = 0;

  207. 		seq.reset();

  208. 		clockIgnoreOnReset = (long) (clockIgnoreOnResetDuration * engineGetSampleRate());

  209. 	}

  210. 	

  211. 	

  212. 	void onRandomize() override {

  213. 		cpSeqLength = getCPMode();

  214. 		if (isEditingSequence() && !attached)

  215. 			seq.randomize();

  216. 		else if (attached)

  217. 			attachedWarning = (long) (warningTime * engineGetSampleRate() / displayRefreshStepSkips);

  218. 	}

  219. 	

  220. 	

  221. 	json_t *toJson() override {

  222. 		json_t *rootJ = json_object();

  223. 

  224. 		// panelTheme

  225. 		json_object_set_new(rootJ, "panelTheme", json_integer(panelTheme));

  226. 

  227. 		// expansion

  228. 		json_object_set_new(rootJ, "expansion", json_integer(expansion));

  229. 

  230. 		// velocityMode

  231. 		json_object_set_new(rootJ, "velocityMode", json_integer(velocityMode));

  232. 

  233. 		// velocityBipol

  234. 		json_object_set_new(rootJ, "velocityBipol", json_integer(velocityBipol));

  235. 

  236. 		// autostepLen

  237. 		json_object_set_new(rootJ, "autostepLen", json_boolean(autostepLen));

  238. 		

  239. 		// multiTracks

  240. 		json_object_set_new(rootJ, "multiTracks", json_boolean(multiTracks));

  241. 		

  242. 		// autoseq

  243. 		json_object_set_new(rootJ, "autoseq", json_boolean(autoseq));

  244. 		

  245. 		// holdTiedNotes

  246. 		json_object_set_new(rootJ, "holdTiedNotes", json_boolean(holdTiedNotes));

  247. 		

  248. 		// showSharp

  249. 		json_object_set_new(rootJ, "showSharp", json_boolean(showSharp));

  250. 		

  251. 		// seqCVmethod

  252. 		json_object_set_new(rootJ, "seqCVmethod", json_integer(seqCVmethod));

  253. 

  254. 		// running

  255. 		json_object_set_new(rootJ, "running", json_boolean(running));

  256. 		

  257. 		// resetOnRun

  258. 		json_object_set_new(rootJ, "resetOnRun", json_boolean(resetOnRun));

  259. 		

  260. 		// attached

  261. 		json_object_set_new(rootJ, "attached", json_boolean(attached));

  262. 

  263. 		// velEditMode

  264. 		json_object_set_new(rootJ, "velEditMode", json_integer(velEditMode));

  265. 

  266. 		// writeMode

  267. 		json_object_set_new(rootJ, "writeMode", json_integer(writeMode));

  268. 

  269. 		seq.toJson(rootJ);

  270. 		

  271. 		return rootJ;

  272. 	}

  273. 

  274. 	

  275. 	void fromJson(json_t *rootJ) override {

  276. 		// panelTheme

  277. 		json_t *panelThemeJ = json_object_get(rootJ, "panelTheme");

  278. 		if (panelThemeJ)

  279. 			panelTheme = json_integer_value(panelThemeJ);

  280. 

  281. 		// expansion

  282. 		json_t *expansionJ = json_object_get(rootJ, "expansion");

  283. 		if (expansionJ)

  284. 			expansion = json_integer_value(expansionJ);

  285. 

  286. 		// velocityMode

  287. 		json_t *velocityModeJ = json_object_get(rootJ, "velocityMode");

  288. 		if (velocityModeJ)

  289. 			velocityMode = json_integer_value(velocityModeJ);

  290. 

  291. 		// velocityBipol

  292. 		json_t *velocityBipolJ = json_object_get(rootJ, "velocityBipol");

  293. 		if (velocityBipolJ)

  294. 			velocityBipol = json_integer_value(velocityBipolJ);

  295. 

  296. 		// autostepLen

  297. 		json_t *autostepLenJ = json_object_get(rootJ, "autostepLen");

  298. 		if (autostepLenJ)

  299. 			autostepLen = json_is_true(autostepLenJ);

  300. 

  301. 		// multiTracks

  302. 		json_t *multiTracksJ = json_object_get(rootJ, "multiTracks");

  303. 		if (multiTracksJ)

  304. 			multiTracks = json_is_true(multiTracksJ);

  305. 

  306. 		// autoseq

  307. 		json_t *autoseqJ = json_object_get(rootJ, "autoseq");

  308. 		if (autoseqJ)

  309. 			autoseq = json_is_true(autoseqJ);

  310. 

  311. 		// holdTiedNotes

  312. 		json_t *holdTiedNotesJ = json_object_get(rootJ, "holdTiedNotes");

  313. 		if (holdTiedNotesJ)

  314. 			holdTiedNotes = json_is_true(holdTiedNotesJ);

  315. 		

  316. 		// showSharp

  317. 		json_t *showSharpJ = json_object_get(rootJ, "showSharp");

  318. 		if (showSharpJ)

  319. 			showSharp = json_is_true(showSharpJ);

  320. 		

  321. 		// seqCVmethod

  322. 		json_t *seqCVmethodJ = json_object_get(rootJ, "seqCVmethod");

  323. 		if (seqCVmethodJ)

  324. 			seqCVmethod = json_integer_value(seqCVmethodJ);

  325. 

  326. 		// running

  327. 		json_t *runningJ = json_object_get(rootJ, "running");

  328. 		if (runningJ)

  329. 			running = json_is_true(runningJ);

  330. 		

  331. 		// resetOnRun

  332. 		json_t *resetOnRunJ = json_object_get(rootJ, "resetOnRun");

  333. 		if (resetOnRunJ)

  334. 			resetOnRun = json_is_true(resetOnRunJ);

  335. 

  336. 		// attached

  337. 		json_t *attachedJ = json_object_get(rootJ, "attached");

  338. 		if (attachedJ)

  339. 			attached = json_is_true(attachedJ);

  340. 		

  341. 		// velEditMode

  342. 		json_t *velEditModeJ = json_object_get(rootJ, "velEditMode");

  343. 		if (velEditModeJ)

  344. 			velEditMode = json_integer_value(velEditModeJ);

  345. 

  346. 		// writeMode

  347. 		json_t *writeModeJ = json_object_get(rootJ, "writeMode");

  348. 		if (writeModeJ)

  349. 			writeMode = json_integer_value(writeModeJ);

  350. 

  351. 		seq.fromJson(rootJ);

  352. 		

  353. 		// Initialize dependants after everything loaded

  354. 		cpSeqLength = getCPMode();

  355. 		seq.initRun();

  356. 	}

  357. 

  358. 

  359. 	void step() override {

  360. 		const float sampleRate = engineGetSampleRate();

  361. 		static const float revertDisplayTime = 0.7f;// seconds

  362. 		static const float showLenInStepsTime = 2.0f;// seconds

  363. 		

  364. 		

  365. 		//********** Buttons, knobs, switches and inputs **********

  366. 		

  367. 		bool editingSequence = isEditingSequence();

  368. 		

  369. 		// Run button

  370. 		if (runningTrigger.process(params[RUN_PARAM].value + inputs[RUNCV_INPUT].value)) {// no input refresh here, don't want to introduce startup skew

  371. 			running = !running;

  372. 			if (running) {

  373. 				if (resetOnRun)

  374. 					seq.initRun();

  375. 				if (resetOnRun || clockIgnoreOnRun)

  376. 					clockIgnoreOnReset = (long) (clockIgnoreOnResetDuration * sampleRate);

  377. 			}

  378. 			displayState = DISP_NORMAL;

  379. 			//multiSteps = false;

  380. 			//multiTracks = false;

  381. 		}

  382. 

  383. 		if ((lightRefreshCounter & userInputsStepSkipMask) == 0) {

  384. 			

  385. 			// Seq CV input

  386. 			if (inputs[SEQCV_INPUT].active) {

  387. 				if (seqCVmethod == 0) {// 0-10 V

  388. 					int newSeq = (int)( inputs[SEQCV_INPUT].value * ((float)SequencerKernel::MAX_SEQS - 1.0f) / 10.0f + 0.5f );

  389. 					seq.setSeqIndexEdit(clamp(newSeq, 0, SequencerKernel::MAX_SEQS - 1));

  390. 				}

  391. 				else if (seqCVmethod == 1) {// C2-D7#

  392. 					int newSeq = (int)( (inputs[SEQCV_INPUT].value + 2.0f) * 12.0f + 0.5f );

  393. 					seq.setSeqIndexEdit(clamp(newSeq, 0, SequencerKernel::MAX_SEQS - 1));

  394. 				}

  395. 				else {// TrigIncr

  396. 					if (seqCVTrigger.process(inputs[SEQCV_INPUT].value))

  397. 						seq.setSeqIndexEdit(clamp(seq.getSeqIndexEdit() + 1, 0, SequencerKernel::MAX_SEQS - 1));

  398. 				}	

  399. 			}

  400. 			

  401. 			// Track CV input

  402. 			if (inputs[TRKCV_INPUT].active) {

  403. 				int newTrk = (int)( inputs[TRKCV_INPUT].value * (2.0f * (float)Sequencer::NUM_TRACKS - 1.0f) / 10.0f + 0.5f );

  404. 				seq.setTrackIndexEdit(abs(newTrk) % Sequencer::NUM_TRACKS);

  405. 				if (newTrk > 3)

  406. 					multiTracks = true;

  407. 				else

  408. 					multiTracks = false;

  409. 			}

  410. 			

  411. 			// Attach button

  412. 			if (attachedTrigger.process(params[ATTACH_PARAM].value)) {

  413. 				attached = !attached;

  414. 				displayState = DISP_NORMAL;			

  415. 				multiSteps = false;

  416. 				multiTracks = false;

  417. 			}

  418. 			if (attached) {//if (running && attached) {

  419. 				seq.attach();

  420. 			}

  421. 			

  422. 	

  423. 			// Copy 

  424. 			if (copyTrigger.process(params[COPY_PARAM].value)) {

  425. 				if (!attached) {

  426. 					multiTracks = false;

  427. 					if (editingSequence) {

  428. 						seq.copySequence(cpSeqLength);					

  429. 						displayState = DISP_COPY_SEQ;

  430. 					}

  431. 					else {

  432. 						int cpMode = getCPMode();

  433. 						if (cpMode == 2000) {

  434. 							if (displayState != DISP_COPY_SONG_CUST) {// first click to set cpSongStart

  435. 								cpSongStart = seq.getPhraseIndexEdit();

  436. 								displayState = DISP_COPY_SONG_CUST;

  437. 							}

  438. 							else {// second click do the copy 

  439. 								seq.copySong(cpSongStart, max(1, seq.getPhraseIndexEdit() - cpSongStart + 1));

  440. 								displayState = DISP_COPY_SONG;

  441. 							}

  442. 						}

  443. 						else {

  444. 							seq.copySong(seq.getPhraseIndexEdit(), cpMode);

  445. 							displayState = DISP_COPY_SONG;

  446. 						}

  447. 					}

  448. 					if (displayState != DISP_COPY_SONG_CUST)

  449. 						revertDisplay = (long) (revertDisplayTime * sampleRate / displayRefreshStepSkips);

  450. 				}

  451. 				else

  452. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  453. 			}

  454. 			// Paste 

  455. 			if (pasteTrigger.process(params[PASTE_PARAM].value)) {

  456. 				if (!attached) {

  457. 					if (editingSequence) {

  458. 						seq.pasteSequence(multiTracks);

  459. 						displayState = DISP_PASTE_SEQ;

  460. 					}

  461. 					else {

  462. 						if (displayState != DISP_COPY_SONG_CUST) {

  463. 							seq.pasteSong(multiTracks);

  464. 							displayState = DISP_PASTE_SONG;

  465. 						}

  466. 					}

  467. 					if (displayState != DISP_COPY_SONG_CUST)

  468. 						revertDisplay = (long) (revertDisplayTime * sampleRate / displayRefreshStepSkips);

  469. 				}

  470. 				else

  471. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  472. 			}			

  473. 			

  474. 

  475. 			// Write input (must be before Left and Right in case route gate simultaneously to Right and Write for example)

  476. 			//  (write must be to correct step)

  477. 			bool writeTrig = writeTrigger.process(inputs[WRITE_INPUT].value);

  478. 			if (writeTrig) {

  479. 				if (editingSequence && !attached) {

  480. 					int multiStepsCount = multiSteps ? cpSeqLength : 1;

  481. 					for (int trkn = 0; trkn < Sequencer::NUM_TRACKS; trkn++) {

  482. 						if (trkn == seq.getTrackIndexEdit() || multiTracks) {

  483. 							if (inputs[VEL_INPUTS + trkn].active && ((writeMode & 0x1) == 0)) {	// must be before seq.writeCV() below, so that editing CV2 can be grabbed

  484. 								float maxVel = (velocityMode > 0 ? 127.0f : 200.0f);

  485. 								float capturedCV = inputs[VEL_INPUTS + trkn].value + (velocityBipol ? 5.0f : 0.0f);

  486. 								int intVel = (int)(capturedCV * maxVel / 10.0f + 0.5f);

  487. 								seq.setVelocityVal(trkn, clamp(intVel, 0, 200), multiStepsCount, false);

  488. 							}

  489. 							if (inputs[CV_INPUTS + trkn].active && ((writeMode & 0x2) == 0)) {

  490. 								seq.writeCV(trkn, clamp(inputs[CV_INPUTS + trkn].value, -10.0f, 10.0f), multiStepsCount, sampleRate, false);

  491. 							}

  492. 						}

  493. 					}

  494. 					seq.setEditingGateKeyLight(-1);

  495. 					if (params[AUTOSTEP_PARAM].value > 0.5f)

  496. 						seq.autostep(autoseq && !inputs[SEQCV_INPUT].active, autostepLen);

  497. 				}

  498. 				else if (attached)

  499. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  500. 			}

  501. 			// Left and right CV inputs

  502. 			int delta = 0;

  503. 			if (leftTrigger.process(inputs[LEFTCV_INPUT].value)) { 

  504. 				delta = -1;

  505. 			}

  506. 			if (rightTrigger.process(inputs[RIGHTCV_INPUT].value)) {

  507. 				delta = +1;

  508. 			}

  509. 			if (delta != 0) {

  510. 				if (editingSequence && !attached) {

  511. 					if (displayState == DISP_NORMAL) {

  512. 						seq.moveStepIndexEditWithEditingGate(delta, writeTrig, sampleRate);

  513. 					}

  514. 				}

  515. 				else if (attached)

  516. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  517. 			}

  518. 

  519. 			// Step button presses

  520. 			int stepPressed = -1;

  521. 			for (int i = 0; i < SequencerKernel::MAX_STEPS; i++) {

  522. 				if (stepTriggers[i].process(params[STEP_PHRASE_PARAMS + i].value))

  523. 					stepPressed = i;

  524. 			}

  525. 			if (stepPressed != -1) {

  526. 				if (editingSequence && !attached) {

  527. 					if (displayState == DISP_LEN) {

  528. 						seq.setLength(stepPressed + 1, multiTracks);

  529. 						revertDisplay = (long) (revertDisplayTime * sampleRate / displayRefreshStepSkips);

  530. 					}

  531. 					else {

  532. 						if (multiSteps && (getCPMode() == 2000) && (stepPressed >= seq.getStepIndexEdit())) {

  533. 							cpSeqLength = stepPressed - seq.getStepIndexEdit() + 1;

  534. 						}

  535. 						else {

  536. 							showLenInSteps = (long) (showLenInStepsTime * sampleRate / displayRefreshStepSkips);

  537. 							seq.setStepIndexEdit(stepPressed, sampleRate);

  538. 							displayState = DISP_NORMAL; // leave this here, the if has it also, but through the revert mechanism

  539. 							if (multiSteps && (getCPMode() == 2000)) {

  540. 								multiSteps = false;

  541. 								cpSeqLength = 2000;

  542. 							}

  543. 						}

  544. 					}

  545. 				}

  546. 				else if (attached)

  547. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  548. 			} 

  549. 			

  550. 			// Mode button

  551. 			if (modeTrigger.process(params[MODE_PARAM].value)) {

  552. 				if (!attached) {

  553. 					if (displayState != DISP_MODE_SEQ && displayState != DISP_MODE_SONG)

  554. 						displayState = editingSequence ? DISP_MODE_SEQ : DISP_MODE_SONG;

  555. 					else

  556. 						displayState = DISP_NORMAL;

  557. 				}

  558. 				else

  559. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  560. 			}

  561. 			

  562. 			// Clk res/delay button

  563. 			if (clkResTrigger.process(params[CLKRES_PARAM].value)) {

  564. 				if (!attached) {

  565. 					if (displayState != DISP_PPQN && displayState != DISP_DELAY)	

  566. 						displayState = DISP_PPQN;

  567. 					else if (displayState == DISP_PPQN)

  568. 						displayState = DISP_DELAY;

  569. 					else

  570. 						displayState = DISP_NORMAL;

  571. 				}

  572. 				else

  573. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  574. 			}

  575. 			

  576. 			// Transpose/Rotate button

  577. 			if (transposeTrigger.process(params[TRAN_ROT_PARAM].value)) {

  578. 				if (editingSequence && !attached) {

  579. 					if (displayState != DISP_TRANSPOSE && displayState != DISP_ROTATE) {

  580. 						displayState = DISP_TRANSPOSE;

  581. 					}

  582. 					else if (displayState == DISP_TRANSPOSE) {

  583. 						displayState = DISP_ROTATE;

  584. 					}

  585. 					else 

  586. 						displayState = DISP_NORMAL;

  587. 				}

  588. 				else if (attached)

  589. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  590. 			}			

  591. 

  592. 			// Begin/End buttons

  593. 			if (beginTrigger.process(params[BEGIN_PARAM].value)) {

  594. 				if (!editingSequence && !attached) {

  595. 					seq.setBegin(multiTracks);

  596. 					displayState = DISP_NORMAL;

  597. 				}

  598. 				else if (attached)

  599. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  600. 			}	

  601. 			if (endTrigger.process(params[END_PARAM].value)) {

  602. 				if (!editingSequence && !attached) {

  603. 					seq.setEnd(multiTracks);

  604. 					displayState = DISP_NORMAL;

  605. 				}

  606. 				else if (attached)

  607. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  608. 			}	

  609. 

  610. 			// Rep/Len button

  611. 			if (repLenTrigger.process(params[REP_LEN_PARAM].value)) {

  612. 				if (!attached) {

  613. 					if (displayState != DISP_LEN && displayState != DISP_REPS)

  614. 						displayState = editingSequence ? DISP_LEN : DISP_REPS;

  615. 					else

  616. 						displayState = DISP_NORMAL;

  617. 				}

  618. 				else

  619. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  620. 			}	

  621. 

  622. 			// Track Inc/Dec buttons

  623. 			if (trackIncTrigger.process(params[TRACKUP_PARAM].value)) {

  624. 				if (!inputs[TRKCV_INPUT].active) {

  625. 					seq.incTrackIndexEdit();

  626. 				}

  627. 			}

  628. 			if (trackDeccTrigger.process(params[TRACKDOWN_PARAM].value)) {

  629. 				if (!inputs[TRKCV_INPUT].active) {

  630. 					seq.decTrackIndexEdit();

  631. 				}

  632. 			}

  633. 			// All button

  634. 			if (allTrigger.process(params[ALLTRACKS_PARAM].value)) {

  635. 				if (!inputs[TRKCV_INPUT].active) {

  636. 					if (!attached) {

  637. 						multiTracks = !multiTracks;

  638. 					}

  639. 					else {

  640. 						multiTracks = false;

  641. 						attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  642. 					}

  643. 				}

  644. 			}	

  645. 			

  646. 			// Sel button

  647. 			if (selTrigger.process(params[SEL_PARAM].value)) {

  648. 				if (!attached && editingSequence)

  649. 					multiSteps = !multiSteps;

  650. 				else if (attached) {

  651. 					multiSteps = false;

  652. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  653. 				}

  654. 			}	

  655. 			

  656. 			// Vel mode button

  657. 			if (velEditTrigger.process(params[VEL_EDIT_PARAM].value)) {

  658. 				if (attached || editingSequence) {

  659. 					if (velEditMode < 2)

  660. 						velEditMode++;

  661. 					else {

  662. 						velEditMode = 0;

  663. 					}

  664. 				}

  665. 			}

  666. 			

  667. 			// Write mode button

  668. 			if (writeModeTrigger.process(params[WRITEMODE_PARAM].value)) {

  669. 				if (attached || editingSequence) {

  670. 					if (++writeMode > 2)

  671. 						writeMode =0;

  672. 				}

  673. 			}

  674. 		

  675. 			// Velocity edit knob 

  676. 			float velParamValue = params[VEL_KNOB_PARAM].value;

  677. 			int newVelocityKnob = (int)roundf(velParamValue * 30.0f);

  678. 			if (velParamValue == 0.0f)// true when constructor or fromJson() occured

  679. 				velocityKnob = newVelocityKnob;

  680. 			int deltaVelKnob = newVelocityKnob - velocityKnob;

  681. 			if (deltaVelKnob != 0) {

  682. 				if (abs(deltaVelKnob) <= 3) {// avoid discontinuous step (initialize for example)

  683. 					// any changes in here should may also require right click behavior to be updated in the knob's onMouseDown()

  684. 					if (editingSequence && !attached) {

  685. 						int mutliStepsCount = multiSteps ? cpSeqLength : 1;

  686. 						if (velEditMode == 2) {

  687. 							seq.modSlideVal(deltaVelKnob, mutliStepsCount, multiTracks);

  688. 						}

  689. 						else if (velEditMode == 1) {

  690. 							seq.modGatePVal(deltaVelKnob, mutliStepsCount, multiTracks);

  691. 						}

  692. 						else {

  693. 							seq.modVelocityVal(deltaVelKnob, mutliStepsCount, multiTracks);

  694. 						}

  695. 						displayState = DISP_NORMAL;

  696. 					}

  697. 					else if (attached)

  698. 						attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  699. 				}

  700. 				velocityKnob = newVelocityKnob;

  701. 			}	

  702. 

  703. 						

  704. 			// Sequence edit knob 

  705. 			float seqParamValue = params[SEQUENCE_PARAM].value;

  706. 			int newSequenceKnob = (int)roundf(seqParamValue * 7.0f);

  707. 			if (seqParamValue == 0.0f)// true when constructor or fromJson() occured

  708. 				sequenceKnob = newSequenceKnob;

  709. 			int deltaSeqKnob = newSequenceKnob - sequenceKnob;

  710. 			if (deltaSeqKnob != 0) {

  711. 				if (abs(deltaSeqKnob) <= 3) {// avoid discontinuous step (initialize for example)

  712. 					// any changes in here should may also require right click behavior to be updated in the knob's onMouseDown()

  713. 					if (displayState == DISP_LEN) {

  714. 						seq.modLength(deltaSeqKnob, multiTracks);

  715. 					}

  716. 					else if (displayState == DISP_TRANSPOSE) {

  717. 						seq.transposeSeq(deltaSeqKnob, multiTracks);

  718. 					}

  719. 					else if (displayState == DISP_ROTATE) {

  720. 						seq.rotateSeq(deltaSeqKnob, multiTracks);

  721. 					}							

  722. 					else if (displayState == DISP_REPS) {

  723. 						seq.modPhraseReps(deltaSeqKnob, multiTracks);

  724. 					}

  725. 					else if (displayState == DISP_PPQN || displayState == DISP_DELAY) {

  726. 					}

  727. 					else if (!attached) {

  728. 						if (editingSequence) {

  729. 							if (!inputs[SEQCV_INPUT].active) {

  730. 								seq.moveSeqIndexEdit(deltaSeqKnob);

  731. 								if (displayState != DISP_MODE_SEQ)

  732. 									displayState = DISP_NORMAL;

  733. 							}

  734. 						}

  735. 						else {// editing song

  736. 							seq.modPhraseSeqNum(deltaSeqKnob, multiTracks);

  737. 							displayState = DISP_NORMAL;

  738. 						}

  739. 					}

  740. 					else if (attached)

  741. 						attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  742. 				}

  743. 				sequenceKnob = newSequenceKnob;

  744. 			}	

  745. 		

  746. 

  747. 			// Phrase edit knob 

  748. 			float phraseParamValue = params[PHRASE_PARAM].value;

  749. 			int newPhraseKnob = (int)roundf(phraseParamValue * 7.0f);

  750. 			if (phraseParamValue == 0.0f)// true when constructor or fromJson() occured

  751. 				phraseKnob = newPhraseKnob;

  752. 			int deltaPhrKnob = newPhraseKnob - phraseKnob;

  753. 			if (deltaPhrKnob != 0) {

  754. 				if (abs(deltaPhrKnob) <= 3) {// avoid discontinuous step (initialize for example)

  755. 					// any changes in here should may also require right click behavior to be updated in the knob's onMouseDown()

  756. 					if (displayState == DISP_MODE_SEQ) {

  757. 						seq.modRunModeSeq(deltaPhrKnob, multiTracks);

  758. 					}

  759. 					else if (displayState == DISP_PPQN) {

  760. 						seq.modPulsesPerStep(deltaPhrKnob, multiTracks);

  761. 					}

  762. 					else if (displayState == DISP_DELAY) {

  763. 						seq.modDelay(deltaPhrKnob, multiTracks);

  764. 					}

  765. 					else if (displayState == DISP_MODE_SONG) {

  766. 						seq.modRunModeSong(deltaPhrKnob, multiTracks);

  767. 					}

  768. 					else if (!editingSequence && !attached && displayState != DISP_PPQN && displayState != DISP_DELAY) {

  769. 						seq.movePhraseIndexEdit(deltaPhrKnob);

  770. 						if (displayState != DISP_REPS && displayState != DISP_COPY_SONG_CUST)

  771. 							displayState = DISP_NORMAL;

  772. 					}

  773. 					else if (attached)

  774. 						attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  775. 				}

  776. 				phraseKnob = newPhraseKnob;

  777. 			}	

  778. 				

  779. 	

  780. 			// Octave buttons

  781. 			for (int octn = 0; octn < 7; octn++) {

  782. 				if (octTriggers[octn].process(params[OCTAVE_PARAM + octn].value)) {

  783. 					if (editingSequence && !attached && displayState != DISP_PPQN) {

  784. 						if (seq.applyNewOctave(6 - octn, multiSteps ? cpSeqLength : 1, sampleRate, multiTracks))

  785. 							tiedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  786. 					}

  787. 					else if (attached)

  788. 						attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  789. 					displayState = DISP_NORMAL;

  790. 				}

  791. 			}

  792. 			

  793. 			// Keyboard buttons

  794. 			for (int keyn = 0; keyn < 12; keyn++) {

  795. 				if (keyTriggers[keyn].process(params[KEY_PARAMS + keyn].value)) {

  796. 					displayState = DISP_NORMAL;

  797. 					if (editingSequence && !attached && displayState != DISP_PPQN) {

  798. 						bool autostepClick = params[KEY_PARAMS + keyn].value > 1.5f;// if right-click

  799. 						if (isEditingGates()) {

  800. 							if (!seq.setGateType(keyn, multiSteps ? cpSeqLength : 1, sampleRate, autostepClick, multiTracks))

  801. 								displayState = DISP_PPQN;

  802. 						}

  803. 						else {

  804. 							if (seq.applyNewKey(keyn, multiSteps ? cpSeqLength : 1, sampleRate, autostepClick, multiTracks))

  805. 								tiedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  806. 						}							

  807. 					}

  808. 					else if (attached)

  809. 						attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  810. 				}

  811. 			}

  812. 			

  813. 			// Gate, GateProb, Slide and Tied buttons

  814. 			if (gate1Trigger.process(params[GATE_PARAM].value + inputs[GATECV_INPUT].value)) {

  815. 				if (editingSequence && !attached) {

  816. 					seq.toggleGate(multiSteps ? cpSeqLength : 1, multiTracks);

  817. 				}

  818. 				else if (attached)

  819. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  820. 				displayState = DISP_NORMAL;

  821. 			}		

  822. 			if (gateProbTrigger.process(params[GATE_PROB_PARAM].value + inputs[GATEPCV_INPUT].value)) {

  823. 				if (editingSequence && !attached) {

  824. 					if (seq.toggleGateP(multiSteps ? cpSeqLength : 1, multiTracks)) 

  825. 						tiedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  826. 					else if (seq.getAttribute().getGateP())

  827. 						velEditMode = 1;

  828. 				}

  829. 				else if (attached)

  830. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  831. 				displayState = DISP_NORMAL;

  832. 			}		

  833. 			if (slideTrigger.process(params[SLIDE_BTN_PARAM].value + inputs[SLIDECV_INPUT].value)) {

  834. 				if (editingSequence && !attached) {

  835. 					if (seq.toggleSlide(multiSteps ? cpSeqLength : 1, multiTracks))

  836. 						tiedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  837. 					else if (seq.getAttribute().getSlide())

  838. 						velEditMode = 2;

  839. 				}

  840. 				else if (attached)

  841. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  842. 				displayState = DISP_NORMAL;

  843. 			}		

  844. 			if (tiedTrigger.process(params[TIE_PARAM].value + inputs[TIEDCV_INPUT].value)) {

  845. 				if (editingSequence && !attached) {

  846. 					seq.toggleTied(multiSteps ? cpSeqLength : 1, multiTracks);// will clear other attribs if new state is on

  847. 				}

  848. 				else if (attached)

  849. 					attachedWarning = (long) (warningTime * sampleRate / displayRefreshStepSkips);

  850. 				displayState = DISP_NORMAL;

  851. 			}		

  852. 			

  853. 			calcClkInSources();

  854. 			

  855. 		}// userInputs refresh

  856. 		

  857. 		

  858. 		

  859. 		//********** Clock and reset **********

  860. 		

  861. 		// Clock

  862. 		if (running && clockIgnoreOnReset == 0l) {

  863. 			bool clockTrigged[Sequencer::NUM_TRACKS];

  864. 			for (int trkn = 0; trkn < Sequencer::NUM_TRACKS; trkn++) {

  865. 				clockTrigged[trkn] = clockTriggers[trkn].process(inputs[CLOCK_INPUTS + trkn].value);

  866. 				if (clockTrigged[clkInSources[trkn]]) {

  867. 					seq.clockStep(trkn);

  868. 				}

  869. 			}

  870. 			seq.step();

  871. 		}

  872. 				

  873. 		// Reset

  874. 		if (resetTrigger.process(inputs[RESET_INPUT].value + params[RESET_PARAM].value)) {

  875. 			seq.initRun();

  876. 			resetLight = 1.0f;

  877. 			displayState = DISP_NORMAL;

  878. 			//multiSteps = false;

  879. 			//multiTracks = false;

  880. 			clockIgnoreOnReset = (long) (clockIgnoreOnResetDuration * sampleRate);

  881. 			for (int trkn = 0; trkn < Sequencer::NUM_TRACKS; trkn++)

  882. 				clockTriggers[trkn].reset();		

  883. 			if (inputs[SEQCV_INPUT].active && seqCVmethod == 2)

  884. 				seq.setSeqIndexEdit(0);

  885. 		}

  886. 		

  887. 		

  888. 		//********** Outputs and lights **********

  889. 				

  890. 		

  891. 		

  892. 		// CV, gate and velocity outputs

  893. 		for (int trkn = 0; trkn < Sequencer::NUM_TRACKS; trkn++) {

  894. 			outputs[CV_OUTPUTS + trkn].value = seq.calcCvOutputAndDecSlideStepsRemain(trkn, running);

  895. 			bool retriggingOnReset = (clockIgnoreOnReset != 0l && retrigGatesOnReset);

  896. 			outputs[GATE_OUTPUTS + trkn].value = seq.calcGateOutput(trkn, running && !retriggingOnReset, clockTriggers[clkInSources[trkn]], sampleRate);

  897. 			outputs[VEL_OUTPUTS + trkn].value = seq.calcVelOutput(trkn, running && !retriggingOnReset) - (velocityBipol ? 5.0f : 0.0f);			

  898. 		}

  899. 

  900. 		// lights

  901. 		lightRefreshCounter++;

  902. 		if (lightRefreshCounter >= displayRefreshStepSkips) {

  903. 			lightRefreshCounter = 0;

  904. 		

  905. 			// Prepare values to visualize

  906. 			StepAttributes attributesVisual;

  907. 			float cvVisual;

  908. 			if (editingSequence || attached) {

  909. 				attributesVisual = seq.getAttribute();

  910. 				cvVisual = seq.getCV();

  911. 			}

  912. 			else {

  913. 				attributesVisual.clear();// clears everything, but just buttons used below

  914. 				cvVisual = 0.0f;// not used

  915. 			}

  916. 			bool editingGates = isEditingGates();

  917. 			

  918. 			// Step lights

  919. 			for (int stepn = 0; stepn < SequencerKernel::MAX_STEPS; stepn++) {

  920. 				float red = 0.0f;

  921. 				float green = 0.0f;	

  922. 				float white = 0.0f;

  923. 				if ((displayState == DISP_COPY_SEQ) || (displayState == DISP_PASTE_SEQ)) {

  924. 					int startCP = seq.getStepIndexEdit();

  925. 					if (stepn >= startCP && stepn < (startCP + seq.getLengthSeqCPbug()))

  926. 						green = 0.5f;

  927. 				}

  928. 				else if (displayState == DISP_TRANSPOSE) {

  929. 					red = 0.5f;

  930. 				}

  931. 				else if (displayState == DISP_ROTATE) {

  932. 					red = (stepn == seq.getStepIndexEdit() ? 1.0f : (stepn < seq.getLength() ? 0.2f : 0.0f));

  933. 				}

  934. 				else if (displayState == DISP_LEN) {

  935. 					int seqEnd = seq.getLength() - 1;

  936. 					if (stepn < seqEnd)

  937. 						green = 0.1f;

  938. 					else if (stepn == seqEnd)

  939. 						green =  1.0f;

  940. 				}				

  941. 				else if (editingSequence && !attached) {

  942. 					if (multiSteps) {

  943. 						if (stepn >= seq.getStepIndexEdit() && stepn < (seq.getStepIndexEdit() + cpSeqLength))

  944. 							red = 0.2f;

  945. 					}

  946. 					else if (!running && showLenInSteps > 0l && stepn < seq.getLength()) {

  947. 						green = 0.01f;

  948. 					}

  949. 					if (stepn == seq.getStepIndexEdit()) {

  950. 						if (red == 0.0f) // don't overwrite light multistep with full red

  951. 							red = 1.0f;

  952. 						green = 0.0f;

  953. 					}

  954. 					if (running && red != 0.2f && stepn == seq.getStepIndexRun(seq.getTrackIndexEdit())) {

  955. 						green = 1.0f;

  956. 					}

  957. 					white = 1.0f;// signal for override below

  958. 				}

  959. 				else if (attached) {

  960. 					// all active light green, current track is bright yellow

  961. 					for (int trkn = 0; trkn < Sequencer::NUM_TRACKS; trkn++) {

  962. 						bool trknIsUsed = outputs[CV_OUTPUTS + trkn].active || outputs[GATE_OUTPUTS + trkn].active || outputs[VEL_OUTPUTS + trkn].active;

  963. 						if (stepn == seq.getStepIndexRun(trkn) && trknIsUsed) 

  964. 							green = 0.1f;	

  965. 					}

  966. 					if (green > 0.2f) 

  967. 						green = 0.2f;

  968. 					if (stepn == seq.getStepIndexEdit()) {

  969. 						green = 1.0f;

  970. 						red = 1.0f;

  971. 					}

  972. 					white = 1.0f;// signal for override below

  973. 				}

  974. 				if (white == 1.0f)

  975. 					white = ((green == 0.0f && red == 0.0f && (editingSequence || attached) && seq.getAttribute(seq.getTrackIndexEdit(), stepn).getGate() && displayState != DISP_MODE_SEQ && displayState != DISP_PPQN && displayState != DISP_DELAY) ? 0.04f : 0.0f);

  976. 				if (editingSequence && white != 0.0f) {

  977. 					green = 0.02f; white = 0.0f;

  978. 				}				

  979. 				setGreenRed(STEP_PHRASE_LIGHTS + stepn * 3, green, red);

  980. 				//if (white != 0.0f && seq.getAttribute(seq.getTrackIndexEdit(), stepn).getGateP()) white = 0.01f;

  981. 				lights[STEP_PHRASE_LIGHTS + stepn * 3 + 2].value = white;

  982. 			}

  983. 			

  984. 			

  985. 			// Octave lights

  986. 			int octLightIndex = (int) floor(cvVisual + 3.0f);

  987. 			for (int i = 0; i < 7; i++) {

  988. 				float red = 0.0f;

  989. 				if (editingSequence || attached) {

  990. 					if (tiedWarning > 0l) {

  991. 						bool warningFlashState = calcWarningFlash(tiedWarning, (long) (warningTime * sampleRate / displayRefreshStepSkips));

  992. 						red = (warningFlashState && (i == (6 - octLightIndex))) ? 1.0f : 0.0f;

  993. 					}

  994. 					else				

  995. 						red = (i == (6 - octLightIndex) ? 1.0f : 0.0f);// no lights when outside of range

  996. 				}

  997. 				lights[OCTAVE_LIGHTS + i].value = red;

  998. 			}

  999. 			

  1000. 			// Keyboard lights

  1001. 			float keyCV = cvVisual + 10.0f;// to properly handle negative note voltages

  1002. 			int keyLightIndex = clamp( (int)((keyCV - floor(keyCV)) * 12.0f + 0.5f),  0,  11);

  1003. 			for (int i = 0; i < 12; i++) {

  1004. 				float green = 0.0f;

  1005. 				float red = 0.0f;

  1006. 				if (displayState == DISP_PPQN) {

  1007. 					if (seq.keyIndexToGateTypeEx(i) != -1) {

  1008. 						green =	1.0f;

  1009. 						red = 1.0f;

  1010. 					}

  1011. 				}

  1012. 				else if (editingSequence || attached) {			

  1013. 					if (editingGates) {

  1014. 						green = 1.0f;

  1015. 						red = 0.2f;

  1016. 						unsigned long editingType = seq.getEditingType();

  1017. 						if (editingType > 0ul) {

  1018. 							if (i == seq.getEditingGateKeyLight()) {

  1019. 								float dimMult = ((float) editingType / (float)(Sequencer::gateTime * sampleRate / displayRefreshStepSkips));

  1020. 								green *= dimMult;

  1021. 								red *= dimMult;

  1022. 							}

  1023. 							else {

  1024. 								green = 0.0f; 

  1025. 								red = 0.0f;

  1026. 							}

  1027. 						}

  1028. 						else {

  1029. 							int modeLightIndex = seq.getGateType();

  1030. 							if (i != modeLightIndex) {// show dim note if gatetype is different than note

  1031. 								green = 0.0f;

  1032. 								red = (i == keyLightIndex ? 0.1f : 0.0f);

  1033. 							}

  1034. 						}

  1035. 					}

  1036. 					else {

  1037. 						if (tiedWarning > 0l) {

  1038. 							bool warningFlashState = calcWarningFlash(tiedWarning, (long) (warningTime * sampleRate / displayRefreshStepSkips));

  1039. 							red = (warningFlashState && i == keyLightIndex) ? 1.0f : 0.0f;

  1040. 						}

  1041. 						else {

  1042. 							red = seq.calcKeyLightWithEditing(i, keyLightIndex, sampleRate);

  1043. 						}

  1044. 					}

  1045. 				}

  1046. 				setGreenRed(KEY_LIGHTS + i * 2, green, red);

  1047. 			}

  1048. 

  1049. 			// Gate, Tied, GateProb, and Slide lights 

  1050. 			if (!attributesVisual.getGate())

  1051. 				setGreenRed(GATE_LIGHT, 0.0f, 0.0f);

  1052. 			else 

  1053. 				setGreenRed(GATE_LIGHT, editingGates ? 1.0f : 0.0f, editingGates ? 0.2f : 1.0f);

  1054. 			if (tiedWarning > 0l) {

  1055. 				bool warningFlashState = calcWarningFlash(tiedWarning, (long) (warningTime * sampleRate / displayRefreshStepSkips));

  1056. 				lights[TIE_LIGHT].value = (warningFlashState) ? 1.0f : 0.0f;

  1057. 			}

  1058. 			else

  1059. 				lights[TIE_LIGHT].value = attributesVisual.getTied() ? 1.0f : 0.0f;			

  1060. 			if (attributesVisual.getGateP())

  1061. 				setGreenRed(GATE_PROB_LIGHT, 1.0f, 1.0f);

  1062. 			else 

  1063. 				setGreenRed(GATE_PROB_LIGHT, 0.0f, 0.0f);

  1064. 			lights[SLIDE_LIGHT].value = attributesVisual.getSlide() ? 1.0f : 0.0f;

  1065. 			

  1066. 			// Reset light

  1067. 			lights[RESET_LIGHT].value =	resetLight;

  1068. 			resetLight -= (resetLight / lightLambda) * engineGetSampleTime() * displayRefreshStepSkips;

  1069. 			

  1070. 			// Run light

  1071. 			lights[RUN_LIGHT].value = (running ? 1.0f : 0.0f);

  1072. 

  1073. 			// Attach light

  1074. 			if (attachedWarning > 0l) {

  1075. 				bool warningFlashState = calcWarningFlash(attachedWarning, (long) (warningTime * sampleRate / displayRefreshStepSkips));

  1076. 				lights[ATTACH_LIGHT].value = (warningFlashState) ? 1.0f : 0.0f;

  1077. 			}

  1078. 			else

  1079. 				lights[ATTACH_LIGHT].value = (attached ? 1.0f : 0.0f);

  1080. 				

  1081. 			// Velocity edit mode lights

  1082. 			if (editingSequence || attached) {

  1083. 				setGreenRed(VEL_PROB_LIGHT, velEditMode == 1 ? 1.0f : 0.0f, velEditMode == 1 ? 1.0f : 0.0f);

  1084. 				lights[VEL_SLIDE_LIGHT].value = (velEditMode == 2 ? 1.0f : 0.0f);

  1085. 			}

  1086. 			else {

  1087. 				setGreenRed(VEL_PROB_LIGHT, 0.0f, 0.0f);

  1088. 				lights[VEL_SLIDE_LIGHT].value = 0.0f;

  1089. 			}

  1090. 			

  1091. 			// CV writing lights

  1092. 			for (int trkn = 0; trkn < Sequencer::NUM_TRACKS; trkn++) {

  1093. 				if (editingSequence && !attached) {

  1094. 					lights[WRITECV_LIGHTS + trkn].value = (((writeMode & 0x2) == 0) && (multiTracks || seq.getTrackIndexEdit() == trkn)) ? 1.0f : 0.0f;

  1095. 					lights[WRITECV2_LIGHTS + trkn].value = (((writeMode & 0x1) == 0) && (multiTracks || seq.getTrackIndexEdit() == trkn)) ? 1.0f : 0.0f;

  1096. 				}

  1097. 				else {

  1098. 					lights[WRITECV_LIGHTS + trkn].value = 0.0f;

  1099. 					lights[WRITECV2_LIGHTS + trkn].value = 0.0f;

  1100. 				}

  1101. 			}				

  1102. 				

  1103. 			seq.stepEditingGate();// also steps editingType

  1104. 			if (tiedWarning > 0l)

  1105. 				tiedWarning--;

  1106. 			if (attachedWarning > 0l)

  1107. 				attachedWarning--;

  1108. 			if (showLenInSteps > 0l)

  1109. 				showLenInSteps--;

  1110. 			if (revertDisplay > 0l) {

  1111. 				if (revertDisplay == 1)

  1112. 					displayState = DISP_NORMAL;

  1113. 				revertDisplay--;

  1114. 			}

  1115. 		}// lightRefreshCounter

  1116. 				

  1117. 		if (clockIgnoreOnReset > 0l)

  1118. 			clockIgnoreOnReset--;

  1119. 		

  1120. 	}// step()

  1121. 	

  1122. 

  1123. 	inline void setGreenRed(int id, float green, float red) {

  1124. 		lights[id + 0].value = green;

  1125. 		lights[id + 1].value = red;

  1126. 	}

  1127. 	

  1128. 	inline void calcClkInSources() {

  1129. 		// index 0 is always 0 so nothing to do for it

  1130. 		for (int trkn = 1; trkn < Sequencer::NUM_TRACKS; trkn++) {

  1131. 			if (inputs[CLOCK_INPUTS + trkn].active)

  1132. 				clkInSources[trkn] = trkn;

  1133. 			else 

  1134. 				clkInSources[trkn] = clkInSources[trkn - 1];

  1135. 		}

  1136. 	}

  1137. 	

  1138. 	

  1139. };

  1140. 

  1141. 

  1142. 

  1143. struct FoundryWidget : ModuleWidget {

  1144. 	Foundry *module;

  1145. 	DynamicSVGPanel *panel;

  1146. 	int oldExpansion;

  1147. 	int expWidth = 105;

  1148. 	IMPort* expPorts[12];

  1149. 	

  1150. 	template <int NUMCHAR>

  1151. 	struct DisplayWidget : TransparentWidget {// a centered display, must derive from this

  1152. 		Foundry *module;

  1153. 		std::shared_ptr<Font> font;

  1154. 		char displayStr[NUMCHAR + 1];

  1155. 		static const int textFontSize = 15;

  1156. 		static constexpr float textOffsetY = 19.9f; // 18.2f for 14 pt, 19.7f for 15pt

  1157. 		

  1158. 		void runModeToStr(int num) {

  1159. 			if (num >= 0 && num < SequencerKernel::NUM_MODES)

  1160. 				snprintf(displayStr, 4, "%s", SequencerKernel::modeLabels[num].c_str());

  1161. 		}

  1162. 

  1163. 		DisplayWidget(Vec _pos, Vec _size, Foundry *_module) {

  1164. 			box.size = _size;

  1165. 			box.pos = _pos.minus(_size.div(2));

  1166. 			module = _module;

  1167. 			font = Font::load(assetPlugin(plugin, "res/fonts/Segment14.ttf"));

  1168. 		}

  1169. 		

  1170. 		void draw(NVGcontext *vg) override {

  1171. 			NVGcolor textColor = prepareDisplay(vg, &box, textFontSize);

  1172. 			nvgFontFaceId(vg, font->handle);

  1173. 			nvgTextLetterSpacing(vg, -0.4);

  1174. 

  1175. 			Vec textPos = Vec(5.7f, textOffsetY);

  1176. 			nvgFillColor(vg, nvgTransRGBA(textColor, displayAlpha));

  1177. 			std::string initString(NUMCHAR,'~');

  1178. 			nvgText(vg, textPos.x, textPos.y, initString.c_str(), NULL);

  1179. 			nvgFillColor(vg, textColor);

  1180. 			char overlayChar = printText();

  1181. 			nvgText(vg, textPos.x, textPos.y, displayStr, NULL);

  1182. 			if (overlayChar != 0) {

  1183. 				displayStr[0] = overlayChar;

  1184. 				displayStr[1] = 0;

  1185. 				nvgText(vg, textPos.x, textPos.y, displayStr, NULL);

  1186. 			}

  1187. 		}

  1188. 		

  1189. 		virtual char printText() = 0;

  1190. 	};

  1191. 	

  1192. 	struct VelocityDisplayWidget : DisplayWidget<4> {

  1193. 		VelocityDisplayWidget(Vec _pos, Vec _size, Foundry *_module) : DisplayWidget(_pos, _size, _module) {};

  1194. 

  1195. 		void draw(NVGcontext *vg) override {

  1196. 			static const float offsetXfrac = 3.5f;

  1197. 			NVGcolor textColor = prepareDisplay(vg, &box, textFontSize);

  1198. 			nvgFontFaceId(vg, font->handle);

  1199. 			nvgTextLetterSpacing(vg, -0.4);

  1200. 

  1201. 			Vec textPos = Vec(6.3f, textOffsetY);

  1202. 			char useRed = printText();

  1203. 			if (useRed == 1)

  1204. 				textColor = nvgRGB(0xE0, 0xD0, 0x30);

  1205. 			nvgFillColor(vg, nvgTransRGBA(textColor, displayAlpha));

  1206. 			nvgText(vg, textPos.x, textPos.y, "~", NULL);

  1207. 			std::string initString(".~~");

  1208. 			nvgText(vg, textPos.x + offsetXfrac, textPos.y, initString.c_str(), NULL);

  1209. 			if (useRed == 1)

  1210. 				textColor = nvgRGB(0xFF, 0x2C, 0x20);

  1211. 			nvgFillColor(vg, textColor);

  1212. 			nvgText(vg, textPos.x + offsetXfrac, textPos.y, &displayStr[1], NULL);

  1213. 			displayStr[1] = 0;

  1214. 			nvgText(vg, textPos.x, textPos.y, displayStr, NULL);

  1215. 		}

  1216. 

  1217. 		char printText() override {

  1218. 			char ret = 0;// used for a color instead of overlay char. 0 = default (green), 1 = red

  1219. 			if (module->isEditingSequence() || module->attached) {

  1220. 				StepAttributes attributesVal = module->seq.getAttribute();

  1221. 				if (module->velEditMode == 2) {

  1222. 					int slide = attributesVal.getSlideVal();						

  1223. 					if ( slide >= 100)

  1224. 						snprintf(displayStr, 5, "   1");

  1225. 					else if (slide >= 1)

  1226. 						snprintf(displayStr, 5, "0.%02u", (unsigned) slide);

  1227. 					else

  1228. 						snprintf(displayStr, 5, "   0");

  1229. 				}

  1230. 				else if (module->velEditMode == 1) {

  1231. 					int prob = attributesVal.getGatePVal();

  1232. 					if ( prob >= 100)

  1233. 						snprintf(displayStr, 5, "   1");

  1234. 					else if (prob >= 1)

  1235. 						snprintf(displayStr, 5, "0.%02u", (unsigned) prob);

  1236. 					else

  1237. 						snprintf(displayStr, 5, "   0");

  1238. 				}

  1239. 				else {

  1240. 					unsigned int velocityDisp = (unsigned)(attributesVal.getVelocityVal());

  1241. 					if (module->velocityMode > 0) {// velocity is 0-127 or semitone

  1242. 						if (module->velocityMode == 2)// semitone

  1243. 							printNote(((float)velocityDisp)/12.0f - (module->velocityBipol ? 5.0f : 0.0f), &displayStr[1], true);// given str pointer must be 4 chars (3 display and one end of string)

  1244. 						else// 0-127

  1245. 							snprintf(displayStr, 5, " %3u", min(velocityDisp, 127));

  1246. 						displayStr[0] = displayStr[1];

  1247. 						displayStr[1] = ' ';

  1248. 					}

  1249. 					else {// velocity is 0-10V

  1250. 						float cvValPrint = (float)velocityDisp;

  1251. 						cvValPrint /= 20.0f;

  1252. 						if (module->velocityBipol) {						

  1253. 							if (cvValPrint < 5.0f)

  1254. 								ret = 1;

  1255. 							cvValPrint = fabsf(cvValPrint - 5.0f);

  1256. 						}

  1257. 						if (cvValPrint > 9.975f)

  1258. 							snprintf(displayStr, 5, "  10");

  1259. 						else if (cvValPrint < 0.025f)

  1260. 							snprintf(displayStr, 5, "   0");

  1261. 						else {

  1262. 							snprintf(displayStr, 5, "%3.2f", cvValPrint);// Three-wide, two positions after the decimal, left-justified

  1263. 							displayStr[1] = '.';// in case locals in printf

  1264. 						}							

  1265. 					}

  1266. 				}

  1267. 			}

  1268. 			else 				

  1269. 				snprintf(displayStr, 5, "  - ");

  1270. 			return ret;

  1271. 		}

  1272. 	};

  1273. 	

  1274. 

  1275. 	struct SeqEditDisplayWidget : DisplayWidget<3> {

  1276. 		SeqEditDisplayWidget(Vec _pos, Vec _size, Foundry *_module) : DisplayWidget(_pos, _size, _module) {};

  1277. 		

  1278. 		char printText() override {

  1279. 			switch (module->displayState) {

  1280. 			

  1281. 				case Foundry::DISP_PPQN :

  1282. 				case Foundry::DISP_DELAY :

  1283. 					snprintf(displayStr, 4, " - ");

  1284. 				break;

  1285. 				case Foundry::DISP_REPS :

  1286. 					snprintf(displayStr, 4, "R%2u", (unsigned) module->seq.getPhraseReps());

  1287. 				break;

  1288. 				case Foundry::DISP_COPY_SEQ :

  1289. 					snprintf(displayStr, 4, "CPY");

  1290. 				break;

  1291. 				case Foundry::DISP_PASTE_SEQ :

  1292. 					snprintf(displayStr, 4, "PST");

  1293. 				break;

  1294. 				case Foundry::DISP_LEN :

  1295. 					snprintf(displayStr, 4, "L%2u", (unsigned) module->seq.getLength());

  1296. 				break;

  1297. 				case Foundry::DISP_TRANSPOSE :

  1298. 				{

  1299. 					int tranOffset = module->seq.getTransposeOffset();

  1300. 					snprintf(displayStr, 4, "+%2u", (unsigned) abs(tranOffset));

  1301. 					if (tranOffset < 0)

  1302. 						displayStr[0] = '-';

  1303. 				}

  1304. 				break;

  1305. 				case Foundry::DISP_ROTATE :

  1306. 				{

  1307. 					int rotOffset = module->seq.getRotateOffset();

  1308. 					snprintf(displayStr, 4, ")%2u", (unsigned) abs(rotOffset));

  1309. 					if (rotOffset < 0)

  1310. 						displayStr[0] = '(';

  1311. 				}

  1312. 				break;

  1313. 				default :

  1314. 					// two paths below are equivalent when attached, so no need to check attached

  1315. 					if (module->isEditingSequence()) {

  1316. 						snprintf(displayStr, 4, " %2u", (unsigned)(module->seq.getSeqIndexEdit() + 1) );

  1317. 						// if (module->displayState == Foundry::DISP_MODE_SEQ) {// Arrow

  1318. 							// displayStr[0] = displayStr[1];

  1319. 							// displayStr[1] = displayStr[2];

  1320. 							// displayStr[2] = ')';

  1321. 						// }

  1322. 				break;

  1323. 

  1324. 					}

  1325. 					else

  1326. 						snprintf(displayStr, 4, " %2u", (unsigned)(module->seq.getPhraseSeq() + 1) );

  1327. 			}

  1328. 			return 0;

  1329. 		}

  1330. 	};

  1331. 	

  1332. 

  1333. 	struct PhrEditDisplayWidget : DisplayWidget<3> {

  1334. 		PhrEditDisplayWidget(Vec _pos, Vec _size, Foundry *_module) : DisplayWidget(_pos, _size, _module) {};

  1335. 

  1336. 		char printText() override {

  1337. 			char overlayChar = 0;// extra char to print an end symbol overlaped (begin symbol done in here)

  1338. 

  1339. 			if (module->displayState == Foundry::DISP_COPY_SONG) {

  1340. 				snprintf(displayStr, 4, "CPY");

  1341. 			}

  1342. 			else if (module->displayState == Foundry::DISP_PASTE_SONG) {

  1343. 				snprintf(displayStr, 4, "PST");

  1344. 			}

  1345. 			else if (module->displayState == Foundry::DISP_MODE_SONG) {

  1346. 				runModeToStr(module->seq.getRunModeSong());

  1347. 			}

  1348. 			else if (module->displayState == Foundry::DISP_PPQN) {

  1349. 				snprintf(displayStr, 4, "x%2u", (unsigned) module->seq.getPulsesPerStep());

  1350. 			}

  1351. 			else if (module->displayState == Foundry::DISP_DELAY) {

  1352. 				snprintf(displayStr, 4, "D%2u", (unsigned) module->seq.getDelay());

  1353. 			}

  1354. 			else if (module->displayState == Foundry::DISP_MODE_SEQ) {

  1355. 				runModeToStr(module->seq.getRunModeSeq());

  1356. 			}

  1357. 			else { 

  1358. 				if (module->isEditingSequence()) {

  1359. 					snprintf(displayStr, 4, " - ");

  1360. 				}

  1361. 				else { // editing song

  1362. 					int phrn = module->seq.getPhraseIndexEdit(); // good whether attached or not

  1363. 					int phrBeg = module->seq.getBegin();

  1364. 					int phrEnd = module->seq.getEnd();

  1365. 					snprintf(displayStr, 4, " %2u", (unsigned)(phrn + 1));

  1366. 					bool begHere = (phrn == phrBeg);

  1367. 					bool endHere = (phrn == phrEnd);

  1368. 					if (begHere) {

  1369. 						displayStr[0] = '{';

  1370. 						if (endHere)

  1371. 							overlayChar = '}';

  1372. 					}

  1373. 					else if (endHere) {

  1374. 						displayStr[0] = '}';

  1375. 						overlayChar = '_';

  1376. 					}

  1377. 					else if (phrn < phrEnd && phrn > phrBeg)

  1378. 						displayStr[0] = '_';

  1379. 					if (module->displayState == Foundry::DISP_COPY_SONG_CUST) {

  1380. 						overlayChar = 0;

  1381. 						displayStr[0] = (time(0) & 0x1) ? 'C' : ' ';

  1382. 					}

  1383. 				}

  1384. 			}

  1385. 			return overlayChar;

  1386. 		}

  1387. 	};

  1388. 	

  1389. 	

  1390. 	struct TrackDisplayWidget : DisplayWidget<2> {

  1391. 		TrackDisplayWidget(Vec _pos, Vec _size, Foundry *_module) : DisplayWidget(_pos, _size, _module) {};

  1392. 		char printText() override {

  1393. 			int trkn = module->seq.getTrackIndexEdit();

  1394. 			if (module->multiTracks)

  1395. 				snprintf(displayStr, 3, "%c%c", (unsigned)(trkn + 0x41), ((module->multiTracks && (time(0) & 0x1)) ? '*' : ' '));

  1396. 			else {

  1397. 				snprintf(displayStr, 3, " %c", (unsigned)(trkn + 0x41));

  1398. 				// if (module->displayState == Foundry::DISP_MODE_SONG || // Arrow

  1399. 					// module->displayState == Foundry::DISP_PPQN || module->displayState == Foundry::DISP_DELAY)

  1400. 					// displayStr[0] = '(';

  1401. 			}

  1402. 			return 0;

  1403. 		}

  1404. 	};

  1405. 	

  1406. 

  1407. 	struct PanelThemeItem : MenuItem {

  1408. 		Foundry *module;

  1409. 		int theme;

  1410. 		void onAction(EventAction &e) override {

  1411. 			module->panelTheme = theme;

  1412. 		}

  1413. 		void step() override {

  1414. 			rightText = (module->panelTheme == theme) ? "✔" : "";

  1415. 		}

  1416. 	};

  1417. 	struct ExpansionItem : MenuItem {

  1418. 		Foundry *module;

  1419. 		void onAction(EventAction &e) override {

  1420. 			module->expansion = module->expansion == 1 ? 0 : 1;

  1421. 		}

  1422. 	};

  1423. 	struct ResetOnRunItem : MenuItem {

  1424. 		Foundry *module;

  1425. 		void onAction(EventAction &e) override {

  1426. 			module->resetOnRun = !module->resetOnRun;

  1427. 		}

  1428. 	};

  1429. 	struct AutoStepLenItem : MenuItem {

  1430. 		Foundry *module;

  1431. 		void onAction(EventAction &e) override {

  1432. 			module->autostepLen = !module->autostepLen;

  1433. 		}

  1434. 	};

  1435. 	struct AutoseqItem : MenuItem {

  1436. 		Foundry *module;

  1437. 		void onAction(EventAction &e) override {

  1438. 			module->autoseq = !module->autoseq;

  1439. 		}

  1440. 	};

  1441. 	struct SeqCVmethodItem : MenuItem {

  1442. 		Foundry *module;

  1443. 		void onAction(EventAction &e) override {

  1444. 			module->seqCVmethod++;

  1445. 			if (module->seqCVmethod > 2)

  1446. 				module->seqCVmethod = 0;

  1447. 		}

  1448. 		void step() override {

  1449. 			if (module->seqCVmethod == 0)

  1450. 				text = "Seq CV in: <0-10V>,  C2-D7#,  Trig-Incr";

  1451. 			else if (module->seqCVmethod == 1)

  1452. 				text = "Seq CV in: 0-10V,  <C2-D7#>,  Trig-Incr";

  1453. 			else

  1454. 				text = "Seq CV in: 0-10V,  C2-D7#,  <Trig-Incr>";

  1455. 		}	

  1456. 	};

  1457. 	struct VelModeItem : MenuItem {

  1458. 		Foundry *module;

  1459. 		void onAction(EventAction &e) override {

  1460. 			module->velocityMode++;

  1461. 			if (module->velocityMode > 2)

  1462. 				module->velocityMode = 0;

  1463. 		}

  1464. 		void step() override {

  1465. 			if (module->velocityMode == 0)

  1466. 				text = "CV2 mode: <Volts>,  0-127,  Notes";

  1467. 			else if (module->velocityMode == 1)

  1468. 				text = "CV2 mode: Volts,  <0-127>,  Notes";

  1469. 			else

  1470. 				text = "CV2 mode: Volts,  0-127,  <Notes>";

  1471. 		}	

  1472. 	};

  1473. 	struct VelBipolItem : MenuItem {

  1474. 		Foundry *module;

  1475. 		void onAction(EventAction &e) override {

  1476. 			module->velocityBipol = !module->velocityBipol;

  1477. 		}

  1478. 	};

  1479. 	struct HoldTiedItem : MenuItem {

  1480. 		Foundry *module;

  1481. 		void onAction(EventAction &e) override {

  1482. 			module->holdTiedNotes = !module->holdTiedNotes;

  1483. 		}

  1484. 	};

  1485. 	Menu *createContextMenu() override {

  1486. 		Menu *menu = ModuleWidget::createContextMenu();

  1487. 

  1488. 		MenuLabel *spacerLabel = new MenuLabel();

  1489. 		menu->addChild(spacerLabel);

  1490. 

  1491. 		Foundry *module = dynamic_cast<Foundry*>(this->module);

  1492. 		assert(module);

  1493. 

  1494. 		MenuLabel *themeLabel = new MenuLabel();

  1495. 		themeLabel->text = "Panel Theme";

  1496. 		menu->addChild(themeLabel);

  1497. 

  1498. 		PanelThemeItem *lightItem = new PanelThemeItem();

  1499. 		lightItem->text = lightPanelID;// ImpromptuModular.hpp

  1500. 		lightItem->module = module;

  1501. 		lightItem->theme = 0;

  1502. 		menu->addChild(lightItem);

  1503. 

  1504. 		PanelThemeItem *metalItem = new PanelThemeItem();

  1505. 		metalItem->text = "Liquid metal";// ImpromptuModular.hpp

  1506. 		metalItem->module = module;

  1507. 		metalItem->theme = 1;

  1508. 		menu->addChild(metalItem);

  1509. 

  1510. 		PanelThemeItem *darkItem = new PanelThemeItem();

  1511. 		darkItem->text = darkPanelID;// ImpromptuModular.hpp

  1512. 		darkItem->module = module;

  1513. 		darkItem->theme = 2;

  1514. 		menu->addChild(darkItem);

  1515. 

  1516. 		menu->addChild(new MenuLabel());// empty line

  1517. 		

  1518. 		MenuLabel *settingsLabel = new MenuLabel();

  1519. 		settingsLabel->text = "Settings";

  1520. 		menu->addChild(settingsLabel);

  1521. 		

  1522. 		ResetOnRunItem *rorItem = MenuItem::create<ResetOnRunItem>("Reset on run", CHECKMARK(module->resetOnRun));

  1523. 		rorItem->module = module;

  1524. 		menu->addChild(rorItem);

  1525. 

  1526. 		AutoStepLenItem *astlItem = MenuItem::create<AutoStepLenItem>("AutoStep write bounded by seq length", CHECKMARK(module->autostepLen));

  1527. 		astlItem->module = module;

  1528. 		menu->addChild(astlItem);

  1529. 

  1530. 		AutoseqItem *aseqItem = MenuItem::create<AutoseqItem>("AutoSeq when writing via CV inputs", CHECKMARK(module->autoseq));

  1531. 		aseqItem->module = module;

  1532. 		menu->addChild(aseqItem);

  1533. 

  1534. 		HoldTiedItem *holdItem = MenuItem::create<HoldTiedItem>("Hold tied notes", CHECKMARK(module->holdTiedNotes));

  1535. 		holdItem->module = module;

  1536. 		menu->addChild(holdItem);

  1537. 

  1538. 		VelBipolItem *bipolItem = MenuItem::create<VelBipolItem>("CV2 bipolar", CHECKMARK(module->velocityBipol));

  1539. 		bipolItem->module = module;

  1540. 		menu->addChild(bipolItem);

  1541. 		

  1542. 		VelModeItem *velItem = MenuItem::create<VelModeItem>("CV2 mode: ", "");

  1543. 		velItem->module = module;

  1544. 		menu->addChild(velItem);

  1545. 		

  1546. 		SeqCVmethodItem *seqcvItem = MenuItem::create<SeqCVmethodItem>("Seq CV in: ", "");

  1547. 		seqcvItem->module = module;

  1548. 		menu->addChild(seqcvItem);

  1549. 		

  1550. 		menu->addChild(new MenuLabel());// empty line

  1551. 		

  1552. 		MenuLabel *expansionLabel = new MenuLabel();

  1553. 		expansionLabel->text = "Expansion module";

  1554. 		menu->addChild(expansionLabel);

  1555. 

  1556. 		std::string expansionMenuLabel32EX(expansionMenuLabel);

  1557. 		std::replace( expansionMenuLabel32EX.begin(), expansionMenuLabel32EX.end(), '4', '7');

  1558. 		ExpansionItem *expItem = MenuItem::create<ExpansionItem>(expansionMenuLabel32EX, CHECKMARK(module->expansion != 0));

  1559. 		expItem->module = module;

  1560. 		menu->addChild(expItem);

  1561. 		

  1562. 		return menu;

  1563. 	}	

  1564. 	

  1565. 	void step() override {

  1566. 		if(module->expansion != oldExpansion) {

  1567. 			if (oldExpansion != -1 && module->expansion == 0) {// if just removed expansion panel, disconnect wires to those jacks

  1568. 				for (int i = 0; i < 12; i++)

  1569. 					RACK_PLUGIN_UI_RACKWIDGET->wireContainer->removeAllWires(expPorts[i]);

  1570. 				module->writeMode = 0;

  1571. 			}

  1572. 			oldExpansion = module->expansion;		

  1573. 		}

  1574. 		box.size.x = panel->box.size.x - (1 - module->expansion) * expWidth;

  1575. 		Widget::step();

  1576. 	}

  1577. 	

  1578. 	struct CKSSNotify : CKSS {// Not randomizable

  1579. 		CKSSNotify() {}

  1580. 		void randomize() override {}

  1581. 		void onChange(EventChange &e) override {

  1582. 			((Foundry*)(module))->displayState = Foundry::DISP_NORMAL;

  1583. 			if (paramId != Foundry::KEY_GATE_PARAM) {

  1584. 				((Foundry*)(module))->multiSteps = false;

  1585. 			}

  1586. 			SVGSwitch::onChange(e);		

  1587. 		}

  1588. 	};

  1589. 	struct CKSSHThreeNotify : CKSSHThree {

  1590. 		CKSSHThreeNotify() {};

  1591. 		void onChange(EventChange &e) override {

  1592. 			((Foundry*)(module))->displayState = Foundry::DISP_NORMAL;

  1593. 			SVGSwitch::onChange(e);		

  1594. 		}

  1595. 	};

  1596. 	struct CPModeSwitch : CKSSThreeInvNoRandom {// Not randomizable

  1597. 		CPModeSwitch() {};

  1598. 		void onChange(EventChange &e) override {

  1599. 			SVGSwitch::onChange(e);	

  1600. 			Foundry* module = dynamic_cast<Foundry*>(this->module);			

  1601. 			module->cpSeqLength = module->getCPMode();

  1602. 			if (module->displayState == Foundry::DISP_COPY_SONG_CUST)

  1603. 				module->displayState = Foundry::DISP_NORMAL;

  1604. 		}

  1605. 	};

  1606. 	struct VelocityKnob : IMMediumKnobInf {

  1607. 		VelocityKnob() {};		

  1608. 		void onMouseDown(EventMouseDown &e) override {// from ParamWidget.cpp

  1609. 			Foundry* module = dynamic_cast<Foundry*>(this->module);

  1610. 			if (e.button == 1) {

  1611. 				// same code structure below as in velocity knob in main step()

  1612. 				if (module->isEditingSequence() && !module->attached) {

  1613. 					int multiStepsCount = module->multiSteps ? module->getCPMode() : 1;

  1614. 					if (module->velEditMode == 2) {

  1615. 						module->seq.initSlideVal(multiStepsCount, module->multiTracks);

  1616. 					}

  1617. 					else if (module->velEditMode == 1) {

  1618. 						module->seq.initGatePVal(multiStepsCount, module->multiTracks);

  1619. 					}

  1620. 					else {

  1621. 						module->seq.initVelocityVal(multiStepsCount, module->multiTracks);

  1622. 					}

  1623. 					module->displayState = Foundry::DISP_NORMAL;

  1624. 				}

  1625. 			}

  1626. 			ParamWidget::onMouseDown(e);

  1627. 		}

  1628. 	};

  1629. 	struct SequenceKnob : IMMediumKnobInf {

  1630. 		SequenceKnob() {};		

  1631. 		void onMouseDown(EventMouseDown &e) override {// from ParamWidget.cpp

  1632. 			Foundry* module = dynamic_cast<Foundry*>(this->module);

  1633. 			if (e.button == 1) {

  1634. 				// same code structure below as in sequence knob in main step()

  1635. 				if (module->displayState == Foundry::DISP_LEN) {

  1636. 					module->seq.initLength(module->multiTracks);

  1637. 				}

  1638. 				else if (module->displayState == Foundry::DISP_TRANSPOSE) {

  1639. 					module->seq.unTransposeSeq(module->multiTracks);

  1640. 				}

  1641. 				else if (module->displayState == Foundry::DISP_ROTATE) {

  1642. 					module->seq.unRotateSeq(module->multiTracks);

  1643. 				}							

  1644. 				else if (module->displayState == Foundry::DISP_REPS) {

  1645. 					module->seq.initPhraseReps(module->multiTracks);

  1646. 				}

  1647. 				else if (!module->attached) {

  1648. 					if (module->isEditingSequence()) {

  1649. 						if (!module->inputs[Foundry::SEQCV_INPUT].active)

  1650. 							module->seq.setSeqIndexEdit(0);

  1651. 					}

  1652. 					else {// editing song

  1653. 						module->seq.initPhraseSeqNum(module->multiTracks);

  1654. 					}

  1655. 					module->displayState = Foundry::DISP_NORMAL;

  1656. 				}

  1657. 			}

  1658. 			ParamWidget::onMouseDown(e);

  1659. 		}

  1660. 	};

  1661. 	struct PhraseKnob : IMMediumKnobInf {

  1662. 		PhraseKnob() {};		

  1663. 		void onMouseDown(EventMouseDown &e) override {// from ParamWidget.cpp

  1664. 			Foundry* module = dynamic_cast<Foundry*>(this->module);

  1665. 			if (e.button == 1) {

  1666. 				// same code structure below as in phrase knob in main step()

  1667. 				if (module->displayState == Foundry::DISP_MODE_SEQ) {

  1668. 					module->seq.initRunModeSeq(module->multiTracks);

  1669. 				}

  1670. 				else if (module->displayState == Foundry::DISP_PPQN) {

  1671. 					module->seq.initPulsesPerStep(module->multiTracks);

  1672. 				}

  1673. 				else if (module->displayState == Foundry::DISP_DELAY) {

  1674. 					module->seq.initDelay(module->multiTracks);

  1675. 				}

  1676. 				else if (module->displayState == Foundry::DISP_MODE_SONG) {

  1677. 					module->seq.initRunModeSong(module->multiTracks);

  1678. 				}

  1679. 				else if (!module->isEditingSequence() && !module->attached) {

  1680. 					module->seq.setPhraseIndexEdit(0);

  1681. 					module->displayState = Foundry::DISP_NORMAL;

  1682. 				}

  1683. 			}

  1684. 			ParamWidget::onMouseDown(e);

  1685. 		}

  1686. 	};

  1687. 		

  1688. 	FoundryWidget(Foundry *module) : ModuleWidget(module) {

  1689. 		this->module = module;

  1690. 		oldExpansion = -1;

  1691. 		

  1692. 		// Main panel from Inkscape

  1693.         panel = new DynamicSVGPanel();

  1694.         panel->mode = &module->panelTheme;

  1695. 		panel->expWidth = &expWidth;

  1696.         panel->addPanel(SVG::load(assetPlugin(plugin, "res/light/Foundry.svg")));

  1697.         panel->addPanel(SVG::load(assetPlugin(plugin, "res/light/Foundry_metal.svg")));

  1698.         panel->addPanel(SVG::load(assetPlugin(plugin, "res/dark/Foundry_dark.svg")));

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

  1700. 		box.size.x = box.size.x - (1 - module->expansion) * expWidth;

  1701.         addChild(panel);

  1702. 		

  1703. 		// Screws

  1704. 		addChild(createDynamicScrew<IMScrew>(Vec(15, 0), &module->panelTheme));

  1705. 		addChild(createDynamicScrew<IMScrew>(Vec(15, 365), &module->panelTheme));

  1706. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30, 0), &module->panelTheme));

  1707. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30, 365), &module->panelTheme));

  1708. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30-expWidth, 0), &module->panelTheme));

  1709. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-30-expWidth, 365), &module->panelTheme));

  1710. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-expWidth + 15, 0), &module->panelTheme));

  1711. 		addChild(createDynamicScrew<IMScrew>(Vec(panel->box.size.x-expWidth + 15, 365), &module->panelTheme));

  1712. 

  1713. 		

  1714. 		

  1715. 		// ****** Top row ******

  1716. 		

  1717. 		static const int rowRulerT0 = 56;

  1718. 		static const int columnRulerT0 = 25;// Step/Phase LED buttons

  1719. 		static const int columnRulerT1 = 373;// Select (multi-steps) 

  1720. 		static const int columnRulerT2 = 426;// Copy-paste-select mode switch

  1721. 		//static const int columnRulerT3 = 463;// Copy paste buttons (not needed when align to track display)

  1722. 		static const int columnRulerT5 = 538;// Edit mode switch (and overview switch also)

  1723. 		static const int stepsOffsetY = 10;

  1724. 		static const int posLEDvsButton = 26;

  1725. 

  1726. 		// Step LED buttons

  1727. 		int posX = columnRulerT0;

  1728. 		static int spacingSteps = 20;

  1729. 		static int spacingSteps4 = 4;

  1730. 		const int numX = SequencerKernel::MAX_STEPS / 2;

  1731. 		for (int x = 0; x < numX; x++) {

  1732. 			// First row

  1733. 			addParam(createParamCentered<LEDButton>(Vec(posX, rowRulerT0 - stepsOffsetY), module, Foundry::STEP_PHRASE_PARAMS + x, 0.0f, 1.0f, 0.0f));

  1734. 			addChild(createLightCentered<MediumLight<GreenRedWhiteLight>>(Vec(posX, rowRulerT0 - stepsOffsetY), module, Foundry::STEP_PHRASE_LIGHTS + (x * 3)));

  1735. 			// Second row

  1736. 			addParam(createParamCentered<LEDButton>(Vec(posX, rowRulerT0 + stepsOffsetY), module, Foundry::STEP_PHRASE_PARAMS + x + numX, 0.0f, 1.0f, 0.0f));

  1737. 			addChild(createLightCentered<MediumLight<GreenRedWhiteLight>>(Vec(posX, rowRulerT0 + stepsOffsetY), module, Foundry::STEP_PHRASE_LIGHTS + ((x + numX) * 3)));

  1738. 			// step position to next location and handle groups of four

  1739. 			posX += spacingSteps;

  1740. 			if ((x + 1) % 4 == 0)

  1741. 				posX += spacingSteps4;

  1742. 		}

  1743. 		// Sel button

  1744. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(columnRulerT1, rowRulerT0), module, Foundry::SEL_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1745. 		

  1746. 		// Copy-paste and select mode switch (3 position)

  1747. 		addParam(createParamCentered<CPModeSwitch>(Vec(columnRulerT2, rowRulerT0), module, Foundry::CPMODE_PARAM, 0.0f, 2.0f, 0.0f));	// 0.0f is top position

  1748. 		

  1749. 		// Copy/paste buttons

  1750. 		// see under Track display

  1751. 		

  1752. 		// Main switch

  1753. 		addParam(createParamCentered<CKSSNotify>(Vec(columnRulerT5, rowRulerT0), module, Foundry::EDIT_PARAM, 0.0f, 1.0f, 0.0f));// 1.0f is top position

  1754. 

  1755. 		

  1756. 		

  1757. 		// ****** Octave and keyboard area ******

  1758. 		

  1759. 		// Octave LED buttons

  1760. 		static const int octLightsIntY = 20;

  1761. 		static const int rowRulerOct = 111;

  1762. 		for (int i = 0; i < 7; i++) {

  1763. 			addParam(createParamCentered<LEDButton>(Vec(columnRulerT0, rowRulerOct + i * octLightsIntY), module, Foundry::OCTAVE_PARAM + i, 0.0f, 1.0f, 0.0f));

  1764. 			addChild(createLightCentered<MediumLight<RedLight>>(Vec(columnRulerT0, rowRulerOct + i * octLightsIntY), module, Foundry::OCTAVE_LIGHTS + i));

  1765. 		}

  1766. 		

  1767. 		// Keys and Key lights

  1768. 		static const int keyNudgeX = 2;

  1769. 		static const int KeyBlackY = 103;

  1770. 		static const int KeyWhiteY = 141;

  1771. 		static const int offsetKeyLEDx = 6;

  1772. 		static const int offsetKeyLEDy = 16;

  1773. 		// Black keys and lights

  1774. 		addParam(createParam<InvisibleKeySmall>(			Vec(65+keyNudgeX, KeyBlackY), module, Foundry::KEY_PARAMS + 1, 0.0, 1.0, 0.0));

  1775. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(65+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 1 * 2));

  1776. 		addParam(createParam<InvisibleKeySmall>(			Vec(93+keyNudgeX, KeyBlackY), module, Foundry::KEY_PARAMS + 3, 0.0, 1.0, 0.0));

  1777. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(93+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 3 * 2));

  1778. 		addParam(createParam<InvisibleKeySmall>(			Vec(150+keyNudgeX, KeyBlackY), module, Foundry::KEY_PARAMS + 6, 0.0, 1.0, 0.0));

  1779. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(150+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 6 * 2));

  1780. 		addParam(createParam<InvisibleKeySmall>(			Vec(178+keyNudgeX, KeyBlackY), module, Foundry::KEY_PARAMS + 8, 0.0, 1.0, 0.0));

  1781. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(178+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 8 * 2));

  1782. 		addParam(createParam<InvisibleKeySmall>(			Vec(206+keyNudgeX, KeyBlackY), module, Foundry::KEY_PARAMS + 10, 0.0, 1.0, 0.0));

  1783. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(206+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 10 * 2));

  1784. 		// White keys and lights

  1785. 		addParam(createParam<InvisibleKeySmall>(			Vec(51+keyNudgeX, KeyWhiteY), module, Foundry::KEY_PARAMS + 0, 0.0, 1.0, 0.0));

  1786. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(51+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 0 * 2));

  1787. 		addParam(createParam<InvisibleKeySmall>(			Vec(79+keyNudgeX, KeyWhiteY), module, Foundry::KEY_PARAMS + 2, 0.0, 1.0, 0.0));

  1788. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(79+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 2 * 2));

  1789. 		addParam(createParam<InvisibleKeySmall>(			Vec(107+keyNudgeX, KeyWhiteY), module, Foundry::KEY_PARAMS + 4, 0.0, 1.0, 0.0));

  1790. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(107+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 4 * 2));

  1791. 		addParam(createParam<InvisibleKeySmall>(			Vec(136+keyNudgeX, KeyWhiteY), module, Foundry::KEY_PARAMS + 5, 0.0, 1.0, 0.0));

  1792. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(136+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 5 * 2));

  1793. 		addParam(createParam<InvisibleKeySmall>(			Vec(164+keyNudgeX, KeyWhiteY), module, Foundry::KEY_PARAMS + 7, 0.0, 1.0, 0.0));

  1794. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(164+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 7 * 2));

  1795. 		addParam(createParam<InvisibleKeySmall>(			Vec(192+keyNudgeX, KeyWhiteY), module, Foundry::KEY_PARAMS + 9, 0.0, 1.0, 0.0));

  1796. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(192+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 9 * 2));

  1797. 		addParam(createParam<InvisibleKeySmall>(			Vec(220+keyNudgeX, KeyWhiteY), module, Foundry::KEY_PARAMS + 11, 0.0, 1.0, 0.0));

  1798. 		addChild(createLight<MediumLight<GreenRedLight>>(Vec(220+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, Foundry::KEY_LIGHTS + 11 * 2));

  1799. 

  1800. 

  1801. 

  1802. 		// ****** Right side control area ******

  1803. 		

  1804. 		static const int rowRulerDisp = 110;

  1805. 		static const int rowRulerKnobs = 145;

  1806. 		static const int rowRulerSmallButtons = 189;

  1807. 		static const int displayWidths = 48; // 43 for 14pt, 46 for 15pt

  1808. 		static const int displayHeights = 24; // 22 for 14pt, 24 for 15pt

  1809. 		static const int displaySpacingX = 62;

  1810. 

  1811. 		// Velocity display

  1812. 		static const int colRulerVel = 289;

  1813. 		static const int trkButtonsOffsetX = 14;

  1814. 		addChild(new VelocityDisplayWidget(Vec(colRulerVel, rowRulerDisp), Vec(displayWidths + 4, displayHeights), module));// 3 characters

  1815. 		// Velocity knob

  1816. 		addParam(createDynamicParamCentered<VelocityKnob>(Vec(colRulerVel, rowRulerKnobs), module, Foundry::VEL_KNOB_PARAM, -INFINITY, INFINITY, 0.0f, &module->panelTheme));	

  1817. 		// Veocity mode button and lights

  1818. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerVel - trkButtonsOffsetX - 2, rowRulerSmallButtons), module, Foundry::VEL_EDIT_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1819. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(Vec(colRulerVel + 4, rowRulerSmallButtons), module, Foundry::VEL_PROB_LIGHT));

  1820. 		addChild(createLightCentered<MediumLight<RedLight>>(Vec(colRulerVel + 20, rowRulerSmallButtons), module, Foundry::VEL_SLIDE_LIGHT));

  1821. 		

  1822. 

  1823. 		// Seq edit display 

  1824. 		static const int colRulerEditSeq = colRulerVel + displaySpacingX + 3;

  1825. 		addChild(new SeqEditDisplayWidget(Vec(colRulerEditSeq, rowRulerDisp), Vec(displayWidths, displayHeights), module));// 5 characters

  1826. 		// Sequence-edit knob

  1827. 		addParam(createDynamicParamCentered<SequenceKnob>(Vec(colRulerEditSeq, rowRulerKnobs), module, Foundry::SEQUENCE_PARAM, -INFINITY, INFINITY, 0.0f, &module->panelTheme));		

  1828. 		// Transpose/rotate button

  1829. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerEditSeq, rowRulerSmallButtons), module, Foundry::TRAN_ROT_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1830. 	

  1831. 			

  1832. 		// Phrase edit display 

  1833. 		static const int colRulerEditPhr = colRulerEditSeq + displaySpacingX + 1;

  1834. 		addChild(new PhrEditDisplayWidget(Vec(colRulerEditPhr, rowRulerDisp), Vec(displayWidths, displayHeights), module));// 5 characters

  1835. 		// Phrase knob

  1836. 		addParam(createDynamicParamCentered<PhraseKnob>(Vec(colRulerEditPhr, rowRulerKnobs), module, Foundry::PHRASE_PARAM, -INFINITY, INFINITY, 0.0f, &module->panelTheme));		

  1837. 		// Begin/end buttons

  1838. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerEditPhr - trkButtonsOffsetX, rowRulerSmallButtons), module, Foundry::BEGIN_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1839. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerEditPhr + trkButtonsOffsetX, rowRulerSmallButtons), module, Foundry::END_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1840. 

  1841. 				

  1842. 		// Track display

  1843. 		static const int colRulerTrk = colRulerEditPhr + displaySpacingX;

  1844. 		addChild(new TrackDisplayWidget(Vec(colRulerTrk, rowRulerDisp), Vec(displayWidths - 13, displayHeights), module));// 2 characters

  1845. 		// Track buttons

  1846. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerTrk + trkButtonsOffsetX, rowRulerKnobs), module, Foundry::TRACKUP_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1847. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerTrk - trkButtonsOffsetX, rowRulerKnobs), module, Foundry::TRACKDOWN_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1848. 		// AllTracks button

  1849. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerTrk, rowRulerSmallButtons - 12), module, Foundry::ALLTRACKS_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1850. 		// Copy/paste buttons

  1851. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerTrk - trkButtonsOffsetX, rowRulerT0), module, Foundry::COPY_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1852. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerTrk + trkButtonsOffsetX, rowRulerT0), module, Foundry::PASTE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1853. 	

  1854. 	

  1855. 		// Attach button and light

  1856. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(columnRulerT5 - 10, rowRulerDisp + 4), module, Foundry::ATTACH_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1857. 		addChild(createLightCentered<MediumLight<RedLight>>(Vec(columnRulerT5 + 10, rowRulerDisp + 4), module, Foundry::ATTACH_LIGHT));

  1858. 	

  1859. 	

  1860. 		// ****** Gate and slide section ******

  1861. 		

  1862. 		static const int rowRulerMB0 = rowRulerOct + 6 * octLightsIntY;

  1863. 		static const int columnRulerMB3 = colRulerVel - displaySpacingX;

  1864. 		static const int columnRulerMB2 = colRulerVel - 2 * displaySpacingX;

  1865. 		static const int columnRulerMB1 = colRulerVel - 3 * displaySpacingX;

  1866. 		

  1867. 		// Key mode LED buttons	

  1868. 		static const int colRulerKM = 61;

  1869. 		addParam(createParamCentered<CKSSNotify>(Vec(colRulerKM, rowRulerMB0), module, Foundry::KEY_GATE_PARAM, 0.0f, 1.0f, 1.0f));

  1870. 		

  1871. 		// Gate 1 light and button

  1872. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(Vec(columnRulerMB1 + posLEDvsButton, rowRulerMB0), module, Foundry::GATE_LIGHT));		

  1873. 		addParam(createDynamicParamCentered<IMBigPushButton>(Vec(columnRulerMB1, rowRulerMB0), module, Foundry::GATE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1874. 		// Tie light and button

  1875. 		addChild(createLightCentered<MediumLight<RedLight>>(Vec(columnRulerMB2 + posLEDvsButton, rowRulerMB0), module, Foundry::TIE_LIGHT));		

  1876. 		addParam(createDynamicParamCentered<IMBigPushButton>(Vec(columnRulerMB2, rowRulerMB0), module, Foundry::TIE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1877. 		// Gate 1 probability light and button

  1878. 		addChild(createLightCentered<MediumLight<GreenRedLight>>(Vec(columnRulerMB3 + posLEDvsButton, rowRulerMB0), module, Foundry::GATE_PROB_LIGHT));		

  1879. 		addParam(createDynamicParamCentered<IMBigPushButton>(Vec(columnRulerMB3, rowRulerMB0), module, Foundry::GATE_PROB_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1880. 		

  1881. 		// Slide light and button

  1882. 		addChild(createLightCentered<MediumLight<RedLight>>(Vec(colRulerVel + posLEDvsButton, rowRulerMB0), module, Foundry::SLIDE_LIGHT));		

  1883. 		addParam(createDynamicParamCentered<IMBigPushButton>(Vec(colRulerVel, rowRulerMB0), module, Foundry::SLIDE_BTN_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1884. 		// Mode button

  1885. 		addParam(createDynamicParamCentered<IMBigPushButton>(Vec(colRulerEditPhr, rowRulerMB0), module, Foundry::MODE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1886. 		// Rep/Len button

  1887. 		addParam(createDynamicParamCentered<IMBigPushButton>(Vec(colRulerEditSeq, rowRulerMB0), module, Foundry::REP_LEN_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1888. 		// Clk res

  1889. 		addParam(createDynamicParamCentered<IMBigPushButton>(Vec(colRulerTrk, rowRulerMB0), module, Foundry::CLKRES_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1890. 		

  1891. 		// Reset and run LED buttons

  1892. 		static const int colRulerResetRun = columnRulerT5;

  1893. 		// Run LED bezel and light

  1894. 		addParam(createParamCentered<LEDBezel>(Vec(colRulerResetRun, rowRulerSmallButtons - 6), module, Foundry::RUN_PARAM, 0.0f, 1.0f, 0.0f));

  1895. 		addChild(createLightCentered<MuteLight<GreenLight>>(Vec(colRulerResetRun, rowRulerSmallButtons - 6), module, Foundry::RUN_LIGHT));

  1896. 		// Reset LED bezel and light

  1897. 		addParam(createParamCentered<LEDBezel>(Vec(colRulerResetRun, rowRulerMB0), module, Foundry::RESET_PARAM, 0.0f, 1.0f, 0.0f));

  1898. 		addChild(createLightCentered<MuteLight<GreenLight>>(Vec(colRulerResetRun, rowRulerMB0), module, Foundry::RESET_LIGHT));

  1899. 		

  1900. 

  1901. 

  1902. 		

  1903. 		// ****** Bottom two rows ******

  1904. 		

  1905. 		static const int rowRulerBLow = 335;

  1906. 		static const int rowRulerBHigh = 286;

  1907. 		

  1908. 		static const int bottomJackSpacingX = 46;

  1909. 		static const int columnRulerB0 = 32;

  1910. 		static const int columnRulerB1 = columnRulerB0 + bottomJackSpacingX;

  1911. 		static const int columnRulerB2 = columnRulerB1 + bottomJackSpacingX;

  1912. 		static const int columnRulerB3 = columnRulerB2 + bottomJackSpacingX;

  1913. 		static const int columnRulerB4 = columnRulerB3 + bottomJackSpacingX;

  1914. 		static const int columnRulerB5 = columnRulerB4 + bottomJackSpacingX;

  1915. 		

  1916. 		static const int columnRulerB6 = columnRulerB5 + bottomJackSpacingX;

  1917. 		static const int columnRulerB7 = columnRulerB6 + bottomJackSpacingX;

  1918. 		static const int columnRulerB8 = columnRulerB7 + bottomJackSpacingX;

  1919. 		static const int columnRulerB9 = columnRulerB8 + bottomJackSpacingX;

  1920. 		static const int columnRulerB10 = columnRulerB9 + bottomJackSpacingX;

  1921. 		static const int columnRulerB11 = columnRulerB10 + bottomJackSpacingX;

  1922. 		

  1923. 

  1924. 		// Autostep and write

  1925. 		addParam(createParamCentered<CKSSNoRandom>(Vec(columnRulerB0, rowRulerBHigh), module, Foundry::AUTOSTEP_PARAM, 0.0f, 1.0f, 1.0f));		

  1926. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB0, rowRulerBLow), Port::INPUT, module, Foundry::WRITE_INPUT, &module->panelTheme));

  1927. 	

  1928. 		// CV IN inputs

  1929. 		static const int writeLEDoffsetX = 16;

  1930. 		static const int writeLEDoffsetY = 18;

  1931. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB1, rowRulerBHigh), Port::INPUT, module, Foundry::CV_INPUTS + 0, &module->panelTheme));

  1932. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(columnRulerB1 + writeLEDoffsetX, rowRulerBHigh + writeLEDoffsetY), module, Foundry::WRITECV_LIGHTS + 0));

  1933. 		

  1934. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB2, rowRulerBHigh), Port::INPUT, module, Foundry::CV_INPUTS + 2, &module->panelTheme));

  1935. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(columnRulerB2 - writeLEDoffsetX, rowRulerBHigh + writeLEDoffsetY), module, Foundry::WRITECV_LIGHTS + 2));

  1936. 

  1937. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB1, rowRulerBLow), Port::INPUT, module, Foundry::CV_INPUTS + 1, &module->panelTheme));

  1938. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(columnRulerB1 + writeLEDoffsetX, rowRulerBLow - writeLEDoffsetY), module, Foundry::WRITECV_LIGHTS + 1));

  1939. 

  1940. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB2, rowRulerBLow), Port::INPUT, module, Foundry::CV_INPUTS + 3, &module->panelTheme));

  1941. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(columnRulerB2 - writeLEDoffsetX, rowRulerBLow - writeLEDoffsetY), module, Foundry::WRITECV_LIGHTS + 3));

  1942. 		

  1943. 		// Clock+CV+Gate+Vel outputs

  1944. 		// Track A

  1945. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB3, rowRulerBHigh), Port::INPUT, module, Foundry::CLOCK_INPUTS + 0, &module->panelTheme));

  1946. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB4, rowRulerBHigh), Port::OUTPUT, module, Foundry::CV_OUTPUTS + 0, &module->panelTheme));

  1947. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB5, rowRulerBHigh), Port::OUTPUT, module, Foundry::GATE_OUTPUTS + 0, &module->panelTheme));

  1948. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB6, rowRulerBHigh), Port::OUTPUT, module, Foundry::VEL_OUTPUTS + 0, &module->panelTheme));

  1949. 		// Track C

  1950. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB7, rowRulerBHigh), Port::INPUT, module, Foundry::CLOCK_INPUTS + 2, &module->panelTheme));

  1951. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB8, rowRulerBHigh), Port::OUTPUT, module, Foundry::CV_OUTPUTS + 2, &module->panelTheme));

  1952. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB9, rowRulerBHigh), Port::OUTPUT, module, Foundry::GATE_OUTPUTS + 2, &module->panelTheme));

  1953. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB10, rowRulerBHigh), Port::OUTPUT, module, Foundry::VEL_OUTPUTS + 2, &module->panelTheme));

  1954. 		//

  1955. 		// Track B

  1956. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB3, rowRulerBLow), Port::INPUT, module, Foundry::CLOCK_INPUTS + 1, &module->panelTheme));

  1957. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB4, rowRulerBLow), Port::OUTPUT, module, Foundry::CV_OUTPUTS + 1, &module->panelTheme));

  1958. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB5, rowRulerBLow), Port::OUTPUT, module, Foundry::GATE_OUTPUTS + 1, &module->panelTheme));

  1959. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB6, rowRulerBLow), Port::OUTPUT, module, Foundry::VEL_OUTPUTS + 1, &module->panelTheme));

  1960. 		// Track D

  1961. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB7, rowRulerBLow), Port::INPUT, module, Foundry::CLOCK_INPUTS + 3, &module->panelTheme));

  1962. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB8, rowRulerBLow), Port::OUTPUT, module, Foundry::CV_OUTPUTS + 3, &module->panelTheme));

  1963. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB9, rowRulerBLow), Port::OUTPUT, module, Foundry::GATE_OUTPUTS + 3, &module->panelTheme));

  1964. 		addOutput(createDynamicPortCentered<IMPort>(Vec(columnRulerB10, rowRulerBLow), Port::OUTPUT, module, Foundry::VEL_OUTPUTS + 3, &module->panelTheme));

  1965. 

  1966. 		// Run and reset inputs

  1967. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB11, rowRulerBHigh), Port::INPUT, module, Foundry::RUNCV_INPUT, &module->panelTheme));

  1968. 		addInput(createDynamicPortCentered<IMPort>(Vec(columnRulerB11, rowRulerBLow), Port::INPUT, module, Foundry::RESET_INPUT, &module->panelTheme));

  1969. 		

  1970. 		

  1971. 		

  1972. 		// Expansion module

  1973. 		static const int rowRulerExpTop = 67;

  1974. 		static const int rowSpacingExp = 51;

  1975. 		static const int colRulerExp = panel->box.size.x - expWidth / 2;

  1976. 		static const int colOffsetX = 23;

  1977. 		addInput(expPorts[4] = createDynamicPortCentered<IMPort>(Vec(colRulerExp - colOffsetX, rowRulerExpTop + rowSpacingExp * 0), Port::INPUT, module, Foundry::SEQCV_INPUT, &module->panelTheme));

  1978. 		addInput(expPorts[5] = createDynamicPortCentered<IMPort>(Vec(colRulerExp + colOffsetX, rowRulerExpTop + rowSpacingExp * 0), Port::INPUT, module, Foundry::TRKCV_INPUT, &module->panelTheme));

  1979. 		

  1980. 		// Step arrow CV inputs

  1981. 		addInput(expPorts[6] = createDynamicPortCentered<IMPort>(Vec(colRulerExp - colOffsetX, rowRulerExpTop + rowSpacingExp * 1), Port::INPUT, module, Foundry::LEFTCV_INPUT, &module->panelTheme));

  1982. 		addInput(expPorts[7] = createDynamicPortCentered<IMPort>(Vec(colRulerExp + colOffsetX, rowRulerExpTop + rowSpacingExp * 1), Port::INPUT, module, Foundry::RIGHTCV_INPUT, &module->panelTheme));

  1983. 

  1984. 		addInput(expPorts[0] = createDynamicPortCentered<IMPort>(Vec(colRulerExp - colOffsetX, rowRulerExpTop + rowSpacingExp * 2), Port::INPUT, module, Foundry::GATECV_INPUT, &module->panelTheme));

  1985. 		addInput(expPorts[1] = createDynamicPortCentered<IMPort>(Vec(colRulerExp + colOffsetX, rowRulerExpTop + rowSpacingExp * 2), Port::INPUT, module, Foundry::TIEDCV_INPUT, &module->panelTheme));

  1986. 		

  1987. 		addInput(expPorts[2] = createDynamicPortCentered<IMPort>(Vec(colRulerExp - colOffsetX, rowRulerExpTop + rowSpacingExp * 3), Port::INPUT, module, Foundry::GATEPCV_INPUT, &module->panelTheme));

  1988. 		addInput(expPorts[3] = createDynamicPortCentered<IMPort>(Vec(colRulerExp + colOffsetX, rowRulerExpTop + rowSpacingExp * 3), Port::INPUT, module, Foundry::SLIDECV_INPUT, &module->panelTheme));

  1989. 		

  1990. 		addParam(createDynamicParamCentered<IMPushButton>(Vec(colRulerExp, rowRulerExpTop + 180), module, Foundry::WRITEMODE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1991. 		

  1992. 		// Velocity inputs 

  1993. 		addInput(expPorts[8] = createDynamicPortCentered<IMPort>(Vec(colRulerExp - colOffsetX, rowRulerBHigh), Port::INPUT, module, Foundry::VEL_INPUTS + 0, &module->panelTheme));

  1994. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(colRulerExp - colOffsetX + writeLEDoffsetX, rowRulerBHigh + writeLEDoffsetY), module, Foundry::WRITECV2_LIGHTS + 0));

  1995. 		

  1996. 		addInput(expPorts[9] = createDynamicPortCentered<IMPort>(Vec(colRulerExp + colOffsetX, rowRulerBHigh), Port::INPUT, module, Foundry::VEL_INPUTS + 2, &module->panelTheme));

  1997. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(colRulerExp + colOffsetX - writeLEDoffsetX, rowRulerBHigh + writeLEDoffsetY), module, Foundry::WRITECV2_LIGHTS + 2));

  1998. 

  1999. 		addInput(expPorts[10] = createDynamicPortCentered<IMPort>(Vec(colRulerExp - colOffsetX, rowRulerBLow), Port::INPUT, module, Foundry::VEL_INPUTS + 1, &module->panelTheme));

  2000. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(colRulerExp - colOffsetX + writeLEDoffsetX, rowRulerBLow - writeLEDoffsetY), module, Foundry::WRITECV2_LIGHTS + 1));

  2001. 

  2002. 		addInput(expPorts[11] = createDynamicPortCentered<IMPort>(Vec(colRulerExp + colOffsetX, rowRulerBLow), Port::INPUT, module, Foundry::VEL_INPUTS + 3, &module->panelTheme));

  2003. 		addChild(createLightCentered<SmallLight<RedLight>>(Vec(colRulerExp + colOffsetX - writeLEDoffsetX, rowRulerBLow - writeLEDoffsetY), module, Foundry::WRITECV2_LIGHTS + 3));

  2004. 	}

  2005. };

  2006. 

  2007. } // namespace rack_plugin_ImpromptuModular

  2008. 

  2009. using namespace rack_plugin_ImpromptuModular;

  2010. 

  2011. RACK_PLUGIN_MODEL_INIT(ImpromptuModular, Foundry) {

  2012.    Model *modelFoundry = Model::create<Foundry, FoundryWidget>("Impromptu Modular", "Foundry", "SEQ - Foundry", SEQUENCER_TAG);

  2013.    return modelFoundry;

  2014. }

  2015. 

  2016. /*CHANGE LOG

  2017. 

  2018. 0.6.16:

  2019. add gate status feedback in steps (white lights)

  2020. 

  2021. 0.6.15:

  2022. save ALL state and don't init ALL nor SEL on run or reset 

  2023. allow END in seq mode to choose custom seq lengths

  2024. add proper CV2 monitoring when not running and editing sequences

  2025. fix TKA song runmode slaving

  2026. add right-click menu option to bound AutoStep writes by sequence lengths

  2027. 

  2028. 0.6.14: 

  2029. allow ctrl-right-click of notes to copy note/gate-type over to next step (not just move to next step)

  2030. add CV IN and CV2 IN LEDs, and make CV2 button, when returning to CV2 mode, toggle which CV or CV2 groups can be written (see LEDs)

  2031. add CV2 bipol option in right click menu; display notes for semitone CV2 mode (now called "Notes")

  2032. rotate offsets are now persistent and stored in the sequencer

  2033. expand TRACK cv input to allow starred tracks (ALL) to be selected, and write CVs only to selected track when not starred

  2034. 

  2035. 0.6.13:

  2036. created

  2037. 

  2038. */