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