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