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.
1063 Commits
4 Branches
569MB
Tree: 56c89c433b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '56c89c433b'
${ noResults }
Rack/plugins/community/repos/ImpromptuModular/src/PhraseSeq16.cpp

1713 lines
67KB
Raw Blame History 

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

  2. //Multi-phrase 16 step 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. //Module inspired by the SA-100 Stepper Acid sequencer by Transistor Sounds Labs

  10. //

  11. //Acknowledgements: please see README.md

  12. //***********************************************************************************************

  13. 

  14. 

  15. #include "ImpromptuModular.hpp"

  16. #include "PhraseSeqUtil.hpp"

  17. 

  18. namespace rack_plugin_ImpromptuModular {

  19. 

  20. struct PhraseSeq16 : Module {

  21. 	enum ParamIds {

  22. 		LEFT_PARAM,

  23. 		RIGHT_PARAM,

  24. 		LENGTH_PARAM,

  25. 		EDIT_PARAM,

  26. 		SEQUENCE_PARAM,

  27. 		RUN_PARAM,

  28. 		COPY_PARAM,

  29. 		PASTE_PARAM,

  30. 		RESET_PARAM,

  31. 		ENUMS(OCTAVE_PARAM, 7),

  32. 		GATE1_PARAM,

  33. 		GATE2_PARAM,

  34. 		SLIDE_BTN_PARAM,

  35. 		SLIDE_KNOB_PARAM,

  36. 		ATTACH_PARAM,

  37. 		ROTATEL_PARAM,// no longer used

  38. 		ROTATER_PARAM,// no longer used

  39. 		PASTESYNC_PARAM,// no longer used

  40. 		AUTOSTEP_PARAM,

  41. 		ENUMS(KEY_PARAMS, 12),

  42. 		TRANSPOSEU_PARAM,// no longer used

  43. 		TRANSPOSED_PARAM,// no longer used

  44. 		// -- 0.6.2 ^^

  45. 		RUNMODE_PARAM,

  46. 		TRAN_ROT_PARAM,

  47. 		ROTATE_PARAM,//no longer used

  48. 		GATE1_KNOB_PARAM,

  49. 		GATE2_KNOB_PARAM,// no longer used

  50. 		GATE1_PROB_PARAM,

  51. 		TIE_PARAM,// Legato

  52. 		// -- 0.6.3 ^^

  53. 		CPMODE_PARAM,

  54. 		// -- 0.6.4 ^^

  55. 		NUM_PARAMS

  56. 	};

  57. 	enum InputIds {

  58. 		WRITE_INPUT,

  59. 		CV_INPUT,

  60. 		RESET_INPUT,

  61. 		CLOCK_INPUT,

  62. 		// -- 0.6.2 ^^

  63. 		LEFTCV_INPUT,

  64. 		RIGHTCV_INPUT,

  65. 		RUNCV_INPUT,

  66. 		SEQCV_INPUT,

  67. 		MODECV_INPUT,

  68. 		// -- 0.6.3 ^^

  69. 		// -- 0.6.4 ^^

  70. 		GATE1CV_INPUT,

  71. 		GATE2CV_INPUT,

  72. 		TIEDCV_INPUT,

  73. 		SLIDECV_INPUT,

  74. 		NUM_INPUTS

  75. 	};

  76. 	enum OutputIds {

  77. 		CV_OUTPUT,

  78. 		GATE1_OUTPUT,

  79. 		GATE2_OUTPUT,

  80. 		// -- 0.6.2 ^^

  81. 		// -- 0.6.3 ^^

  82. 		NUM_OUTPUTS

  83. 	};

  84. 	enum LightIds {

  85. 		ENUMS(STEP_PHRASE_LIGHTS, 16 * 2),// room for GreenRed

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

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

  88. 		RUN_LIGHT,

  89. 		RESET_LIGHT,

  90. 		ENUMS(GATE1_LIGHT, 2),// room for GreenRed

  91. 		ENUMS(GATE2_LIGHT, 2),// room for GreenRed

  92. 		SLIDE_LIGHT,

  93. 		ATTACH_LIGHT,

  94. 		PENDING_LIGHT,// no longer used

  95. 		// -- 0.6.2 ^^

  96. 		GATE1_PROB_LIGHT,

  97. 		// -- 0.6.3 ^^

  98. 		TIE_LIGHT,

  99. 		NUM_LIGHTS

  100. 	};

  101. 	

  102. 	enum DisplayStateIds {DISP_NORMAL, DISP_MODE, DISP_TRANSPOSE, DISP_ROTATE};

  103. 	

  104. 

  105. 	// Need to save

  106. 	int panelTheme = 0;

  107. 	int expansion = 0;

  108. 	int pulsesPerStep;// 1 means normal gate mode, alt choices are 4, 6, 12, 24 PPS (Pulses per step)

  109. 	bool running;

  110. 	int runModeSeq[16]; 

  111. 	int runModeSong;

  112. 	//

  113. 	int sequence;

  114. 	int lengths[16];//1 to 16

  115. 	//

  116. 	int phrase[16];// This is the song (series of phases; a phrase is a patten number)

  117. 	int phrases;//1 to 16

  118. 	//

  119. 	float cv[16][16];// [-3.0 : 3.917]. First index is patten number, 2nd index is step

  120. 	int attributes[16][16];// First index is patten number, 2nd index is step (see enum AttributeBitMasks for details)

  121. 	//

  122. 	bool resetOnRun;

  123. 	bool attached;

  124. 

  125. 	// No need to save

  126. 	float resetLight = 0.0f;

  127. 	int stepIndexEdit;

  128. 	int stepIndexRun;

  129. 	int phraseIndexEdit;

  130. 	int phraseIndexRun;

  131. 	unsigned long editingLength;// 0 when not editing length, downward step counter timer when editing length

  132. 	long infoCopyPaste;// 0 when no info, positive downward step counter timer when copy, negative upward when paste

  133. 	unsigned long editingGate;// 0 when no edit gate, downward step counter timer when edit gate

  134. 	float editingGateCV;// no need to initialize, this is a companion to editingGate (output this only when editingGate > 0)

  135. 	int editingGateKeyLight;// no need to initialize, this is a companion to editingGate (use this only when editingGate > 0)

  136. 	int stepIndexRunHistory;// no need to initialize

  137. 	int phraseIndexRunHistory;// no need to initialize

  138. 	int displayState;

  139. 	unsigned long slideStepsRemain;// 0 when no slide under way, downward step counter when sliding

  140. 	float slideCVdelta;// no need to initialize, this is a companion to slideStepsRemain

  141. 	float cvCPbuffer[16];// copy paste buffer for CVs

  142. 	int attributesCPbuffer[16];// copy paste buffer for attributes

  143. 	int lengthCPbuffer;

  144. 	int modeCPbuffer;

  145. 	int countCP;// number of steps to paste (in case CPMODE_PARAM changes between copy and paste)

  146. 	int transposeOffset;// no need to initialize, this is companion to displayMode = DISP_TRANSPOSE

  147. 	int rotateOffset;// no need to initialize, this is companion to displayMode = DISP_ROTATE

  148. 	long clockIgnoreOnReset;

  149. 	const float clockIgnoreOnResetDuration = 0.001f;// disable clock on powerup and reset for 1 ms (so that the first step plays)

  150. 	unsigned long clockPeriod;// counts number of step() calls upward from last clock (reset after clock processed)

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

  152. 	int sequenceKnob = 0;

  153. 	int gate1Code;

  154. 	int gate2Code;

  155. 	long editingGateLength;// 0 when no info, positive downward step counter timer when gate1, negative upward when gate2

  156. 	long editGateLengthTimeInitMult;// multiplier for extended setting of advanced gates

  157. 	long editingPpqn;// 0 when no info, positive downward step counter timer when editing ppqn

  158. 	int ppqnCount;

  159. 	int lightRefreshCounter;

  160. 

  161. 	static constexpr float EDIT_PARAM_INIT_VALUE = 1.0f;// so that module constructor is coherent with widget initialization, since module created before widget

  162. 	bool editingSequence;

  163. 	bool editingSequenceLast;

  164. 

  165. 	

  166. 	SchmittTrigger resetTrigger;

  167. 	SchmittTrigger leftTrigger;

  168. 	SchmittTrigger rightTrigger;

  169. 	SchmittTrigger runningTrigger;

  170. 	SchmittTrigger clockTrigger;

  171. 	SchmittTrigger octTriggers[7];

  172. 	SchmittTrigger octmTrigger;

  173. 	SchmittTrigger gate1Trigger;

  174. 	SchmittTrigger gate1ProbTrigger;

  175. 	SchmittTrigger gate2Trigger;

  176. 	SchmittTrigger slideTrigger;

  177. 	SchmittTrigger lengthTrigger;

  178. 	SchmittTrigger keyTriggers[12];

  179. 	SchmittTrigger writeTrigger;

  180. 	SchmittTrigger attachedTrigger;

  181. 	SchmittTrigger copyTrigger;

  182. 	SchmittTrigger pasteTrigger;

  183. 	SchmittTrigger modeTrigger;

  184. 	SchmittTrigger rotateTrigger;

  185. 	SchmittTrigger transposeTrigger;

  186. 	SchmittTrigger tiedTrigger;

  187. 	HoldDetect modeHoldDetect;

  188. 	HoldDetect gate1HoldDetect;

  189. 	HoldDetect gate2HoldDetect;

  190. 

  191. 	

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

  193. 	inline bool getGate1(int seq, int step) {return getGate1a(attributes[seq][step]);}

  194. 	inline bool getGate1P(int seq, int step) {return getGate1Pa(attributes[seq][step]);}

  195. 	inline bool getGate2(int seq, int step) {return getGate2a(attributes[seq][step]);}

  196. 	inline bool getSlide(int seq, int step) {return getSlideA(attributes[seq][step]);}

  197. 	inline bool getTied(int seq, int step) {return getTiedA(attributes[seq][step]);}

  198. 	inline int getGate1Mode(int seq, int step) {return getGate1aMode(attributes[seq][step]);}

  199. 	inline int getGate2Mode(int seq, int step) {return getGate2aMode(attributes[seq][step]);}

  200. 	

  201. 	inline void setGate1Mode(int seq, int step, int gateMode) {attributes[seq][step] &= ~ATT_MSK_GATE1MODE; attributes[seq][step] |= (gateMode << gate1ModeShift);}

  202. 	inline void setGate2Mode(int seq, int step, int gateMode) {attributes[seq][step] &= ~ATT_MSK_GATE2MODE; attributes[seq][step] |= (gateMode << gate2ModeShift);}

  203. 

  204. 	

  205. 	PhraseSeq16() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  206. 		onReset();

  207. 	}

  208. 	

  209. 

  210. 	void onReset() override {

  211. 		pulsesPerStep = 1;

  212. 		running = false;

  213. 		runModeSong = MODE_FWD;

  214. 		stepIndexEdit = 0;

  215. 		phraseIndexEdit = 0;

  216. 		sequence = 0;

  217. 		phrases = 4;

  218. 		for (int i = 0; i < 16; i++) {

  219. 			for (int s = 0; s < 16; s++) {

  220. 				cv[i][s] = 0.0f;

  221. 				attributes[i][s] = ATT_MSK_GATE1;

  222. 			}

  223. 			runModeSeq[i] = MODE_FWD;

  224. 			phrase[i] = 0;

  225. 			lengths[i] = 16;

  226. 			cvCPbuffer[i] = 0.0f;

  227. 			attributesCPbuffer[i] = ATT_MSK_GATE1;

  228. 		}

  229. 		initRun(true);

  230. 		lengthCPbuffer = 16;

  231. 		modeCPbuffer = MODE_FWD;

  232. 		countCP = 16;

  233. 		editingLength = 0ul;

  234. 		editingGate = 0ul;

  235. 		infoCopyPaste = 0l;

  236. 		displayState = DISP_NORMAL;

  237. 		slideStepsRemain = 0ul;

  238. 		attached = true;

  239. 		clockPeriod = 0ul;

  240. 		tiedWarning = 0ul;

  241. 		editingSequence = EDIT_PARAM_INIT_VALUE > 0.5f;

  242. 		editingSequenceLast = editingSequence;

  243. 		resetOnRun = false;

  244. 		modeHoldDetect.reset();

  245. 		gate1HoldDetect.reset();

  246. 		gate2HoldDetect.reset();

  247. 		editGateLengthTimeInitMult = 1l;

  248. 		editingPpqn = 0l;

  249. 		lightRefreshCounter = 0;

  250. 	}

  251. 

  252. 	

  253. 	void onRandomize() override {

  254. 		running = false;

  255. 		runModeSong = randomu32() % 5;

  256. 		stepIndexEdit = 0;

  257. 		phraseIndexEdit = 0;

  258. 		sequence = randomu32() % 16;

  259. 		phrases = 1 + (randomu32() % 16);

  260. 		for (int i = 0; i < 16; i++) {

  261. 			for (int s = 0; s < 16; s++) {

  262. 				cv[i][s] = ((float)(randomu32() % 7)) + ((float)(randomu32() % 12)) / 12.0f - 3.0f;

  263. 				attributes[i][s] = randomu32() & 0x1FFF;// 5 bit for normal attributes + 2 * 4 bits for advanced gate modes

  264. 				if (getTied(i,s)) {

  265. 					attributes[i][s] = ATT_MSK_TIED;// clear other attributes if tied

  266. 					applyTiedStep(i, s, lengths[i]);

  267. 				}

  268. 			}

  269. 			runModeSeq[i] = randomu32() % NUM_MODES;

  270. 			phrase[i] = randomu32() % 16;

  271. 			lengths[i] = 1 + (randomu32() % 16);

  272. 			cvCPbuffer[i] = 0.0f;

  273. 			attributesCPbuffer[i] = ATT_MSK_GATE1;

  274. 		}

  275. 		initRun(true);

  276. 		lengthCPbuffer = 16;

  277. 		modeCPbuffer = MODE_FWD;

  278. 		countCP = 16;

  279. 		editingLength = 0ul;

  280. 		editingGate = 0ul;

  281. 		infoCopyPaste = 0l;

  282. 		displayState = DISP_NORMAL;

  283. 		slideStepsRemain = 0ul;

  284. 		attached = true;

  285. 		clockPeriod = 0ul;

  286. 		tiedWarning = 0ul;

  287. 		editingSequence = isEditingSequence();

  288. 		editingSequenceLast = editingSequence;

  289. 		resetOnRun = false;

  290. 		modeHoldDetect.reset();

  291. 		gate1HoldDetect.reset();

  292. 		gate2HoldDetect.reset();

  293. 		editGateLengthTimeInitMult = 1l;

  294. 		editingPpqn = 0l;

  295. 	}

  296. 	

  297. 	

  298. 	void initRun(bool hard) {// run button activated or run edge in run input jack or edit mode toggled

  299. 		if (hard) 

  300. 			phraseIndexRun = (runModeSong == MODE_REV ? phrases - 1 : 0);

  301. 		int seq = (editingSequence ? sequence : phrase[phraseIndexRun]);

  302. 		if (hard)	

  303. 			stepIndexRun = (runModeSeq[seq] == MODE_REV ? lengths[seq] - 1 : 0);

  304. 		ppqnCount = 0;

  305. 		gate1Code = calcGate1Code(attributes[seq][stepIndexRun], 0, pulsesPerStep, params[GATE1_KNOB_PARAM].value);

  306. 		gate2Code = calcGate2Code(attributes[seq][stepIndexRun], 0, pulsesPerStep);

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

  308. 		editingGateLength = 0l;

  309. 	}

  310. 	

  311. 	

  312. 	json_t *toJson() override {

  313. 		json_t *rootJ = json_object();

  314. 

  315. 		// panelTheme

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

  317. 

  318. 		// expansion

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

  320. 

  321. 		// pulsesPerStep

  322. 		json_object_set_new(rootJ, "pulsesPerStep", json_integer(pulsesPerStep));

  323. 

  324. 		// running

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

  326. 		

  327. 		// runModeSeq

  328. 		json_t *runModeSeqJ = json_array();

  329. 		for (int i = 0; i < 16; i++)

  330. 			json_array_insert_new(runModeSeqJ, i, json_integer(runModeSeq[i]));

  331. 		json_object_set_new(rootJ, "runModeSeq2", runModeSeqJ);// "2" appended so no break patches

  332. 

  333. 		// runModeSong

  334. 		json_object_set_new(rootJ, "runModeSong", json_integer(runModeSong));

  335. 

  336. 		// sequence

  337. 		json_object_set_new(rootJ, "sequence", json_integer(sequence));

  338. 

  339. 		// lengths

  340. 		json_t *lengthsJ = json_array();

  341. 		for (int i = 0; i < 16; i++)

  342. 			json_array_insert_new(lengthsJ, i, json_integer(lengths[i]));

  343. 		json_object_set_new(rootJ, "lengths", lengthsJ);

  344. 

  345. 		// phrase 

  346. 		json_t *phraseJ = json_array();

  347. 		for (int i = 0; i < 16; i++)

  348. 			json_array_insert_new(phraseJ, i, json_integer(phrase[i]));

  349. 		json_object_set_new(rootJ, "phrase", phraseJ);

  350. 

  351. 		// phrases

  352. 		json_object_set_new(rootJ, "phrases", json_integer(phrases));

  353. 

  354. 		// CV

  355. 		json_t *cvJ = json_array();

  356. 		for (int i = 0; i < 16; i++)

  357. 			for (int s = 0; s < 16; s++) {

  358. 				json_array_insert_new(cvJ, s + (i * 16), json_real(cv[i][s]));

  359. 			}

  360. 		json_object_set_new(rootJ, "cv", cvJ);

  361. 

  362. 		// attributes

  363. 		json_t *attributesJ = json_array();

  364. 		for (int i = 0; i < 16; i++)

  365. 			for (int s = 0; s < 16; s++) {

  366. 				json_array_insert_new(attributesJ, s + (i * 16), json_integer(attributes[i][s]));

  367. 			}

  368. 		json_object_set_new(rootJ, "attributes", attributesJ);

  369. 

  370. 		// attached

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

  372. 

  373. 		// resetOnRun

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

  375. 		

  376. 		return rootJ;

  377. 	}

  378. 

  379. 	void fromJson(json_t *rootJ) override {

  380. 		// panelTheme

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

  382. 		if (panelThemeJ)

  383. 			panelTheme = json_integer_value(panelThemeJ);

  384. 

  385. 		// expansion

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

  387. 		if (expansionJ)

  388. 			expansion = json_integer_value(expansionJ);

  389. 

  390. 		// pulsesPerStep

  391. 		json_t *pulsesPerStepJ = json_object_get(rootJ, "pulsesPerStep");

  392. 		if (pulsesPerStepJ)

  393. 			pulsesPerStep = json_integer_value(pulsesPerStepJ);

  394. 

  395. 		// running

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

  397. 		if (runningJ)

  398. 			running = json_is_true(runningJ);

  399. 

  400. 		// runModeSeq

  401. 		json_t *runModeSeqJ = json_object_get(rootJ, "runModeSeq2");// "2" appended so no break patches

  402. 		if (runModeSeqJ) {

  403. 			for (int i = 0; i < 16; i++)

  404. 			{

  405. 				json_t *runModeSeqArrayJ = json_array_get(runModeSeqJ, i);

  406. 				if (runModeSeqArrayJ)

  407. 					runModeSeq[i] = json_integer_value(runModeSeqArrayJ);

  408. 			}			

  409. 		}		

  410. 		else {// legacy

  411. 			runModeSeqJ = json_object_get(rootJ, "runModeSeq");

  412. 			if (runModeSeqJ)

  413. 				runModeSeq[0] = json_integer_value(runModeSeqJ);

  414. 			for (int i = 1; i < 16; i++)

  415. 				runModeSeq[i] = runModeSeq[0];

  416. 		}

  417. 		

  418. 		// runModeSong

  419. 		json_t *runModeSongJ = json_object_get(rootJ, "runModeSong");

  420. 		if (runModeSongJ)

  421. 			runModeSong = json_integer_value(runModeSongJ);

  422. 		

  423. 		// sequence

  424. 		json_t *sequenceJ = json_object_get(rootJ, "sequence");

  425. 		if (sequenceJ)

  426. 			sequence = json_integer_value(sequenceJ);

  427. 		

  428. 		// lengths

  429. 		json_t *lengthsJ = json_object_get(rootJ, "lengths");

  430. 		if (lengthsJ) {

  431. 			for (int i = 0; i < 16; i++)

  432. 			{

  433. 				json_t *lengthsArrayJ = json_array_get(lengthsJ, i);

  434. 				if (lengthsArrayJ)

  435. 					lengths[i] = json_integer_value(lengthsArrayJ);

  436. 			}			

  437. 		}

  438. 		else {// legacy

  439. 			json_t *stepsJ = json_object_get(rootJ, "steps");

  440. 			if (stepsJ) {

  441. 				int steps = json_integer_value(stepsJ);

  442. 				for (int i = 0; i < 16; i++)

  443. 					lengths[i] = steps;

  444. 			}

  445. 		}

  446. 		

  447. 		// phrase

  448. 		json_t *phraseJ = json_object_get(rootJ, "phrase");

  449. 		if (phraseJ)

  450. 			for (int i = 0; i < 16; i++)

  451. 			{

  452. 				json_t *phraseArrayJ = json_array_get(phraseJ, i);

  453. 				if (phraseArrayJ)

  454. 					phrase[i] = json_integer_value(phraseArrayJ);

  455. 			}

  456. 			

  457. 		// phrases

  458. 		json_t *phrasesJ = json_object_get(rootJ, "phrases");

  459. 		if (phrasesJ)

  460. 			phrases = json_integer_value(phrasesJ);

  461. 		

  462. 		// CV

  463. 		json_t *cvJ = json_object_get(rootJ, "cv");

  464. 		if (cvJ) {

  465. 			for (int i = 0; i < 16; i++)

  466. 				for (int s = 0; s < 16; s++) {

  467. 					json_t *cvArrayJ = json_array_get(cvJ, s + (i * 16));

  468. 					if (cvArrayJ)

  469. 						cv[i][s] = json_real_value(cvArrayJ);

  470. 				}

  471. 		}

  472. 

  473. 		// attributes

  474. 		json_t *attributesJ = json_object_get(rootJ, "attributes");

  475. 		if (attributesJ) {

  476. 			for (int i = 0; i < 16; i++)

  477. 				for (int s = 0; s < 16; s++) {

  478. 					json_t *attributesArrayJ = json_array_get(attributesJ, s + (i * 16));

  479. 					if (attributesArrayJ)

  480. 						attributes[i][s] = json_integer_value(attributesArrayJ);

  481. 				}

  482. 		}

  483. 		else {// legacy

  484. 			for (int i = 0; i < 16; i++)

  485. 				for (int s = 0; s < 16; s++)

  486. 					attributes[i][s] = 0;

  487. 			// gate1

  488. 			json_t *gate1J = json_object_get(rootJ, "gate1");

  489. 			if (gate1J) {

  490. 				for (int i = 0; i < 16; i++)

  491. 					for (int s = 0; s < 16; s++) {

  492. 						json_t *gate1arrayJ = json_array_get(gate1J, s + (i * 16));

  493. 						if (gate1arrayJ)

  494. 							if (!!json_integer_value(gate1arrayJ)) attributes[i][s] |= ATT_MSK_GATE1;

  495. 					}

  496. 			}

  497. 			// gate1Prob

  498. 			json_t *gate1ProbJ = json_object_get(rootJ, "gate1Prob");

  499. 			if (gate1ProbJ) {

  500. 				for (int i = 0; i < 16; i++)

  501. 					for (int s = 0; s < 16; s++) {

  502. 						json_t *gate1ProbarrayJ = json_array_get(gate1ProbJ, s + (i * 16));

  503. 						if (gate1ProbarrayJ)

  504. 							if (!!json_integer_value(gate1ProbarrayJ)) attributes[i][s] |= ATT_MSK_GATE1P;

  505. 					}

  506. 			}

  507. 			// gate2

  508. 			json_t *gate2J = json_object_get(rootJ, "gate2");

  509. 			if (gate2J) {

  510. 				for (int i = 0; i < 16; i++)

  511. 					for (int s = 0; s < 16; s++) {

  512. 						json_t *gate2arrayJ = json_array_get(gate2J, s + (i * 16));

  513. 						if (gate2arrayJ)

  514. 							if (!!json_integer_value(gate2arrayJ)) attributes[i][s] |= ATT_MSK_GATE2;

  515. 					}

  516. 			}

  517. 			// slide

  518. 			json_t *slideJ = json_object_get(rootJ, "slide");

  519. 			if (slideJ) {

  520. 				for (int i = 0; i < 16; i++)

  521. 					for (int s = 0; s < 16; s++) {

  522. 						json_t *slideArrayJ = json_array_get(slideJ, s + (i * 16));

  523. 						if (slideArrayJ)

  524. 							if (!!json_integer_value(slideArrayJ)) attributes[i][s] |= ATT_MSK_SLIDE;

  525. 					}

  526. 			}

  527. 			// tied

  528. 			json_t *tiedJ = json_object_get(rootJ, "tied");

  529. 			if (tiedJ) {

  530. 				for (int i = 0; i < 16; i++)

  531. 					for (int s = 0; s < 16; s++) {

  532. 						json_t *tiedArrayJ = json_array_get(tiedJ, s + (i * 16));

  533. 						if (tiedArrayJ)

  534. 							if (!!json_integer_value(tiedArrayJ)) attributes[i][s] |= ATT_MSK_TIED;

  535. 					}

  536. 			}

  537. 		}

  538. 	

  539. 		// attached

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

  541. 		if (attachedJ)

  542. 			attached = json_is_true(attachedJ);

  543. 		

  544. 		// resetOnRun

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

  546. 		if (resetOnRunJ)

  547. 			resetOnRun = json_is_true(resetOnRunJ);

  548. 

  549. 		// Initialize dependants after everything loaded

  550. 		initRun(true);

  551. 		editingSequence = isEditingSequence();

  552. 		editingSequenceLast = editingSequence;

  553. 	}

  554. 

  555. 

  556. 	void rotateSeq(int seqNum, bool directionRight, int seqLength) {

  557. 		float rotCV;

  558. 		int rotAttributes;

  559. 		int iStart = 0;

  560. 		int iEnd = seqLength - 1;

  561. 		int iRot = iStart;

  562. 		int iDelta = 1;

  563. 		if (directionRight) {

  564. 			iRot = iEnd;

  565. 			iDelta = -1;

  566. 		}

  567. 		rotCV = cv[seqNum][iRot];

  568. 		rotAttributes = attributes[seqNum][iRot];

  569. 		for ( ; ; iRot += iDelta) {

  570. 			if (iDelta == 1 && iRot >= iEnd) break;

  571. 			if (iDelta == -1 && iRot <= iStart) break;

  572. 			cv[seqNum][iRot] = cv[seqNum][iRot + iDelta];

  573. 			attributes[seqNum][iRot] = attributes[seqNum][iRot + iDelta];

  574. 		}

  575. 		cv[seqNum][iRot] = rotCV;

  576. 		attributes[seqNum][iRot] = rotAttributes;

  577. 	}

  578. 	

  579. 

  580. 	// Advances the module by 1 audio frame with duration 1.0 / engineGetSampleRate()

  581. 	void step() override {

  582. 		float sampleRate = engineGetSampleRate();

  583. 		static const float gateTime = 0.4f;// seconds

  584. 		static const float copyPasteInfoTime = 0.5f;// seconds

  585. 		static const float editLengthTime = 2.0f;// seconds

  586. 		static const float tiedWarningTime = 0.7f;// seconds

  587. 		static const float holdDetectTime = 2.0f;// seconds

  588. 		static const float editGateLengthTime = 4.0f;// seconds

  589. 		

  590. 		

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

  592. 		

  593. 		// Notes: 

  594. 		// * a tied step's attributes can not be modified by any of the following: 

  595. 		//   write input, oct and keyboard buttons, gate1Prob and slide buttons

  596. 		//   however, paste, transpose, rotate obviously can, and gate1/2 can be turned back on if desired.

  597. 		// * Whenever cv[][] is modified or tied[] is activated for a step, call applyTiedStep(sequence,stepIndexEdit,steps)

  598. 		

  599. 		// Edit mode

  600. 		editingSequence = isEditingSequence();// true = editing sequence, false = editing song

  601. 		if (editingSequenceLast != editingSequence) {

  602. 			if (running)

  603. 				initRun(true);

  604. 			displayState = DISP_NORMAL;

  605. 			editingSequenceLast = editingSequence;

  606. 		}

  607. 		

  608. 		// Seq CV input

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

  610. 			sequence = (int) clamp( round(inputs[SEQCV_INPUT].value * (16.0f - 1.0f) / 10.0f), 0.0f, (16.0f - 1.0f) );

  611. 		}

  612. 		// Mode CV input

  613. 		if (inputs[MODECV_INPUT].active) {

  614. 			if (editingSequence)

  615. 				runModeSeq[sequence] = (int) clamp( round(inputs[MODECV_INPUT].value * ((float)NUM_MODES - 1.0f) / 10.0f), 0.0f, (float)NUM_MODES - 1.0f );

  616. 		}

  617. 		

  618. 		// Run button

  619. 		if (runningTrigger.process(params[RUN_PARAM].value + inputs[RUNCV_INPUT].value)) {

  620. 			running = !running;

  621. 			if (running)

  622. 				initRun(resetOnRun);

  623. 			displayState = DISP_NORMAL;

  624. 		}

  625. 

  626. 		// Attach button

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

  628. 			if (running)

  629. 				attached = !attached;	

  630. 			displayState = DISP_NORMAL;			

  631. 		}

  632. 		if (running && attached) {

  633. 			if (editingSequence)

  634. 				stepIndexEdit = stepIndexRun;

  635. 			else

  636. 				phraseIndexEdit = phraseIndexRun;

  637. 		}

  638. 		

  639. 		// Copy button

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

  641. 			if (editingSequence) {

  642. 				infoCopyPaste = (long) (copyPasteInfoTime * sampleRate / displayRefreshStepSkips);

  643. 				int sStart = stepIndexEdit;

  644. 				int sCount = 16;

  645. 				if (params[CPMODE_PARAM].value > 1.5f)// all

  646. 					sStart = 0;

  647. 				else if (params[CPMODE_PARAM].value < 0.5f)// 4

  648. 					sCount = 4;

  649. 				else// 8

  650. 					sCount = 8;

  651. 				countCP = sCount;

  652. 				for (int i = 0, s = sStart; i < countCP; i++, s++) {

  653. 					if (s >= 16) s = 0;

  654. 					cvCPbuffer[i] = cv[sequence][s];

  655. 					attributesCPbuffer[i] = attributes[sequence][s];

  656. 					if ((--sCount) <= 0)

  657. 						break;

  658. 				}

  659. 				lengthCPbuffer = lengths[sequence];

  660. 				modeCPbuffer = runModeSeq[sequence];

  661. 			}

  662. 			displayState = DISP_NORMAL;

  663. 		}

  664. 		// Paste button

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

  666. 			if (editingSequence) {

  667. 				infoCopyPaste = (long) (-1 * copyPasteInfoTime * sampleRate / displayRefreshStepSkips);

  668. 				int sStart = ((countCP == 16) ? 0 : stepIndexEdit);

  669. 				int sCount = countCP;

  670. 				for (int i = 0, s = sStart; i < countCP; i++, s++) {

  671. 					if (s >= 16) 

  672. 						break;

  673. 					cv[sequence][s] = cvCPbuffer[i];

  674. 					attributes[sequence][s] = attributesCPbuffer[i];

  675. 					if ((--sCount) <= 0)

  676. 						break;

  677. 				}

  678. 				if (params[CPMODE_PARAM].value > 1.5f) {// all

  679. 					lengths[sequence] = lengthCPbuffer;

  680. 					runModeSeq[sequence] = modeCPbuffer;

  681. 				}

  682. 			}

  683. 			displayState = DISP_NORMAL;

  684. 		}

  685. 

  686. 		// Length button

  687. 		if (lengthTrigger.process(params[LENGTH_PARAM].value)) {

  688. 			if (editingLength > 0ul)

  689. 				editingLength = 0ul;// allow user to quickly leave editing mode when re-press

  690. 			else

  691. 				editingLength = (unsigned long) (editLengthTime * sampleRate / displayRefreshStepSkips);

  692. 			displayState = DISP_NORMAL;

  693. 		}

  694. 		

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

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

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

  698. 		if (writeTrig) {

  699. 			if (editingSequence) {

  700. 				cv[sequence][stepIndexEdit] = inputs[CV_INPUT].value;

  701. 				// Extra CVs from expansion panel:

  702. 				if (inputs[TIEDCV_INPUT].active)

  703. 					setTiedA(&attributes[sequence][stepIndexEdit], inputs[TIEDCV_INPUT].value > 1.0f);

  704. 				if (inputs[GATE1CV_INPUT].active)

  705. 					setGate1a(&attributes[sequence][stepIndexEdit], inputs[GATE1CV_INPUT].value > 1.0f);

  706. 				if (inputs[GATE2CV_INPUT].active)

  707. 					setGate2a(&attributes[sequence][stepIndexEdit], inputs[GATE2CV_INPUT].value > 1.0f);

  708. 				if (inputs[SLIDECV_INPUT].active)

  709. 					setSlideA(&attributes[sequence][stepIndexEdit], inputs[SLIDECV_INPUT].value > 1.0f);			

  710. 				applyTiedStep(sequence, stepIndexEdit, lengths[sequence]);

  711. 				editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  712. 				editingGateCV = cv[sequence][stepIndexEdit];

  713. 				editingGateKeyLight = -1;

  714. 				// Autostep (after grab all active inputs)

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

  716. 					stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + 1, 16);

  717. 			}

  718. 			displayState = DISP_NORMAL;

  719. 		}

  720. 		// Left and Right CV inputs and buttons

  721. 		int delta = 0;

  722. 		if (leftTrigger.process(inputs[LEFTCV_INPUT].value + params[LEFT_PARAM].value)) { 

  723. 			delta = -1;

  724. 			displayState = DISP_NORMAL;

  725. 		}

  726. 		if (rightTrigger.process(inputs[RIGHTCV_INPUT].value + params[RIGHT_PARAM].value)) {

  727. 			delta = +1;

  728. 			displayState = DISP_NORMAL;

  729. 		}

  730. 		if (delta != 0) {

  731. 			if (editingLength > 0ul) {

  732. 				editingLength = (unsigned long) (editLengthTime * sampleRate / displayRefreshStepSkips);// restart editing length timer

  733. 				if (editingSequence) {

  734. 					lengths[sequence] += delta;

  735. 					if (lengths[sequence] > 16) lengths[sequence] = 16;

  736. 					if (lengths[sequence] < 1 ) lengths[sequence] = 1;

  737. 				}

  738. 				else {

  739. 					phrases += delta;

  740. 					if (phrases > 16) phrases = 16;

  741. 					if (phrases < 1 ) phrases = 1;

  742. 				}

  743. 			}

  744. 			else {

  745. 				if (!running || !attached) {// don't move heads when attach and running

  746. 					if (editingSequence) {

  747. 						stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + delta, 16);

  748. 						if (!getTied(sequence,stepIndexEdit)) {// play if non-tied step

  749. 							if (!writeTrig) {// in case autostep when simultaneous writeCV and stepCV (keep what was done in Write Input block above)

  750. 								editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  751. 								editingGateCV = cv[sequence][stepIndexEdit];

  752. 								editingGateKeyLight = -1;

  753. 							}

  754. 						}

  755. 					}

  756. 					else

  757. 						phraseIndexEdit = moveIndex(phraseIndexEdit, phraseIndexEdit + delta, 16);

  758. 				}

  759. 			}

  760. 		}

  761. 		

  762. 		// Mode and Transpose/Rotate buttons

  763. 		if (modeTrigger.process(params[RUNMODE_PARAM].value)) {

  764. 			if (displayState != DISP_MODE)

  765. 				displayState = DISP_MODE;

  766. 			else

  767. 				displayState = DISP_NORMAL;

  768. 			//if (!running) {

  769. 				modeHoldDetect.start((long) (holdDetectTime * sampleRate / displayRefreshStepSkips));

  770. 			//}

  771. 		}

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

  773. 			if (editingSequence) {

  774. 				if (displayState == DISP_NORMAL || displayState == DISP_MODE) {

  775. 					displayState = DISP_TRANSPOSE;

  776. 					transposeOffset = 0;

  777. 				}

  778. 				else if (displayState == DISP_TRANSPOSE) {

  779. 					displayState = DISP_ROTATE;

  780. 					rotateOffset = 0;

  781. 				}

  782. 				else 

  783. 					displayState = DISP_NORMAL;

  784. 			}

  785. 		}			

  786. 		

  787. 		// Sequence knob  

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

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

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

  791. 			sequenceKnob = newSequenceKnob;

  792. 		int deltaKnob = newSequenceKnob - sequenceKnob;

  793. 		if (deltaKnob != 0) {

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

  795. 				 if (editingLength > 0ul) {

  796. 					editingLength = (unsigned long) (editLengthTime * sampleRate / displayRefreshStepSkips);// restart editing length timer

  797. 					if (editingSequence) {

  798. 						lengths[sequence] += deltaKnob;

  799. 						if (lengths[sequence] > 16) lengths[sequence] = 16 ;

  800. 						if (lengths[sequence] < 1 ) lengths[sequence] = 1;

  801. 					}

  802. 					else {

  803. 						phrases += deltaKnob;

  804. 						if (phrases > 16) phrases = 16;

  805. 						if (phrases < 1 ) phrases = 1;

  806. 					}

  807. 				}

  808. 				else if (editingPpqn != 0) {

  809. 					pulsesPerStep = indexToPps(ppsToIndex(pulsesPerStep) + deltaKnob);// indexToPps() does clamping

  810. 					editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  811. 				}

  812. 				else if (displayState == DISP_MODE) {

  813. 					if (editingSequence) {

  814. 						if (!inputs[MODECV_INPUT].active) {

  815. 							runModeSeq[sequence] += deltaKnob;

  816. 							if (runModeSeq[sequence] < 0) runModeSeq[sequence] = 0;

  817. 							if (runModeSeq[sequence] >= NUM_MODES) runModeSeq[sequence] = NUM_MODES - 1;

  818. 						}

  819. 					}

  820. 					else {

  821. 						runModeSong += deltaKnob;

  822. 						if (runModeSong < 0) runModeSong = 0;

  823. 						if (runModeSong >= 5) runModeSong = 5 - 1;

  824. 					}

  825. 				}

  826. 				else if (displayState == DISP_TRANSPOSE) {

  827. 					if (editingSequence) {

  828. 						transposeOffset += deltaKnob;

  829. 						if (transposeOffset > 99) transposeOffset = 99;

  830. 						if (transposeOffset < -99) transposeOffset = -99;						

  831. 						// Tranpose by this number of semi-tones: deltaKnob

  832. 						float transposeOffsetCV = ((float)(deltaKnob))/12.0f;

  833. 						for (int s = 0; s < 16; s++) {

  834. 							cv[sequence][s] += transposeOffsetCV;

  835. 						}

  836. 					}

  837. 				}

  838. 				else if (displayState == DISP_ROTATE) {

  839. 					if (editingSequence) {

  840. 						rotateOffset += deltaKnob;

  841. 						if (rotateOffset > 99) rotateOffset = 99;

  842. 						if (rotateOffset < -99) rotateOffset = -99;	

  843. 						if (deltaKnob > 0 && deltaKnob < 99) {// Rotate right, 99 is safety

  844. 							for (int i = deltaKnob; i > 0; i--)

  845. 								rotateSeq(sequence, true, lengths[sequence]);

  846. 						}

  847. 						if (deltaKnob < 0 && deltaKnob > -99) {// Rotate left, 99 is safety

  848. 							for (int i = deltaKnob; i < 0; i++)

  849. 								rotateSeq(sequence, false, lengths[sequence]);

  850. 						}

  851. 					}						

  852. 				}

  853. 				else {// DISP_NORMAL

  854. 					if (editingSequence) {

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

  856. 							sequence += deltaKnob;

  857. 							if (sequence < 0) sequence = 0;

  858. 							if (sequence >= 16) sequence = (16 - 1);

  859. 						}

  860. 					}

  861. 					else {

  862. 						phrase[phraseIndexEdit] += deltaKnob;

  863. 						if (phrase[phraseIndexEdit] < 0) phrase[phraseIndexEdit] = 0;

  864. 						if (phrase[phraseIndexEdit] >= 16) phrase[phraseIndexEdit] = (16 - 1);				

  865. 					}

  866. 				}

  867. 			}

  868. 			sequenceKnob = newSequenceKnob;

  869. 		}	

  870. 		

  871. 		// Octave buttons

  872. 		int newOct = -1;

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

  874. 			if (octTriggers[i].process(params[OCTAVE_PARAM + i].value)) {

  875. 				newOct = 6 - i;

  876. 				displayState = DISP_NORMAL;

  877. 			}

  878. 		}

  879. 		if (newOct >= 0 && newOct <= 6) {

  880. 			if (editingSequence) {

  881. 				if (getTied(sequence,stepIndexEdit))

  882. 					tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  883. 				else {			

  884. 					float newCV = cv[sequence][stepIndexEdit] + 10.0f;//to properly handle negative note voltages

  885. 					newCV = newCV - floor(newCV) + (float) (newOct - 3);

  886. 					if (newCV >= -3.0f && newCV < 4.0f) {

  887. 						cv[sequence][stepIndexEdit] = newCV;

  888. 						applyTiedStep(sequence, stepIndexEdit, lengths[sequence]);

  889. 					}

  890. 					editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  891. 					editingGateCV = cv[sequence][stepIndexEdit];

  892. 					editingGateKeyLight = -1;

  893. 				}

  894. 			}

  895. 		}		

  896. 		

  897. 		// Keyboard buttons

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

  899. 			if (keyTriggers[i].process(params[KEY_PARAMS + i].value)) {

  900. 				if (editingSequence) {

  901. 					if (editingGateLength != 0l) {

  902. 						int newMode = keyIndexToGateMode(i, pulsesPerStep);

  903. 						if (editingGateLength > 0l) {

  904. 							if (newMode != -1)

  905. 								setGate1Mode(sequence, stepIndexEdit, newMode);

  906. 							else

  907. 								editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  908. 							editingGateLength = ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult);

  909. 						}

  910. 						else {

  911. 							if (newMode != -1)

  912. 								setGate2Mode(sequence, stepIndexEdit, newMode);

  913. 							else

  914. 								editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  915. 							editingGateLength = -1l * ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult);

  916. 						}

  917. 					}

  918. 					else if (getTied(sequence,stepIndexEdit)) {

  919. 						if (params[KEY_PARAMS + i].value > 1.5f)

  920. 							stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + 1, 16);

  921. 						else

  922. 							tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  923. 					}

  924. 					else {			

  925. 						cv[sequence][stepIndexEdit] = floor(cv[sequence][stepIndexEdit]) + ((float) i) / 12.0f;

  926. 						applyTiedStep(sequence, stepIndexEdit, lengths[sequence]);

  927. 						editingGate = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  928. 						editingGateCV = cv[sequence][stepIndexEdit];

  929. 						editingGateKeyLight = -1;

  930. 						if (params[KEY_PARAMS + i].value > 1.5f) {

  931. 							stepIndexEdit = moveIndex(stepIndexEdit, stepIndexEdit + 1, 16);

  932. 							editingGateKeyLight = i;

  933. 						}

  934. 					}						

  935. 				}

  936. 				displayState = DISP_NORMAL;

  937. 			}

  938. 		}

  939. 				

  940. 		// Gate1, Gate1Prob, Gate2, Slide and Tied buttons

  941. 		if (gate1Trigger.process(params[GATE1_PARAM].value)) {

  942. 			if (editingSequence) {

  943. 				toggleGate1a(&attributes[sequence][stepIndexEdit]);

  944. 				//if (!running) {

  945. 					if (pulsesPerStep != 1) {

  946. 						editingGateLength = getGate1(sequence,stepIndexEdit) ? ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult) : 0l;

  947. 						gate1HoldDetect.start((long) (holdDetectTime * sampleRate / displayRefreshStepSkips));

  948. 					}

  949. 				//}

  950. 			}

  951. 			displayState = DISP_NORMAL;

  952. 		}		

  953. 		if (gate1ProbTrigger.process(params[GATE1_PROB_PARAM].value)) {

  954. 			if (editingSequence) {

  955. 				if (getTied(sequence,stepIndexEdit))

  956. 					tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  957. 				else

  958. 					toggleGate1Pa(&attributes[sequence][stepIndexEdit]);

  959. 			}

  960. 			displayState = DISP_NORMAL;

  961. 		}		

  962. 		if (gate2Trigger.process(params[GATE2_PARAM].value)) {

  963. 			if (editingSequence) {

  964. 				toggleGate2a(&attributes[sequence][stepIndexEdit]);

  965. 				//if (!running) {

  966. 					if (pulsesPerStep != 1) {

  967. 						editingGateLength = getGate2(sequence,stepIndexEdit) ? -1l * ((long) (editGateLengthTime * sampleRate / displayRefreshStepSkips) * editGateLengthTimeInitMult) : 0l;

  968. 						gate2HoldDetect.start((long) (holdDetectTime * sampleRate / displayRefreshStepSkips));

  969. 					}

  970. 				//}

  971. 			}

  972. 			displayState = DISP_NORMAL;

  973. 		}		

  974. 		if (slideTrigger.process(params[SLIDE_BTN_PARAM].value)) {

  975. 			if (editingSequence) {

  976. 				if (getTied(sequence,stepIndexEdit))

  977. 					tiedWarning = (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips);

  978. 				else

  979. 					toggleSlideA(&attributes[sequence][stepIndexEdit]);

  980. 			}

  981. 			displayState = DISP_NORMAL;

  982. 		}		

  983. 		if (tiedTrigger.process(params[TIE_PARAM].value)) {

  984. 			if (editingSequence) {

  985. 				toggleTiedA(&attributes[sequence][stepIndexEdit]);

  986. 				if (getTied(sequence,stepIndexEdit)) {

  987. 					setGate1a(&attributes[sequence][stepIndexEdit], false);

  988. 					setGate2a(&attributes[sequence][stepIndexEdit], false);

  989. 					setSlideA(&attributes[sequence][stepIndexEdit], false);

  990. 					applyTiedStep(sequence, stepIndexEdit, lengths[sequence]);

  991. 				}

  992. 			}

  993. 			displayState = DISP_NORMAL;

  994. 		}		

  995. 		

  996. 		

  997. 		//********** Clock and reset **********

  998. 		

  999. 		// Clock

  1000. 		if (clockTrigger.process(inputs[CLOCK_INPUT].value)) {

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

  1002. 				ppqnCount++;

  1003. 				if (ppqnCount >= pulsesPerStep)

  1004. 					ppqnCount = 0;

  1005. 

  1006. 				int newSeq = sequence;// good value when editingSequence, overwrite if not editingSequence

  1007. 				if (ppqnCount == 0) {

  1008. 					float slideFromCV = 0.0f;

  1009. 					if (editingSequence) {

  1010. 						slideFromCV = cv[sequence][stepIndexRun];

  1011. 						moveIndexRunMode(&stepIndexRun, lengths[sequence], runModeSeq[sequence], &stepIndexRunHistory);

  1012. 					}

  1013. 					else {

  1014. 						slideFromCV = cv[phrase[phraseIndexRun]][stepIndexRun];

  1015. 						if (moveIndexRunMode(&stepIndexRun, lengths[phrase[phraseIndexRun]], runModeSeq[phrase[phraseIndexRun]], &stepIndexRunHistory)) {

  1016. 							moveIndexRunMode(&phraseIndexRun, phrases, runModeSong, &phraseIndexRunHistory);

  1017. 							stepIndexRun = (runModeSeq[phrase[phraseIndexRun]] == MODE_REV ? lengths[phrase[phraseIndexRun]] - 1 : 0);// must always refresh after phraseIndexRun has changed

  1018. 						}

  1019. 						newSeq = phrase[phraseIndexRun];

  1020. 					}

  1021. 					

  1022. 					// Slide

  1023. 					if (getSlide(newSeq, stepIndexRun)) {

  1024. 						// activate sliding (slideStepsRemain can be reset, else runs down to 0, either way, no need to reinit)

  1025. 						slideStepsRemain =   (unsigned long) (((float)clockPeriod * pulsesPerStep)   * params[SLIDE_KNOB_PARAM].value / 2.0f);// 0-T slide, where T is clock period (can be too long when user does clock gating)

  1026. 						//slideStepsRemain = (unsigned long)  (engineGetSampleRate() * params[SLIDE_KNOB_PARAM].value );// 0-2s slide

  1027. 						float slideToCV = cv[newSeq][stepIndexRun];

  1028. 						slideCVdelta = (slideToCV - slideFromCV)/(float)slideStepsRemain;

  1029. 					}

  1030. 				}

  1031. 				else {

  1032. 					if (!editingSequence)

  1033. 						newSeq = phrase[phraseIndexRun];

  1034. 				}

  1035. 				if (gate1Code != -1 || ppqnCount == 0)

  1036. 					gate1Code = calcGate1Code(attributes[newSeq][stepIndexRun], ppqnCount, pulsesPerStep, params[GATE1_KNOB_PARAM].value);

  1037. 				gate2Code = calcGate2Code(attributes[newSeq][stepIndexRun], ppqnCount, pulsesPerStep);						 

  1038. 			}

  1039. 			clockPeriod = 0ul;

  1040. 		}	

  1041. 		clockPeriod++;

  1042. 		

  1043. 		// Reset

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

  1045. 			//stepIndexEdit = 0;

  1046. 			//sequence = 0;

  1047. 			initRun(true);// must be after sequence reset

  1048. 			resetLight = 1.0f;

  1049. 			displayState = DISP_NORMAL;

  1050. 			clockTrigger.reset();

  1051. 		}

  1052. 		

  1053. 		

  1054. 		//********** Outputs and lights **********

  1055. 				

  1056. 		// CV and gates outputs

  1057. 		int seq = editingSequence ? (sequence) : (running ? phrase[phraseIndexRun] : phrase[phraseIndexEdit]);

  1058. 		int step = editingSequence ? (running ? stepIndexRun : stepIndexEdit) : (stepIndexRun);

  1059. 		if (running) {

  1060. 			float slideOffset = (slideStepsRemain > 0ul ? (slideCVdelta * (float)slideStepsRemain) : 0.0f);

  1061. 			outputs[CV_OUTPUT].value = cv[seq][step] - slideOffset;

  1062. 			outputs[GATE1_OUTPUT].value = calcGate(gate1Code, clockTrigger, clockPeriod, sampleRate) ? 10.0f : 0.0f;

  1063. 			outputs[GATE2_OUTPUT].value = calcGate(gate2Code, clockTrigger, clockPeriod, sampleRate) ? 10.0f : 0.0f;

  1064. 		}

  1065. 		else {// not running

  1066. 			outputs[CV_OUTPUT].value = (editingGate > 0ul) ? editingGateCV : cv[seq][step];

  1067. 			outputs[GATE1_OUTPUT].value = (editingGate > 0ul) ? 10.0f : 0.0f;

  1068. 			outputs[GATE2_OUTPUT].value = (editingGate > 0ul) ? 10.0f : 0.0f;

  1069. 		}

  1070. 		if (slideStepsRemain > 0ul)

  1071. 			slideStepsRemain--;

  1072. 		

  1073. 		lightRefreshCounter++;

  1074. 		if (lightRefreshCounter > displayRefreshStepSkips) {

  1075. 			lightRefreshCounter = 0;

  1076. 

  1077. 			// Step/phrase lights

  1078. 			if (infoCopyPaste != 0l) {

  1079. 				for (int i = 0; i < 16; i++) {

  1080. 					if ( (i >= stepIndexEdit && i < (stepIndexEdit + countCP)) || (countCP == 16) )

  1081. 						lights[STEP_PHRASE_LIGHTS + (i<<1)].value = 0.5f;// Green when copy interval

  1082. 					else

  1083. 						lights[STEP_PHRASE_LIGHTS + (i<<1)].value = 0.0f; // Green (nothing)

  1084. 					lights[STEP_PHRASE_LIGHTS + (i<<1) + 1].value = 0.0f;// Red (nothing)

  1085. 				}

  1086. 			}

  1087. 			else {

  1088. 				for (int i = 0; i < 16; i++) {

  1089. 					if (editingLength > 0ul) {

  1090. 						// Length (green)

  1091. 						if (editingSequence)

  1092. 							lights[STEP_PHRASE_LIGHTS + (i<<1)].value = ((i < lengths[sequence]) ? 0.5f : 0.0f);

  1093. 						else

  1094. 							lights[STEP_PHRASE_LIGHTS + (i<<1)].value = ((i < phrases) ? 0.5f : 0.0f);

  1095. 						// Nothing (red)

  1096. 						lights[STEP_PHRASE_LIGHTS + (i<<1) + 1].value = 0.0f;

  1097. 					}

  1098. 					else {

  1099. 						// Run cursor (green)

  1100. 						if (editingSequence)

  1101. 							lights[STEP_PHRASE_LIGHTS + (i<<1)].value = ((running && (i == stepIndexRun)) ? 1.0f : 0.0f);

  1102. 						else {

  1103. 							float green = ((running && (i == phraseIndexRun)) ? 1.0f : 0.0f);

  1104. 							green += ((running && (i == stepIndexRun) && i != phraseIndexEdit) ? 0.1f : 0.0f);

  1105. 							lights[STEP_PHRASE_LIGHTS + (i<<1)].value = clamp(green, 0.0f, 1.0f);

  1106. 						}

  1107. 						// Edit cursor (red)

  1108. 						if (editingSequence)

  1109. 							lights[STEP_PHRASE_LIGHTS + (i<<1) + 1].value = (i == stepIndexEdit ? 1.0f : 0.0f);

  1110. 						else

  1111. 							lights[STEP_PHRASE_LIGHTS + (i<<1) + 1].value = (i == phraseIndexEdit ? 1.0f : 0.0f);

  1112. 					}

  1113. 				}

  1114. 			}

  1115. 		

  1116. 			// Octave lights

  1117. 			float octCV = 0.0f;

  1118. 			if (editingSequence)

  1119. 				octCV = cv[sequence][stepIndexEdit];

  1120. 			else

  1121. 				octCV = cv[phrase[phraseIndexEdit]][stepIndexRun];

  1122. 			int octLightIndex = (int) floor(octCV + 3.0f);

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

  1124. 				if (!editingSequence && (!attached || !running))// no oct lights when song mode and either (detached [1] or stopped [2])

  1125. 												// [1] makes no sense, can't mod steps and stepping though seq that may not be playing

  1126. 												// [2] CV is set to 0V when not running and in song mode, so cv[][] makes no sense to display

  1127. 					lights[OCTAVE_LIGHTS + i].value = 0.0f;

  1128. 				else {

  1129. 					if (tiedWarning > 0l) {

  1130. 						bool warningFlashState = calcWarningFlash(tiedWarning, (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips));

  1131. 						lights[OCTAVE_LIGHTS + i].value = (warningFlashState && (i == (6 - octLightIndex))) ? 1.0f : 0.0f;

  1132. 					}

  1133. 					else				

  1134. 						lights[OCTAVE_LIGHTS + i].value = (i == (6 - octLightIndex) ? 1.0f : 0.0f);

  1135. 				}

  1136. 			}

  1137. 			

  1138. 			// Keyboard lights

  1139. 			float cvValOffset;

  1140. 			if (editingSequence) 

  1141. 				cvValOffset = cv[sequence][stepIndexEdit] + 10.0f;//to properly handle negative note voltages

  1142. 			else	

  1143. 				cvValOffset = cv[phrase[phraseIndexEdit]][stepIndexRun] + 10.0f;//to properly handle negative note voltages

  1144. 			int keyLightIndex = (int) clamp(  roundf( (cvValOffset-floor(cvValOffset)) * 12.0f ),  0.0f,  11.0f);

  1145. 			if (editingGateLength != 0 && editingSequence) {

  1146. 				int modeLightIndex = gateModeToKeyLightIndex(attributes[sequence][stepIndexEdit], editingGateLength > 0l);

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

  1148. 					if (i == modeLightIndex) {

  1149. 						lights[KEY_LIGHTS + i * 2 + 0].value = editingGateLength > 0l ? 1.0f : 0.2f;

  1150. 						lights[KEY_LIGHTS + i * 2 + 1].value = editingGateLength > 0l ? 0.2f : 1.0f;

  1151. 					}

  1152. 					else { 

  1153. 						lights[KEY_LIGHTS + i * 2 + 0].value = 0.0f;

  1154. 						if (i == keyLightIndex) 

  1155. 							lights[KEY_LIGHTS + i * 2 + 1].value = 0.1f;	

  1156. 						else 

  1157. 							lights[KEY_LIGHTS + i * 2 + 1].value = 0.0f;

  1158. 					}

  1159. 				}

  1160. 			}

  1161. 			else {

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

  1163. 					lights[KEY_LIGHTS + i * 2 + 0].value = 0.0f;

  1164. 					if (!editingSequence && (!attached || !running))// no keyboard lights when song mode and either (detached [1] or stopped [2])

  1165. 													// [1] makes no sense, can't mod steps and stepping though seq that may not be playing

  1166. 													// [2] CV is set to 0V when not running and in song mode, so cv[][] makes no sense to display

  1167. 						lights[KEY_LIGHTS + i * 2 + 1].value = 0.0f;

  1168. 					else {

  1169. 						if (tiedWarning > 0l) {

  1170. 							bool warningFlashState = calcWarningFlash(tiedWarning, (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips));

  1171. 							lights[KEY_LIGHTS + i * 2 + 1].value = (warningFlashState && i == keyLightIndex) ? 1.0f : 0.0f;

  1172. 						}

  1173. 						else {

  1174. 							if (editingGate > 0ul && editingGateKeyLight != -1)

  1175. 								lights[KEY_LIGHTS + i * 2 + 1].value = (i == editingGateKeyLight ? ((float) editingGate / (float)(gateTime * sampleRate / displayRefreshStepSkips)) : 0.0f);

  1176. 							else

  1177. 								lights[KEY_LIGHTS + i * 2 + 1].value = (i == keyLightIndex ? 1.0f : 0.0f);

  1178. 						}

  1179. 					}

  1180. 				}	

  1181. 			}			

  1182. 			

  1183. 			// Gate1, Gate1Prob, Gate2, Slide and Tied lights

  1184. 			int attributesVal = attributes[sequence][stepIndexEdit];

  1185. 			if (!editingSequence)

  1186. 				attributesVal = attributes[phrase[phraseIndexEdit]][stepIndexRun];

  1187. 			//

  1188. 			setGateLight(getGate1a(attributesVal), GATE1_LIGHT);

  1189. 			setGateLight(getGate2a(attributesVal), GATE2_LIGHT);

  1190. 			lights[GATE1_PROB_LIGHT].value = getGate1Pa(attributesVal) ? 1.0f : 0.0f;

  1191. 			lights[SLIDE_LIGHT].value = getSlideA(attributesVal) ? 1.0f : 0.0f;

  1192. 			if (tiedWarning > 0l) {

  1193. 				bool warningFlashState = calcWarningFlash(tiedWarning, (long) (tiedWarningTime * sampleRate / displayRefreshStepSkips));

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

  1195. 			}

  1196. 			else

  1197. 				lights[TIE_LIGHT].value = getTiedA(attributesVal) ? 1.0f : 0.0f;

  1198. 

  1199. 			// Attach light

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

  1201. 			

  1202. 			// Reset light

  1203. 			lights[RESET_LIGHT].value =	resetLight;	

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

  1205. 			

  1206. 			// Run light

  1207. 			lights[RUN_LIGHT].value = running ? 1.0f : 0.0f;

  1208. 			

  1209. 			if (tiedWarning > 0l)

  1210. 				tiedWarning--;

  1211. 			if (editingLength > 0ul)

  1212. 				editingLength--;

  1213. 			if (editingGate > 0ul)

  1214. 				editingGate--;

  1215. 			if (infoCopyPaste != 0l) {

  1216. 				if (infoCopyPaste > 0l)

  1217. 					infoCopyPaste --;

  1218. 				if (infoCopyPaste < 0l)

  1219. 					infoCopyPaste ++;

  1220. 			}

  1221. 			if (modeHoldDetect.process(params[RUNMODE_PARAM].value)) {

  1222. 				displayState = DISP_NORMAL;

  1223. 				editingPpqn = (long) (editGateLengthTime * sampleRate / displayRefreshStepSkips);

  1224. 			}

  1225. 			if (gate1HoldDetect.process(params[GATE1_PARAM].value)) {

  1226. 				toggleGate1a(&attributes[sequence][stepIndexEdit]);

  1227. 				editGateLengthTimeInitMult = 1;

  1228. 			}

  1229. 			if (gate2HoldDetect.process(params[GATE2_PARAM].value)) {

  1230. 				toggleGate2a(&attributes[sequence][stepIndexEdit]);

  1231. 				editGateLengthTimeInitMult = 100;

  1232. 			}

  1233. 			if (editingPpqn > 0l)

  1234. 				editingPpqn--;

  1235. 			if (editingGateLength != 0l) {

  1236. 				if (editingGateLength > 0l)

  1237. 					editingGateLength --;

  1238. 				if (editingGateLength < 0l)

  1239. 					editingGateLength ++;

  1240. 			}

  1241. 		}// lightRefreshCounter

  1242. 		

  1243. 		if (clockIgnoreOnReset > 0l)

  1244. 			clockIgnoreOnReset--;

  1245. 

  1246. 	}// step()

  1247. 	

  1248. 	void applyTiedStep(int seqNum, int indexTied, int seqLength) {

  1249. 		// Start on indexTied and loop until seqLength

  1250. 		// Called because either:

  1251. 		//   case A: tied was activated for given step

  1252. 		//   case B: the given step's CV was modified

  1253. 		// These cases are mutually exclusive

  1254. 		

  1255. 		// copy previous CV over to current step if tied

  1256. 		if (getTied(seqNum,indexTied) && (indexTied > 0))

  1257. 			cv[seqNum][indexTied] = cv[seqNum][indexTied - 1];

  1258. 		

  1259. 		// Affect downstream CVs of subsequent tied note chain (can be 0 length if next note is not tied)

  1260. 		for (int i = indexTied + 1; i < seqLength && getTied(seqNum,i); i++) 

  1261. 			cv[seqNum][i] = cv[seqNum][indexTied];

  1262. 	}

  1263. 	

  1264. 	int calcNewGateMode(int currentGateMode, int deltaKnob) {

  1265. 		return clamp(currentGateMode + deltaKnob, 0, NUM_GATES - 1); 

  1266. 	}

  1267. 	

  1268. 	inline void setGateLight(bool gateOn, int lightIndex) {

  1269. 		if (!gateOn) {

  1270. 			lights[lightIndex + 0].value = 0.0f;

  1271. 			lights[lightIndex + 1].value = 0.0f;

  1272. 		}

  1273. 		else if (pulsesPerStep == 1) {

  1274. 			lights[lightIndex + 0].value = 0.0f;

  1275. 			lights[lightIndex + 1].value = 1.0f;

  1276. 		}

  1277. 		else {

  1278. 			lights[lightIndex + 0].value = lightIndex == GATE1_LIGHT ? 1.0f : 0.2f;

  1279. 			lights[lightIndex + 1].value = lightIndex == GATE1_LIGHT ? 0.2f : 1.0f;

  1280. 		}

  1281. 	}

  1282. 	

  1283. };

  1284. 

  1285. 

  1286. 

  1287. struct PhraseSeq16Widget : ModuleWidget {

  1288. 	PhraseSeq16 *module;

  1289. 	DynamicSVGPanel *panel;

  1290. 	int oldExpansion;

  1291. 	int expWidth = 60;

  1292. 	IMPort* expPorts[5];

  1293. 

  1294. 	struct SequenceDisplayWidget : TransparentWidget {

  1295. 		PhraseSeq16 *module;

  1296. 		std::shared_ptr<Font> font;

  1297. 		char displayStr[4];

  1298. 		

  1299. 		SequenceDisplayWidget() {

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

  1301. 		}

  1302. 		

  1303. 		void runModeToStr(int num) {

  1304. 			if (num >= 0 && num < NUM_MODES)

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

  1306. 		}

  1307. 

  1308. 		void draw(NVGcontext *vg) override {

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

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

  1311. 			//nvgTextLetterSpacing(vg, 2.5);

  1312. 

  1313. 			Vec textPos = Vec(6, 24);

  1314. 			nvgFillColor(vg, nvgTransRGBA(textColor, 16));

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

  1316. 			nvgFillColor(vg, textColor);

  1317. 			if (module->infoCopyPaste != 0l) {

  1318. 				if (module->infoCopyPaste > 0l)

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

  1320. 				else

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

  1322. 			}

  1323. 			else if (module->editingLength > 0ul) {

  1324. 				if (module->editingSequence)

  1325. 					snprintf(displayStr, 4, "L%2u", (unsigned) module->lengths[module->sequence]);

  1326. 				else

  1327. 					snprintf(displayStr, 4, "L%2u", (unsigned) module->phrases);

  1328. 			}

  1329. 			else if (module->editingPpqn != 0ul) {

  1330. 				snprintf(displayStr, 4, "x%2u", (unsigned) module->pulsesPerStep);

  1331. 			}

  1332. 			else if (module->displayState == PhraseSeq16::DISP_MODE) {

  1333. 				if (module->editingSequence)

  1334. 					runModeToStr(module->runModeSeq[module->sequence]);

  1335. 				else

  1336. 					runModeToStr(module->runModeSong);

  1337. 			}

  1338. 			else if (module->displayState == PhraseSeq16::DISP_TRANSPOSE) {

  1339. 				snprintf(displayStr, 4, "+%2u", (unsigned) abs(module->transposeOffset));

  1340. 				if (module->transposeOffset < 0)

  1341. 					displayStr[0] = '-';

  1342. 			}

  1343. 			else if (module->displayState == PhraseSeq16::DISP_ROTATE) {

  1344. 				snprintf(displayStr, 4, ")%2u", (unsigned) abs(module->rotateOffset));

  1345. 				if (module->rotateOffset < 0)

  1346. 					displayStr[0] = '(';

  1347. 			}

  1348. 			else {// DISP_NORMAL

  1349. 				snprintf(displayStr, 4, " %2u", (unsigned) (module->editingSequence ? 

  1350. 					module->sequence : module->phrase[module->phraseIndexEdit]) + 1 );

  1351. 			}

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

  1353. 		}

  1354. 	};		

  1355. 	

  1356. 	struct PanelThemeItem : MenuItem {

  1357. 		PhraseSeq16 *module;

  1358. 		int theme;

  1359. 		void onAction(EventAction &e) override {

  1360. 			module->panelTheme = theme;

  1361. 		}

  1362. 		void step() override {

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

  1364. 		}

  1365. 	};

  1366. 	struct ExpansionItem : MenuItem {

  1367. 		PhraseSeq16 *module;

  1368. 		void onAction(EventAction &e) override {

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

  1370. 		}

  1371. 	};

  1372. 	struct ResetOnRunItem : MenuItem {

  1373. 		PhraseSeq16 *module;

  1374. 		void onAction(EventAction &e) override {

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

  1376. 		}

  1377. 	};

  1378. 	Menu *createContextMenu() override {

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

  1380. 

  1381. 		MenuLabel *spacerLabel = new MenuLabel();

  1382. 		menu->addChild(spacerLabel);

  1383. 

  1384. 		PhraseSeq16 *module = dynamic_cast<PhraseSeq16*>(this->module);

  1385. 		assert(module);

  1386. 

  1387. 		MenuLabel *themeLabel = new MenuLabel();

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

  1389. 		menu->addChild(themeLabel);

  1390. 

  1391. 		PanelThemeItem *lightItem = new PanelThemeItem();

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

  1393. 		lightItem->module = module;

  1394. 		lightItem->theme = 0;

  1395. 		menu->addChild(lightItem);

  1396. 

  1397. 		PanelThemeItem *darkItem = new PanelThemeItem();

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

  1399. 		darkItem->module = module;

  1400. 		darkItem->theme = 1;

  1401. 		menu->addChild(darkItem);

  1402. 

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

  1404. 		

  1405. 		MenuLabel *settingsLabel = new MenuLabel();

  1406. 		settingsLabel->text = "Settings";

  1407. 		menu->addChild(settingsLabel);

  1408. 		

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

  1410. 		rorItem->module = module;

  1411. 		menu->addChild(rorItem);

  1412. 		

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

  1414. 		

  1415. 		MenuLabel *expansionLabel = new MenuLabel();

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

  1417. 		menu->addChild(expansionLabel);

  1418. 

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

  1420. 		expItem->module = module;

  1421. 		menu->addChild(expItem);

  1422. 		

  1423. 		return menu;

  1424. 	}	

  1425. 	

  1426. 	void step() override {

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

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

  1429. 				for (int i = 0; i < 5; i++)

  1430.                rack::global_ui->app.gRackWidget->wireContainer->removeAllWires(expPorts[i]);

  1431. 			}

  1432. 			oldExpansion = module->expansion;		

  1433. 		}

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

  1435. 		Widget::step();

  1436. 	}

  1437. 	

  1438. 	PhraseSeq16Widget(PhraseSeq16 *module) : ModuleWidget(module) {

  1439. 		this->module = module;

  1440. 		oldExpansion = -1;

  1441. 		

  1442. 		// Main panel from Inkscape

  1443.       panel = new DynamicSVGPanel();

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

  1445. 		panel->expWidth = &expWidth;

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

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

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

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

  1450.       addChild(panel);		

  1451. 		

  1452. 		// Screws

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

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

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

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

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

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

  1459. 

  1460. 		

  1461. 		

  1462. 		// ****** Top row ******

  1463. 		

  1464. 		static const int rowRulerT0 = 48;

  1465. 		static const int columnRulerT0 = 15;// Length button

  1466. 		static const int columnRulerT1 = columnRulerT0 + 47;// Left/Right buttons

  1467. 		static const int columnRulerT2 = columnRulerT1 + 75;// Step/Phase lights

  1468. 		static const int columnRulerT3 = columnRulerT2 + 263;// Attach (also used to align rest of right side of module)

  1469. 

  1470. 		// Length button

  1471. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerT0 + offsetCKD6b, rowRulerT0 + offsetCKD6b), module, PhraseSeq16::LENGTH_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1472. 		// Left/Right buttons

  1473. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerT1 + offsetCKD6b, rowRulerT0 + offsetCKD6b), module, PhraseSeq16::LEFT_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1474. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerT1 + 38 + offsetCKD6b, rowRulerT0 + offsetCKD6b), module, PhraseSeq16::RIGHT_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1475. 		// Step/Phrase lights

  1476. 		static const int spLightsSpacing = 15;

  1477. 		for (int i = 0; i < 16; i++) {

  1478. 			addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(columnRulerT2 + spLightsSpacing * i + offsetMediumLight, rowRulerT0 + offsetMediumLight), module, PhraseSeq16::STEP_PHRASE_LIGHTS + (i*2)));

  1479. 		}

  1480. 		// Attach button and light

  1481. 		addParam(ParamWidget::create<TL1105>(Vec(columnRulerT3 - 4, rowRulerT0 + 2 + offsetTL1105), module, PhraseSeq16::ATTACH_PARAM, 0.0f, 1.0f, 0.0f));

  1482. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerT3 + 12 + offsetMediumLight, rowRulerT0 + offsetMediumLight), module, PhraseSeq16::ATTACH_LIGHT));		

  1483. 

  1484. 		

  1485. 		

  1486. 		// ****** Octave and keyboard area ******

  1487. 		

  1488. 		// Octave LED buttons

  1489. 		static const float octLightsIntY = 20.0f;

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

  1491. 			addParam(ParamWidget::create<LEDButton>(Vec(15 + 3, 82 + 24 + i * octLightsIntY- 4.4f), module, PhraseSeq16::OCTAVE_PARAM + i, 0.0f, 1.0f, 0.0f));

  1492. 			addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(15 + 3 + 4.4f, 82 + 24 + i * octLightsIntY), module, PhraseSeq16::OCTAVE_LIGHTS + i));

  1493. 		}

  1494. 		// Keys and Key lights

  1495. 		static const int keyNudgeX = 7;

  1496. 		static const int KeyBlackY = 103;

  1497. 		static const int KeyWhiteY = 141;

  1498. 		static const int offsetKeyLEDx = 6;

  1499. 		static const int offsetKeyLEDy = 16;

  1500. 		// Black keys and lights

  1501. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(65+keyNudgeX, KeyBlackY), module, PhraseSeq16::KEY_PARAMS + 1, 0.0, 1.0, 0.0));

  1502. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(65+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 1 * 2));

  1503. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(93+keyNudgeX, KeyBlackY), module, PhraseSeq16::KEY_PARAMS + 3, 0.0, 1.0, 0.0));

  1504. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(93+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 3 * 2));

  1505. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(150+keyNudgeX, KeyBlackY), module, PhraseSeq16::KEY_PARAMS + 6, 0.0, 1.0, 0.0));

  1506. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(150+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 6 * 2));

  1507. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(178+keyNudgeX, KeyBlackY), module, PhraseSeq16::KEY_PARAMS + 8, 0.0, 1.0, 0.0));

  1508. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(178+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 8 * 2));

  1509. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(206+keyNudgeX, KeyBlackY), module, PhraseSeq16::KEY_PARAMS + 10, 0.0, 1.0, 0.0));

  1510. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(206+keyNudgeX+offsetKeyLEDx, KeyBlackY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 10 * 2));

  1511. 		// White keys and lights

  1512. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(51+keyNudgeX, KeyWhiteY), module, PhraseSeq16::KEY_PARAMS + 0, 0.0, 1.0, 0.0));

  1513. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(51+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 0 * 2));

  1514. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(79+keyNudgeX, KeyWhiteY), module, PhraseSeq16::KEY_PARAMS + 2, 0.0, 1.0, 0.0));

  1515. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(79+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 2 * 2));

  1516. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(107+keyNudgeX, KeyWhiteY), module, PhraseSeq16::KEY_PARAMS + 4, 0.0, 1.0, 0.0));

  1517. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(107+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 4 * 2));

  1518. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(136+keyNudgeX, KeyWhiteY), module, PhraseSeq16::KEY_PARAMS + 5, 0.0, 1.0, 0.0));

  1519. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(136+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 5 * 2));

  1520. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(164+keyNudgeX, KeyWhiteY), module, PhraseSeq16::KEY_PARAMS + 7, 0.0, 1.0, 0.0));

  1521. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(164+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 7 * 2));

  1522. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(192+keyNudgeX, KeyWhiteY), module, PhraseSeq16::KEY_PARAMS + 9, 0.0, 1.0, 0.0));

  1523. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(192+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 9 * 2));

  1524. 		addParam(ParamWidget::create<InvisibleKeySmall>(			Vec(220+keyNudgeX, KeyWhiteY), module, PhraseSeq16::KEY_PARAMS + 11, 0.0, 1.0, 0.0));

  1525. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(220+keyNudgeX+offsetKeyLEDx, KeyWhiteY+offsetKeyLEDy), module, PhraseSeq16::KEY_LIGHTS + 11 * 2));

  1526. 		

  1527. 		

  1528. 		

  1529. 		// ****** Right side control area ******

  1530. 

  1531. 		static const int rowRulerMK0 = 101;// Edit mode row

  1532. 		static const int rowRulerMK1 = rowRulerMK0 + 56; // Run row

  1533. 		static const int rowRulerMK2 = rowRulerMK1 + 54; // Reset row

  1534. 		static const int columnRulerMK0 = 277;// Edit mode column

  1535. 		static const int columnRulerMK1 = columnRulerMK0 + 59;// Display column

  1536. 		static const int columnRulerMK2 = columnRulerT3;// Run mode column

  1537. 		

  1538. 		// Edit mode switch

  1539. 		addParam(ParamWidget::create<CKSS>(Vec(columnRulerMK0 + hOffsetCKSS, rowRulerMK0 + vOffsetCKSS), module, PhraseSeq16::EDIT_PARAM, 0.0f, 1.0f, PhraseSeq16::EDIT_PARAM_INIT_VALUE));

  1540. 		// Sequence display

  1541. 		SequenceDisplayWidget *displaySequence = new SequenceDisplayWidget();

  1542. 		displaySequence->box.pos = Vec(columnRulerMK1-15, rowRulerMK0 + 3 + vOffsetDisplay);

  1543. 		displaySequence->box.size = Vec(55, 30);// 3 characters

  1544. 		displaySequence->module = module;

  1545. 		addChild(displaySequence);

  1546. 		// Run mode button

  1547. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMK2 + offsetCKD6b, rowRulerMK0 + 0 + offsetCKD6b), module, PhraseSeq16::RUNMODE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1548. 

  1549. 		// Run LED bezel and light

  1550. 		addParam(ParamWidget::create<LEDBezel>(Vec(columnRulerMK0 + offsetLEDbezel, rowRulerMK1 + 7 + offsetLEDbezel), module, PhraseSeq16::RUN_PARAM, 0.0f, 1.0f, 0.0f));

  1551. 		addChild(ModuleLightWidget::create<MuteLight<GreenLight>>(Vec(columnRulerMK0 + offsetLEDbezel + offsetLEDbezelLight, rowRulerMK1 + 7 + offsetLEDbezel + offsetLEDbezelLight), module, PhraseSeq16::RUN_LIGHT));

  1552. 		// Sequence knob

  1553. 		addParam(createDynamicParam<IMBigKnobInf>(Vec(columnRulerMK1 + 1 + offsetIMBigKnob, rowRulerMK0 + 55 + offsetIMBigKnob), module, PhraseSeq16::SEQUENCE_PARAM, -INFINITY, INFINITY, 0.0f, &module->panelTheme));		

  1554. 		// Transpose/rotate button

  1555. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMK2 + offsetCKD6b, rowRulerMK1 + 4 + offsetCKD6b), module, PhraseSeq16::TRAN_ROT_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1556. 		

  1557. 		// Reset LED bezel and light

  1558. 		addParam(ParamWidget::create<LEDBezel>(Vec(columnRulerMK0 + offsetLEDbezel, rowRulerMK2 + 5 + offsetLEDbezel), module, PhraseSeq16::RESET_PARAM, 0.0f, 1.0f, 0.0f));

  1559. 		addChild(ModuleLightWidget::create<MuteLight<GreenLight>>(Vec(columnRulerMK0 + offsetLEDbezel + offsetLEDbezelLight, rowRulerMK2 + 5 + offsetLEDbezel + offsetLEDbezelLight), module, PhraseSeq16::RESET_LIGHT));

  1560. 		// Copy/paste buttons

  1561. 		addParam(ParamWidget::create<TL1105>(Vec(columnRulerMK1 - 10, rowRulerMK2 + 5 + offsetTL1105), module, PhraseSeq16::COPY_PARAM, 0.0f, 1.0f, 0.0f));

  1562. 		addParam(ParamWidget::create<TL1105>(Vec(columnRulerMK1 + 20, rowRulerMK2 + 5 + offsetTL1105), module, PhraseSeq16::PASTE_PARAM, 0.0f, 1.0f, 0.0f));

  1563. 		// Copy-paste mode switch (3 position)

  1564. 		addParam(ParamWidget::create<CKSSThreeInv>(Vec(columnRulerMK2 + hOffsetCKSS + 1, rowRulerMK2 - 3 + vOffsetCKSSThree), module, PhraseSeq16::CPMODE_PARAM, 0.0f, 2.0f, 2.0f));	// 0.0f is top position

  1565. 

  1566. 		

  1567. 		

  1568. 		// ****** Gate and slide section ******

  1569. 		

  1570. 		static const int rowRulerMB0 = 214;

  1571. 		static const int columnRulerMBspacing = 70;

  1572. 		static const int columnRulerMB2 = 130;// Gate2

  1573. 		static const int columnRulerMB1 = columnRulerMB2 - columnRulerMBspacing;// Gate1 

  1574. 		static const int columnRulerMB3 = columnRulerMB2 + columnRulerMBspacing;// Tie

  1575. 		static const int posLEDvsButton = + 25;

  1576. 		

  1577. 		// Gate 1 light and button

  1578. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(columnRulerMB1 + posLEDvsButton + offsetMediumLight, rowRulerMB0 + 4 + offsetMediumLight), module, PhraseSeq16::GATE1_LIGHT));		

  1579. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMB1 + offsetCKD6b, rowRulerMB0 + 4 + offsetCKD6b), module, PhraseSeq16::GATE1_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1580. 		// Gate 2 light and button

  1581. 		addChild(ModuleLightWidget::create<MediumLight<GreenRedLight>>(Vec(columnRulerMB2 + posLEDvsButton + offsetMediumLight, rowRulerMB0 + 4 + offsetMediumLight), module, PhraseSeq16::GATE2_LIGHT));		

  1582. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMB2 + offsetCKD6b, rowRulerMB0 + 4 + offsetCKD6b), module, PhraseSeq16::GATE2_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1583. 		// Tie light and button

  1584. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerMB3 + posLEDvsButton + offsetMediumLight, rowRulerMB0 + 4 + offsetMediumLight), module, PhraseSeq16::TIE_LIGHT));		

  1585. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerMB3 + offsetCKD6b, rowRulerMB0 + 4 + offsetCKD6b), module, PhraseSeq16::TIE_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1586. 

  1587. 						

  1588. 		

  1589. 		// ****** Bottom two rows ******

  1590. 		

  1591. 		static const int outputJackSpacingX = 54;

  1592. 		static const int rowRulerB0 = 323;

  1593. 		static const int rowRulerB1 = 269;

  1594. 		static const int columnRulerB0 = 22;

  1595. 		static const int columnRulerB1 = columnRulerB0 + outputJackSpacingX;

  1596. 		static const int columnRulerB2 = columnRulerB1 + outputJackSpacingX;

  1597. 		static const int columnRulerB3 = columnRulerB2 + outputJackSpacingX;

  1598. 		static const int columnRulerB4 = columnRulerB3 + outputJackSpacingX;

  1599. 		static const int columnRulerB7 = columnRulerMK2 + 1;

  1600. 		static const int columnRulerB6 = columnRulerB7 - outputJackSpacingX;

  1601. 		static const int columnRulerB5 = columnRulerB6 - outputJackSpacingX;

  1602. 

  1603. 		

  1604. 		// Gate 1 probability light and button

  1605. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerB0 + posLEDvsButton + offsetMediumLight, rowRulerB1 + offsetMediumLight), module, PhraseSeq16::GATE1_PROB_LIGHT));		

  1606. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerB0 + offsetCKD6b, rowRulerB1 + offsetCKD6b), module, PhraseSeq16::GATE1_PROB_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1607. 		// Gate 1 probability knob

  1608. 		addParam(createDynamicParam<IMSmallKnob>(Vec(columnRulerB1 + offsetIMSmallKnob, rowRulerB1 + offsetIMSmallKnob), module, PhraseSeq16::GATE1_KNOB_PARAM, 0.0f, 1.0f, 1.0f, &module->panelTheme));

  1609. 		// Slide light and button

  1610. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(columnRulerB2 + posLEDvsButton + offsetMediumLight, rowRulerB1 + offsetMediumLight), module, PhraseSeq16::SLIDE_LIGHT));		

  1611. 		addParam(createDynamicParam<IMBigPushButton>(Vec(columnRulerB2 + offsetCKD6b, rowRulerB1 + offsetCKD6b), module, PhraseSeq16::SLIDE_BTN_PARAM, 0.0f, 1.0f, 0.0f, &module->panelTheme));

  1612. 		// Slide knob

  1613. 		addParam(createDynamicParam<IMSmallKnob>(Vec(columnRulerB3 + offsetIMSmallKnob, rowRulerB1 + offsetIMSmallKnob), module, PhraseSeq16::SLIDE_KNOB_PARAM, 0.0f, 2.0f, 0.2f, &module->panelTheme));

  1614. 		// Autostep

  1615. 		addParam(ParamWidget::create<CKSS>(Vec(columnRulerB4 + hOffsetCKSS, rowRulerB1 + vOffsetCKSS), module, PhraseSeq16::AUTOSTEP_PARAM, 0.0f, 1.0f, 1.0f));		

  1616. 		// CV in

  1617. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB5, rowRulerB1), Port::INPUT, module, PhraseSeq16::CV_INPUT, &module->panelTheme));

  1618. 		// Clock

  1619. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB6, rowRulerB1), Port::INPUT, module, PhraseSeq16::CLOCK_INPUT, &module->panelTheme));

  1620. 		// Reset

  1621. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB7, rowRulerB1), Port::INPUT, module, PhraseSeq16::RESET_INPUT, &module->panelTheme));

  1622. 

  1623. 		

  1624. 

  1625. 		// ****** Bottom row (all aligned) ******

  1626. 

  1627. 	

  1628. 		// CV control Inputs 

  1629. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB0, rowRulerB0), Port::INPUT, module, PhraseSeq16::LEFTCV_INPUT, &module->panelTheme));

  1630. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB1, rowRulerB0), Port::INPUT, module, PhraseSeq16::RIGHTCV_INPUT, &module->panelTheme));

  1631. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB2, rowRulerB0), Port::INPUT, module, PhraseSeq16::SEQCV_INPUT, &module->panelTheme));

  1632. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB3, rowRulerB0), Port::INPUT, module, PhraseSeq16::RUNCV_INPUT, &module->panelTheme));

  1633. 		addInput(createDynamicPort<IMPort>(Vec(columnRulerB4, rowRulerB0), Port::INPUT, module, PhraseSeq16::WRITE_INPUT, &module->panelTheme));

  1634. 		// Outputs

  1635. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB5, rowRulerB0), Port::OUTPUT, module, PhraseSeq16::CV_OUTPUT, &module->panelTheme));

  1636. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB6, rowRulerB0), Port::OUTPUT, module, PhraseSeq16::GATE1_OUTPUT, &module->panelTheme));

  1637. 		addOutput(createDynamicPort<IMPort>(Vec(columnRulerB7, rowRulerB0), Port::OUTPUT, module, PhraseSeq16::GATE2_OUTPUT, &module->panelTheme));

  1638. 

  1639. 		

  1640. 		// Expansion module

  1641. 		static const int rowRulerExpTop = 65;

  1642. 		static const int rowSpacingExp = 60;

  1643. 		static const int colRulerExp = 497 - 30;// PS16 is 2HP less than PS32

  1644. 		addInput(expPorts[0] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 0), Port::INPUT, module, PhraseSeq16::GATE1CV_INPUT, &module->panelTheme));

  1645. 		addInput(expPorts[1] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 1), Port::INPUT, module, PhraseSeq16::GATE2CV_INPUT, &module->panelTheme));

  1646. 		addInput(expPorts[2] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 2), Port::INPUT, module, PhraseSeq16::TIEDCV_INPUT, &module->panelTheme));

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

  1648. 		addInput(expPorts[4] = createDynamicPort<IMPort>(Vec(colRulerExp, rowRulerExpTop + rowSpacingExp * 4), Port::INPUT, module, PhraseSeq16::MODECV_INPUT, &module->panelTheme));

  1649. 	}

  1650. };

  1651. 

  1652. } // namespace rack_plugin_ImpromptuModular

  1653. 

  1654. using namespace rack_plugin_ImpromptuModular;

  1655. 

  1656. RACK_PLUGIN_MODEL_INIT(ImpromptuModular, PhraseSeq16) {

  1657.    Model *modelPhraseSeq16 = Model::create<PhraseSeq16, PhraseSeq16Widget>("Impromptu Modular", "Phrase-Seq-16", "SEQ - Phrase-Seq-16", SEQUENCER_TAG);

  1658.    return modelPhraseSeq16;

  1659. }

  1660. 

  1661. /*CHANGE LOG

  1662. 

  1663. 0.6.11:

  1664. step optimization of lights refresh

  1665. 

  1666. 

  1667. 0.6.10:

  1668. add advanced gate mode

  1669. unlock gates when tied (turn off when press tied, but allow to be turned back on)

  1670. allow main knob to also change length when length editing is active

  1671. 

  1672. 0.6.9:

  1673. add FW2, FW3 and FW4 run modes for sequences (but not for song)

  1674. right click on notes now does same as left click but with autostep

  1675. 

  1676. 0.6.8:

  1677. show length in display when editing length

  1678. 

  1679. 0.6.7:

  1680. allow full edit capabilities in Seq and song mode

  1681. no reset on run by default, with switch added in context menu

  1682. reset does not revert seq or song number to 1

  1683. gate 2 is off by default

  1684. fix emitted monitoring gates to depend on gate states instead of always triggering

  1685. 

  1686. 0.6.6:

  1687. knob bug fixes when loading patch

  1688. 

  1689. 0.6.5:

  1690. paste 4, 8 doesn't loop over to overwrite first steps

  1691. small adjustements to gates and CVs used in monitoring write operations

  1692. add GATE1, GATE2, TIED, SLIDE CV inputs 

  1693. add MODE CV input (affects only selected sequence and in Seq mode)

  1694. add expansion panel option

  1695. 

  1696. 0.6.4:

  1697. turn off keyboard and oct lights when detached in song mode (makes no sense, can't mod steps and shows stepping though seq that may not be playing)

  1698. removed mode CV input, added paste 4/8/ALL option (ALL copies length and run mode also)

  1699. allow each sequence to have its own length and run mode

  1700. merged functionalities of transpose and rotate into one knob

  1701. implemented tied notes state bit for each step, and added light to tied steps

  1702. implemented 0-T slide as opposed to 0-2s slide, where T is clock period

  1703. changed copy-paste indication, now uses display rather than keyboard lights

  1704. 

  1705. 0.6.3: 

  1706. added tie step macro button

  1707. added gate probabilities (one prob setting for all steps)

  1708. removed paste-sync

  1709. 

  1710. 0.6.2:

  1711. initial release of PS16

  1712. */