Moving mixxx/* to the root. A new era begins!

1 files changed, 595 insertions, 0 deletions

diff --git a/res/controllers/Akai-LPD8-RK-scripts.js b/res/controllers/Akai-LPD8-RK-scripts.js
new file mode 100644
index 0000000000..f52b2e9bd3
--- /dev/null
+++ b/res/controllers/Akai-LPD8-RK-scripts.js
@@ -0,0 +1,595 @@
+function LPD8RK() {}
+LPD8RK.debug=false;
+
+//set defaults - don't change these
+LPD8RK.oldHotcueBank=0;//storage for the last active hotcue bank - used for bank indicator lights
+LPD8RK.LEDinterval=300;//interval in milliseconds for LED update
+LPD8RK.hotcueClear=false;//if true, hitting hotcue button clears it.
+LPD8RK.loopbuttonDown=false;//if true, special loop functions with knob modifiers are enabled.
+LPD8RK.looplen=0x40;//default position of looplength dial - active when loop buttons are held down
+LPD8RK.looptype="beatloop";//default looptype - beatloop if <64, beatlooproll otherwise
+LPD8RK.loopmove=0.0125;//default loop move distance in seconds
+LPD8RK.doreloop=true;//don't change this
+LPD8RK.beatjumpstep=1;//default beat jump step in beats
+LPD8RK.vol=new Array();//array of volumes to return to after mute - don't change
+LPD8RK.hotcueBank=1;//default hotcue bank to show on PAD setting, adjustable by knob
+
+
+//array of valid LED addresses
+LPD8RK.validLEDS = new Array();
+LPD8RK.validLEDS[0x90]={0x2b : true,0x27 : true,0x2a : true,0x26 : true,0x29 : true,0x25 : true,0x28 : true,0x24 : true};
+LPD8RK.validLEDS[0x91]={0x2c : true,0x27 : true,0x2e : true,0x2a : true,0x26 : true,0x24 : true,0x25 : true,0x23 : true};
+LPD8RK.validLEDS[0x92]={0x48 : true,0x41 : true,0x47 : true,0x40 : true,0x45 : true,0x3e : true,0x43 : true,0x3c : true};
+LPD8RK.validLEDS[0x93]={0x30 : true,0x29 : true,0x2f : true,0x28 : true,0x2d : true,0x26 : true,0x2b : true,0x24 : true};
+LPD8RK.validLEDS[0xb0]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};
+LPD8RK.validLEDS[0xb1]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};
+LPD8RK.validLEDS[0xb2]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};
+LPD8RK.validLEDS[0xb3]={0x01 : true,0x09 : true,0x04 : true,0x08 : true,0x03 : true,0x06 : true,0x03 : true,0x05 : true};
+
+
+//map hotcue pads and leds
+LPD8RK.hotcues = new Array();
+//preset 1 (group, cuenum, status, ctrl)
+//initialize
+LPD8RK.hotcues["902b"] = new Array();
+LPD8RK.hotcues["9027"] = new Array();
+LPD8RK.hotcues["902a"] = new Array();
+LPD8RK.hotcues["9026"] = new Array();
+LPD8RK.hotcues["9029"] = new Array();
+LPD8RK.hotcues["9025"] = new Array();
+//bank 1
+LPD8RK.hotcues["902b"][1] = new Array("[Channel1]", "1", 0x90, 0x2b);
+LPD8RK.hotcues["9027"][1] = new Array("[Channel1]", "2", 0x90, 0x27);
+LPD8RK.hotcues["902a"][1] = new Array("[Channel1]", "3", 0x90, 0x2a);
+LPD8RK.hotcues["9026"][1] = new Array("[Channel1]", "4", 0x90, 0x26);
+LPD8RK.hotcues["9029"][1] = new Array("[Channel1]", "5", 0x90, 0x29);
+LPD8RK.hotcues["9025"][1] = new Array("[Channel1]", "6", 0x90, 0x25);
+//bank 2
+LPD8RK.hotcues["902b"][2] = new Array("[Channel1]", "7", 0x90, 0x2b);
+LPD8RK.hotcues["9027"][2] = new Array("[Channel1]", "8", 0x90, 0x27);
+LPD8RK.hotcues["902a"][2] = new Array("[Channel1]", "9", 0x90, 0x2a);
+LPD8RK.hotcues["9026"][2] = new Array("[Channel1]", "10", 0x90, 0x26);
+LPD8RK.hotcues["9029"][2] = new Array("[Channel1]", "11", 0x90, 0x29);
+LPD8RK.hotcues["9025"][2] = new Array("[Channel1]", "12", 0x90, 0x25);
+//bank 3
+LPD8RK.hotcues["902b"][3] = new Array("[Channel1]", "13", 0x90, 0x2b);
+LPD8RK.hotcues["9027"][3] = new Array("[Channel1]", "14", 0x90, 0x27);
+LPD8RK.hotcues["902a"][3] = new Array("[Channel1]", "15", 0x90, 0x2a);
+LPD8RK.hotcues["9026"][3] = new Array("[Channel1]", "16", 0x90, 0x26);
+LPD8RK.hotcues["9029"][3] = new Array("[Channel1]", "17", 0x90, 0x29);
+LPD8RK.hotcues["9025"][3] = new Array("[Channel1]", "18", 0x90, 0x25);
+//bank 4
+LPD8RK.hotcues["902b"][4] = new Array("[Channel1]", "19", 0x90, 0x2b);
+LPD8RK.hotcues["9027"][4] = new Array("[Channel1]", "20", 0x90, 0x27);
+LPD8RK.hotcues["902a"][4] = new Array("[Channel1]", "21", 0x90, 0x2a);
+LPD8RK.hotcues["9026"][4] = new Array("[Channel1]", "22", 0x90, 0x26);
+LPD8RK.hotcues["9029"][4] = new Array("[Channel1]", "23", 0x90, 0x29);
+LPD8RK.hotcues["9025"][4] = new Array("[Channel1]", "24", 0x90, 0x25);
+//bank 5
+LPD8RK.hotcues["902b"][5] = new Array("[Channel1]", "25", 0x90, 0x2b);
+LPD8RK.hotcues["9027"][5] = new Array("[Channel1]", "26", 0x90, 0x27);
+LPD8RK.hotcues["902a"][5] = new Array("[Channel1]", "27", 0x90, 0x2a);
+LPD8RK.hotcues["9026"][5] = new Array("[Channel1]", "28", 0x90, 0x26);
+LPD8RK.hotcues["9029"][5] = new Array("[Channel1]", "29", 0x90, 0x29);
+LPD8RK.hotcues["9025"][5] = new Array("[Channel1]", "30", 0x90, 0x25);
+
+//##################
+//preset 2 (group, cuenum, status, ctrl)
+//initialize
+LPD8RK.hotcues["912c"] = new Array();
+LPD8RK.hotcues["9127"] = new Array();
+LPD8RK.hotcues["912e"] = new Array();
+LPD8RK.hotcues["912a"] = new Array();
+LPD8RK.hotcues["9126"] = new Array();
+LPD8RK.hotcues["9124"] = new Array();
+//bank 1
+LPD8RK.hotcues["912c"][1] = new Array("[Channel2]", "1", 0x91, 0x2c);
+LPD8RK.hotcues["9127"][1] = new Array("[Channel2]", "2", 0x91, 0x27);
+LPD8RK.hotcues["912e"][1] = new Array("[Channel2]", "3", 0x91, 0x2e);
+LPD8RK.hotcues["912a"][1] = new Array("[Channel2]", "4", 0x91, 0x2a);
+LPD8RK.hotcues["9126"][1] = new Array("[Channel2]", "5", 0x91, 0x26);
+LPD8RK.hotcues["9124"][1] = new Array("[Channel2]", "6", 0x91, 0x24);
+//bank 2
+LPD8RK.hotcues["912c"][2] = new Array("[Channel2]", "7", 0x91, 0x2c);
+LPD8RK.hotcues["9127"][2] = new Array("[Channel2]", "8", 0x91, 0x27);
+LPD8RK.hotcues["912e"][2] = new Array("[Channel2]", "9", 0x91, 0x2e);
+LPD8RK.hotcues["912a"][2] = new Array("[Channel2]", "10", 0x91, 0x2a);
+LPD8RK.hotcues["9126"][2] = new Array("[Channel2]", "11", 0x91, 0x26);
+LPD8RK.hotcues["9124"][2] = new Array("[Channel2]", "12", 0x91, 0x24);
+//bank 3
+LPD8RK.hotcues["912c"][3] = new Array("[Channel2]", "13", 0x91, 0x2c);
+LPD8RK.hotcues["9127"][3] = new Array("[Channel2]", "14", 0x91, 0x27);
+LPD8RK.hotcues["912e"][3] = new Array("[Channel2]", "15", 0x91, 0x2e);
+LPD8RK.hotcues["912a"][3] = new Array("[Channel2]", "16", 0x91, 0x2a);
+LPD8RK.hotcues["9126"][3] = new Array("[Channel2]", "17", 0x91, 0x26);
+LPD8RK.hotcues["9124"][3] = new Array("[Channel2]", "18", 0x91, 0x24);
+//bank 4
+LPD8RK.hotcues["912c"][4] = new Array("[Channel2]", "19", 0x91, 0x2c);
+LPD8RK.hotcues["9127"][4] = new Array("[Channel2]", "20", 0x91, 0x27);
+LPD8RK.hotcues["912e"][4] = new Array("[Channel2]", "21", 0x91, 0x2e);
+LPD8RK.hotcues["912a"][4] = new Array("[Channel2]", "22", 0x91, 0x2a);
+LPD8RK.hotcues["9126"][4] = new Array("[Channel2]", "23", 0x91, 0x26);
+LPD8RK.hotcues["9124"][4] = new Array("[Channel2]", "24", 0x91, 0x24);
+//bank 5
+LPD8RK.hotcues["912c"][5] = new Array("[Channel2]", "25", 0x91, 0x2c);
+LPD8RK.hotcues["9127"][5] = new Array("[Channel2]", "26", 0x91, 0x27);
+LPD8RK.hotcues["912e"][5] = new Array("[Channel2]", "27", 0x91, 0x2e);
+LPD8RK.hotcues["912a"][5] = new Array("[Channel2]", "28", 0x91, 0x2a);
+LPD8RK.hotcues["9126"][5] = new Array("[Channel2]", "29", 0x91, 0x26);
+LPD8RK.hotcues["9124"][5] = new Array("[Channel2]", "30", 0x91, 0x24);
+
+//##################
+//preset 3 (group, cuenum, status, ctrl)
+//initialize
+LPD8RK.hotcues["9248"] = new Array();
+LPD8RK.hotcues["9241"] = new Array();
+LPD8RK.hotcues["9247"] = new Array();
+LPD8RK.hotcues["9240"] = new Array();
+LPD8RK.hotcues["9245"] = new Array();
+LPD8RK.hotcues["923e"] = new Array();
+//bank 1
+LPD8RK.hotcues["9248"][1] = new Array("[Sampler1]", "1", 0x92, 0x48);
+LPD8RK.hotcues["9241"][1] = new Array("[Sampler1]", "2", 0x92, 0x41);
+LPD8RK.hotcues["9247"][1] = new Array("[Sampler1]", "3", 0x92, 0x47);
+LPD8RK.hotcues["9240"][1] = new Array("[Sampler1]", "4", 0x92, 0x40);
+LPD8RK.hotcues["9245"][1] = new Array("[Sampler1]", "5", 0x92, 0x45);
+LPD8RK.hotcues["923e"][1] = new Array("[Sampler1]", "6", 0x92, 0x3e);
+//bank 2
+LPD8RK.hotcues["9248"][2] = new Array("[Sampler1]", "7", 0x92, 0x48);
+LPD8RK.hotcues["9241"][2] = new Array("[Sampler1]", "8", 0x92, 0x41);
+LPD8RK.hotcues["9247"][2] = new Array("[Sampler1]", "9", 0x92, 0x47);
+LPD8RK.hotcues["9240"][2] = new Array("[Sampler1]", "10", 0x92, 0x40);
+LPD8RK.hotcues["9245"][2] = new Array("[Sampler1]", "11", 0x92, 0x45);
+LPD8RK.hotcues["923e"][2] = new Array("[Sampler1]", "12", 0x92, 0x3e);
+//bank 3
+LPD8RK.hotcues["9248"][3] = new Array("[Sampler1]", "13", 0x92, 0x48);
+LPD8RK.hotcues["9241"][3] = new Array("[Sampler1]", "14", 0x92, 0x41);
+LPD8RK.hotcues["9247"][3] = new Array("[Sampler1]", "15", 0x92, 0x47);
+LPD8RK.hotcues["9240"][3] = new Array("[Sampler1]", "16", 0x92, 0x40);
+LPD8RK.hotcues["9245"][3] = new Array("[Sampler1]", "17", 0x92, 0x45);
+LPD8RK.hotcues["923e"][3] = new Array("[Sampler1]", "18", 0x92, 0x3e);
+//bank 4
+LPD8RK.hotcues["9248"][4] = new Array("[Sampler1]", "19", 0x92, 0x48);
+LPD8RK.hotcues["9241"][4] = new Array("[Sampler1]", "20", 0x92, 0x41);
+LPD8RK.hotcues["9247"][4] = new Array("[Sampler1]", "21", 0x92, 0x47);
+LPD8RK.hotcues["9240"][4] = new Array("[Sampler1]", "22", 0x92, 0x40);
+LPD8RK.hotcues["9245"][4] = new Array("[Sampler1]", "23", 0x92, 0x45);
+LPD8RK.hotcues["923e"][4] = new Array("[Sampler1]", "24", 0x92, 0x3e);
+//bank 5
+LPD8RK.hotcues["9248"][5] = new Array("[Sampler1]", "25", 0x92, 0x48);
+LPD8RK.hotcues["9241"][5] = new Array("[Sampler1]", "26", 0x92, 0x41);
+LPD8RK.hotcues["9247"][5] = new Array("[Sampler1]", "27", 0x92, 0x47);
+LPD8RK.hotcues["9240"][5] = new Array("[Sampler1]", "28", 0x92, 0x40);
+LPD8RK.hotcues["9245"][5] = new Array("[Sampler1]", "29", 0x92, 0x45);
+LPD8RK.hotcues["923e"][5] = new Array("[Sampler1]", "30", 0x92, 0x3e);
+
+//##################
+//preset 4 (group, cuenum, status, ctrl)
+//initialize
+LPD8RK.hotcues["9330"] = new Array();
+LPD8RK.hotcues["9329"] = new Array();
+LPD8RK.hotcues["932f"] = new Array();
+LPD8RK.hotcues["9328"] = new Array();
+LPD8RK.hotcues["932d"] = new Array();
+LPD8RK.hotcues["9326"] = new Array();
+//bank 1
+LPD8RK.hotcues["9330"][1] = new Array("[Sampler2]", "1", 0x93, 0x30);
+LPD8RK.hotcues["9329"][1] = new Array("[Sampler2]", "2", 0x93, 0x29);
+LPD8RK.hotcues["932f"][1] = new Array("[Sampler2]", "3", 0x93, 0x2f);
+LPD8RK.hotcues["9328"][1] = new Array("[Sampler2]", "4", 0x93, 0x28);
+LPD8RK.hotcues["932d"][1] = new Array("[Sampler2]", "5", 0x93, 0x2d);
+LPD8RK.hotcues["9326"][1] = new Array("[Sampler2]", "6", 0x93, 0x26);
+//bank 2
+LPD8RK.hotcues["9330"][2] = new Array("[Sampler2]", "7", 0x93, 0x30);
+LPD8RK.hotcues["9329"][2] = new Array("[Sampler2]", "8", 0x93, 0x29);
+LPD8RK.hotcues["932f"][2] = new Array("[Sampler2]", "9", 0x93, 0x2f);
+LPD8RK.hotcues["9328"][2] = new Array("[Sampler2]", "10", 0x93, 0x28);
+LPD8RK.hotcues["932d"][2] = new Array("[Sampler2]", "11", 0x93, 0x2d);
+LPD8RK.hotcues["9326"][2] = new Array("[Sampler2]", "12", 0x93, 0x26);
+//bank 3
+LPD8RK.hotcues["9330"][3] = new Array("[Sampler2]", "13", 0x93, 0x30);
+LPD8RK.hotcues["9329"][3] = new Array("[Sampler2]", "14", 0x93, 0x29);
+LPD8RK.hotcues["932f"][3] = new Array("[Sampler2]", "15", 0x93, 0x2f);
+LPD8RK.hotcues["9328"][3] = new Array("[Sampler2]", "16", 0x93, 0x28);
+LPD8RK.hotcues["932d"][3] = new Array("[Sampler2]", "17", 0x93, 0x2d);
+LPD8RK.hotcues["9326"][3] = new Array("[Sampler2]", "18", 0x93, 0x26);
+//bank 4
+LPD8RK.hotcues["9330"][4] = new Array("[Sampler2]", "19", 0x93, 0x30);
+LPD8RK.hotcues["9329"][4] = new Array("[Sampler2]", "20", 0x93, 0x29);
+LPD8RK.hotcues["932f"][4] = new Array("[Sampler2]", "21", 0x93, 0x2f);
+LPD8RK.hotcues["9328"][4] = new Array("[Sampler2]", "22", 0x93, 0x28);
+LPD8RK.hotcues["932d"][4] = new Array("[Sampler2]", "23", 0x93, 0x2d);
+LPD8RK.hotcues["9326"][4] = new Array("[Sampler2]", "24", 0x93, 0x26);
+//bank 5
+LPD8RK.hotcues["9330"][5] = new Array("[Sampler2]", "25", 0x93, 0x30);
+LPD8RK.hotcues["9329"][5] = new Array("[Sampler2]", "26", 0x93, 0x29);
+LPD8RK.hotcues["932f"][5] = new Array("[Sampler2]", "27", 0x93, 0x2f);
+LPD8RK.hotcues["9328"][5] = new Array("[Sampler2]", "28", 0x93, 0x28);
+LPD8RK.hotcues["932d"][5] = new Array("[Sampler2]", "29", 0x93, 0x2d);
+LPD8RK.hotcues["9326"][5] = new Array("[Sampler2]", "30", 0x93, 0x26);
+
+
+
+
+//map hotcue loop and leds
+LPD8RK.loops = new Array();
+//preset 1 (group, beatloop_len, status, ctrl)
+LPD8RK.loops["b09"] = new Array("[Channel1]", "1", 0xB0, 0x09);
+LPD8RK.loops["b04"] = new Array("[Channel1]", "2", 0xB0, 0x04);
+LPD8RK.loops["b08"] = new Array("[Channel1]", "4", 0xB0, 0x08);
+LPD8RK.loops["b03"] = new Array("[Channel1]", "8", 0xB0, 0x03);
+
+//preset 2 (group, beatloop_len, status, ctrl)
+LPD8RK.loops["b19"] = new Array("[Channel2]", "1", 0xB1, 0x09);
+LPD8RK.loops["b14"] = new Array("[Channel2]", "2", 0xB1, 0x04);
+LPD8RK.loops["b18"] = new Array("[Channel2]", "4", 0xB1, 0x08);
+LPD8RK.loops["b13"] = new Array("[Channel2]", "8", 0xB1, 0x03);
+
+//preset 3 (group, beatloop_len, status, ctrl)
+LPD8RK.loops["b29"] = new Array("[Sampler1]", "1", 0xB2, 0x09);
+LPD8RK.loops["b24"] = new Array("[Sampler1]", "2", 0xB2, 0x04);
+LPD8RK.loops["b28"] = new Array("[Sampler1]", "4", 0xB2, 0x08);
+LPD8RK.loops["b23"] = new Array("[Sampler1]", "8", 0xB2, 0x03);
+
+//preset 4 (group, beatloop_len, status, ctrl)
+LPD8RK.loops["b39"] = new Array("[Sampler2]", "1", 0xB3, 0x09);
+LPD8RK.loops["b34"] = new Array("[Sampler2]", "2", 0xB3, 0x04);
+LPD8RK.loops["b38"] = new Array("[Sampler2]", "4", 0xB3, 0x08);
+LPD8RK.loops["b33"] = new Array("[Sampler2]", "8", 0xB3, 0x03);
+
+
+
+LPD8RK.init = function (id, debug) { // called when the device is opened & set up
+	if (LPD8RK.debug){print("###init##############")};
+	//soft takeovers
+	engine.softTakeover("[Master]","crossfader",true);
+	engine.softTakeover("[Channel1]","volume",true);
+	engine.softTakeover("[Channel1]","rate",true);
+	engine.softTakeover("[Channel2]","volume",true);
+	engine.softTakeover("[Channel2]","rate",true);
+	engine.softTakeover("[Sampler1]","volume",true);
+	engine.softTakeover("[Sampler1]","rate",true);
+	engine.softTakeover("[Sampler2]","volume",true);
+	engine.softTakeover("[Sampler2]","rate",true);
+	
+	//set LED timer
+	LPD8RK.ledTimer = engine.beginTimer(LPD8RK.LEDinterval, "LPD8RK.setLeds()");
+};
+
+LPD8RK.shutdown = function () {
+	engine.stopTimer(LPD8RK.ledTimer);
+};
+
+LPD8RK.resetLEDTimer = function () {
+	engine.stopTimer(LPD8RK.ledTimer);
+	LPD8RK.setLeds()
+	LPD8RK.ledTimer = engine.beginTimer(LPD8RK.LEDinterval, "LPD8RK.setLeds()");
+};
+
+LPD8RK.setLeds = function () {
+	//runs repeatedly on a timer set in init()
+	//has to run on a timer because you apparently can only set LEDs on the current prog selection on the LPD8
+	//ie: leds on a PAD or CC other than the one you're currently using can't be set.
+	//and no midi messages are sent when you change a PROG or pad.  No way of telling MIXXX which LEDs are currently active
+	//so, this runs 4x a second to make sure LEDs are updated.  Kludge, but so it goes.
+
+	//hotcues
+	for (var id in LPD8RK.hotcues){
+		for (var bank in LPD8RK.hotcues[id]){
+			//iterate through hotcues for current bank, set hotcue leds
+			var status = LPD8RK.hotcues[id][LPD8RK.hotcueBank][2];
+			var ctrl = LPD8RK.hotcues[id][LPD8RK.hotcueBank][3];
+			var state = engine.getValue(LPD8RK.hotcues[id][LPD8RK.hotcueBank][0], "hotcue_"+LPD8RK.hotcues[id][LPD8RK.hotcueBank][1]+"_enabled");
+
+			//if (LPD8RK.debug){print("midi.sendShortMsg("+status+", "+ctrl+", "+state+")")};
+			
+			LPD8RK.lightLED(status, ctrl, state);
+			};
+		};
+	
+	//loops
+	for (var id in LPD8RK.loops){
+		//iterate through hotcues, set hotcue leds
+		var status = LPD8RK.loops[id][2];
+		var ctrl = LPD8RK.loops[id][3];
+		var state = engine.getValue(LPD8RK.loops[id][0], "beatloop_"+LPD8RK.loops[id][1]+"_enabled");
+
+		//if (LPD8RK.debug){print("midi.sendShortMsg("+status+", "+ctrl+", "+state+")")};
+	
+		LPD8RK.lightLED(status, ctrl, state);
+		};
+	
+	//reloop buttons
+	LPD8RK.lightLED(0xb0, 0x01, engine.getValue("[Channel1]", "loop_enabled"));	
+	LPD8RK.lightLED(0xb1, 0x01, engine.getValue("[Channel2]", "loop_enabled"));	
+	LPD8RK.lightLED(0xb2, 0x01, engine.getValue("[Sampler1]", "loop_enabled"));	
+	LPD8RK.lightLED(0xb3, 0x01, engine.getValue("[Sampler2]", "loop_enabled"));	
+	};
+
+LPD8RK.lightLED = function (status, ctrl, state){
+	//function to check for valid LED lighting messages - LPD8 seems to go into a weird nonresponsive mode when some unknown code is sent to it
+	//don't know what the messed code is, but this function checks for valid LED addresses.  Hopefully this will prevent problems.
+	if (LPD8RK.validLEDS[status][ctrl] !== true){
+		print("######## INVALID STATUS ########");
+		return false;
+		} else {
+		if (state > 0 || state === true){state=1;}//make sure state is valid
+		midi.sendShortMsg(status, ctrl, state);
+		}
+	};	
+	
+LPD8RK.clear = function (){//enables hotcue clearing
+	if (LPD8RK.debug){print("###hotcueclear##############")};
+	LPD8RK.hotcueClear=true;
+	};
+
+LPD8RK.noclear = function (){//disables hotcue clearing
+	LPD8RK.hotcueClear=false;
+	};
+
+LPD8RK.hotcueButton = function (channel, control, value, status, group) {
+	//weird status bug workaround
+	if (channel==0 && status != 0x90){status = 0x90};
+	if (channel==1 && status != 0x91){status = 0x91};
+	if (channel==2 && status != 0x92){status = 0x92};
+	if (channel==3 && status != 0x93){status = 0x93};
+
+	if (LPD8RK.debug){print("###hotcueButton##############")};
+	if (LPD8RK.debug){print("status:"+status)};
+	if (LPD8RK.debug){print("channel:"+channel)};
+	if (LPD8RK.debug){print("control:"+control)};
+	if (LPD8RK.debug){print("hotcuebank:"+LPD8RK.hotcueBank)};
+	if (LPD8RK.debug){print("phrase:#"+status.toString(16).toLowerCase()+control.toString(16).toLowerCase()+"#")};
+	//activate or clear depending on whether clear button is pressed
+	var thecue = LPD8RK.hotcues[status.toString(16).toLowerCase()+control.toString(16).toLowerCase()][LPD8RK.hotcueBank];
+	if (LPD8RK.hotcueClear){
+		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_clear", 1);
+		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_clear", 0);
+		if (LPD8RK.debug){print("cleared")};
+		} else {
+		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_activate", 1);
+		engine.setValue(thecue[0], "hotcue_"+thecue[1]+"_activate", 0);
+		if (LPD8RK.debug){print("###"+status.toString(16).toLowerCase()+control.toString(16).toLowerCase()+"--activated")};
+		};
+
+	};
+
+LPD8RK.loopButton = function (channel, control, value, status, group) {
+	if (LPD8RK.debug){print(LPD8RK.looplen+"len");}
+	if (LPD8RK.debug){print(LPD8RK.looptype+"type");}
+	//activate beatloop
+	var theloop = LPD8RK.loops[status.toString(16).toLowerCase()+control.toString(16).toLowerCase()];
+	if (value>0){//button was pressed
+		LPD8RK.loopbuttonDown=true;
+		engine.setValue(group, LPD8RK.looptype+"_"+theloop[1]+"_activate", 1);
+		} else {//button was released
+		LPD8RK.loopbuttonDown=false;
+		};
+
+	};
+
+LPD8RK.reloopButton = function (channel, control, value, status, group) {
+	if (LPD8RK.debug){print(LPD8RK.looplen+"len");}
+	if (LPD8RK.debug){print(LPD8RK.looptype+"type");}
+	
+	if (value>0){//button was pressed
+		engine.stopTimer(LPD8RK.reloopTimer);
+		LPD8RK.loopbuttonDown=true;
+		LPD8RK.doreloop=true;
+		LPD8RK.reloopTimer = engine.beginTimer(500, "LPD8RK.disablereloop()", true);
+		} else {//button was released
+		LPD8RK.loopbuttonDown=false;
+		if (LPD8RK.doreloop===true) {engine.setValue(group, "reloop_exit", 1);};
+		LPD8RK.doreloop=true;
+		engine.stopTimer(LPD8RK.reloopTimer);
+		};
+
+	};
+
+LPD8RK.disablereloop = function () {
+	//timed function - fires half a second after pressing reloop.  Don't do the reloop if you hold down the button (so you can move the loop without exiting)
+	LPD8RK.doreloop=false;
+	};
+
+LPD8RK.looptypeDial = function (channel, control, value, status, group) {
+	//activates variable length type depending on dial position
+	//beatlooproll only works in 1.11 or above - script is a placeholder, knob used to select hotcue bank for now
+	//if(value>63){LPD8RK.looptype="beatlooproll";}else{LPD8RK.looptype="beatloop";}
+	//if (LPD8RK.debug){print(LPD8RK.looptype);}
+	};
+
+LPD8RK.resetOldBank = function () {
+	//clears stored old hotcue bank
+	LPD8RK.oldHotcueBank=0;
+	};
+
+LPD8RK.hotcueBankDial = function (channel, control, value, status, group) {
+	//sets which hotcue bank to display (separate this out on dedicated controller)
+	
+	//pause LED resets, so bank indicator lights will be visible
+	engine.stopTimer(LPD8RK.ledTimer);
+
+	//select hotcue bank
+	if (value>=0 && value <=12){LPD8RK.hotcueBank=1;};
+	if (value>12 && value <=46){LPD8RK.hotcueBank=2;};
+	if (value>46 && value <=80){LPD8RK.hotcueBank=3;};
+	if (value>80 && value <=114){LPD8RK.hotcueBank=4;};
+	if (value>114 && value <=128){LPD8RK.hotcueBank=5;};
+
+	//light up indicator light
+	if (LPD8RK.oldHotcueBank != LPD8RK.hotcueBank){//check if the bank's changed.  If it has, change the LEDs - LPD8RK.oldHotcueBank != LPD8RK.hotcueBank
+		for (var id in LPD8RK.hotcues){
+			for (var bank in LPD8RK.hotcues[id][1]){
+				var status = LPD8RK.hotcues[id][1][2];
+				var ctrl = LPD8RK.hotcues[id][1][3];
+				//find bank number indicator light
+				if (LPD8RK.hotcues[id][1][1]==LPD8RK.hotcueBank){
+					var state = 1;
+					}else{
+					var state = 0;
+					};
+
+				LPD8RK.lightLED(status, ctrl, state);
+				};
+			};
+		};
+	//record last hotcue bank
+	LPD8RK.oldHotcueBank=LPD8RK.hotcueBank;
+	//set timer to clear old bank number after 500 msec, so bank indicator light will light up
+	engine.stopTimer(LPD8RK.oldbanktimer);
+	LPD8RK.oldbanktimer = engine.beginTimer(500, "LPD8RK.resetOldBank()", true);	
+
+	//set timer to restart LED updates in 500 msec
+	engine.stopTimer(LPD8RK.LEDPauseTimer);
+	LPD8RK.LEDPauseTimer = engine.beginTimer(LPD8RK.LEDinterval, "LPD8RK.resetLEDTimer()", true);	
+	};
+
+LPD8RK.looplenDial = function (channel, control, value, status, group) {
+	//activates variable length loop depending on dial position
+	LPD8RK.looplen=value;
+
+	if (LPD8RK.loopbuttonDown !== true){return false;}//exit if no loop button down 
+	else if (LPD8RK.looplen<=0x12){engine.setValue(group, LPD8RK.looptype+"_0.0625_activate", .0625);return true;} else 
+	if (LPD8RK.looplen<=0x25){engine.setValue(group, LPD8RK.looptype+"_0.125_activate", .125);return true;} else 
+	if (LPD8RK.looplen<=0x37){engine.setValue(group, LPD8RK.looptype+"_0.25_activate", .25);return true;} else 
+	if (LPD8RK.looplen<=0x49){engine.setValue(group, LPD8RK.looptype+"_0.5_activate", .5);return true;} else 
+	if (LPD8RK.looplen<=0x5b){engine.setValue(group, LPD8RK.looptype+"_1_activate", 1);return true;} else 
+	if (LPD8RK.looplen<=0x6d){engine.setValue(group, LPD8RK.looptype+"_2_activate", 2);return true;} else 
+	if (LPD8RK.looplen<=0x70){engine.setValue(group, LPD8RK.looptype+"_4_activate", 4);return true;} else	
+	if (LPD8RK.looplen<=0x7f){engine.setValue(group, LPD8RK.looptype+"_8_activate", 8);return true;};	
+	};
+
+LPD8RK.loopminus = function (channel, control, value, status, group) {
+	//shrinks loop or moves loop back
+	if (LPD8RK.loopbuttonDown !== true){engine.setValue(group, "loop_halve", 1);engine.setValue(group, "loop_halve", 0); return false;}//shrink loop if no loop button down 
+	else if (engine.getValue(group, "loop_start_position")>=0 && engine.getValue(group, "loop_end_position")>=0 ){
+		//move loop
+		var interval =	LPD8RK.loopmove*engine.getValue(group, "track_samples")/engine.getValue(group, "duration");
+		var start = engine.getValue(group, "loop_start_position");
+		var end = engine.getValue(group, "loop_end_position");
+		engine.setValue(group, "loop_start_position", start-interval);
+		engine.setValue(group, "loop_end_position", end-interval);
+		return true;
+		};
+	};
+
+LPD8RK.loopplus = function (channel, control, value, status, group) {
+	//grows loop or moves loop forward
+	if (LPD8RK.loopbuttonDown !== true){engine.setValue(group, "loop_double", 1); engine.setValue(group, "loop_double", 0); return false;}//shrink loop if no loop button down 
+	else if (engine.getValue(group, "loop_start_position")>=0 && engine.getValue(group, "loop_end_position")>=0 ){
+		//move loop
+		var interval =	LPD8RK.loopmove*engine.getValue(group, "track_samples")/engine.getValue(group, "duration");
+		var start = engine.getValue(group, "loop_start_position");
+		var end = engine.getValue(group, "loop_end_position");
+		engine.setValue(group, "loop_start_position", start+interval);
+		engine.setValue(group, "loop_end_position", end+interval);
+		return true;
+		};
+	};
+
+LPD8RK.beatjump = function (channel, control, value, status, group) {
+	//jumps back certain number of beats depending on knob modifier
+	var curpos = engine.getValue(group, "playposition")*engine.getValue(group, "track_samples");
+	var numbeats = LPD8RK.beatjumpstep;
+	var backseconds = numbeats*(1/(engine.getValue(group, "bpm")/60));
+	var backsamples = backseconds*engine.getValue(group, "track_samples")/engine.getValue(group, "duration");
+	var newpos = curpos-(backsamples+engine.getValue("Master", "latency"));
+	
+	if (LPD8RK.debug){print("backseconds: "+backseconds);}
+	if (LPD8RK.debug){print("backsamples: "+backsamples);}
+	if (LPD8RK.debug){print("curpos: "+curpos);}
+	if (LPD8RK.debug){print("newpos: "+newpos);}
+	if (LPD8RK.debug){print("numbeats: "+numbeats);}
+	
+	engine.setValue(group, "playposition", newpos/engine.getValue(group, "track_samples"));
+	};
+
+LPD8RK.beatjumpDial = function (channel, control, value, status, group) {
+	//activates variable length loop depending on dial position
+	if(value>=0 && value <=127){
+		if (value<=1){LPD8RK.beatjumpstep=.25; return true;} else 
+		if (value<=31){LPD8RK.beatjumpstep=.5; return true;} else 	
+		if (value<=63){LPD8RK.beatjumpstep=1; return true;} else 	
+		if (value<=94){LPD8RK.beatjumpstep=2; return true;} else 	
+		if (value<=125){LPD8RK.beatjumpstep=4; return true;} else 	
+		if (value<=127){LPD8RK.beatjumpstep=8; return true;};
+		};	
+	};
+
+LPD8RK.mute = function (group) {
+	//toggles mute, then returns to previous volume
+	storedvol=LPD8RK.vol[group];
+	curvol=engine.getValue(group, "volume");
+	engine.softTakeover(group,"volume",false);
+	if (curvol==0){//is muted.  unmute.
+		engine.setValue(group, "volume", storedvol);
+		}else{//is not muted.  mute.
+		engine.setValue(group, "volume", 0);
+		LPD8RK.vol[group]=curvol;
+		};
+	engine.softTakeover(group,"volume",true);
+	
+	if (LPD8RK.debug){print("MUTE");}
+	};
+
+LPD8RK.progChng = function (channel, control, value, status, group) {
+	if (LPD8RK.debug){print("###PROG CHANGE###");}
+	//workaround because prog chng buttons don't seem to like to work unless they're linked to scripts
+	if (control==0x07){LPD8RK.toggleplay(group, engine.getValue(group, "play")); return true;} else 
+	if (control==0x03){engine.setValue(group, "cue_default", true); engine.setValue(group, "cue_default", false); return true;} else 
+	if (control==0x06){engine.setValue(group, "beatsync", true); engine.setValue(group, "beatsync", false); return true;} else 
+	if (control==0x02){LPD8RK.togglepfl(group, engine.getValue(group, "pfl")); return true;} else 
+	if (control==0x05){LPD8RK.togglereverse(group, engine.getValue(group, "reverse")); return true;} else 
+	if (control==0x04){LPD8RK.toggleback(group, engine.getValue(group, "back")); return true;} else 
+	if (control==0x00){LPD8RK.togglefwd(group, engine.getValue(group, "fwd")); return true;}
+	if (control==0x01){LPD8RK.mute(group); return true;}
+	};
+
+LPD8RK.toggleplay = function (group, state) {
+	if (state==true){engine.setValue(group, "reverse",0);engine.setValue(group, "play", false);} else {engine.setValue(group, "reverse",0);engine.setValue(group, "play", true);};
+	};
+
+LPD8RK.togglepfl = function (group, state) {
+	if (state==true){engine.setValue(group, "pfl", false);} else {engine.setValue(group, "pfl", true);};
+	};
+
+LPD8RK.togglereverse = function (group, state) {
+	if (state==true){engine.setValue(group, "reverse", false);} else {engine.setValue(group, "reverse", true);};	
+	};
+
+LPD8RK.toggleback = function (group, state) {
+	if (state==true){engine.setValue(group, "back", false);} else {engine.setValue(group, "back", true);};	
+	};
+
+LPD8RK.togglefwd = function (group, state) {
+	if (state==true){engine.setValue(group, "fwd", false);} else {engine.setValue(group, "fwd", true);};	
+	};
+
+LPD8RK.softXfade = function (channel, control, value, status, group) {
+	engine.setValue(group, "crossfader", (value/64)-1);
+	};
+
+LPD8RK.softVolume = function (channel, control, value, status, group) {
+	engine.setValue(group, "volume", (value/127));
+	};
+
+LPD8RK.softRate = function (channel, control, value, status, group) {
+	engine.setValue(group, "rate", (value/64)-1);
+	};
+
+
+LPD8RK.test = function (channel, control, value, status, group) {
+	print("channel: "+channel);
+	print("control: "+control.toString(16));
+	print("value: "+value);
+	print("status: "+status);
+	print("group: "+group);
+	print("test: ##"+status.toString(16)+control.toString(16)+"##");
+	print("loopbuttondown: ##"+LPD8RK.loopbuttonDown+"##");
+	print("LPD8RK.looplen: ##"+LPD8RK.looplen+"##");
+	print("LPD8RK.looplen.tostring: ##"+LPD8RK.looplen.toString(16)+"##");
+	print("LPD8RK.looptype: ##"+LPD8RK.looptype+"##");
+	print("test: ##"+2+"##");
+	};
+
+