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