[SugarCubes.git] / _MIDI.pde

/**
 *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
 *
 *         //\\   //\\                 //\\   //\\  
 *        ///\\\ ///\\\               ///\\\ ///\\\
 *        \\\/// \\\///               \\\/// \\\///
 *         \\//   \\//                 \\//   \\//
 *
 *        EXPERTS ONLY!!              EXPERTS ONLY!!
 *
 * This file defines the MIDI mapping interfaces. This shouldn't
 * need editing unless you're adding top level support for a
 * specific MIDI device of some sort. Generally, all MIDI devices
 * will just work with the default configuration, and you can
 * set your SCPattern class to respond to the controllers that you
 * care about.
 */

interface MidiEngineListener {
  public void onFocusedDeck(int deckIndex);
}

class MidiEngine {

  private final List<MidiEngineListener> listeners = new ArrayList<MidiEngineListener>();
  private final List<SCMidiInput> midiControllers = new ArrayList<SCMidiInput>();

  public MidiEngine addListener(MidiEngineListener l) {
    listeners.add(l);
    return this;
  }

  public MidiEngine removeListener(MidiEngineListener l) {
    listeners.remove(l);
    return this;
  }

  private SCMidiInput midiQwertyKeys;
  private SCMidiInput midiQwertyAPC;

  private int activeDeckIndex = 0;

  public MidiEngine() {

    midiControllers.add(midiQwertyKeys = new SCMidiInput(SCMidiInput.KEYS));
    midiControllers.add(midiQwertyAPC = new SCMidiInput(SCMidiInput.APC));
    for (MidiInputDevice device : RWMidi.getInputDevices()) {
      if (device.getName().contains("APC")) {
        midiControllers.add(new APC40MidiInput(device).setEnabled(true));
      } else if (device.getName().contains("SLIDER/KNOB KORG")) {
        midiControllers.add(new KorgNanoKontrolMidiInput(device).setEnabled(true));
      } else {
        boolean enabled = device.getName().contains("KEYBOARD KORG");
        midiControllers.add(new SCMidiInput(device).setEnabled(enabled));
      }
    }
  }

  public List<SCMidiInput> getControllers() {
    return this.midiControllers;
  }

  public MidiEngine setFocusedDeck(int deckIndex) {
    if (this.activeDeckIndex != deckIndex) {
      this.activeDeckIndex = deckIndex;
      for (MidiEngineListener listener : listeners) {
        listener.onFocusedDeck(deckIndex);
      }
    }
    return this;
  }

  public Engine.Deck getFocusedDeck() {
    return lx.engine.getDeck(activeDeckIndex);
  }

  public boolean isQwertyEnabled() {
    return midiQwertyKeys.isEnabled() || midiQwertyAPC.isEnabled();
  }
}

public interface SCMidiInputListener {
  public void onEnabled(SCMidiInput controller, boolean enabled);
}

public class SCMidiInput extends AbstractScrollItem {

  public static final int MIDI = 0;
  public static final int KEYS = 1;
  public static final int APC = 2;

  private boolean enabled = false;
  private final String name;
  private final int mode;
  private int octaveShift = 0;

  class NoteMeta {
    int channel;
    int number;
    NoteMeta(int channel, int number) {
      this.channel = channel;
      this.number = number;
    }
  }

  final Map<Character, NoteMeta> keyToNote = new HashMap<Character, NoteMeta>();

  final List<SCMidiInputListener> listeners = new ArrayList<SCMidiInputListener>();

  public SCMidiInput addListener(SCMidiInputListener l) {
    listeners.add(l);
    return this;
  }

  public SCMidiInput removeListener(SCMidiInputListener l) {
    listeners.remove(l);
    return this;
  }

  SCMidiInput(MidiInputDevice d) {
    mode = MIDI;
    d.createInput(this);
    name = d.getName().replace("Unknown vendor","");
  }

