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.
1263 Commits
4 Branches
576MB
Tree: 486cd3ad32
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '486cd3ad32'
${ noResults }
Rack/plugins/community/repos/ImpromptuModular/src/FoundrySequencer.cpp

528 lines
18KB
Raw Blame History 

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

  2. //Impromptu Modular: Modules for VCV Rack by Marc Boulé

  3. //***********************************************************************************************

  4. 

  5. 

  6. #include "FoundrySequencer.hpp"

  7. 

  8. namespace rack_plugin_ImpromptuModular {

  9. 

  10. void Sequencer::construct(bool* _holdTiedNotesPtr, int* _velocityModePtr) {// don't want regaular constructor mechanism

  11. 	velocityModePtr = _velocityModePtr;

  12. 	sek[0].construct(0, nullptr, _holdTiedNotesPtr);

  13. 	for (int trkn = 1; trkn < NUM_TRACKS; trkn++)

  14. 		sek[trkn].construct(trkn, &sek[0], _holdTiedNotesPtr);

  15. }

  16. 

  17. 

  18. void Sequencer::setVelocityVal(int trkn, int intVel, int multiStepsCount, bool multiTracks) {

  19. 	sek[trkn].setVelocityVal(seqIndexEdit, stepIndexEdit, intVel, multiStepsCount);

  20. 	if (multiTracks) {

  21. 		for (int i = 0; i < NUM_TRACKS; i++) {

  22. 			if (i == trkn) continue;

  23. 			sek[i].setVelocityVal(seqIndexEdit, stepIndexEdit, intVel, multiStepsCount);

  24. 		}

  25. 	}

  26. }

  27. void Sequencer::setLength(int length, bool multiTracks) {

  28. 	sek[trackIndexEdit].setLength(seqIndexEdit, length);

  29. 	if (multiTracks) {

  30. 		for (int i = 0; i < NUM_TRACKS; i++) {

  31. 			if (i == trackIndexEdit) continue;

  32. 			sek[i].setLength(seqIndexEdit, length);

  33. 		}

  34. 	}

  35. }

  36. void Sequencer::setBegin(bool multiTracks) {

  37. 	sek[trackIndexEdit].setBegin(phraseIndexEdit);

  38. 	if (multiTracks) {

  39. 		for (int i = 0; i < NUM_TRACKS; i++) {

  40. 			if (i == trackIndexEdit) continue;

  41. 			sek[i].setBegin(phraseIndexEdit);

  42. 		}

  43. 	}

  44. }

  45. void Sequencer::setEnd(bool multiTracks) {

  46. 	sek[trackIndexEdit].setEnd(phraseIndexEdit);

  47. 	if (multiTracks) {

  48. 		for (int i = 0; i < NUM_TRACKS; i++) {

  49. 			if (i == trackIndexEdit) continue;

  50. 			sek[i].setEnd(phraseIndexEdit);

  51. 		}

  52. 	}

  53. }

  54. bool Sequencer::setGateType(int keyn, int multiSteps, float sampleRate, bool autostepClick, bool multiTracks) {// Third param is for right-click autostep. Returns success

  55. 	int newMode = keyIndexToGateTypeEx(keyn);

  56. 	if (newMode == -1) 

  57. 		return false;

  58. 	sek[trackIndexEdit].setGateType(seqIndexEdit, stepIndexEdit, newMode, multiSteps);

  59. 	if (multiTracks) {

  60. 		for (int i = 0; i < NUM_TRACKS; i++) {

  61. 			if (i == trackIndexEdit) continue;

  62. 			sek[i].setGateType(seqIndexEdit, stepIndexEdit, newMode, multiSteps);

  63. 		}

  64. 	}

  65. 	if (autostepClick){ // if right-click then move to next step

  66. 		moveStepIndexEdit(1, false);

  67. 		editingGateKeyLight = keyn;

  68. 		editingType = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  69. 		if (windowIsModPressed() && multiSteps < 2)

  70. 			setGateType(keyn, 1, sampleRate, false, multiTracks);

  71. 	}

  72. 	return true;

  73. }

  74. 

  75. 

  76. void Sequencer::initSlideVal(int multiStepsCount, bool multiTracks) {

  77. 	sek[trackIndexEdit].setSlideVal(seqIndexEdit, stepIndexEdit, StepAttributes::INIT_SLIDE, multiStepsCount);

  78. 	if (multiTracks) {

  79. 		for (int i = 0; i < NUM_TRACKS; i++) {

  80. 			if (i == trackIndexEdit) continue;

  81. 			sek[i].setSlideVal(seqIndexEdit, stepIndexEdit, StepAttributes::INIT_SLIDE, multiStepsCount);

  82. 		}

  83. 	}		

  84. }

  85. void Sequencer::initGatePVal(int multiStepsCount, bool multiTracks) {

  86. 	sek[trackIndexEdit].setGatePVal(seqIndexEdit, stepIndexEdit, StepAttributes::INIT_PROB, multiStepsCount);

  87. 	if (multiTracks) {

  88. 		for (int i = 0; i < NUM_TRACKS; i++) {

  89. 			if (i == trackIndexEdit) continue;

  90. 			sek[i].setGatePVal(seqIndexEdit, stepIndexEdit, StepAttributes::INIT_PROB, multiStepsCount);

  91. 		}

  92. 	}		

  93. }

  94. void Sequencer::initVelocityVal(int multiStepsCount, bool multiTracks) {

  95. 	sek[trackIndexEdit].setVelocityVal(seqIndexEdit, stepIndexEdit, StepAttributes::INIT_VELOCITY, multiStepsCount);

  96. 	if (multiTracks) {

  97. 		for (int i = 0; i < NUM_TRACKS; i++) {

  98. 			if (i == trackIndexEdit) continue;

  99. 			sek[i].setVelocityVal(seqIndexEdit, stepIndexEdit, StepAttributes::INIT_VELOCITY, multiStepsCount);

  100. 		}

  101. 	}		

  102. }

  103. void Sequencer::initPulsesPerStep(bool multiTracks) {

  104. 	sek[trackIndexEdit].initPulsesPerStep();

  105. 	if (multiTracks) {

  106. 		for (int i = 0; i < NUM_TRACKS; i++) {

  107. 			if (i == trackIndexEdit) continue;

  108. 			sek[i].initPulsesPerStep();

  109. 		}

  110. 	}		

  111. }

  112. void Sequencer::initDelay(bool multiTracks) {

  113. 	sek[trackIndexEdit].initDelay();

  114. 	if (multiTracks) {

  115. 		for (int i = 0; i < NUM_TRACKS; i++) {

  116. 			if (i == trackIndexEdit) continue;

  117. 			sek[i].initDelay();

  118. 		}

  119. 	}		

  120. }

  121. void Sequencer::initRunModeSong(bool multiTracks) {

  122. 	sek[trackIndexEdit].setRunModeSong(SequencerKernel::MODE_FWD);

  123. 	if (multiTracks) {

  124. 		for (int i = 0; i < NUM_TRACKS; i++) {

  125. 			if (i == trackIndexEdit) continue;

  126. 			sek[i].setRunModeSong(SequencerKernel::MODE_FWD);

  127. 		}

  128. 	}		

  129. }

  130. void Sequencer::initRunModeSeq(bool multiTracks) {

  131. 	sek[trackIndexEdit].setRunModeSeq(seqIndexEdit, SequencerKernel::MODE_FWD);

  132. 	if (multiTracks) {

  133. 		for (int i = 0; i < NUM_TRACKS; i++) {

  134. 			if (i == trackIndexEdit) continue;

  135. 			sek[i].setRunModeSeq(seqIndexEdit, SequencerKernel::MODE_FWD);

  136. 		}

  137. 	}		

  138. }

  139. void Sequencer::initLength(bool multiTracks) {

  140. 	sek[trackIndexEdit].setLength(seqIndexEdit, SequencerKernel::MAX_STEPS);

  141. 	if (multiTracks) {

  142. 		for (int i = 0; i < NUM_TRACKS; i++) {

  143. 			if (i == trackIndexEdit) continue;

  144. 			sek[i].setLength(seqIndexEdit, SequencerKernel::MAX_STEPS);

  145. 		}

  146. 	}		

  147. }

  148. void Sequencer::initPhraseReps(bool multiTracks) {

  149. 	sek[trackIndexEdit].setPhraseReps(phraseIndexEdit, 1);

  150. 	if (multiTracks) {

  151. 		for (int i = 0; i < NUM_TRACKS; i++) {

  152. 			if (i == trackIndexEdit) continue;

  153. 			sek[i].setPhraseReps(phraseIndexEdit, 1);

  154. 		}

  155. 	}		

  156. }

  157. void Sequencer::initPhraseSeqNum(bool multiTracks) {

  158. 	sek[trackIndexEdit].setPhraseSeqNum(phraseIndexEdit, 0);

  159. 	if (multiTracks) {

  160. 		for (int i = 0; i < NUM_TRACKS; i++) {

  161. 			if (i == trackIndexEdit) continue;

  162. 			sek[i].setPhraseSeqNum(phraseIndexEdit, 0);

  163. 		}

  164. 	}		

  165. }

  166. 

  167. void Sequencer::copySequence(int countCP) {

  168. 	int startCP = stepIndexEdit;

  169. 	sek[trackIndexEdit].copySequence(&seqCPbuf, seqIndexEdit, startCP, countCP);

  170. }

  171. void Sequencer::pasteSequence(bool multiTracks) {

  172. 	int startCP = stepIndexEdit;

  173. 	sek[trackIndexEdit].pasteSequence(&seqCPbuf, seqIndexEdit, startCP);

  174. 	if (multiTracks) {

  175. 		for (int i = 0; i < NUM_TRACKS; i++) {

  176. 			if (i == trackIndexEdit) continue;

  177. 			sek[i].pasteSequence(&seqCPbuf, seqIndexEdit, startCP);

  178. 		}

  179. 	}

  180. }

  181. void Sequencer::copySong(int startCP, int countCP) {

  182. 	sek[trackIndexEdit].copySong(&songCPbuf, startCP, countCP);

  183. }

  184. void Sequencer::pasteSong(bool multiTracks) {

  185. 	sek[trackIndexEdit].pasteSong(&songCPbuf, phraseIndexEdit);

  186. 	if (multiTracks) {

  187. 		for (int i = 0; i < NUM_TRACKS; i++) {

  188. 			if (i == trackIndexEdit) continue;

  189. 			sek[i].pasteSong(&songCPbuf, phraseIndexEdit);

  190. 		}

  191. 	}

  192. }

  193. 

  194. 

  195. void Sequencer::writeCV(int trkn, float cvVal, int multiStepsCount, float sampleRate, bool multiTracks) {

  196. 	sek[trkn].writeCV(seqIndexEdit, stepIndexEdit, cvVal, multiStepsCount);

  197. 	editingGateCV[trkn] = cvVal;

  198. 	editingGateCV2[trkn] = sek[trkn].getVelocityVal(seqIndexEdit, stepIndexEdit);

  199. 	editingGate[trkn] = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  200. 	if (multiTracks) {

  201. 		for (int i = 0; i < NUM_TRACKS; i++) {

  202. 			if (i == trkn) continue;

  203. 			sek[i].writeCV(seqIndexEdit, stepIndexEdit, cvVal, multiStepsCount);

  204. 		}

  205. 	}

  206. }

  207. void Sequencer::autostep(bool autoseq, bool autostepLen) {

  208. 	moveStepIndexEdit(1, autostepLen);

  209. 	if (stepIndexEdit == 0 && autoseq)

  210. 		seqIndexEdit = moveIndex(seqIndexEdit, seqIndexEdit + 1, SequencerKernel::MAX_SEQS);	

  211. }	

  212. 

  213. bool Sequencer::applyNewOctave(int octn, int multiSteps, float sampleRate, bool multiTracks) { // returns true if tied

  214. 	if (sek[trackIndexEdit].getTied(seqIndexEdit, stepIndexEdit))

  215. 		return true;

  216. 	editingGateCV[trackIndexEdit] = sek[trackIndexEdit].applyNewOctave(seqIndexEdit, stepIndexEdit, octn, multiSteps);

  217. 	editingGateCV2[trackIndexEdit] = sek[trackIndexEdit].getVelocityVal(seqIndexEdit, stepIndexEdit);

  218. 	editingGate[trackIndexEdit] = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  219. 	editingGateKeyLight = -1;

  220. 	if (multiTracks) {

  221. 		for (int i = 0; i < NUM_TRACKS; i++) {

  222. 			if (i == trackIndexEdit) continue;

  223. 			sek[i].applyNewOctave(seqIndexEdit, stepIndexEdit, octn, multiSteps);

  224. 		}

  225. 	}

  226. 	return false;

  227. }

  228. bool Sequencer::applyNewKey(int keyn, int multiSteps, float sampleRate, bool autostepClick, bool multiTracks) { // returns true if tied

  229. 	bool ret = false;

  230. 	if (sek[trackIndexEdit].getTied(seqIndexEdit, stepIndexEdit)) {

  231. 		if (autostepClick)

  232. 			moveStepIndexEdit(1, false);

  233. 		else

  234. 			ret = true;

  235. 	}

  236. 	else {

  237. 		editingGateCV[trackIndexEdit] = sek[trackIndexEdit].applyNewKey(seqIndexEdit, stepIndexEdit, keyn, multiSteps);

  238. 		editingGateCV2[trackIndexEdit] = sek[trackIndexEdit].getVelocityVal(seqIndexEdit, stepIndexEdit);

  239. 		editingGate[trackIndexEdit] = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  240. 		editingGateKeyLight = -1;

  241. 		if (multiTracks) {

  242. 			for (int i = 0; i < NUM_TRACKS; i++) {

  243. 				if (i == trackIndexEdit) continue;

  244. 				sek[i].applyNewKey(seqIndexEdit, stepIndexEdit, keyn, multiSteps);

  245. 			}

  246. 		}

  247. 		if (autostepClick) {// if right-click then move to next step

  248. 			moveStepIndexEdit(1, false);

  249. 			if (windowIsModPressed() && multiSteps < 2) // if ctrl-right-click and SEL is off

  250. 				writeCV(trackIndexEdit, editingGateCV[trackIndexEdit], 1, sampleRate, multiTracks);// copy CV only to next step

  251. 			editingGateKeyLight = keyn;

  252. 		}

  253. 	}

  254. 	return ret;

  255. }

  256. 

  257. void Sequencer::moveStepIndexEditWithEditingGate(int delta, bool writeTrig, float sampleRate) {

  258. 	moveStepIndexEdit(delta, false);

  259. 	for (int trkn = 0; trkn < NUM_TRACKS; trkn++) {

  260. 		if (!sek[trkn].getTied(seqIndexEdit, stepIndexEdit)) {// play if non-tied step

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

  262. 				editingGate[trkn] = (unsigned long) (gateTime * sampleRate / displayRefreshStepSkips);

  263. 				editingGateCV[trkn] = sek[trkn].getCV(seqIndexEdit, stepIndexEdit);

  264. 				editingGateCV2[trkn] = sek[trkn].getVelocityVal(seqIndexEdit, stepIndexEdit);

  265. 				editingGateKeyLight = -1;

  266. 			}

  267. 		}

  268. 	}

  269. }

  270. 

  271. 

  272. 

  273. void Sequencer::modSlideVal(int deltaVelKnob, int mutliStepsCount, bool multiTracks) {

  274. 	int sVal = sek[trackIndexEdit].modSlideVal(seqIndexEdit, stepIndexEdit, deltaVelKnob, mutliStepsCount);

  275. 	if (multiTracks) {

  276. 		for (int i = 0; i < NUM_TRACKS; i++) {

  277. 			if (i == trackIndexEdit) continue;

  278. 			sek[i].setSlideVal(seqIndexEdit, stepIndexEdit, sVal, mutliStepsCount);

  279. 		}

  280. 	}		

  281. }

  282. void Sequencer::modGatePVal(int deltaVelKnob, int mutliStepsCount, bool multiTracks) {

  283. 	int gpVal = sek[trackIndexEdit].modGatePVal(seqIndexEdit, stepIndexEdit, deltaVelKnob, mutliStepsCount);

  284. 	if (multiTracks) {

  285. 		for (int i = 0; i < NUM_TRACKS; i++) {

  286. 			if (i == trackIndexEdit) continue;

  287. 			sek[i].setGatePVal(seqIndexEdit, stepIndexEdit, gpVal, mutliStepsCount);

  288. 		}

  289. 	}		

  290. }

  291. void Sequencer::modVelocityVal(int deltaVelKnob, int mutliStepsCount, bool multiTracks) {

  292. 	int upperLimit = ((*velocityModePtr) == 0 ? 200 : 127);

  293. 	int vVal = sek[trackIndexEdit].modVelocityVal(seqIndexEdit, stepIndexEdit, deltaVelKnob, upperLimit, mutliStepsCount);

  294. 	if (multiTracks) {

  295. 		for (int i = 0; i < NUM_TRACKS; i++) {

  296. 			if (i == trackIndexEdit) continue;

  297. 			sek[i].setVelocityVal(seqIndexEdit, stepIndexEdit, vVal, mutliStepsCount);

  298. 		}

  299. 	}		

  300. }

  301. void Sequencer::modRunModeSong(int deltaPhrKnob, bool multiTracks) {

  302. 	int newRunMode = sek[trackIndexEdit].modRunModeSong(deltaPhrKnob);

  303. 	if (multiTracks) {

  304. 		for (int i = 0; i < NUM_TRACKS; i++) {

  305. 			if (i == trackIndexEdit) continue;

  306. 			sek[i].setRunModeSong(newRunMode);

  307. 		}

  308. 	}		

  309. }

  310. void Sequencer::modPulsesPerStep(int deltaSeqKnob, bool multiTracks) {

  311. 	int newPPS = sek[trackIndexEdit].modPulsesPerStep(deltaSeqKnob);

  312. 	if (multiTracks) {

  313. 		for (int i = 0; i < NUM_TRACKS; i++) {

  314. 			if (i == trackIndexEdit) continue;

  315. 			sek[i].setPulsesPerStep(newPPS);

  316. 		}

  317. 	}		

  318. }

  319. void Sequencer::modDelay(int deltaSeqKnob, bool multiTracks) {

  320. 	int newDelay = sek[trackIndexEdit].modDelay(deltaSeqKnob);

  321. 	if (multiTracks) {

  322. 		for (int i = 0; i < NUM_TRACKS; i++) {

  323. 			if (i == trackIndexEdit) continue;

  324. 			sek[i].setDelay(newDelay);

  325. 		}

  326. 	}		

  327. }

  328. void Sequencer::modRunModeSeq(int deltaSeqKnob, bool multiTracks) {

  329. 	int newRunMode = sek[trackIndexEdit].modRunModeSeq(seqIndexEdit, deltaSeqKnob);

  330. 	if (multiTracks) {

  331. 		for (int i = 0; i < NUM_TRACKS; i++) {

  332. 			if (i == trackIndexEdit) continue;

  333. 			sek[i].setRunModeSeq(seqIndexEdit, newRunMode);

  334. 		}

  335. 	}		

  336. }

  337. void Sequencer::modLength(int deltaSeqKnob, bool multiTracks) {

  338. 	int newLength = sek[trackIndexEdit].modLength(seqIndexEdit, deltaSeqKnob);

  339. 	if (multiTracks) {

  340. 		for (int i = 0; i < NUM_TRACKS; i++) {

  341. 			if (i == trackIndexEdit) continue;

  342. 			sek[i].setLength(seqIndexEdit, newLength);

  343. 		}

  344. 	}		

  345. }

  346. void Sequencer::modPhraseReps(int deltaSeqKnob, bool multiTracks) {

  347. 	int newReps = sek[trackIndexEdit].modPhraseReps(phraseIndexEdit, deltaSeqKnob);

  348. 	if (multiTracks) {

  349. 		for (int i = 0; i < NUM_TRACKS; i++) {

  350. 			if (i == trackIndexEdit) continue;

  351. 			sek[i].setPhraseReps(phraseIndexEdit, newReps);

  352. 		}

  353. 	}		

  354. }

  355. void Sequencer::modPhraseSeqNum(int deltaSeqKnob, bool multiTracks) {

  356. 	int newSeqn = sek[trackIndexEdit].modPhraseSeqNum(phraseIndexEdit, deltaSeqKnob);

  357. 	if (multiTracks) {

  358. 		for (int i = 0; i < NUM_TRACKS; i++) {

  359. 			if (i == trackIndexEdit) continue;

  360. 			sek[i].setPhraseSeqNum(phraseIndexEdit, newSeqn);

  361. 		}

  362. 	}		

  363. }

  364. void Sequencer::transposeSeq(int deltaSeqKnob, bool multiTracks) {

  365. 	sek[trackIndexEdit].transposeSeq(seqIndexEdit, deltaSeqKnob);

  366. 	if (multiTracks) {

  367. 		for (int i = 0; i < NUM_TRACKS; i++) {

  368. 			if (i == trackIndexEdit) continue;

  369. 			sek[i].transposeSeq(seqIndexEdit, deltaSeqKnob);

  370. 		}

  371. 	}		

  372. }

  373. void Sequencer::unTransposeSeq(bool multiTracks) {

  374. 	sek[trackIndexEdit].unTransposeSeq(seqIndexEdit);

  375. 	if (multiTracks) {

  376. 		for (int i = 0; i < NUM_TRACKS; i++) {

  377. 			if (i == trackIndexEdit) continue;

  378. 			sek[i].unTransposeSeq(seqIndexEdit);

  379. 		}

  380. 	}		

  381. }

  382. void Sequencer::rotateSeq(int deltaSeqKnob, bool multiTracks) {

  383. 	sek[trackIndexEdit].rotateSeq(seqIndexEdit, deltaSeqKnob);

  384. 	if (stepIndexEdit < getLength())

  385. 		moveStepIndexEdit(deltaSeqKnob, true);

  386. 	if (multiTracks) {

  387. 		for (int i = 0; i < NUM_TRACKS; i++) {

  388. 			if (i == trackIndexEdit) continue;

  389. 			sek[i].rotateSeq(seqIndexEdit, deltaSeqKnob);

  390. 		}

  391. 	}		

  392. }

  393. void Sequencer::unRotateSeq(bool multiTracks) {

  394. 	sek[trackIndexEdit].unRotateSeq(seqIndexEdit);

  395. 	if (multiTracks) {

  396. 		for (int i = 0; i < NUM_TRACKS; i++) {

  397. 			if (i == trackIndexEdit) continue;

  398. 			sek[i].unRotateSeq(seqIndexEdit);

  399. 		}

  400. 	}		

  401. }

  402. void Sequencer::toggleGate(int multiSteps, bool multiTracks) {

  403. 	bool newGate = sek[trackIndexEdit].toggleGate(seqIndexEdit, stepIndexEdit, multiSteps);

  404. 	if (multiTracks) {

  405. 		for (int i = 0; i < NUM_TRACKS; i++) {

  406. 			if (i == trackIndexEdit) continue;			

  407. 			sek[i].setGate(seqIndexEdit, stepIndexEdit, newGate, multiSteps);

  408. 		}

  409. 	}		

  410. }

  411. bool Sequencer::toggleGateP(int multiSteps, bool multiTracks) { // returns true if tied

  412. 	if (sek[trackIndexEdit].getTied(seqIndexEdit,stepIndexEdit))

  413. 		return true;

  414. 	bool newGateP = sek[trackIndexEdit].toggleGateP(seqIndexEdit, stepIndexEdit, multiSteps);

  415. 	if (multiTracks) {

  416. 		for (int i = 0; i < NUM_TRACKS; i++) {

  417. 			if (i == trackIndexEdit) continue;			

  418. 			sek[i].setGateP(seqIndexEdit, stepIndexEdit, newGateP, multiSteps);

  419. 		}

  420. 	}				

  421. 	return false;

  422. }

  423. bool Sequencer::toggleSlide(int multiSteps, bool multiTracks) { // returns true if tied

  424. 	if (sek[trackIndexEdit].getTied(seqIndexEdit,stepIndexEdit))

  425. 		return true;

  426. 	bool newSlide = sek[trackIndexEdit].toggleSlide(seqIndexEdit, stepIndexEdit, multiSteps);

  427. 	if (multiTracks) {

  428. 		for (int i = 0; i < NUM_TRACKS; i++) {

  429. 			if (i == trackIndexEdit) continue;			

  430. 			sek[i].setSlide(seqIndexEdit, stepIndexEdit, newSlide, multiSteps);

  431. 		}

  432. 	}				

  433. 	return false;

  434. }

  435. void Sequencer::toggleTied(int multiSteps, bool multiTracks) {

  436. 	bool newTied = sek[trackIndexEdit].toggleTied(seqIndexEdit, stepIndexEdit, multiSteps);// will clear other attribs if new state is on

  437. 	if (multiTracks) {

  438. 		for (int i = 0; i < NUM_TRACKS; i++) {

  439. 			if (i == trackIndexEdit) continue;			

  440. 			sek[i].setTied(seqIndexEdit, stepIndexEdit, newTied, multiSteps);

  441. 		}

  442. 	}						

  443. }

  444. 

  445. 

  446. void Sequencer::toJson(json_t *rootJ) {

  447. 	// stepIndexEdit

  448. 	json_object_set_new(rootJ, "stepIndexEdit", json_integer(stepIndexEdit));

  449. 

  450. 	// seqIndexEdit

  451. 	json_object_set_new(rootJ, "seqIndexEdit", json_integer(seqIndexEdit));

  452. 

  453. 	// phraseIndexEdit

  454. 	json_object_set_new(rootJ, "phraseIndexEdit", json_integer(phraseIndexEdit));

  455. 

  456. 	// trackIndexEdit

  457. 	json_object_set_new(rootJ, "trackIndexEdit", json_integer(trackIndexEdit));

  458. 

  459. 	for (int trkn = 0; trkn < NUM_TRACKS; trkn++)

  460. 		sek[trkn].toJson(rootJ);

  461. }

  462. 

  463. 

  464. void Sequencer::fromJson(json_t *rootJ) {

  465. 	// stepIndexEdit

  466. 	json_t *stepIndexEditJ = json_object_get(rootJ, "stepIndexEdit");

  467. 	if (stepIndexEditJ)

  468. 		stepIndexEdit = json_integer_value(stepIndexEditJ);

  469. 	

  470. 	// phraseIndexEdit

  471. 	json_t *phraseIndexEditJ = json_object_get(rootJ, "phraseIndexEdit");

  472. 	if (phraseIndexEditJ)

  473. 		phraseIndexEdit = json_integer_value(phraseIndexEditJ);

  474. 	

  475. 	// seqIndexEdit

  476. 	json_t *seqIndexEditJ = json_object_get(rootJ, "seqIndexEdit");

  477. 	if (seqIndexEditJ)

  478. 		seqIndexEdit = json_integer_value(seqIndexEditJ);

  479. 	

  480. 	// trackIndexEdit

  481. 	json_t *trackIndexEditJ = json_object_get(rootJ, "trackIndexEdit");

  482. 	if (trackIndexEditJ)

  483. 		trackIndexEdit = json_integer_value(trackIndexEditJ);

  484. 	

  485. 	for (int trkn = 0; trkn < NUM_TRACKS; trkn++)

  486. 		sek[trkn].fromJson(rootJ);

  487. }

  488. 

  489. 

  490. void Sequencer::reset() {

  491. 	stepIndexEdit = 0;

  492. 	phraseIndexEdit = 0;

  493. 	seqIndexEdit = 0;

  494. 	trackIndexEdit = 0;

  495. 	seqCPbuf.reset();

  496. 	songCPbuf.reset();

  497. 

  498. 	for (int trkn = 0; trkn < NUM_TRACKS; trkn++) {

  499. 		editingGate[trkn] = 0ul;

  500. 		sek[trkn].reset();

  501. 	}

  502. 	editingType = 0ul;

  503. }

  504. 

  505. 

  506. void Sequencer::clockStep(int trkn) {

  507. 	bool phraseChange = sek[trkn].clockStep();

  508. 	if (trkn == 0 && phraseChange) {

  509. 		for (int tkbcd = 1; tkbcd < NUM_TRACKS; tkbcd++) {// check for song run mode slaving

  510. 			if (sek[tkbcd].getRunModeSong() == SequencerKernel::MODE_TKA) {

  511. 				sek[tkbcd].setPhraseIndexRun(sek[0].getPhraseIndexRun());

  512. 				// The code below is to make it such that stepIndexRun should re-init upon phraseChange

  513. 				//   example for phrase jump does not reset stepIndexRun in B

  514. 					//A (FWD): 1 = 1x10, 2 = 1x10

  515. 					//B (TKA): 1 = 1x20, 2 = 1x20

  516. 				// next line will not work, it will result in a double move of stepIndexRun since clock will move it also

  517. 				//sek[tkbcd].moveStepIndexRun(true); 

  518. 				// this next mechanism works, the chain of events will make moveStepIndexRun(true) happen automatically and no double move will occur

  519. 				sek[tkbcd].setMoveStepIndexRunIgnore();// 

  520. 			}

  521. 		}

  522. 	}

  523. }

  524. 

  525. } // namespace rack_plugin_ImpromptuModular

  526.