UIImplementation.pde

   1 /**
   2  *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
   3  *
   4  *         //\\   //\\                 //\\   //\\
   5  *        ///\\\ ///\\\               ///\\\ ///\\\
   6  *        \\\/// \\\///               \\\/// \\\///
   7  *         \\//   \\//                 \\//   \\//
   8  *
   9  *        EXPERTS ONLY!!              EXPERTS ONLY!!
  10  *
  11  * Custom UI components using the framework.
  12  */
  13
  14 import java.nio.*;
  15 import java.util.Arrays;
  16 class UICubesLayer extends UICameraComponent {
  17
  18 int nvert = 200000;
  19 int SIZEOF_INT = Integer.SIZE / 8;
  20 int SIZEOF_FLOAT = Float.SIZE / 8;
  21
  22 PGL pgl;
  23 PShader sh;
  24
  25 int vertLoc;
  26 int colorLoc;
  27
  28 IntBuffer vboName;
  29 FloatBuffer vertData;
  30
  31   boolean initted = false;
  32   PShape sha1;
  33   int numPoints = 10000;
  34
  35   void initme()
  36   {
  37     nvert = model.points.size();
  38     sh = loadShader("frag.glsl", "vert.glsl");
  39     /*color[] simulationColors = lx.getColors();
  40     sha1= createShape();
  41     sha1.beginShape(POINTS);
  42     for (LXPoint p : model.points) {
  43       stroke(simulationColors[p.index]);
  44       //pointColor(simulationColors[p.index]);
  45       gl2.glPointColor=100;
  46       sha1.vertex(p.x, p.y, p.z);
  47     }
  48     sha1.endShape();*/
  49  float[] temp = new float[nvert * 7];
  50       for (LXPoint p : model.points) {
  51     // position
  52     temp[p.index * 7 + 0] = p.x;
  53     temp[p.index * 7 + 1] = p.y;
  54     temp[p.index * 7 + 2] = p.z;
  55
  56     // color
  57     temp[p.index * 7 + 3] = 0.0;
  58     temp[p.index * 7 + 4] = 0.0;
  59     temp[p.index * 7 + 5] = 0.0;
  60     temp[p.index * 7 + 6] = 1.0;
  61   }
  62
  63   vertData = allocateDirectFloatBuffer(nvert * 7);
  64   vertData.rewind();
  65   vertData.put(temp);
  66   vertData.position(0);
  67   vboName = allocateDirectIntBuffer(1);
  68   initVBO();
  69   }
  70   void onDraw(UI ui) {
  71     if(!initted)
  72     {
  73       initted=true;
  74       initme();
  75     }
  76     color[] simulationColors = lx.getColors();
  77     String displayMode = uiCrossfader.getDisplayMode();
  78     if (displayMode == "A") {
  79       simulationColors = lx.engine.getDeck(LEFT_DECK).getColors();
  80     } else if (displayMode == "B") {
  81       simulationColors = lx.engine.getDeck(RIGHT_DECK).getColors();
  82     }
  83
  84     long simulationStart = System.nanoTime();
  85     if (simulationOn) {
  86       drawSimulation(simulationColors);
  87     }
  88     simulationNanos = System.nanoTime() - simulationStart;
  89     camera();
  90     strokeWeight(1);
  91   }
  92   void drawSimulation(color[] simulationColors) {
  93     translate(0, 30, 0);
  94
  95     fill(#141414);
  96     //drawBox(0, -TRAILER_HEIGHT, 0, 0, 0, 0, TRAILER_WIDTH, TRAILER_HEIGHT, TRAILER_DEPTH, TRAILER_HEIGHT/2.);
  97     fill(#070707);
  98     stroke(#222222);
  99     beginShape();
 100     vertex(0, 0, 0);
 101     vertex(TRAILER_WIDTH, 0, 0);
 102     vertex(TRAILER_WIDTH, 0, TRAILER_DEPTH);
 103     vertex(0, 0, TRAILER_DEPTH);
 104     endShape();
 105
 106     // Draw the logo on the front of platform
 107     pushMatrix();
 108     translate(0, 0, -1);
 109     float s = .07;
 110     scale(s, -s, s);
 111     image(logo, TRAILER_WIDTH/2/s-logo.width/2, TRAILER_HEIGHT/2/s-logo.height/2-2/s);
 112     popMatrix();
 113
 114     noStroke();
 115     for (Cube c : model.cubes) {
 116       drawCube(c);
 117     }
 118
 119     noFill();
 120     //strokeWeight(2);
 121     int count=0;
 122
 123     ///magic:
 124
 125     pgl = beginPGL();
 126
 127
 128   sh.bind();
 129
 130   vertLoc = pgl.getAttribLocation(sh.glProgram, "vertex");
 131   colorLoc = pgl.getAttribLocation(sh.glProgram, "color");
 132
 133   pgl.bindBuffer(PGL.ARRAY_BUFFER, vboName.get(0));
 134   pgl.enableVertexAttribArray(vertLoc);
 135   pgl.enableVertexAttribArray(colorLoc);
 136
 137   pgl.vertexAttribPointer(vertLoc, 3, PGL.FLOAT, false, 7 * SIZEOF_FLOAT, 0);
 138   pgl.vertexAttribPointer(colorLoc, 4, PGL.FLOAT, false, 7 * SIZEOF_FLOAT, 3 * SIZEOF_FLOAT);
 139
 140   pgl.drawArrays(PGL.POINTS, 0, nvert);
 141
 142   pgl.disableVertexAttribArray(vertLoc);
 143   pgl.disableVertexAttribArray(colorLoc);
 144   pgl.bindBuffer(PGL.ARRAY_BUFFER, 0);
 145
 146   sh.unbind();
 147   endPGL();
 148   createGeometry(simulationColors);
 149   pgl.bindBuffer(PGL.ARRAY_BUFFER, vboName.get(0));
 150   pgl.bufferData(PGL.ARRAY_BUFFER, nvert * 7 * SIZEOF_FLOAT, vertData, PGL.STATIC_DRAW);
 151   }
 152
 153   void createGeometry(color[] simulationColors) {
 154     for (LXPoint p : model.points) {
 155         vertData.put(p.index * 7 + 3, ((simulationColors[p.index] >> 16) & 0xFF)/255.0);
 156         vertData.put(p.index * 7 + 4, ((simulationColors[p.index] >> 8) & 0xFF)/255.0);
 157         vertData.put(p.index * 7 + 5, (simulationColors[p.index]& 0xFF)/255.0);
 158       }
 159   }
 160 void initVBO() {
 161
 162   pgl = beginPGL();
 163   pgl.genBuffers(1, vboName);
 164   pgl.bindBuffer(PGL.ARRAY_BUFFER, vboName.get(0));
 165   pgl.bufferData(PGL.ARRAY_BUFFER, nvert * 7 * SIZEOF_FLOAT, vertData, PGL.DYNAMIC_DRAW);
 166   pgl.bindBuffer(PGL.ARRAY_BUFFER, 0);
 167   endPGL();
 168 }
 169
 170 IntBuffer allocateDirectIntBuffer(int n) {
 171   return ByteBuffer.allocateDirect(n * SIZEOF_INT).order(ByteOrder.nativeOrder()).asIntBuffer();
 172 }
 173
 174 FloatBuffer allocateDirectFloatBuffer(int n) {
 175   return ByteBuffer.allocateDirect(n * SIZEOF_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
 176 }
 177
 178   void drawCube(Cube c) {
 179     float in = .15;
 180     noStroke();
 181     fill(#393939);
 182     //drawBox(c.x+in, c.y+in, c.z+in, c.rx, c.ry, c.rz, Cube.EDGE_WIDTH-in*2, Cube.EDGE_HEIGHT-in*2, Cube.EDGE_WIDTH-in*2, Cube.CHANNEL_WIDTH-in);
 183   }
 184
 185   void drawBox(float x, float y, float z, float rx, float ry, float rz, float xd, float yd, float zd, float sw) {
 186     pushMatrix();
 187     translate(x, y, z);
 188     rotate(rx / 180. * PI, -1, 0, 0);
 189     rotate(ry / 180. * PI, 0, -1, 0);
 190     rotate(rz / 180. * PI, 0, 0, -1);
 191     for (int i = 0; i < 4; ++i) {
 192       float wid = (i % 2 == 0) ? xd : zd;
 193
 194       beginShape();
 195       vertex(0, 0);
 196       vertex(wid, 0);
 197       vertex(wid, yd);
 198       vertex(wid - sw, yd);
 199       vertex(wid - sw, sw);
 200       vertex(0, sw);
 201       endShape();
 202       beginShape();
 203       vertex(0, sw);
 204       vertex(0, yd);
 205       vertex(wid - sw, yd);
 206       vertex(wid - sw, yd - sw);
 207       vertex(sw, yd - sw);
 208       vertex(sw, sw);
 209       endShape();
 210
 211       translate(wid, 0, 0);
 212       rotate(HALF_PI, 0, -1, 0);
 213     }
 214     popMatrix();
 215   }
 216 }
 217
 218 class UIBlendMode extends UIWindow {
 219   public UIBlendMode(float x, float y, float w, float h) {
 220     super(lx.ui, "BLEND MODE", x, y, w, h);
 221     List<UIScrollList.Item> items = new ArrayList<UIScrollList.Item>();
 222     for (LXTransition t : transitions) {
 223       items.add(new TransitionScrollItem(t));
 224     }
 225     final UIScrollList tList;
 226     (tList = new UIScrollList(1, UIWindow.TITLE_LABEL_HEIGHT, w-2, 60)).setItems(items).addToContainer(this);
 227
 228     lx.engine.getDeck(RIGHT_DECK).addListener(new LXDeck.AbstractListener() {
 229       public void faderTransitionDidChange(LXDeck deck, LXTransition transition) {
 230         tList.redraw();
 231       }
 232     });
 233   }
 234
 235   class TransitionScrollItem extends UIScrollList.AbstractItem {
 236     private final LXTransition transition;
 237     private final String label;
 238
 239     TransitionScrollItem(LXTransition transition) {
 240       this.transition = transition;
 241       this.label = className(transition, "Transition");
 242     }
 243
 244     public String getLabel() {
 245       return label;
 246     }
 247
 248     public boolean isSelected() {
 249       return this.transition == lx.engine.getDeck(RIGHT_DECK).getFaderTransition();
 250     }
 251
 252     public boolean isPending() {
 253       return false;
 254     }
 255
 256     public void onMousePressed() {
 257       lx.engine.getDeck(RIGHT_DECK).setFaderTransition(this.transition);
 258     }
 259   }
 260
 261 }
 262
 263 class UICrossfader extends UIWindow {
 264
 265   private final UIToggleSet displayMode;
 266
 267   public UICrossfader(float x, float y, float w, float h) {
 268     super(lx.ui, "CROSSFADER", x, y, w, h);
 269
 270     new UISlider(4, UIWindow.TITLE_LABEL_HEIGHT, w-9, 32).setParameter(lx.engine.getDeck(RIGHT_DECK).getFader()).addToContainer(this);
 271     (displayMode = new UIToggleSet(4, UIWindow.TITLE_LABEL_HEIGHT + 36, w-9, 20)).setOptions(new String[] { "A", "COMP", "B" }).setValue("COMP").addToContainer(this);
 272   }
 273
 274   public UICrossfader setDisplayMode(String value) {
 275     displayMode.setValue(value);
 276     return this;
 277   }
 278
 279   public String getDisplayMode() {
 280     return displayMode.getValue();
 281   }
 282 }
 283
 284 class UIEffects extends UIWindow {
 285   UIEffects(float x, float y, float w, float h) {
 286     super(lx.ui, "FX", x, y, w, h);
 287
 288     int yp = UIWindow.TITLE_LABEL_HEIGHT;
 289     List<UIScrollList.Item> items = new ArrayList<UIScrollList.Item>();
 290     int i = 0;
 291     for (LXEffect fx : effectsArr) {
 292       items.add(new FXScrollItem(fx, i++));
 293     }
 294     final UIScrollList effectsList = new UIScrollList(1, yp, w-2, 60).setItems(items);
 295     effectsList.addToContainer(this);
 296     yp += effectsList.getHeight() + 10;
 297
 298     final UIKnob[] parameterKnobs = new UIKnob[4];
 299     for (int ki = 0; ki < parameterKnobs.length; ++ki) {
 300       parameterKnobs[ki] = new UIKnob(5 + 34*(ki % 4), yp + (ki/4) * 48);
 301       parameterKnobs[ki].addToContainer(this);
 302     }
 303
 304     LXParameterListener fxListener = new LXParameterListener() {
 305       public void onParameterChanged(LXParameter parameter) {
 306         int i = 0;
 307         for (LXParameter p : getSelectedEffect().getParameters()) {
 308           if (i >= parameterKnobs.length) {
 309             break;
 310           }
 311           if (p instanceof BasicParameter) {
 312             parameterKnobs[i++].setParameter((BasicParameter) p);
 313           }
 314         }
 315         while (i < parameterKnobs.length) {
 316           parameterKnobs[i++].setParameter(null);
 317         }
 318       }
 319     };
 320
 321     selectedEffect.addListener(fxListener);
 322     fxListener.onParameterChanged(null);
 323
 324   }
 325
 326   class FXScrollItem extends UIScrollList.AbstractItem {
 327
 328     private final LXEffect effect;
 329     private final int index;
 330     private final String label;
 331
 332     FXScrollItem(LXEffect effect, int index) {
 333       this.effect = effect;
 334       this.index = index;
 335       this.label = className(effect, "Effect");
 336     }
 337
 338     public String getLabel() {
 339       return label;
 340     }
 341
 342     public boolean isSelected() {
 343       return !effect.isEnabled() && (effect == getSelectedEffect());
 344     }
 345
 346     public boolean isPending() {
 347       return effect.isEnabled();
 348     }
 349
 350     public void onMousePressed() {
 351       if (effect == getSelectedEffect()) {
 352         if (effect.isMomentary()) {
 353           effect.enable();
 354         } else {
 355           effect.toggle();
 356         }
 357       } else {
 358         selectedEffect.setValue(index);
 359       }
 360     }
 361
 362     public void onMouseReleased() {
 363       if (effect.isMomentary()) {
 364         effect.disable();
 365       }
 366     }
 367
 368   }
 369
 370 }
 371
 372 class UIOutput extends UIWindow {
 373   public UIOutput(GrizzlyOutput[] grizzlies, float x, float y, float w, float h) {
 374     super(lx.ui, "OUTPUT", x, y, w, h);
 375     float yp = UIWindow.TITLE_LABEL_HEIGHT;
 376
 377     final UIScrollList outputs = new UIScrollList(1, UIWindow.TITLE_LABEL_HEIGHT, w-2, 80);
 378
 379     List<UIScrollList.Item> items = new ArrayList<UIScrollList.Item>();
 380     for (GrizzlyOutput grizzly : grizzlies) {
 381       items.add(new GrizzlyScrollItem(grizzly));
 382       grizzly.enabled.addListener(new LXParameterListener() {
 383         public void onParameterChanged(LXParameter parameter) {
 384            outputs.redraw();
 385         }
 386       });
 387     }
 388     outputs.setItems(items).addToContainer(this);
 389   }
 390
 391   class GrizzlyScrollItem extends UIScrollList.AbstractItem {
 392     final GrizzlyOutput output;
 393
 394     GrizzlyScrollItem(GrizzlyOutput output) {
 395       this.output = output;
 396     }
 397
 398     public String getLabel() {
 399       return output.ipAddress;
 400     }
 401
 402     public boolean isSelected() {
 403       return output.enabled.isOn();
 404     }
 405
 406     public void onMousePressed() {
 407       output.enabled.setValue(!isSelected());
 408     }
 409   }
 410 }
 411
 412 class UITempo extends UIWindow {
 413
 414   private final UIButton tempoButton;
 415
 416   UITempo(float x, float y, float w, float h) {
 417     super(lx.ui, "TEMPO", x, y, w, h);
 418     tempoButton = new UIButton(4, UIWindow.TITLE_LABEL_HEIGHT, w-10, 20) {
 419       protected void onToggle(boolean active) {
 420         if (active) {
 421           lx.tempo.tap();
 422         }
 423       }
 424     }.setMomentary(true);
 425     tempoButton.addToContainer(this);
 426     new UITempoBlipper(8, UIWindow.TITLE_LABEL_HEIGHT + 5, 12, 12).addToContainer(this);
 427   }
 428
 429   class UITempoBlipper extends UIObject {
 430     UITempoBlipper(float x, float y, float w, float h) {
 431       super(x, y, w, h);
 432     }
 433
 434     void onDraw(UI ui, PGraphics pg) {
 435       tempoButton.setLabel("" + ((int)(lx.tempo.bpm() * 10)) / 10.);
 436
 437       // Overlay tempo thing with openGL, redraw faster than button UI
 438       pg.fill(color(0, 0, 24 - 8*lx.tempo.rampf()));
 439       pg.noStroke();
 440       pg.rect(0, 0, width, height);
 441
 442       redraw();
 443     }
 444   }
 445
 446 }
 447
 448 class UIMapping extends UIWindow {
 449
 450   private static final String MAP_MODE_ALL = "ALL";
 451   private static final String MAP_MODE_CHANNEL = "CHNL";
 452   private static final String MAP_MODE_CUBE = "CUBE";
 453
 454   private static final String CUBE_MODE_ALL = "ALL";
 455   private static final String CUBE_MODE_STRIP = "SNGL";
 456   private static final String CUBE_MODE_PATTERN = "PTRN";
 457
 458   private final MappingTool mappingTool;
 459
 460   private final UIIntegerBox channelBox;
 461   private final UIIntegerBox cubeBox;
 462   private final UIIntegerBox stripBox;
 463
 464   UIMapping(MappingTool tool, float x, float y, float w, float h) {
 465     super(lx.ui, "MAPPING", x, y, w, h);
 466     mappingTool = tool;
 467
 468     int yp = UIWindow.TITLE_LABEL_HEIGHT;
 469     new UIToggleSet(4, yp, w-10, 20) {
 470       protected void onToggle(String value) {
 471         if (value == MAP_MODE_ALL) mappingTool.mappingMode = mappingTool.MAPPING_MODE_ALL;
 472         else if (value == MAP_MODE_CHANNEL) mappingTool.mappingMode = mappingTool.MAPPING_MODE_CHANNEL;
 473         else if (value == MAP_MODE_CUBE) mappingTool.mappingMode = mappingTool.MAPPING_MODE_SINGLE_CUBE;
 474       }
 475     }.setOptions(new String[] { MAP_MODE_ALL, MAP_MODE_CHANNEL, MAP_MODE_CUBE }).addToContainer(this);
 476     yp += 24;
 477     new UILabel(4, yp+8, w-10, 20).setLabel("CHANNEL ID").addToContainer(this);
 478     yp += 24;
 479     (channelBox = new UIIntegerBox(4, yp, w-10, 20) {
 480       protected void onValueChange(int value) {
 481         mappingTool.setChannel(value-1);
 482       }
 483     }).setRange(1, mappingTool.numChannels()).addToContainer(this);
 484     yp += 24;
 485
 486     new UILabel(4, yp+8, w-10, 20).setLabel("CUBE ID").addToContainer(this);
 487     yp += 24;
 488     (cubeBox = new UIIntegerBox(4, yp, w-10, 20) {
 489       protected void onValueChange(int value) {
 490         mappingTool.setCube(value-1);
 491       }
 492     }).setRange(1, model.cubes.size()).addToContainer(this);
 493     yp += 24;
 494
 495     yp += 10;
 496
 497     new UIScrollList(1, yp, w-2, 60).setItems(Arrays.asList(new UIScrollList.Item[] {
 498       new ColorScrollItem(ColorScrollItem.COLOR_RED),
 499       new ColorScrollItem(ColorScrollItem.COLOR_GREEN),
 500       new ColorScrollItem(ColorScrollItem.COLOR_BLUE),
 501     })).addToContainer(this);
 502     yp += 64;
 503
 504     new UILabel(4, yp+8, w-10, 20).setLabel("STRIP MODE").addToContainer(this);
 505     yp += 24;
 506
 507     new UIToggleSet(4, yp, w-10, 20) {
 508       protected void onToggle(String value) {
 509         if (value == CUBE_MODE_ALL) mappingTool.cubeMode = mappingTool.CUBE_MODE_ALL;
 510         else if (value == CUBE_MODE_STRIP) mappingTool.cubeMode = mappingTool.CUBE_MODE_SINGLE_STRIP;
 511         else if (value == CUBE_MODE_PATTERN) mappingTool.cubeMode = mappingTool.CUBE_MODE_STRIP_PATTERN;
 512       }
 513     }.setOptions(new String[] { CUBE_MODE_ALL, CUBE_MODE_STRIP, CUBE_MODE_PATTERN }).addToContainer(this);
 514
 515     yp += 24;
 516     new UILabel(4, yp+8, w-10, 20).setLabel("STRIP ID").addToContainer(this);
 517
 518     yp += 24;
 519     (stripBox = new UIIntegerBox(4, yp, w-10, 20) {
 520       protected void onValueChange(int value) {
 521         mappingTool.setStrip(value-1);
 522       }
 523     }).setRange(1, Cube.STRIPS_PER_CUBE).addToContainer(this);
 524
 525   }
 526
 527   public void setChannelID(int value) {
 528     channelBox.setValue(value);
 529   }
 530
 531   public void setCubeID(int value) {
 532     cubeBox.setValue(value);
 533   }
 534
 535   public void setStripID(int value) {
 536     stripBox.setValue(value);
 537   }
 538
 539   class ColorScrollItem extends UIScrollList.AbstractItem {
 540
 541     public static final int COLOR_RED = 1;
 542     public static final int COLOR_GREEN = 2;
 543     public static final int COLOR_BLUE = 3;
 544
 545     private final int colorChannel;
 546
 547     ColorScrollItem(int colorChannel) {
 548       this.colorChannel = colorChannel;
 549     }
 550
 551     public String getLabel() {
 552       switch (colorChannel) {
 553         case COLOR_RED: return "Red";
 554         case COLOR_GREEN: return "Green";
 555         case COLOR_BLUE: return "Blue";
 556       }
 557       return "";
 558     }
 559
 560     public boolean isSelected() {
 561       switch (colorChannel) {
 562         case COLOR_RED: return mappingTool.channelModeRed;
 563         case COLOR_GREEN: return mappingTool.channelModeGreen;
 564         case COLOR_BLUE: return mappingTool.channelModeBlue;
 565       }
 566       return false;
 567     }
 568
 569     public void onMousePressed() {
 570       switch (colorChannel) {
 571         case COLOR_RED: mappingTool.channelModeRed = !mappingTool.channelModeRed; break;
 572         case COLOR_GREEN: mappingTool.channelModeGreen = !mappingTool.channelModeGreen; break;
 573         case COLOR_BLUE: mappingTool.channelModeBlue = !mappingTool.channelModeBlue; break;
 574       }
 575     }
 576   }
 577 }
 578
 579 class UIDebugText extends UIContext {
 580
 581   private String line1 = "";
 582   private String line2 = "";
 583
 584   UIDebugText(float x, float y, float w, float h) {
 585     super(lx.ui, x, y, w, h);
 586   }
 587
 588   public UIDebugText setText(String line1) {
 589     return setText(line1, "");
 590   }
 591
 592   public UIDebugText setText(String line1, String line2) {
 593     if (!line1.equals(this.line1) || !line2.equals(this.line2)) {
 594       this.line1 = line1;
 595       this.line2 = line2;
 596       setVisible(line1.length() + line2.length() > 0);
 597       redraw();
 598     }
 599     return this;
 600   }
 601
 602   protected void onDraw(UI ui, PGraphics pg) {
 603     super.onDraw(ui, pg);
 604     if (line1.length() + line2.length() > 0) {
 605       pg.noStroke();
 606       pg.fill(#444444);
 607       pg.rect(0, 0, width, height);
 608       pg.textFont(ui.getItemFont());
 609       pg.textSize(10);
 610       pg.textAlign(LEFT, TOP);
 611       pg.fill(#cccccc);
 612       pg.text(line1, 4, 4);
 613       pg.text(line2, 4, 24);
 614     }
 615   }
 616 }
 617
 618 class UISpeed extends UIWindow {
 619
 620   final BasicParameter speed;
 621
 622   UISpeed(float x, float y, float w, float h) {
 623     super(lx.ui, "SPEED", x, y, w, h);
 624     speed = new BasicParameter("SPEED", 0.5);
 625     speed.addListener(new LXParameterListener() {
 626       public void onParameterChanged(LXParameter parameter) {
 627         lx.setSpeed(parameter.getValuef() * 2);
 628       }
 629     });
 630     new UISlider(4, UIWindow.TITLE_LABEL_HEIGHT, w-10, 20).setParameter(speed).addToContainer(this);
 631   }
 632 }
 633
 634 class UIMidi extends UIWindow {
 635
 636   private final UIToggleSet deckMode;
 637   private final UIButton logMode;
 638
 639   UIMidi(final MidiEngine midiEngine, float x, float y, float w, float h) {
 640     super(lx.ui, "MIDI", x, y, w, h);
 641
 642     // Processing compiler doesn't seem to get that list of class objects also conform to interface
 643     List<UIScrollList.Item> scrollItems = new ArrayList<UIScrollList.Item>();
 644     for (SCMidiInput mc : midiEngine.getControllers()) {
 645       scrollItems.add(mc);
 646     }
 647     final UIScrollList scrollList;
 648     (scrollList = new UIScrollList(1, UIWindow.TITLE_LABEL_HEIGHT, w-2, 100)).setItems(scrollItems).addToContainer(this);
 649     (deckMode = new UIToggleSet(4, 130, 90, 20) {
 650       protected void onToggle(String value) {
 651         midiEngine.setFocusedDeck(value == "A" ? 0 : 1);
 652       }
 653     }).setOptions(new String[] { "A", "B" }).addToContainer(this);
 654     (logMode = new UIButton(98, 130, w-103, 20)).setLabel("LOG").addToContainer(this);
 655
 656     SCMidiInputListener listener = new SCMidiInputListener() {
 657       public void onEnabled(SCMidiInput controller, boolean enabled) {
 658         scrollList.redraw();
 659       }
 660     };
 661     for (SCMidiInput mc : midiEngine.getControllers()) {
 662       mc.addListener(listener);
 663     }
 664
 665     midiEngine.addListener(new MidiEngineListener() {
 666       public void onFocusedDeck(int deckIndex) {
 667         deckMode.setValue(deckIndex == 0 ? "A" : "B");
 668       }
 669     });
 670
 671   }
 672
 673   public boolean logMidi() {
 674     return logMode.isActive();
 675   }
 676
 677   public LXDeck getFocusedDeck() {
 678     return lx.engine.getDeck(deckMode.getValue() == "A" ? LEFT_DECK : RIGHT_DECK);
 679   }
 680 }
 681
 682 String className(Object p, String suffix) {
 683   String s = p.getClass().getName();
 684   int li;
 685   if ((li = s.lastIndexOf(".")) > 0) {
 686     s = s.substring(li + 1);
 687   }
 688   if (s.indexOf("SugarCubes$") == 0) {
 689     s = s.substring("SugarCubes$".length());
 690   }
 691   if ((suffix != null) && ((li = s.indexOf(suffix)) != -1)) {
 692     s = s.substring(0, li);
 693   }
 694   return s;
 695 }