  SCMidiInput(int mode) {
    this.mode = mode;
    switch (mode) {
    case APC:
      name = "QWERTY (APC Mode)";
      mapAPC();
      break;
    default:
    case KEYS:
      name = "QWERTY (Key Mode)";
      mapKeys();
      break;
    }
  }

  private void mapAPC() {
    mapNote('1', 0, 53);
    mapNote('2', 1, 53);
    mapNote('3', 2, 53);
    mapNote('4', 3, 53);
    mapNote('5', 4, 53);
    mapNote('6', 5, 53);
    mapNote('q', 0, 54);
    mapNote('w', 1, 54);
    mapNote('e', 2, 54);
    mapNote('r', 3, 54);
    mapNote('t', 4, 54);
    mapNote('y', 5, 54);
    mapNote('a', 0, 55);
    mapNote('s', 1, 55);
    mapNote('d', 2, 55);
    mapNote('f', 3, 55);
    mapNote('g', 4, 55);
    mapNote('h', 5, 55);
    mapNote('z', 0, 56);
    mapNote('x', 1, 56);
    mapNote('c', 2, 56);
    mapNote('v', 3, 56);
    mapNote('b', 4, 56);
    mapNote('n', 5, 56);
    registerKeyEvent(this);
  }

  private void mapKeys() {
    int note = 48;
    mapNote('a', 1, note++);
    mapNote('w', 1, note++);
    mapNote('s', 1, note++);
    mapNote('e', 1, note++);
    mapNote('d', 1, note++);
    mapNote('f', 1, note++);
    mapNote('t', 1, note++);
    mapNote('g', 1, note++);
    mapNote('y', 1, note++);
    mapNote('h', 1, note++);
    mapNote('u', 1, note++);
    mapNote('j', 1, note++);
    mapNote('k', 1, note++);
    mapNote('o', 1, note++);
    mapNote('l', 1, note++);
    registerKeyEvent(this);
  }

  void mapNote(char ch, int channel, int number) {
    keyToNote.put(ch, new NoteMeta(channel, number));
  }

  public String getLabel() {
    return name;
  }

  public void keyEvent(KeyEvent e) {
    if (!enabled) {
      return;
    }
    char c = Character.toLowerCase(e.getKeyChar());
    NoteMeta nm = keyToNote.get(c);
    if (nm != null) {
      switch (e.getID()) {
      case KeyEvent.KEY_PRESSED:
        noteOnReceived(new Note(Note.NOTE_ON, nm.channel, nm.number + octaveShift*12, 127));
        break;
      case KeyEvent.KEY_RELEASED:
        noteOffReceived(new Note(Note.NOTE_OFF, nm.channel, nm.number + octaveShift*12, 0));
        break;
      }
    }
    if ((mode == KEYS) && (e.getID() == KeyEvent.KEY_PRESSED)) {
      switch (c) {
      case 'z':
        octaveShift = constrain(octaveShift-1, -4, 4);
        break;
      case 'x':
        octaveShift = constrain(octaveShift+1, -4, 4);
        break;
      }
    }
  }

  public boolean isEnabled() {
    return enabled;
  }

  public boolean isSelected() {
    return enabled;
  }

  public void onMousePressed() {
    setEnabled(!enabled);
  }

  public SCMidiInput setEnabled(boolean enabled) {
    if (enabled != this.enabled) {
      this.enabled = enabled;
      for (SCMidiInputListener l : listeners) {
        l.onEnabled(this, enabled);
      }
    }
    return this;
  }

  protected SCPattern getFocusedPattern() {
    return (SCPattern) midiEngine.getFocusedDeck().getActivePattern();
  }

  private boolean logMidi() {
    return (uiMidi != null) && uiMidi.logMidi();
  }

  final void programChangeReceived(ProgramChange pc) {
    if (!enabled) {
      return;
    }
    if (logMidi()) {
      println(getLabel() + " :: Program Change :: " + pc.getNumber());
    }
    handleProgramChange(pc);
  }

