_MIDI.pde

   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   public final GridController grid;
  26   private final List<MidiEngineListener> listeners = new ArrayList<MidiEngineListener>();
  27   private final List<SCMidiInput> midiControllers = new ArrayList<SCMidiInput>();
  28
  29   public MidiEngine addListener(MidiEngineListener l) {
  30     listeners.add(l);
  31     return this;
  32   }
  33
  34   public MidiEngine removeListener(MidiEngineListener l) {
  35     listeners.remove(l);
  36     return this;
  37   }
  38
  39   private SCMidiInput midiQwertyKeys;
  40   private SCMidiInput midiQwertyAPC;
  41
  42   private int activeDeckIndex = 0;
  43
  44   public MidiEngine() {
  45     grid = new GridController(this);
  46     midiControllers.add(midiQwertyKeys = new VirtualKeyMidiInput(this, VirtualKeyMidiInput.KEYS));
  47     midiControllers.add(midiQwertyAPC = new VirtualKeyMidiInput(this, VirtualKeyMidiInput.APC));
  48     int apcCount = 0;
  49     for (MidiInputDevice device : RWMidi.getInputDevices()) {
  50       if (device.getName().contains("APC")) {
  51         ++apcCount;
  52       }
  53     }
  54
  55     int apcIndex = 0;
  56     for (MidiInputDevice device : RWMidi.getInputDevices()) {
  57       if (device.getName().contains("APC")) {
  58         int apcDeck = -1;
  59         if (apcCount > 1 && apcIndex < 2) {
  60           apcDeck = apcIndex++;
  61         }
  62         midiControllers.add(new APC40MidiInput(this, device, apcDeck).setEnabled(true));
  63       } else if (device.getName().contains("SLIDER/KNOB KORG")) {
  64         midiControllers.add(new KorgNanoKontrolMidiInput(this, device).setEnabled(true));
  65       } else {
  66         boolean enabled = device.getName().contains("KEYBOARD KORG") || device.getName().contains("Bus 1 Apple");
  67         midiControllers.add(new GenericDeviceMidiInput(this, device).setEnabled(enabled));
  68       }
  69     }
  70
  71     apcIndex = 0;
  72     for (MidiOutputDevice device : RWMidi.getOutputDevices()) {
  73       if (device.getName().contains("APC")) {
  74         int apcDeck = -1;
  75         if (apcCount > 1 && apcIndex < 2) {
  76           apcDeck = apcIndex++;
  77         }
  78         new APC40MidiOutput(this, device, apcDeck);
  79       }
  80     }
  81   }
  82
  83   public List<SCMidiInput> getControllers() {
  84     return this.midiControllers;
  85   }
  86
  87   public Engine.Deck getFocusedDeck() {
  88     return lx.engine.getDeck(activeDeckIndex);
  89   }
  90
  91   public SCPattern getFocusedPattern() {
  92     return (SCPattern) getFocusedDeck().getActivePattern();
  93   }
  94
  95   public MidiEngine setFocusedDeck(int deckIndex) {
  96     if (this.activeDeckIndex != deckIndex) {
  97       this.activeDeckIndex = deckIndex;
  98       for (MidiEngineListener listener : listeners) {
  99         listener.onFocusedDeck(deckIndex);
 100       }
 101     }
 102     return this;
 103   }
 104
 105   public boolean isQwertyEnabled() {
 106     return midiQwertyKeys.isEnabled() || midiQwertyAPC.isEnabled();
 107   }
 108 }
 109
 110 public interface SCMidiInputListener {
 111   public void onEnabled(SCMidiInput controller, boolean enabled);
 112 }
 113
 114 public abstract class SCMidiInput extends AbstractScrollItem {
 115
 116   protected boolean enabled = false;
 117   private final String name;
 118
 119   protected final MidiEngine midiEngine;
 120
 121   final List<SCMidiInputListener> listeners = new ArrayList<SCMidiInputListener>();
 122
 123   protected SCMidiInput(MidiEngine midiEngine, String name) {
 124     this.midiEngine = midiEngine;
 125     this.name = name;
 126   }
 127
 128   public SCMidiInput addListener(SCMidiInputListener l) {
 129     listeners.add(l);
 130     return this;
 131   }
 132
 133   public SCMidiInput removeListener(SCMidiInputListener l) {
 134     listeners.remove(l);
 135     return this;
 136   }
 137
 138   public String getLabel() {
 139     return name;
 140   }
 141
 142   public boolean isEnabled() {
 143     return enabled;
 144   }
 145
 146   public boolean isSelected() {
 147     return enabled;
 148   }
 149
 150   public void onMousePressed() {
 151     setEnabled(!enabled);
 152   }
 153
 154   public SCMidiInput setEnabled(boolean enabled) {
 155     if (enabled != this.enabled) {
 156       this.enabled = enabled;
 157       for (SCMidiInputListener l : listeners) {
 158         l.onEnabled(this, enabled);
 159       }
 160     }
 161     return this;
 162   }
 163
 164   private boolean logMidi() {
 165     return (uiMidi != null) && uiMidi.logMidi();
 166   }
 167
 168   protected SCPattern getTargetPattern() {
 169     return midiEngine.getFocusedPattern();
 170   }
 171
 172   final void programChangeReceived(ProgramChange pc) {
 173     if (!enabled) {
 174       return;
 175     }
 176     if (logMidi()) {
 177       println(getLabel() + " :: Program Change :: " + pc.getNumber());
 178     }
 179     handleProgramChange(pc);
 180   }
 181
 182   final void controllerChangeReceived(rwmidi.Controller cc) {
 183     if (!enabled) {
 184       return;
 185     }
 186     if (logMidi()) {
 187       println(getLabel() + " :: Controller :: " + cc.getChannel() + " :: " + cc.getCC() + ":" + cc.getValue());
 188     }
 189     if (!handleGridControllerChange(cc)) {
 190       if (!getTargetPattern().controllerChange(cc)) {
 191         handleControllerChange(cc);
 192       }
 193     }
 194   }
 195
 196   final void noteOnReceived(Note note) {
 197     if (!enabled) {
 198       return;
 199     }
 200     if (logMidi()) {
 201       println(getLabel() + " :: Note On  :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
 202     }
 203     if (!handleGridNoteOn(note)) {
 204       if (!getTargetPattern().noteOn(note)) {
 205         handleNoteOn(note);
 206       }
 207     }
 208   }
 209
 210   final void noteOffReceived(Note note) {
 211     if (!enabled) {
 212       return;
 213     }
 214     if (logMidi()) {
 215       println(getLabel() + " :: Note Off :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
 216     }
 217     if (!handleGridNoteOff(note)) {
 218       if (!getTargetPattern().noteOff(note)) {
 219         handleNoteOff(note);
 220       }
 221     }
 222   }
 223
 224   // Subclasses may implement these to map top-level functionality
 225   protected boolean handleGridNoteOn(Note note) { return false; }
 226   protected boolean handleGridNoteOff(Note note) { return false; }
 227   protected boolean handleGridControllerChange(rwmidi.Controller cc) { return false; }
 228   protected void handleProgramChange(ProgramChange pc) {}
 229   protected void handleControllerChange(rwmidi.Controller cc) {}
 230   protected void handleNoteOn(Note note) {}
 231   protected void handleNoteOff(Note note) {}
 232 }
 233
 234 public class VirtualKeyMidiInput extends SCMidiInput {
 235
 236   public static final int KEYS = 1;
 237   public static final int APC = 2;
 238
 239   private final int mode;
 240
 241   private int octaveShift = 0;
 242
 243   class NoteMeta {
 244     int channel;
 245     int number;
 246     NoteMeta(int channel, int number) {
 247       this.channel = channel;
 248       this.number = number;
 249     }
 250   }
 251
 252   final Map<Character, NoteMeta> keyToNote = new HashMap<Character, NoteMeta>();
 253
 254   VirtualKeyMidiInput(MidiEngine midiEngine, int mode) {
 255     super(midiEngine, "QWERTY (" + (mode == APC ? "APC" : "Key") + "  Mode)");
 256     this.mode = mode;
 257     if (mode == APC) {
 258       mapAPC();
 259     } else {
 260       mapKeys();
 261     }
 262     registerKeyEvent(this);
 263   }
 264
 265   private void mapAPC() {
 266     mapNote('1', 0, 53);
 267     mapNote('2', 1, 53);
 268     mapNote('3', 2, 53);
 269     mapNote('4', 3, 53);
 270     mapNote('5', 4, 53);
 271     mapNote('6', 5, 53);
 272     mapNote('q', 0, 54);
 273     mapNote('w', 1, 54);
 274     mapNote('e', 2, 54);
 275     mapNote('r', 3, 54);
 276     mapNote('t', 4, 54);
 277     mapNote('y', 5, 54);
 278     mapNote('a', 0, 55);
 279     mapNote('s', 1, 55);
 280     mapNote('d', 2, 55);
 281     mapNote('f', 3, 55);
 282     mapNote('g', 4, 55);
 283     mapNote('h', 5, 55);
 284     mapNote('z', 0, 56);
 285     mapNote('x', 1, 56);
 286     mapNote('c', 2, 56);
 287     mapNote('v', 3, 56);
 288     mapNote('b', 4, 56);
 289     mapNote('n', 5, 56);
 290   }
 291
 292   private void mapKeys() {
 293     int note = 48;
 294     mapNote('a', 1, note++);
 295     mapNote('w', 1, note++);
 296     mapNote('s', 1, note++);
 297     mapNote('e', 1, note++);
 298     mapNote('d', 1, note++);
 299     mapNote('f', 1, note++);
 300     mapNote('t', 1, note++);
 301     mapNote('g', 1, note++);
 302     mapNote('y', 1, note++);
 303     mapNote('h', 1, note++);
 304     mapNote('u', 1, note++);
 305     mapNote('j', 1, note++);
 306     mapNote('k', 1, note++);
 307     mapNote('o', 1, note++);
 308     mapNote('l', 1, note++);
 309   }
 310
 311   void mapNote(char ch, int channel, int number) {
 312     keyToNote.put(ch, new NoteMeta(channel, number));
 313   }
 314
 315   public void keyEvent(KeyEvent e) {
 316     if (!enabled) {
 317       return;
 318     }
 319     char c = Character.toLowerCase(e.getKeyChar());
 320     NoteMeta nm = keyToNote.get(c);
 321     if (nm != null) {
 322       switch (e.getID()) {
 323       case KeyEvent.KEY_PRESSED:
 324         noteOnReceived(new Note(Note.NOTE_ON, nm.channel, nm.number + octaveShift*12, 127));
 325         break;
 326       case KeyEvent.KEY_RELEASED:
 327         noteOffReceived(new Note(Note.NOTE_OFF, nm.channel, nm.number + octaveShift*12, 0));
 328         break;
 329       }
 330     }
 331     if ((mode == KEYS) && (e.getID() == KeyEvent.KEY_PRESSED)) {
 332       switch (c) {
 333       case 'z':
 334         octaveShift = constrain(octaveShift-1, -4, 4);
 335         break;
 336       case 'x':
 337         octaveShift = constrain(octaveShift+1, -4, 4);
 338         break;
 339       }
 340     }
 341   }
 342 }
 343
 344 public class GenericDeviceMidiInput extends SCMidiInput {
 345   GenericDeviceMidiInput(MidiEngine midiEngine, MidiInputDevice d) {
 346     super(midiEngine, d.getName().replace("Unknown vendor",""));
 347     d.createInput(this);
 348   }
 349 }
 350
 351 public class APC40MidiInput extends GenericDeviceMidiInput {
 352
 353   private boolean shiftOn = false;
 354   private LXEffect releaseEffect = null;
 355   final private Engine.Deck targetDeck;
 356
 357   APC40MidiInput(MidiEngine midiEngine, MidiInputDevice d) {
 358     this(midiEngine, d, -1);
 359   }
 360
 361   APC40MidiInput(MidiEngine midiEngine, MidiInputDevice d, int deckIndex) {
 362     super(midiEngine, d);
 363     targetDeck = (deckIndex < 0) ? null : lx.engine.getDecks().get(deckIndex);
 364   }
 365
 366   protected Engine.Deck getTargetDeck() {
 367     if (targetDeck != null) {
 368       return targetDeck;
 369     }
 370     return midiEngine.getFocusedDeck();
 371   }
 372
 373   protected SCPattern getTargetPattern() {
 374     if (targetDeck != null) {
 375       return (SCPattern) (targetDeck.getActivePattern());
 376     }
 377     return super.getTargetPattern();
 378   }
 379
 380   private class GridPosition {
 381     public final int row, col;
 382     GridPosition(int r, int c) {
 383       row = r;
 384       col = c;
 385     }
 386   }
 387
 388   private GridPosition getGridPosition(Note note) {
 389     int channel = note.getChannel();
 390     int pitch = note.getPitch();
 391     if (channel < 8) {
 392       if (pitch >= 53 && pitch <=57) return new GridPosition(pitch-53, channel);
 393     }
 394     return null;
 395   }
 396
 397   protected boolean handleGridNoteOn(Note note) {
 398     GridPosition p = getGridPosition(note);
 399     if (p != null) {
 400       return midiEngine.grid.gridPressed(p.row, p.col);
 401     }
 402     return false;
 403   }
 404
 405   protected boolean handleGridNoteOff(Note note) {
 406     GridPosition p = getGridPosition(note);
 407     if (p != null) {
 408       return midiEngine.grid.gridReleased(p.row, p.col);
 409     }
 410     return false;
 411   }
 412
 413   protected void handleControllerChange(rwmidi.Controller cc) {
 414     int channel = cc.getChannel();
 415     int number = cc.getCC();
 416     float value = cc.getValue() / 127.;
 417     switch (number) {
 418
 419     case 7:
 420      switch (channel) {
 421        case 0:
 422          EFF_colorFucker.hueShift.setValue(value);
 423          break;
 424        case 1:
 425          EFF_colorFucker.desat.setValue(value);
 426          break;
 427        case 2:
 428          EFF_colorFucker.sharp.setValue(value);
 429          break;
 430        case 3:
 431          EFF_blur.amount.setValue(value);
 432          break;
 433        case 4:
 434          EFF_quantize.amount.setValue(value);
 435          break;
 436      }
 437      break;
 438
 439     // Master bright
 440     case 14:
 441       EFF_colorFucker.level.setValue(value);
 442       break;
 443
 444     // Crossfader
 445     case 15:
 446       lx.engine.getDeck(1).getCrossfader().setValue(value);
 447       break;
 448     }
 449
 450     int parameterIndex = -1;
 451     if (number >= 48 && number <= 55) {
 452       parameterIndex = number - 48;
 453     } else if (number >= 16 && number <= 19) {
 454       parameterIndex = 8 + (number-16);
 455     }
 456     if (parameterIndex >= 0) {
 457       List<LXParameter> parameters = getTargetPattern().getParameters();
 458       if (parameterIndex < parameters.size()) {
 459         parameters.get(parameterIndex).setValue(value);
 460       }
 461     }
 462
 463     if (number >= 20 && number <= 23) {
 464       int effectIndex = number - 20;
 465       List<LXParameter> parameters = glucose.getSelectedEffect().getParameters();
 466       if (effectIndex < parameters.size()) {
 467         parameters.get(effectIndex).setValue(value);
 468       }
 469     }
 470   }
 471
 472   private long tap1 = 0;
 473
 474   private boolean lbtwn(long a, long b, long c) {
 475     return a >= b && a <= c;
 476   }
 477
 478   protected void handleNoteOn(Note note) {
 479     int nPitch = note.getPitch();
 480     int nChan = note.getChannel();
 481     switch (nPitch) {
 482
 483     case 49: // SOLO/CUE
 484       switch (nChan) {
 485         case 4:
 486           EFF_colorFucker.mono.setValue(1);
 487           break;
 488         case 5:
 489           EFF_colorFucker.invert.setValue(1);
 490           break;
 491         case 6:
 492           lx.cycleBaseHue(60000);
 493           break;
 494       }
 495       break;
 496
 497     case 82: // scene 1
 498       EFF_boom.trigger();
 499       break;
 500
 501     case 83: // scene 2
 502       EFF_flash.trigger();
 503       break;
 504
 505     case 90:
 506       // dan's dirty tapping mechanism
 507       lx.tempo.trigger();
 508       tap1 = millis();
 509       break;
 510
 511     case 91: // play
 512     case 97: // left bank
 513       midiEngine.setFocusedDeck(0);
 514       break;
 515
 516     case 93: // rec
 517     case 96: // right bank
 518       midiEngine.setFocusedDeck(1);
 519       break;
 520
 521     case 94: // up bank
 522       if (shiftOn) {
 523         glucose.incrementSelectedEffectBy(-1);
 524       } else {
 525         getTargetDeck().goPrev();
 526       }
 527       break;
 528     case 95: // down bank
 529       if (shiftOn) {
 530         glucose.incrementSelectedEffectBy(1);
 531       } else {
 532         getTargetDeck().goNext();
 533       }
 534       break;
 535
 536     case 98: // shift
 537       shiftOn = true;
 538       break;
 539
 540     case 99: // tap tempo
 541       lx.tempo.tap();
 542       break;
 543     case 100: // nudge+
 544       lx.tempo.setBpm(lx.tempo.bpm() + (shiftOn ? 1 : .1));
 545       break;
 546     case 101: // nudge-
 547       lx.tempo.setBpm(lx.tempo.bpm() - (shiftOn ? 1 : .1));
 548       break;
 549
 550     case 62: // Detail View / red 5
 551       releaseEffect = glucose.getSelectedEffect();
 552       if (releaseEffect.isMomentary()) {
 553         releaseEffect.enable();
 554       } else {
 555         releaseEffect.toggle();
 556       }
 557       break;
 558
 559     case 63: // rec quantize / red 6
 560       glucose.getSelectedEffect().disable();
 561       break;
 562     }
 563   }
 564
 565   protected void handleNoteOff(Note note) {
 566     int nPitch = note.getPitch();
 567     int nChan = note.getChannel();
 568
 569     switch (nPitch) {
 570
 571     case 49: // SOLO/CUE
 572       switch (nChan) {
 573         case 4:
 574           EFF_colorFucker.mono.setValue(0);
 575           break;
 576         case 5:
 577           EFF_colorFucker.invert.setValue(0);
 578           break;
 579         case 6:
 580           lx.setBaseHue(lx.getBaseHue());
 581           break;
 582       }
 583       break;
 584
 585     case 52: // CLIP STOP
 586       if (nChan < PresetManager.NUM_PRESETS) {
 587         if (shiftOn) {
 588           presetManager.store(getTargetDeck(), nChan);
 589         } else {
 590           presetManager.select(getTargetDeck(), nChan);
 591         }
 592       }
 593       break;
 594
 595     case 90: // SEND C
 596       long tapDelta = millis() - tap1;
 597       if (lbtwn(tapDelta,5000,300*1000)) {      // hackish tapping mechanism
 598         double bpm = 32.*60000./(tapDelta);
 599         while (bpm < 20) bpm*=2;
 600         while (bpm > 40) bpm/=2;
 601         lx.tempo.setBpm(bpm);
 602         lx.tempo.trigger();
 603         tap1 = 0;
 604         println("Tap Set - " + bpm + " bpm");
 605       }
 606       break;
 607
 608     case 63: // rec quantize / RED 6
 609       if (releaseEffect != null) {
 610         if (releaseEffect.isMomentary()) {
 611           releaseEffect.disable();
 612         }
 613       }
 614       break;
 615
 616     case 98: // shift
 617       shiftOn = false;
 618       break;
 619     }
 620   }
 621 }
 622
 623 class KorgNanoKontrolMidiInput extends GenericDeviceMidiInput {
 624
 625   KorgNanoKontrolMidiInput(MidiEngine midiEngine, MidiInputDevice d) {
 626     super(midiEngine, d);
 627   }
 628
 629   protected void handleControllerChange(rwmidi.Controller cc) {
 630     int number = cc.getCC();
 631     if (number >= 16 && number <= 23) {
 632       int parameterIndex = number - 16;
 633       List<LXParameter> parameters = midiEngine.getFocusedPattern().getParameters();
 634       if (parameterIndex < parameters.size()) {
 635         parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
 636       }
 637     }
 638
 639     if (cc.getValue() == 127) {
 640       switch (number) {
 641       // Left track
 642       case 58:
 643         midiEngine.setFocusedDeck(0);
 644         break;
 645       // Right track
 646       case 59:
 647         midiEngine.setFocusedDeck(1);
 648         break;
 649       // Left chevron
 650       case 43:
 651         midiEngine.getFocusedDeck().goPrev();
 652         break;
 653       // Right chevron
 654       case 44:
 655         midiEngine.getFocusedDeck().goNext();
 656         break;
 657       }
 658     }
 659   }
 660 }
 661
 662 class APC40MidiOutput implements LXParameter.Listener, GridOutput {
 663
 664   private final MidiEngine midiEngine;
 665   private final MidiOutput output;
 666   private LXPattern focusedPattern = null;
 667   private LXEffect focusedEffect = null;
 668   private final Engine.Deck targetDeck;
 669
 670   APC40MidiOutput(MidiEngine midiEngine, MidiOutputDevice device) {
 671     this(midiEngine, device, -1);
 672   }
 673
 674   APC40MidiOutput(MidiEngine midiEngine, MidiOutputDevice device, int deckIndex) {
 675     this.midiEngine = midiEngine;
 676     output = device.createOutput();
 677     targetDeck = (deckIndex < 0) ? null : lx.engine.getDecks().get(deckIndex);
 678     setDPatternOutputs();
 679     if (targetDeck != null) {
 680       midiEngine.addListener(new MidiEngineListener() {
 681         public void onFocusedDeck(int deckIndex) {
 682           resetPatternParameters();
 683         }
 684       });
 685     }
 686     glucose.addEffectListener(new GLucose.EffectListener() {
 687       public void effectSelected(LXEffect effect) {
 688         resetEffectParameters();
 689       }
 690     });
 691     Engine.Listener deckListener = new Engine.AbstractListener() {
 692       public void patternDidChange(Engine.Deck deck, LXPattern pattern) {
 693         resetPatternParameters();
 694       }
 695     };
 696     for (Engine.Deck d : lx.engine.getDecks()) {
 697       if (targetDeck == null || d == targetDeck) {
 698         d.addListener(deckListener);
 699       }
 700     }
 701     presetManager.addListener(new PresetListener() {
 702       public void onPresetLoaded(Preset preset) {
 703         for (int i = 0; i < 8; ++i) {
 704           output.sendNoteOn(i, 52, (preset.index == i) ? 1 : 0);
 705         }
 706       }
 707       public void onPresetDirty(Preset preset) {
 708         output.sendNoteOn(preset.index, 52, 2);
 709       }
 710       public void onPresetStored(Preset preset) {
 711         onPresetLoaded(preset);
 712       }
 713       public void onPresetUnloaded() {
 714         for (int i = 0; i < 8; ++i) {
 715           output.sendNoteOn(i, 52, 0);
 716         }
 717       }
 718     });
 719     resetParameters();
 720     midiEngine.grid.addOutput(this);
 721
 722     lx.cycleBaseHue(60000);
 723     output.sendNoteOn(6, 49, 127);
 724
 725     // Turn off the track selection lights and preset selectors
 726     for (int i = 0; i < 8; ++i) {
 727       output.sendNoteOn(i, 51, 0);
 728       output.sendNoteOn(i, 52, 0);
 729     }
 730
 731     // Turn off the MASTER selector
 732     output.sendNoteOn(0, 80, 0);
 733   }
 734
 735   private void setDPatternOutputs() {
 736     for (Engine.Deck deck : lx.engine.getDecks()) {
 737       if (targetDeck == null || deck == targetDeck) {
 738         for (LXPattern pattern : deck.getPatterns()) {
 739           if (pattern instanceof DPat) {
 740             ((DPat)pattern).setAPCOutput(output);
 741           }
 742         }
 743       }
 744     }
 745   }
 746
 747   protected Engine.Deck getTargetDeck() {
 748     if (targetDeck != null) {
 749       return targetDeck;
 750     }
 751     return midiEngine.getFocusedDeck();
 752   }
 753
 754   private void resetParameters() {
 755     resetPatternParameters();
 756     resetEffectParameters();
 757   }
 758
 759   private void resetPatternParameters() {
 760     LXPattern newPattern = getTargetDeck().getActivePattern();
 761     if (newPattern == focusedPattern) {
 762       return;
 763     }
 764     if (focusedPattern != null) {
 765       for (LXParameter p : focusedPattern.getParameters()) {
 766         ((LXListenableParameter) p).removeListener(this);
 767       }
 768     }
 769     focusedPattern = newPattern;
 770     int i = 0;
 771     for (LXParameter p : focusedPattern.getParameters()) {
 772       ((LXListenableParameter) p).addListener(this);
 773       sendKnob(i++, p);
 774     }
 775     while (i < 12) {
 776       sendKnob(i++, 0);
 777     }
 778     if (focusedPattern instanceof DPat) {
 779       ((DPat)focusedPattern).updateLights();
 780     } else {
 781       for (int j = 0; j < 8; ++j) {
 782         output.sendNoteOn(j, 48, 0);
 783       }
 784       for (int row = 0; row < 7; ++row) {
 785         for (int col = 0; col < 8; ++col) {
 786           setGridState(row, col, 0);
 787         }
 788       }
 789     }
 790   }
 791
 792   private void resetEffectParameters() {
 793     LXEffect newEffect = glucose.getSelectedEffect();
 794     if (newEffect == focusedEffect) {
 795       return;
 796     }
 797     if (focusedEffect != null) {
 798       for (LXParameter p : focusedPattern.getParameters()) {
 799         ((LXListenableParameter) p).removeListener(this);
 800       }
 801     }
 802     focusedEffect = newEffect;
 803     int i = 0;
 804     for (LXParameter p : focusedEffect.getParameters()) {
 805       ((LXListenableParameter) p).addListener(this);
 806       sendKnob(12 + i++, p);
 807     }
 808     while (i < 4) {
 809       sendKnob(12 + i++, 0);
 810     }
 811   }
 812
 813   private void sendKnob(int i, LXParameter p) {
 814     sendKnob(i, (int) (p.getValuef() * 127.));
 815   }
 816
 817   private void sendKnob(int i, int value) {
 818     if (i < 8) {
 819       output.sendController(0, 48+i, value);
 820     } else if (i < 16) {
 821       output.sendController(0, 8+i, value);
 822     }
 823   }
 824
 825   public void onParameterChanged(LXParameter parameter) {
 826     int i = 0;
 827     for (LXParameter p : focusedPattern.getParameters()) {
 828       if (p == parameter) {
 829         sendKnob(i, p);
 830         break;
 831       }
 832       ++i;
 833     }
 834     i = 12;
 835     for (LXParameter p : focusedEffect.getParameters()) {
 836       if (p == parameter) {
 837         sendKnob(i, p);
 838         break;
 839       }
 840       ++i;
 841     }
 842   }
 843
 844   public void setGridState(int row, int col, int state) {
 845     if (col < 8 && row < 5) {
 846       output.sendNoteOn(col, 53+row, state);
 847     }
 848   }
 849 }
 850
 851 interface GridOutput {
 852   public static final int OFF = 0;
 853   public static final int GREEN = 1;
 854   public static final int GREEN_BLINK = 2;
 855   public static final int RED = 3;
 856   public static final int RED_BLINK = 4;
 857   public static final int YELLOW = 5;
 858   public static final int YELLOW_BLINK = 6;
 859   public static final int ON = 127;
 860
 861   public void setGridState(int row, int col, int state);
 862 }
 863
 864 class GridController {
 865   private final List<GridOutput> outputs = new ArrayList<GridOutput>();
 866
 867   private final MidiEngine midiEngine;
 868
 869   GridController(MidiEngine midiEngine) {
 870     this.midiEngine = midiEngine;
 871   }
 872
 873   public void addOutput(GridOutput output) {
 874     outputs.add(output);
 875   }
 876
 877   public boolean gridPressed(int row, int col) {
 878     return midiEngine.getFocusedPattern().gridPressed(row, col);
 879   }
 880
 881   public boolean gridReleased(int row, int col) {
 882     return midiEngine.getFocusedPattern().gridReleased(row, col);
 883   }
 884
 885   public void setState(int row, int col, int state) {
 886     for (GridOutput g : outputs) {
 887       g.setGridState(row, col, state);
 888     }
 889   }
 890 }
 891