_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.hueShift.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         case 6:
 448           lx.cycleBaseHue(60000);
 449           break;
 450       }
 451       break;
 452
 453     case 82: // scene 1
 454       EFF_boom.trigger();
 455       break;
 456
 457     case 83: // scene 2
 458       EFF_flash.trigger();
 459       break;
 460
 461     case 90:
 462       // dan's dirty tapping mechanism
 463       lx.tempo.trigger();
 464       tap1 = millis();
 465       break;
 466
 467     case 91: // play
 468     case 97: // left bank
 469       midiEngine.setFocusedDeck(0);
 470       break;
 471
 472     case 93: // rec
 473     case 96: // right bank
 474       midiEngine.setFocusedDeck(1);
 475       break;
 476
 477     case 94: // up bank
 478       if (shiftOn) {
 479         glucose.incrementSelectedEffectBy(-1);
 480       } else {
 481         midiEngine.getFocusedDeck().goPrev();
 482       }
 483       break;
 484     case 95: // down bank
 485       if (shiftOn) {
 486         glucose.incrementSelectedEffectBy(1);
 487       } else {
 488         midiEngine.getFocusedDeck().goNext();
 489       }
 490       break;
 491
 492     case 98: // shift
 493       shiftOn = true;
 494       break;
 495
 496     case 99: // tap tempo
 497       lx.tempo.tap();
 498       break;
 499     case 100: // nudge+
 500       lx.tempo.setBpm(lx.tempo.bpm() + (shiftOn ? 1 : .1));
 501       break;
 502     case 101: // nudge-
 503       lx.tempo.setBpm(lx.tempo.bpm() - (shiftOn ? 1 : .1));
 504       break;
 505
 506     case 62: // Detail View / red 5
 507       releaseEffect = glucose.getSelectedEffect();
 508       if (releaseEffect.isMomentary()) {
 509         releaseEffect.enable();
 510       } else {
 511         releaseEffect.toggle();
 512       }
 513       break;
 514
 515     case 63: // rec quantize / red 6
 516       glucose.getSelectedEffect().disable();
 517       break;
 518     }
 519   }
 520
 521   protected void handleNoteOff(Note note) {
 522     int nPitch = note.getPitch();
 523     int nChan = note.getChannel();
 524
 525     switch (nPitch) {
 526
 527     case 49: // SOLO/CUE
 528       switch (nChan) {
 529         case 5:
 530           EFF_colorFucker.invert.setValue(0);
 531           break;
 532         case 6:
 533           lx.setBaseHue(lx.getBaseHue());
 534           break;
 535       }
 536       break;
 537
 538     case 90: // SEND C
 539       long tapDelta = millis() - tap1;
 540       if (lbtwn(tapDelta,5000,300*1000)) {      // hackish tapping mechanism
 541         double bpm = 32.*60000./(tapDelta);
 542         while (bpm < 20) bpm*=2;
 543         while (bpm > 40) bpm/=2;
 544         lx.tempo.setBpm(bpm);
 545         lx.tempo.trigger();
 546         tap1 = 0;
 547         println("Tap Set - " + bpm + " bpm");
 548       }
 549       break;
 550
 551     case 63: // rec quantize / RED 6
 552       if (releaseEffect != null) {
 553         if (releaseEffect.isMomentary()) {
 554           releaseEffect.disable();
 555         }
 556       }
 557       break;
 558
 559     case 98: // shift
 560       shiftOn = false;
 561       break;
 562     }
 563   }
 564 }
 565
 566 class KorgNanoKontrolMidiInput extends GenericDeviceMidiInput {
 567
 568   KorgNanoKontrolMidiInput(MidiEngine midiEngine, MidiInputDevice d) {
 569     super(midiEngine, d);
 570   }
 571
 572   protected void handleControllerChange(rwmidi.Controller cc) {
 573     int number = cc.getCC();
 574     if (number >= 16 && number <= 23) {
 575       int parameterIndex = number - 16;
 576       List<LXParameter> parameters = midiEngine.getFocusedPattern().getParameters();
 577       if (parameterIndex < parameters.size()) {
 578         parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
 579       }
 580     }
 581
 582     if (cc.getValue() == 127) {
 583       switch (number) {
 584       // Left track
 585       case 58:
 586         midiEngine.setFocusedDeck(0);
 587         break;
 588       // Right track
 589       case 59:
 590         midiEngine.setFocusedDeck(1);
 591         break;
 592       // Left chevron
 593       case 43:
 594         midiEngine.getFocusedDeck().goPrev();
 595         break;
 596       // Right chevron
 597       case 44:
 598         midiEngine.getFocusedDeck().goNext();
 599         break;
 600       }
 601     }
 602   }
 603 }
 604
 605 class APC40MidiOutput implements LXParameter.Listener, GridOutput {
 606
 607   private final MidiEngine midiEngine;
 608   private final MidiOutput output;
 609   private LXPattern focusedPattern = null;
 610   private LXEffect focusedEffect = null;
 611
 612   APC40MidiOutput(MidiEngine midiEngine, MidiOutputDevice device) {
 613     this.midiEngine = midiEngine;
 614     output = device.createOutput();
 615     midiEngine.addListener(new MidiEngineListener() {
 616       public void onFocusedDeck(int deckIndex) {
 617         resetPatternParameters();
 618       }
 619     });
 620     glucose.addEffectListener(new GLucose.EffectListener() {
 621       public void effectSelected(LXEffect effect) {
 622         resetEffectParameters();
 623       }
 624     });
 625     Engine.Listener deckListener = new Engine.AbstractListener() {
 626       public void patternDidChange(Engine.Deck deck, LXPattern pattern) {
 627         resetPatternParameters();
 628       }
 629     };
 630     for (Engine.Deck d : lx.engine.getDecks()) {
 631       d.addListener(deckListener);
 632     }
 633     resetParameters();
 634     midiEngine.grid.addOutput(this);
 635
 636     lx.cycleBaseHue(60000);
 637     output.sendNoteOn(6, 49, 127);
 638   }
 639
 640   private void resetParameters() {
 641     resetPatternParameters();
 642     resetEffectParameters();
 643   }
 644
 645   private void resetPatternParameters() {
 646     LXPattern newPattern = midiEngine.getFocusedDeck().getActivePattern();
 647     if (newPattern == focusedPattern) {
 648       return;
 649     }
 650     if (focusedPattern != null) {
 651       for (LXParameter p : focusedPattern.getParameters()) {
 652         ((LXListenableParameter) p).removeListener(this);
 653       }
 654     }
 655     focusedPattern = newPattern;
 656     int i = 0;
 657     for (LXParameter p : focusedPattern.getParameters()) {
 658       ((LXListenableParameter) p).addListener(this);
 659       sendKnob(i++, p);
 660     }
 661     while (i < 12) {
 662       sendKnob(i++, 0);
 663     }
 664     for (int row = 0; row < 7; ++row) {
 665       for (int col = 0; col < 8; ++col) {
 666         setGridState(row, col, 0);
 667       }
 668     }
 669   }
 670
 671   private void resetEffectParameters() {
 672     LXEffect newEffect = glucose.getSelectedEffect();
 673     if (newEffect == focusedEffect) {
 674       return;
 675     }
 676     if (focusedEffect != null) {
 677       for (LXParameter p : focusedPattern.getParameters()) {
 678         ((LXListenableParameter) p).removeListener(this);
 679       }
 680     }
 681     focusedEffect = newEffect;
 682     int i = 0;
 683     for (LXParameter p : focusedEffect.getParameters()) {
 684       ((LXListenableParameter) p).addListener(this);
 685       sendKnob(12 + i++, p);
 686     }
 687     while (i < 4) {
 688       sendKnob(12 + i++, 0);
 689     }
 690   }
 691
 692   private void sendKnob(int i, LXParameter p) {
 693     sendKnob(i, (int) (p.getValuef() * 127.));
 694   }
 695
 696   private void sendKnob(int i, int value) {
 697     if (i < 8) {
 698       output.sendController(0, 48+i, value);
 699     } else if (i < 16) {
 700       output.sendController(0, 8+i, value);
 701     }
 702   }
 703
 704   public void onParameterChanged(LXParameter parameter) {
 705     int i = 0;
 706     for (LXParameter p : focusedPattern.getParameters()) {
 707       if (p == parameter) {
 708         sendKnob(i, p);
 709         break;
 710       }
 711       ++i;
 712     }
 713     i = 12;
 714     for (LXParameter p : focusedEffect.getParameters()) {
 715       if (p == parameter) {
 716         sendKnob(i, p);
 717         break;
 718       }
 719       ++i;
 720     }
 721   }
 722
 723   public void setGridState(int row, int col, int state) {
 724     if (col < 8) {
 725       if (row < 5) output.sendNoteOn(col, 53+row, state);
 726       else if (row == 6) output.sendNoteOn(col, 52, state);
 727     }
 728   }
 729 }
 730
 731 interface GridOutput {
 732   public static final int OFF = 0;
 733   public static final int GREEN = 1;
 734   public static final int GREEN_BLINK = 2;
 735   public static final int RED = 3;
 736   public static final int RED_BLINK = 4;
 737   public static final int YELLOW = 5;
 738   public static final int YELLOW_BLINK = 6;
 739   public static final int ON = 127;
 740
 741   public void setGridState(int row, int col, int state);
 742 }
 743
 744 class GridController {
 745   private final List<GridOutput> outputs = new ArrayList<GridOutput>();
 746
 747   private final MidiEngine midiEngine;
 748
 749   GridController(MidiEngine midiEngine) {
 750     this.midiEngine = midiEngine;
 751   }
 752
 753   public void addOutput(GridOutput output) {
 754     outputs.add(output);
 755   }
 756
 757   public boolean gridPressed(int row, int col) {
 758     return midiEngine.getFocusedPattern().gridPressed(row, col);
 759   }
 760
 761   public boolean gridReleased(int row, int col) {
 762     return midiEngine.getFocusedPattern().gridReleased(row, col);
 763   }
 764
 765   public void setState(int row, int col, int state) {
 766     for (GridOutput g : outputs) {
 767       g.setGridState(row, col, state);
 768     }
 769   }
 770 }
 771