  final void controllerChangeReceived(rwmidi.Controller cc) {
    if (!enabled) {
      return;
    }
    if (logMidi()) {
      println(getLabel() + " :: Controller :: " + cc.getCC() + ":" + cc.getValue());
    }
    if (!getFocusedPattern().controllerChangeReceived(cc)) {
      handleControllerChange(cc);
    }
  }

  final void noteOnReceived(Note note) {
    if (!enabled) {
      return;
    }
    if (logMidi()) {
      println(getLabel() + " :: Note On  :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
    }
    if (!getFocusedPattern().noteOnReceived(note)) {
      handleNoteOn(note);
    }
  }

  final void noteOffReceived(Note note) {
    if (!enabled) {
      return;
    }
    if (logMidi()) {
      println(getLabel() + " :: Note Off :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
    }
    if (!getFocusedPattern().noteOffReceived(note)) {
      handleNoteOff(note);
    }
  }

  // Subclasses may implement these to map top-level functionality
  protected void handleProgramChange(ProgramChange pc) {
  }
  protected void handleControllerChange(rwmidi.Controller cc) {
  }
  protected void handleNoteOn(Note note) {
  }
  protected void handleNoteOff(Note note) {
  }
}

public class APC40MidiInput extends SCMidiInput {

  private boolean shiftOn = false;
  private LXEffect releaseEffect = null;
  
  APC40MidiInput(MidiInputDevice d) {
    super(d);
  }

  protected void handleControllerChange(rwmidi.Controller cc) {
    int number = cc.getCC();
    switch (number) {
    // Crossfader
    case 15:
      lx.engine.getDeck(1).getCrossfader().setValue(cc.getValue() / 127.);
      break;
    }
    
    int parameterIndex = -1;
    if (number >= 48 && number <= 55) {
      parameterIndex = number - 48;
    } else if (number >= 16 && number <= 19) {
      parameterIndex = 8 + (number-16);
    }
    if (parameterIndex >= 0) {
      List<LXParameter> parameters = getFocusedPattern().getParameters();
      if (parameterIndex < parameters.size()) {
        parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
      }
    }
    
    if (number >= 20 && number <= 23) {
      int effectIndex = number - 20;
      List<LXParameter> parameters = glucose.getSelectedEffect().getParameters();
      if (effectIndex < parameters.size()) {
        parameters.get(effectIndex).setValue(cc.getValue() / 127.);
      }
    }
  }

  protected void handleNoteOn(Note note) {
    switch (note.getPitch()) {
    case 94: // right bank
      midiEngine.setFocusedDeck(1);
      break;
    case 95: // left bank
      midiEngine.setFocusedDeck(0);
      break;
    case 96: // up bank
      if (shiftOn) {
        glucose.incrementSelectedEffectBy(1);
      } else {
        midiEngine.getFocusedDeck().goNext();
      }
      break;
    case 97: // down bank
      if (shiftOn) {
        glucose.incrementSelectedEffectBy(-1);
      } else {
        midiEngine.getFocusedDeck().goPrev();
      }
      break;

    case 98: // shift
      shiftOn = true;
      break;

    case 99: // tap tempo
      lx.tempo.tap();
      break;
    case 100: // nudge+
      lx.tempo.setBpm(lx.tempo.bpm() + (shiftOn ? 1 : .1));
      break;
    case 101: // nudge-
      lx.tempo.setBpm(lx.tempo.bpm() - (shiftOn ? 1 : .1));
      break;

    case 91: // play
    case 93: // rec
      releaseEffect = glucose.getSelectedEffect(); 
      if (releaseEffect.isMomentary()) {
        releaseEffect.enable();
      } else {
        releaseEffect.toggle();
      }
      break;

    case 92: // stop
      glucose.getSelectedEffect().disable();
      break;
    }
  }

  protected void handleNoteOff(Note note) {
    switch (note.getPitch()) {
    case 93: // rec
      if (releaseEffect != null) {
        if (releaseEffect.isMomentary()) {
          releaseEffect.disable();
        }
      }
      break;
		
    case 98: // shift
      shiftOn = false;
       break;
    }
  }
}

class KorgNanoKontrolMidiInput extends SCMidiInput {
  
  KorgNanoKontrolMidiInput(MidiInputDevice d) {
    super(d);
  }
  
  protected void handleControllerChange(rwmidi.Controller cc) {
    int number = cc.getCC();
    if (number >= 16 && number <= 23) {
      int parameterIndex = number - 16;
      List<LXParameter> parameters = getFocusedPattern().getParameters();
      if (parameterIndex < parameters.size()) {
        parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
      }
    }
    
    if (cc.getValue() == 127) {
      switch (number) {
      // Left track
      case 58:
        midiEngine.setFocusedDeck(0);
        break;
      // Right track
      case 59:
        midiEngine.setFocusedDeck(1);
        break;
      // Left chevron
      case 43:
        midiEngine.getFocusedDeck().goPrev();
        break;
      // Right chevron
      case 44:
        midiEngine.getFocusedDeck().goNext();
        break;
      }
    }
  }
}
Commit	Line	Data
d6ac1ee8 MS	1	/**
	2	* DOUBLE BLACK DIAMOND DOUBLE BLACK DIAMOND
	3	*
	4	* //\\ //\\ //\\ //\\
	5	* ///\\\ ///\\\ ///\\\ ///\\\
	6	* \\\/// \\\/// \\\/// \\\///
	7	* \\// \\// \\// \\//
	8	*
	9	* EXPERTS ONLY!! EXPERTS ONLY!!
	10	*
	11	* This file defines the MIDI mapping interfaces. This shouldn't
	12	* need editing unless you're adding top level support for a
	13	* specific MIDI device of some sort. Generally, all MIDI devices
	14	* will just work with the default configuration, and you can
	15	* set your SCPattern class to respond to the controllers that you
	16	* care about.
	17	*/
	18
	19	interface MidiEngineListener {
	20	public void onFocusedDeck(int deckIndex);
	21	}
	22
	23	class MidiEngine {
	24
	25	private final List<MidiEngineListener> listeners = new ArrayList<MidiEngineListener>();
	26	private final List<SCMidiInput> midiControllers = new ArrayList<SCMidiInput>();
	27
	28	public MidiEngine addListener(MidiEngineListener l) {
	29	listeners.add(l);
	30	return this;
	31	}
	32
	33	public MidiEngine removeListener(MidiEngineListener l) {
	34	listeners.remove(l);
	35	return this;
	36	}
	37
	38	private SCMidiInput midiQwertyKeys;
	39	private SCMidiInput midiQwertyAPC;
	40
	41	private int activeDeckIndex = 0;
	42
	43	public MidiEngine() {
	44
	45	midiControllers.add(midiQwertyKeys = new SCMidiInput(SCMidiInput.KEYS));
	46	midiControllers.add(midiQwertyAPC = new SCMidiInput(SCMidiInput.APC));
	47	for (MidiInputDevice device : RWMidi.getInputDevices()) {
	48	if (device.getName().contains("APC")) {
	49	midiControllers.add(new APC40MidiInput(device).setEnabled(true));
	50	} else if (device.getName().contains("SLIDER/KNOB KORG")) {
	51	midiControllers.add(new KorgNanoKontrolMidiInput(device).setEnabled(true));
	52	} else {
cc8b3f82 MS	53	boolean enabled = device.getName().contains("KEYBOARD KORG");
cc8b3f82 MS	54	midiControllers.add(new SCMidiInput(device).setEnabled(enabled));
d6ac1ee8 MS	55	}
	56	}
	57	}
	58
	59	public List<SCMidiInput> getControllers() {
	60	return this.midiControllers;
	61	}
	62
	63	public MidiEngine setFocusedDeck(int deckIndex) {
	64	if (this.activeDeckIndex != deckIndex) {
	65	this.activeDeckIndex = deckIndex;
	66	for (MidiEngineListener listener : listeners) {
	67	listener.onFocusedDeck(deckIndex);
	68	}
	69	}
	70	return this;
	71	}
	72
	73	public Engine.Deck getFocusedDeck() {
	74	return lx.engine.getDeck(activeDeckIndex);
	75	}
	76
	77	public boolean isQwertyEnabled() {
	78	return midiQwertyKeys.isEnabled() \|\| midiQwertyAPC.isEnabled();
	79	}
	80	}
	81
	82	public interface SCMidiInputListener {
	83	public void onEnabled(SCMidiInput controller, boolean enabled);
	84	}
	85
	86	public class SCMidiInput extends AbstractScrollItem {
	87
	88	public static final int MIDI = 0;
	89	public static final int KEYS = 1;
	90	public static final int APC = 2;
	91
	92	private boolean enabled = false;
	93	private final String name;
	94	private final int mode;
	95	private int octaveShift = 0;
	96
	97	class NoteMeta {
	98	int channel;
	99	int number;
	100	NoteMeta(int channel, int number) {
	101	this.channel = channel;
	102	this.number = number;
	103	}
	104	}
	105
	106	final Map<Character, NoteMeta> keyToNote = new HashMap<Character, NoteMeta>();
	107
	108	final List<SCMidiInputListener> listeners = new ArrayList<SCMidiInputListener>();
	109
	110	public SCMidiInput addListener(SCMidiInputListener l) {
	111	listeners.add(l);
	112	return this;
	113	}
	114
	115	public SCMidiInput removeListener(SCMidiInputListener l) {
	116	listeners.remove(l);
	117	return this;
	118	}
119
120	SCMidiInput(MidiInputDevice d) {
121	mode = MIDI;
122	d.createInput(this);
123	name = d.getName().replace("Unknown vendor","");
124	}
125
126	SCMidiInput(int mode) {
127	this.mode = mode;
128	switch (mode) {
129	case APC:
130	name = "QWERTY (APC Mode)";
131	mapAPC();
132	break;
133	default:
134	case KEYS:
135	name = "QWERTY (Key Mode)";
136	mapKeys();
137	break;
138	}
139	}
140
141	private void mapAPC() {
142	mapNote('1', 0, 53);
143	mapNote('2', 1, 53);
144	mapNote('3', 2, 53);
145	mapNote('4', 3, 53);
146	mapNote('5', 4, 53);
147	mapNote('6', 5, 53);
148	mapNote('q', 0, 54);
149	mapNote('w', 1, 54);
150	mapNote('e', 2, 54);
151	mapNote('r', 3, 54);
152	mapNote('t', 4, 54);
153	mapNote('y', 5, 54);
154	mapNote('a', 0, 55);
155	mapNote('s', 1, 55);
156	mapNote('d', 2, 55);
157	mapNote('f', 3, 55);
158	mapNote('g', 4, 55);
159	mapNote('h', 5, 55);
160	mapNote('z', 0, 56);
161	mapNote('x', 1, 56);
162	mapNote('c', 2, 56);
163	mapNote('v', 3, 56);
164	mapNote('b', 4, 56);
165	mapNote('n', 5, 56);
166	registerKeyEvent(this);
167	}
168
169	private void mapKeys() {
170	int note = 48;
171	mapNote('a', 1, note++);
172	mapNote('w', 1, note++);
173	mapNote('s', 1, note++);
174	mapNote('e', 1, note++);
175	mapNote('d', 1, note++);
176	mapNote('f', 1, note++);
177	mapNote('t', 1, note++);
178	mapNote('g', 1, note++);
179	mapNote('y', 1, note++);
180	mapNote('h', 1, note++);
181	mapNote('u', 1, note++);
182	mapNote('j', 1, note++);
183	mapNote('k', 1, note++);
184	mapNote('o', 1, note++);
185	mapNote('l', 1, note++);
186	registerKeyEvent(this);
187	}
188
189	void mapNote(char ch, int channel, int number) {
190	keyToNote.put(ch, new NoteMeta(channel, number));
191	}
192
193	public String getLabel() {
194	return name;
195	}
196
197	public void keyEvent(KeyEvent e) {
198	if (!enabled) {
199	return;
200	}
201	char c = Character.toLowerCase(e.getKeyChar());
202	NoteMeta nm = keyToNote.get(c);
203	if (nm != null) {
204	switch (e.getID()) {
205	case KeyEvent.KEY_PRESSED:
206	noteOnReceived(new Note(Note.NOTE_ON, nm.channel, nm.number + octaveShift*12, 127));
207	break;
208	case KeyEvent.KEY_RELEASED:
209	noteOffReceived(new Note(Note.NOTE_OFF, nm.channel, nm.number + octaveShift*12, 0));
210	break;
211	}
212	}
213	if ((mode == KEYS) && (e.getID() == KeyEvent.KEY_PRESSED)) {
214	switch (c) {
215	case 'z':
216	octaveShift = constrain(octaveShift-1, -4, 4);
217	break;
218	case 'x':
219	octaveShift = constrain(octaveShift+1, -4, 4);
220	break;
221	}
222	}
223	}
224
225	public boolean isEnabled() {
226	return enabled;
227	}
228
229	public boolean isSelected() {
230	return enabled;
231	}
232
233	public void onMousePressed() {
234	setEnabled(!enabled);
235	}
236
237	public SCMidiInput setEnabled(boolean enabled) {
238	if (enabled != this.enabled) {
239	this.enabled = enabled;
240	for (SCMidiInputListener l : listeners) {
241	l.onEnabled(this, enabled);
242	}
243	}
244	return this;
245	}
246
247	protected SCPattern getFocusedPattern() {
248	return (SCPattern) midiEngine.getFocusedDeck().getActivePattern();
249	}
250
251	private boolean logMidi() {
252	return (uiMidi != null) && uiMidi.logMidi();
253	}
254
255	final void programChangeReceived(ProgramChange pc) {
256	if (!enabled) {
257	return;
258	}
259	if (logMidi()) {
260	println(getLabel() + " :: Program Change :: " + pc.getNumber());
261	}
262	handleProgramChange(pc);
263	}
264
265	final void controllerChangeReceived(rwmidi.Controller cc) {
266	if (!enabled) {
267	return;
268	}
269	if (logMidi()) {
270	println(getLabel() + " :: Controller :: " + cc.getCC() + ":" + cc.getValue());
271	}
272	if (!getFocusedPattern().controllerChangeReceived(cc)) {
273	handleControllerChange(cc);
274	}
275	}
276
277	final void noteOnReceived(Note note) {
278	if (!enabled) {
279	return;
280	}
281	if (logMidi()) {
282	println(getLabel() + " :: Note On :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
283	}
284	if (!getFocusedPattern().noteOnReceived(note)) {
285	handleNoteOn(note);
286	}
287	}
288
289	final void noteOffReceived(Note note) {
290	if (!enabled) {
291	return;
292	}
293	if (logMidi()) {
294	println(getLabel() + " :: Note Off :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
295	}
296	if (!getFocusedPattern().noteOffReceived(note)) {
297	handleNoteOff(note);
298	}
299	}
300
301	// Subclasses may implement these to map top-level functionality
302	protected void handleProgramChange(ProgramChange pc) {
303	}
304	protected void handleControllerChange(rwmidi.Controller cc) {
305	}
306	protected void handleNoteOn(Note note) {
307	}
308	protected void handleNoteOff(Note note) {
309	}
310	}
311
312	public class APC40MidiInput extends SCMidiInput {
313
314	private boolean shiftOn = false;
315	private LXEffect releaseEffect = null;
316
317	APC40MidiInput(MidiInputDevice d) {
318	super(d);
319	}
320
321	protected void handleControllerChange(rwmidi.Controller cc) {
322	int number = cc.getCC();
323	switch (number) {
324	// Crossfader
325	case 15:
326	lx.engine.getDeck(1).getCrossfader().setValue(cc.getValue() / 127.);
327	break;
328	}
329
330	int parameterIndex = -1;
331	if (number >= 48 && number <= 55) {
332	parameterIndex = number - 48;
333	} else if (number >= 16 && number <= 19) {
334	parameterIndex = 8 + (number-16);
335	}
336	if (parameterIndex >= 0) {
337	List<LXParameter> parameters = getFocusedPattern().getParameters();
338	if (parameterIndex < parameters.size()) {
339	parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
340	}
341	}
342
343	if (number >= 20 && number <= 23) {
344	int effectIndex = number - 20;
345	List<LXParameter> parameters = glucose.getSelectedEffect().getParameters();
346	if (effectIndex < parameters.size()) {
347	parameters.get(effectIndex).setValue(cc.getValue() / 127.);
348	}
349	}
350	}
351
352	protected void handleNoteOn(Note note) {
353	switch (note.getPitch()) {
354	case 94: // right bank
355	midiEngine.setFocusedDeck(1);
356	break;
357	case 95: // left bank
358	midiEngine.setFocusedDeck(0);
359	break;
360	case 96: // up bank
361	if (shiftOn) {
362	glucose.incrementSelectedEffectBy(1);
363	} else {
364	midiEngine.getFocusedDeck().goNext();
365	}
366	break;
367	case 97: // down bank
368	if (shiftOn) {
369	glucose.incrementSelectedEffectBy(-1);
370	} else {
371	midiEngine.getFocusedDeck().goPrev();
372	}
373	break;
374
375	case 98: // shift
376	shiftOn = true;
377	break;
378
379	case 99: // tap tempo
380	lx.tempo.tap();
381	break;
382	case 100: // nudge+
383	lx.tempo.setBpm(lx.tempo.bpm() + (shiftOn ? 1 : .1));
384	break;
385	case 101: // nudge-
386	lx.tempo.setBpm(lx.tempo.bpm() - (shiftOn ? 1 : .1));
387	break;
388
389	case 91: // play
390	case 93: // rec
391	releaseEffect = glucose.getSelectedEffect();
392	if (releaseEffect.isMomentary()) {
393	releaseEffect.enable();
394	} else {
395	releaseEffect.toggle();
396	}
397	break;
398
399	case 92: // stop
400	glucose.getSelectedEffect().disable();
401	break;
402	}
403	}
404
405	protected void handleNoteOff(Note note) {
406	switch (note.getPitch()) {
407	case 93: // rec
408	if (releaseEffect != null) {
409	if (releaseEffect.isMomentary()) {
410	releaseEffect.disable();
411	}
412	}
413	break;
414
415	case 98: // shift
416	shiftOn = false;
417	break;
418	}
419	}
420	}
421
422	class KorgNanoKontrolMidiInput extends SCMidiInput {
423
424	KorgNanoKontrolMidiInput(MidiInputDevice d) {
425	super(d);
426	}
427
428	protected void handleControllerChange(rwmidi.Controller cc) {
429	int number = cc.getCC();
430	if (number >= 16 && number <= 23) {
431	int parameterIndex = number - 16;
432	List<LXParameter> parameters = getFocusedPattern().getParameters();
433	if (parameterIndex < parameters.size()) {
434	parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
435	}
436	}
437
438	if (cc.getValue() == 127) {
439	switch (number) {
440	// Left track
441	case 58:
442	midiEngine.setFocusedDeck(0);
443	break;
444	// Right track
445	case 59:
446	midiEngine.setFocusedDeck(1);
447	break;
448	// Left chevron
449	case 43:
450	midiEngine.getFocusedDeck().goPrev();
451	break;
452	// Right chevron
453	case 44:
454	midiEngine.getFocusedDeck().goNext();
455	break;
456	}
457	}
458	}
459	}
460