private Method patternStateMethod;
private Method transitionStateMethod;
private Method effectStateMethod;
-
- private final int NUM_PATTERN_KNOBS = 8;
- private final int NUM_TRANSITION_KNOBS = 4;
- private final int NUM_EFFECT_KNOBS = 4;
-
- private int activeTransitionIndex = 0;
- private int activeEffectIndex = 0;
-
- public final VirtualPatternKnob[] patternKnobs;
- public final VirtualTransitionKnob[] transitionKnobs;
- public final VirtualEffectKnob[] effectKnobs;
-
+
ControlUI() {
patternNames = classNameArray(patterns, "Pattern");
transitionNames = classNameArray(transitions, "Transition");
effectNames = classNameArray(effects, "Effect");
- patternKnobs = new VirtualPatternKnob[NUM_PATTERN_KNOBS];
- for (int i = 0; i < patternKnobs.length; ++i) {
- patternKnobs[i] = new VirtualPatternKnob(i);
- }
-
- transitionKnobs = new VirtualTransitionKnob[NUM_TRANSITION_KNOBS];
- for (int i = 0; i < transitionKnobs.length; ++i) {
- transitionKnobs[i] = new VirtualTransitionKnob(i);
- }
-
- effectKnobs = new VirtualEffectKnob[NUM_EFFECT_KNOBS];
- for (int i = 0; i < effectKnobs.length; ++i) {
- effectKnobs[i] = new VirtualEffectKnob(i);
- }
-
try {
patternStateMethod = getClass().getMethod("getState", LXPattern.class);
effectStateMethod = getClass().getMethod("getState", LXEffect.class);
yPos += controlSpacing;
firstPatternKnobY = yPos;
int xPos = leftTextPos;
- for (int i = 0; i < NUM_PATTERN_KNOBS/2; ++i) {
- drawKnob(xPos, yPos, knobSize, patternKnobs[i]);
- drawKnob(xPos, yPos + knobSize + knobSpacing + knobLabelHeight, knobSize, patternKnobs[NUM_PATTERN_KNOBS/2 + i]);
+ for (int i = 0; i < glucose.NUM_PATTERN_KNOBS/2; ++i) {
+ drawKnob(xPos, yPos, knobSize, glucose.patternKnobs.get(i));
+ drawKnob(xPos, yPos + knobSize + knobSpacing + knobLabelHeight, knobSize, glucose.patternKnobs.get(glucose.NUM_PATTERN_KNOBS/2 + i));
xPos += knobSize + knobSpacing;
}
yPos += 2*(knobSize + knobLabelHeight) + knobSpacing;
yPos += controlSpacing;
firstTransitionKnobY = yPos;
xPos = leftTextPos;
- for (int i = 0; i < transitionKnobs.length; ++i) {
- drawKnob(xPos, yPos, knobSize, transitionKnobs[i]);
+ for (VirtualTransitionKnob knob : glucose.transitionKnobs) {
+ drawKnob(xPos, yPos, knobSize, knob);
xPos += knobSize + knobSpacing;
}
yPos += knobSize + knobLabelHeight;
yPos += controlSpacing;
firstEffectKnobY = yPos;
xPos = leftTextPos;
- for (int i = 0; i < effectKnobs.length; ++i) {
- drawKnob(xPos, yPos, knobSize, effectKnobs[i]);
+ for (VirtualEffectKnob knob : glucose.effectKnobs) {
+ drawKnob(xPos, yPos, knobSize, knob);
xPos += knobSize + knobSpacing;
}
yPos += knobSize + knobLabelHeight;
public int getState(LXEffect e) {
if (e.isEnabled()) {
return STATE_PENDING;
- } else if (effects[activeEffectIndex] == e) {
+ } else if (e == glucose.getSelectedEffect()) {
return STATE_ACTIVE;
}
return STATE_DEFAULT;
public int getState(LXTransition t) {
if (t == lx.getTransition()) {
return STATE_PENDING;
- } else if (t == transitions[activeTransitionIndex]) {
+ } else if (t == glucose.getSelectedTransition()) {
return STATE_ACTIVE;
}
return STATE_DEFAULT;
textFont(knobFont);
text(knobLabel, xPos + knobSize/2, yPos + knobSize + knobLabelHeight - 2);
}
-
- class VirtualPatternKnob extends LXVirtualParameter {
- private final int index;
-
- VirtualPatternKnob(int index) {
- this.index = index;
- }
-
- public LXParameter getRealParameter() {
- List<LXParameter> parameters = glucose.getPattern().getParameters();
- if (index < parameters.size()) {
- return parameters.get(index);
- }
- return null;
- }
- }
-
- class VirtualTransitionKnob extends LXVirtualParameter {
- private final int index;
-
- VirtualTransitionKnob(int index) {
- this.index = index;
- }
-
- public LXParameter getRealParameter() {
- List<LXParameter> parameters = transitions[activeTransitionIndex].getParameters();
- if (index < parameters.size()) {
- return parameters.get(index);
- }
- return null;
- }
- }
-
- class VirtualEffectKnob extends LXVirtualParameter {
- private final int index;
-
- VirtualEffectKnob(int index) {
- this.index = index;
- }
-
- public LXParameter getRealParameter() {
- List<LXParameter> parameters = effects[activeEffectIndex].getParameters();
- if (index < parameters.size()) {
- return parameters.get(index);
- }
- return null;
- }
- }
private int patternKnobIndex = -1;
private int transitionKnobIndex = -1;
} else if (mouseY > firstEffectY) {
int effectIndex = objectClickIndex(firstEffectY);
if (effectIndex < effects.length) {
- if (activeEffectIndex == effectIndex) {
+ if (effects[effectIndex] == glucose.getSelectedEffect()) {
effects[effectIndex].enable();
releaseEffect = effectIndex;
}
- activeEffectIndex = effectIndex;
+ glucose.setSelectedEffect(effectIndex);
}
} else if ((mouseY >= firstTransitionKnobY) && (mouseY < firstTransitionKnobY + knobSize + knobLabelHeight)) {
transitionKnobIndex = (mouseX - leftTextPos) / (knobSize + knobSpacing);
} else if (mouseY > firstTransitionY) {
int transitionIndex = objectClickIndex(firstTransitionY);
if (transitionIndex < transitions.length) {
- activeTransitionIndex = transitionIndex;
+ glucose.setSelectedTransition(transitionIndex);
}
} else if ((mouseY >= firstPatternKnobY) && (mouseY < firstPatternKnobY + 2*(knobSize+knobLabelHeight) + knobSpacing)) {
patternKnobIndex = (mouseX - leftTextPos) / (knobSize + knobSpacing);
if (mouseY >= firstPatternKnobY + knobSize + knobLabelHeight + knobSpacing) {
- patternKnobIndex += NUM_PATTERN_KNOBS / 2;
+ patternKnobIndex += glucose.NUM_PATTERN_KNOBS / 2;
}
} else if (mouseY > firstPatternY) {
int patternIndex = objectClickIndex(firstPatternY);
if (patternIndex < patterns.length) {
- patterns[patternIndex].setTransition(transitions[activeTransitionIndex]);
lx.goIndex(patternIndex);
}
}
public void mouseDragged() {
int dy = lastY - mouseY;
lastY = mouseY;
- if (patternKnobIndex >= 0 && patternKnobIndex < NUM_PATTERN_KNOBS) {
- LXParameter p = patternKnobs[patternKnobIndex];
+ if (patternKnobIndex >= 0 && patternKnobIndex < glucose.NUM_PATTERN_KNOBS) {
+ LXParameter p = glucose.patternKnobs.get(patternKnobIndex);
p.setValue(constrain(p.getValuef() + dy*.01, 0, 1));
- } else if (effectKnobIndex >= 0 && effectKnobIndex < NUM_EFFECT_KNOBS) {
- LXParameter p = effectKnobs[effectKnobIndex];
+ } else if (effectKnobIndex >= 0 && effectKnobIndex < glucose.NUM_EFFECT_KNOBS) {
+ LXParameter p = glucose.effectKnobs.get(effectKnobIndex);
p.setValue(constrain(p.getValuef() + dy*.01, 0, 1));
- } else if (transitionKnobIndex >= 0 && transitionKnobIndex < NUM_TRANSITION_KNOBS) {
- LXParameter p = transitionKnobs[transitionKnobIndex];
+ } else if (transitionKnobIndex >= 0 && transitionKnobIndex < glucose.NUM_TRANSITION_KNOBS) {
+ LXParameter p = glucose.transitionKnobs.get(transitionKnobIndex);
p.setValue(constrain(p.getValuef() + dy*.01, 0, 1));
}
}
private MappingTool mappingTool;
private final String MAPPING_MODE_ALL = "All On";
+ private final String MAPPING_MODE_CHANNEL = "Channel";
private final String MAPPING_MODE_SINGLE_CUBE = "Single Cube";
+
private final String[] mappingModes = {
MAPPING_MODE_ALL,
- MAPPING_MODE_SINGLE_CUBE,
+ MAPPING_MODE_CHANNEL,
+ MAPPING_MODE_SINGLE_CUBE
};
private final Method mappingModeStateMethod;
private int firstMappingY;
private int firstCubeY;
private int firstChannelY;
+ private int channelFieldY;
private int cubeFieldY;
private int stripFieldY;
private boolean dragCube;
private boolean dragStrip;
+ private boolean dragChannel;
MappingUI(MappingTool mappingTool) {
this.mappingTool = mappingTool;
}
public int getMappingState(Object mappingMode) {
- boolean active = (mappingMode == MAPPING_MODE_SINGLE_CUBE) == mappingTool.mappingModeSingleCube;
+ boolean active = false;
+ if (mappingMode == MAPPING_MODE_ALL) {
+ active = mappingTool.mappingMode == mappingTool.MAPPING_MODE_ALL;
+ } else if (mappingMode == MAPPING_MODE_CHANNEL) {
+ active = mappingTool.mappingMode == mappingTool.MAPPING_MODE_CHANNEL;
+ } else if (mappingMode == MAPPING_MODE_SINGLE_CUBE) {
+ active = mappingTool.mappingMode == mappingTool.MAPPING_MODE_SINGLE_CUBE;
+ }
return active ? STATE_ACTIVE : STATE_DEFAULT;
}
firstChannelY = yPos + lineHeight + 6;
yPos = drawObjectList(yPos, "CHANNELS", channelModes, channelModes, channelModeStateMethod);
yPos += sectionSpacing;
+
+ channelFieldY = yPos + lineHeight + 6;
+ yPos = drawValueField(yPos, "CHANNEL ID", mappingTool.channelIndex + 1);
+ yPos += sectionSpacing;
cubeFieldY = yPos + lineHeight + 6;
yPos = drawValueField(yPos, "CUBE ID", glucose.model.getRawIndexForCube(mappingTool.cubeIndex));
private int lastY;
public void mousePressed() {
- dragCube = dragStrip = false;
+ dragCube = dragStrip = dragChannel = false;
lastY = mouseY;
if (mouseY >= stripFieldY) {
if (mouseY < stripFieldY + lineHeight) {
if (mouseY < cubeFieldY + lineHeight) {
dragCube = true;
}
+ } else if (mouseY >= channelFieldY) {
+ if (mouseY < channelFieldY + lineHeight) {
+ dragChannel = true;
+ }
} else if (mouseY >= firstChannelY) {
int index = objectClickIndex(firstChannelY);
switch (index) {
}
} else if (mouseY >= firstMappingY) {
int index = objectClickIndex(firstMappingY);
- if (index < 2) {
- mappingTool.mappingModeSingleCube = (index > 0);
+ switch (index) {
+ case 0: mappingTool.mappingMode = mappingTool.MAPPING_MODE_ALL; break;
+ case 1: mappingTool.mappingMode = mappingTool.MAPPING_MODE_CHANNEL; break;
+ case 2: mappingTool.mappingMode = mappingTool.MAPPING_MODE_SINGLE_CUBE; break;
}
}
}
} else {
mappingTool.incStrip();
}
+ } else if (dragChannel) {
+ if (dy < 0) {
+ mappingTool.decChannel();
+ } else {
+ mappingTool.incChannel();
+ }
}
}