Go to most recent revision | Blame | Last modification | View Log | Download
package avr.swing;
import com.sun.java.swing.SwingUtilities2;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.plaf.metal.*;
import avr.lang.*;
import avr.swing.*;
import avr.connection.event.ConnectionListener;
import avr.connection.event.ConnectionEvent;
import avr.device.event.DataAdapter;
import avr.device.event.DataListener;
import java.io.IOException;
public class JNewColorMapPanel extends JColorMapInterface {
public static void main(String[] args) {
JFrame frame = new JFrame("Testing");
// frame.getContentPane().setLayout(new FlowLayout());
frame.getContentPane().add(new JNewColorMapPanel(null), BorderLayout.CENTER);
frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.show();
}
private JSelectionPanel redP;
private JSelectionPanel greenP;
private JSelectionPanel blueP;
private JIndexRadioButton indicies[];
private static final int RED_INDEX = 0;
private static final int GREEN_INDEX = 1;
private static final int BLUE_INDEX = 2;
private static final int RED_MASK = 0xFF0000;
private static final int GREEN_MASK = 0x00FF00;
private static final int BLUE_MASK = 0x0000FF;
private static final int MIN_INDEX = 0;
private static final int MAX_INDEX = 1;
private int[][][] cachedMap;
private JMessagePanel messageP;
private Action checkAction;
private Action clearColumnAction;
private Action clearAction;
private Action resetAction;
private Action sendAction;
public JNewColorMapPanel(JMessagePanel messageP) {
super(null);
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
this.messageP = messageP;
cachedMap = new int[8][3][2];
redP = new JSelectionPanel(JSelectionPanel.RED_INDEX);
greenP = new JSelectionPanel(JSelectionPanel.GREEN_INDEX);
blueP = new JSelectionPanel(JSelectionPanel.BLUE_INDEX);
JPanel topP = new JPanel();
topP.add(new JLabel("Color Index:"));
ButtonGroup bg = new ButtonGroup();
indicies = new JIndexRadioButton[8];
ProxyAction indexAction = new ProxyAction(this, "updateSliders", (String)null);
ItemListener itemHandler = new ItemHandler();
for(int i = 0; i < 8; i++) {
indicies[i] = new JIndexRadioButton("" + (i + 1), i == 0);
indicies[i].addActionListener(indexAction);
indicies[i].addItemListener(itemHandler);
indicies[i].setOpaque(false);
bg.add(indicies[i]);
topP.add(indicies[i]);
}
checkAction = new ProxyAction(this, "check", "Auto Check", 'a');
clearColumnAction = new ProxyAction(this, "clearColumn", "Clear Indicies", 'l');
clearAction = new ProxyAction(this, "clear", "Clear All", 'c');
resetAction = new ProxyAction(this, "reset", "Reset", 'r');
sendAction = new ProxyAction(this, "send", "Send", 's');
sendAction.setEnabled(false);
Box southBox = new Box(BoxLayout.X_AXIS);
southBox.setBorder(new CompoundBorder(new EtchedBorder(), new EmptyBorder(5, 5, 5, 5)));
southBox.add(new JButton(checkAction));
southBox.add(Box.createHorizontalGlue());
southBox.add(Box.createHorizontalStrut(5));
southBox.add(new JButton(clearColumnAction));
southBox.add(Box.createHorizontalStrut(5));
southBox.add(new JButton(clearAction));
southBox.add(Box.createHorizontalStrut(5));
southBox.add(new JButton(resetAction));
southBox.add(Box.createHorizontalStrut(5));
southBox.add(new JButton(sendAction));
add(topP);
add(Box.createVerticalStrut(5));
add(redP);
add(Box.createVerticalStrut(5));
add(greenP);
add(Box.createVerticalStrut(5));
add(blueP);
add(Box.createVerticalStrut(5));
add(southBox);
reset();
AVRSystem.DEVICE.addConnectionListener(new ConnectionHandler());
}
private static String formatColorMapException(InvalidColorMapException icme) {
StringBuffer builder = new StringBuffer("Invalid Color Map: ");
int[] indicies = icme.getIndicies();
builder.append("Indicies ");
for(int i = 0; i < indicies.length; i++) {
builder.append(indicies[i]);
if((i + 1) < indicies.length) {
builder.append(" and ");
}
}
builder.append(" intersect at values Red: ")
.append(icme.getRed())
.append(" Green: ")
.append(icme.getGreen())
.append(" Blue: ")
.append(icme.getBlue());
return builder.toString();
}
public void check() {
try {
checkMap();
JOptionPane.showMessageDialog(getRootPane(),
"Color Map is valid.",
"Color Map Validated",
JOptionPane.INFORMATION_MESSAGE);
} catch(InvalidColorMapException icme) {
JOptionPane.showMessageDialog(getRootPane(), formatColorMapException(icme));
}
}
/* *************************************
* Copied from java.lang.Integer class
* from the JDK 1.5 version.
*/
private int bitCount(int i) {
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}
private void checkMap() throws InvalidColorMapException {
updateCacheMap();
int[][] colorMap = convert();
for(int redI = 0; redI < AVRSystem.NUM_INTENSITIES; redI++) {
int red = colorMap[0][redI];
for(int greenI = 0; greenI < AVRSystem.NUM_INTENSITIES; greenI++) {
int green = colorMap[1][greenI];
for(int blueI = 0; blueI < AVRSystem.NUM_INTENSITIES; blueI++) {
int blue = colorMap[2][blueI];
int value = red & green & blue;
// In JDk 1.5 the Integer class has the bitCount
// method. To be backward compatible, use the bitCount
// method above.
// if(value != 0 && (Integer.bitCount(value) > 1)) {
if(value != 0 && (bitCount(value) > 1)) {
int[] indicies = new int[bitCount(value)];
int count = 0;
for(int i = 0; i < 8; i++) {
if((value & (0x80 >>> i)) != 0) {
indicies[count++] = (i + 1);
}
}
throw new InvalidColorMapException("Color Map is invalid.", indicies, redI * 16, greenI * 16, blueI * 16);
}
}
}
}
}
private int[][] convert() {
int[][] colorMap = new int[3][AVRSystem.NUM_INTENSITIES];
for(int color = 0; color < 3; color++) {
for(int col = 0; col < 8; col++) {
for(int i = 1; i < AVRSystem.NUM_INTENSITIES; i++) {
int min = cachedMap[col][color][MIN_INDEX];
int max = cachedMap[col][color][MAX_INDEX];
if((min <= (i * 16)) && ((i * 16) <= max)) {
colorMap[color][i] |= (0x01 << (7 - col));
}
}
}
}
return colorMap;
}
public boolean isColumnClear(int column) {
return cachedMap[column][RED_INDEX][MIN_INDEX] == 0 &&
cachedMap[column][RED_INDEX][MAX_INDEX] == 0 &&
cachedMap[column][GREEN_INDEX][MIN_INDEX] == 0 &&
cachedMap[column][GREEN_INDEX][MAX_INDEX] == 0 &&
cachedMap[column][BLUE_INDEX][MIN_INDEX] == 0 &&
cachedMap[column][BLUE_INDEX][MAX_INDEX] == 0;
}
public void clear() {
cachedMap = new int[8][3][2];
updateSliders();
updateBackgrounds();
}
public void reset() {
int[][] colorMap = AVRSystem.DEVICE.getColorMap();
for(int c = 0; c < 8; c++) {
int minRed = 0;
int maxRed = 0;
int minGreen = 0;
int maxGreen = 0;
int minBlue = 0;
int maxBlue = 0;
for(int i = 0; i < AVRSystem.NUM_INTENSITIES; i++) {
int value = i * 16;
if((colorMap[0][i] & (0x01 << (7 - c))) != 0) {
if(minRed == 0 || value < minRed) {
minRed = value;
}
if(maxRed < (value)) {
maxRed = value;
}
}
if((colorMap[1][i] & (0x01 << (7 - c))) != 0) {
if(minGreen == 0 || value < minGreen) {
minGreen = value;
}
if(maxGreen < (value)) {
maxGreen = value;
}
}
if((colorMap[2][i] & (0x01 << (7 - c))) != 0) {
if(minBlue == 0 || value < minBlue) {
minBlue = value;
}
if(maxBlue < (value)) {
maxBlue = value;
}
}
}
int col = c;
cachedMap[col][RED_INDEX][MIN_INDEX] = minRed;
cachedMap[col][RED_INDEX][MAX_INDEX] = maxRed;
cachedMap[col][GREEN_INDEX][MIN_INDEX] = minGreen;
cachedMap[col][GREEN_INDEX][MAX_INDEX] = maxGreen;
cachedMap[col][BLUE_INDEX][MIN_INDEX] = minBlue;
cachedMap[col][BLUE_INDEX][MAX_INDEX] = maxBlue;
}
updateSliders();
updateBackgrounds();
}
public void clearColumn() {
JPanel displayP = new JPanel(new BorderLayout());
JPanel selectColP = new JPanel();
JCheckBox[] colCB = new JCheckBox[8];
for(int i = 0; i < colCB.length; i++) {
colCB[i] = new JCheckBox((i + 1) + "");
selectColP.add(colCB[i]);
}
displayP.add(new JLabel("Select Color Map Index:"), BorderLayout.NORTH);
displayP.add(selectColP, BorderLayout.SOUTH);
int option = JOptionPane.showConfirmDialog(getRootPane(),
displayP,
"Select Indicies to clear:",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
if(option == JOptionPane.OK_OPTION) {
/* *********************************************
* NOTE: This one loop is only checking the
* length of the red color panels but is also
* looping over the green and blue ones!!!!
**/
for(int col = 0; col < 8; col++) {
if(colCB[col].isSelected()) {
cachedMap[col][RED_INDEX][MIN_INDEX] = 0;
cachedMap[col][RED_INDEX][MAX_INDEX] = 0;
cachedMap[col][GREEN_INDEX][MIN_INDEX] = 0;
cachedMap[col][GREEN_INDEX][MAX_INDEX] = 0;
cachedMap[col][BLUE_INDEX][MIN_INDEX] = 0;
cachedMap[col][BLUE_INDEX][MAX_INDEX] = 0;
}
}
updateSliders();
updateBackgrounds();
}
}
public void send() {
try {
checkMap();
int[][] newColorMap = convert();
DataListener handler = new DataHandler(newColorMap);
try {
AVRSystem.DEVICE.addDataListener(handler);
getRootPane().getGlassPane().setVisible(true);
SwingUtilities.getRootPane(messageP).getGlassPane().setVisible(true);
AVRSystem.DEVICE.sendSetColorMap(newColorMap[0], newColorMap[1], newColorMap[2]);
messageP.append("Sent Color Map");
} catch(IOException ioe) {
AVRSystem.DEVICE.removeDataListener(handler);
getRootPane().getGlassPane().setVisible(false);
SwingUtilities.getRootPane(messageP).getGlassPane().setVisible(false);
ioe.printStackTrace();
AVRSystem.LOG.severe(ioe.getMessage());
}
} catch(InvalidColorMapException icme) {
JOptionPane.showMessageDialog(getRootPane(),
formatColorMapException(icme),
"Check Failed",
JOptionPane.ERROR_MESSAGE);
}
}
public void setColor(int index, int color) {
int minRed = (color & RED_MASK) >>> 16;
int minGreen = (color & GREEN_MASK) >>> 8;
int minBlue = (color & BLUE_MASK) >>> 0;
int maxRed = minRed;
int maxGreen = minGreen;
int maxBlue = minBlue;
if(minRed == 16) {
maxRed *= 3;
} else if(minRed == 240) {
minRed -= (16 * 2);
} else {
minRed -= 16;
maxRed += 16;
}
if(minGreen == 16) {
maxGreen *= 3;
} else if(minGreen == 240) {
minGreen -= (16 * 2);
} else {
minGreen -= 16;
maxGreen += 16;
}
if(minBlue == 16) {
maxBlue *= 3;
} else if(minBlue == 240) {
minBlue -= (16 * 2);
} else {
minBlue -= 16;
maxBlue += 16;
}
cachedMap[index][RED_INDEX][MIN_INDEX] = minRed;
cachedMap[index][RED_INDEX][MAX_INDEX] = maxRed;
cachedMap[index][GREEN_INDEX][MIN_INDEX] = minGreen;
cachedMap[index][GREEN_INDEX][MAX_INDEX] = maxGreen;
cachedMap[index][BLUE_INDEX][MIN_INDEX] = minBlue;
cachedMap[index][BLUE_INDEX][MAX_INDEX] = maxBlue;
indicies[index].setSelected(true);
updateSliders();
// updateBackgrounds();
}
private void updateCacheMap() {
for(int i = 0; i < 8; i++) {
if(indicies[i].isSelected()) {
cachedMap[i][RED_INDEX][MIN_INDEX] = redP.getMin();
cachedMap[i][RED_INDEX][MAX_INDEX] = redP.getMax();
cachedMap[i][GREEN_INDEX][MIN_INDEX] = greenP.getMin();
cachedMap[i][GREEN_INDEX][MAX_INDEX] = greenP.getMax();
cachedMap[i][BLUE_INDEX][MIN_INDEX] = blueP.getMin();
cachedMap[i][BLUE_INDEX][MAX_INDEX] = blueP.getMax();
}
}
}
public void update() {
updateCacheMap();
updateSliders();
}
public void updateBackgrounds() {
for(int i = 0; i < indicies.length; i++) {
int avgRed = (cachedMap[i][RED_INDEX][MIN_INDEX] +
cachedMap[i][RED_INDEX][MAX_INDEX]) / 2;
int avgGreen = (cachedMap[i][GREEN_INDEX][MIN_INDEX] +
cachedMap[i][GREEN_INDEX][MAX_INDEX]) / 2;
int avgBlue = (cachedMap[i][BLUE_INDEX][MIN_INDEX] +
cachedMap[i][BLUE_INDEX][MAX_INDEX]) / 2;
indicies[i].setToolTipText("Average Color: Red (" + avgRed + ") Green (" + avgGreen + ") Blue (" + avgBlue + ")");
indicies[i].setMinColor(
new Color(cachedMap[i][RED_INDEX][MIN_INDEX],
cachedMap[i][GREEN_INDEX][MIN_INDEX],
cachedMap[i][BLUE_INDEX][MIN_INDEX]));
indicies[i].setMaxColor(
new Color(cachedMap[i][RED_INDEX][MAX_INDEX],
cachedMap[i][GREEN_INDEX][MAX_INDEX],
cachedMap[i][BLUE_INDEX][MAX_INDEX]));
indicies[i].repaint();
}
}
public void updateSliders() {
for(int i = 0; i < indicies.length; i++) {
if(indicies[i].isSelected()) {
redP.setMin(cachedMap[i][RED_INDEX][MIN_INDEX]);
redP.setMax(cachedMap[i][RED_INDEX][MAX_INDEX]);
greenP.setMin(cachedMap[i][GREEN_INDEX][MIN_INDEX]);
greenP.setMax(cachedMap[i][GREEN_INDEX][MAX_INDEX]);
blueP.setMin(cachedMap[i][BLUE_INDEX][MIN_INDEX]);
blueP.setMax(cachedMap[i][BLUE_INDEX][MAX_INDEX]);
}
}
}
private static final class JIndexRadioButton extends JRadioButton {
private Color min;
private Color max;
public JIndexRadioButton(String text, boolean selected) {
super(text, selected);
min = Color.BLACK;
max = Color.BLACK;
}
public Dimension getPreferredSize() {
Dimension size = super.getPreferredSize();
size.width += 20;
return size;
}
public void setMinColor(Color min) {
this.min = min;
}
public void setMaxColor(Color max) {
this.max = max;
}
public void paintComponent(Graphics g) {
AbstractButton b = (AbstractButton) this;
JComponent c = this;
Dimension size = c.getSize();
Font f = c.getFont();
FontMetrics fm = SwingUtilities2.getFontMetrics(c, g, f);
Rectangle viewRect = new Rectangle(size);
Rectangle iconRect = new Rectangle();
Rectangle textRect = new Rectangle();
Insets i = c.getInsets();
viewRect.x += i.left;
viewRect.y += i.top;
viewRect.width -= (i.right + viewRect.x);
viewRect.height -= (i.bottom + viewRect.y);
Icon altIcon = b.getIcon();
String text = SwingUtilities.layoutCompoundLabel(
c, fm, b.getText(), altIcon != null ? altIcon : UIManager.getIcon("RadioButton.icon"),
b.getVerticalAlignment(), b.getHorizontalAlignment(),
b.getVerticalTextPosition(), b.getHorizontalTextPosition(),
viewRect, iconRect, textRect, b.getIconTextGap());
Graphics2D g2d = (Graphics2D)g;
Paint paint = g2d.getPaint();
Stroke stroke = g2d.getStroke();
g2d.setPaint(new GradientPaint(0, 0, min, size.width, 0, max));
g2d.setStroke(new BasicStroke(size.height));
g2d.fillRect(0, 0, size.width, size.height);
g2d.setPaint(paint);
g2d.setStroke(stroke);
super.paintComponent(g);
g.setColor(Color.WHITE);
g.fillRect(textRect.x - 1, textRect.y + 2, textRect.width + 2, textRect.height - 4);
paintText(g, c, textRect, text);
}
protected void paintText(Graphics g, JComponent c, Rectangle textRect,
String text) {
AbstractButton b = (AbstractButton)c;
ButtonModel model = b.getModel();
FontMetrics fm = SwingUtilities2.getFontMetrics(c, g);
int mnemonicIndex = b.getDisplayedMnemonicIndex();
/* Draw the Text */
if(model.isEnabled()) {
/*** paint the text normally */
g.setColor(b.getForeground());
SwingUtilities2.drawStringUnderlineCharAt(c, g, text, mnemonicIndex,
textRect.x + UIManager.getInt("Button.textShiftOffset"),
textRect.y + fm.getAscent() + UIManager.getInt("Button.textShiftOffset"));
} else {
/*** paint the text disabled ***/
g.setColor(b.getBackground().brighter());
SwingUtilities2.drawStringUnderlineCharAt(c, g, text, mnemonicIndex,
textRect.x, textRect.y + fm.getAscent());
g.setColor(b.getBackground().darker());
SwingUtilities2.drawStringUnderlineCharAt(c, g, text, mnemonicIndex,
textRect.x - 1, textRect.y + fm.getAscent() - 1);
}
}
}
private final class ItemHandler implements ItemListener {
public void itemStateChanged(ItemEvent e) {
if(e.getStateChange() == ItemEvent.DESELECTED) {
for(int i = 0; i < 8; i++) {
if(indicies[i] == e.getSource()) {
cachedMap[i][RED_INDEX][MIN_INDEX] = redP.getMin();
cachedMap[i][RED_INDEX][MAX_INDEX] = redP.getMax();
cachedMap[i][GREEN_INDEX][MIN_INDEX] = greenP.getMin();
cachedMap[i][GREEN_INDEX][MAX_INDEX] = greenP.getMax();
cachedMap[i][BLUE_INDEX][MIN_INDEX] = blueP.getMin();
cachedMap[i][BLUE_INDEX][MAX_INDEX] = blueP.getMax();
}
}
}
}
}
private static final class JSelectionPanel extends Box {
public static final int RED_INDEX = 0;
public static final int GREEN_INDEX = 1;
public static final int BLUE_INDEX = 2;
private JSlider minS;
private JSlider maxS;
private JColorLabel colorL;
private int index;
public JSelectionPanel(int index) {
super(BoxLayout.Y_AXIS);
this.index = index;
minS = new JSlider(0, 16 * (AVRSystem.NUM_INTENSITIES - 1), 16);
maxS = new JSlider(0, 16 * (AVRSystem.NUM_INTENSITIES - 1), 16);
minS.setUI(new AVRSliderUI(AVRSliderUI.RIGHT));
maxS.setUI(new AVRSliderUI(AVRSliderUI.LEFT));
colorL = new JColorLabel(index);
minS.setMajorTickSpacing(16);
minS.setSnapToTicks(true);
minS.setOpaque(false);
maxS.setPaintTicks(true);
maxS.setMajorTickSpacing(16);
maxS.setSnapToTicks(true);
maxS.setOpaque(false);
maxS.setPaintLabels(true);
minS.addChangeListener(new MinChangeHandler());
maxS.addChangeListener(new MaxChangeHandler());
minS.setForeground(Color.WHITE);
maxS.setForeground(Color.WHITE);
int sliderWidth = Math.max(minS.getPreferredSize().width,
maxS.getPreferredSize().width);
sliderWidth = (int)(sliderWidth * 1.75);
minS.setBorder(new CompoundBorder(minS.getBorder(), new EmptyBorder(0, 3, 0, 3)));
Dimension sliderDim = minS.getPreferredSize();
sliderDim.width = sliderWidth;
minS.setPreferredSize(sliderDim);
sliderDim = maxS.getPreferredSize();
sliderDim.width = sliderWidth;
maxS.setPreferredSize(sliderDim);
Enumeration labels = maxS.getLabelTable().elements();
while(labels.hasMoreElements()) {
((JLabel)labels.nextElement()).setForeground(Color.WHITE);
}
add(minS);
add(maxS);
}
public int getMin() {
return minS.getValue();
}
public void setMin(int min) {
minS.setValue(min);
}
public int getMax() {
return maxS.getValue();
}
public void setMax(int max) {
maxS.setValue(max);
}
public void paintComponent(Graphics g) {
Insets insets = getInsets();
Dimension size = getSize();
Graphics2D g2d = (Graphics2D)g;
int minRed = 0;
int minGreen = 0;
int minBlue = 0;
int maxRed = 0;
int maxGreen = 0;
int maxBlue = 0;
switch(index) {
case RED_INDEX:
maxRed = maxS.getValue();
minRed = minS.getValue();
break;
case GREEN_INDEX:
maxGreen = maxS.getValue();
minGreen = minS.getValue();
break;
case BLUE_INDEX:
maxBlue = maxS.getValue();
minBlue = minS.getValue();
break;
}
Color minColor = new Color(minRed, minGreen, minBlue);
Color maxColor = new Color(maxRed, maxGreen, maxBlue);
Paint paint = new GradientPaint(insets.left, insets.top, minColor,
size.width - insets.right, insets.top, maxColor);
g2d.setPaint(paint);
g2d.fillRect(insets.left, insets.top,
size.width - insets.left - insets.right,
size.height - insets.top - insets.bottom);
}
private final class MinChangeHandler implements ChangeListener {
public void stateChanged(ChangeEvent e) {
if(maxS.getValue() < minS.getValue()) {
maxS.setValue(minS.getValue());
}
// colorL.setMin(minS.getValue());
repaint();
}
}
private final class MaxChangeHandler implements ChangeListener {
public void stateChanged(ChangeEvent e) {
if(maxS.getValue() < minS.getValue()) {
minS.setValue(maxS.getValue());
}
// colorL.setMax(maxS.getValue());
repaint();
}
}
private static final class JColorLabel extends JLabel {
private int index;
private int max;
private int min;
public JColorLabel(int index) {
this.index = index;
setBorder(new LineBorder(Color.BLACK));
setOpaque(true);
min = 0;
max = 0;
}
public void setMin(int min) {
this.min = min;
repaint();
}
public void setMax(int max) {
this.max = max;
repaint();
}
public void paintComponent(Graphics g) {
Insets insets = getInsets();
Dimension size = getSize();
Graphics2D g2d = (Graphics2D)g;
int minRed = 0;
int minGreen = 0;
int minBlue = 0;
int maxRed = 0;
int maxGreen = 0;
int maxBlue = 0;
switch(index) {
case RED_INDEX:
maxRed = max;
minRed = min;
break;
case GREEN_INDEX:
maxGreen = max;
minGreen = min;
break;
case BLUE_INDEX:
maxBlue = max;
minBlue = min;
break;
}
Color minColor = new Color(minRed, minGreen, minBlue);
Color maxColor = new Color(maxRed, maxGreen, maxBlue);
Paint paint = new GradientPaint(insets.left, insets.top, minColor,
size.width - insets.right, insets.top, maxColor);
g2d.setPaint(paint);
g2d.fillRect(insets.left, insets.top,
size.width - insets.left - insets.right,
size.height - insets.top - insets.bottom);
}
}
private static final class AVRSliderUI extends MetalSliderUI {
public static final int LEFT = 0;
public static final int RIGHT = 1;
private int direction;
public AVRSliderUI(int direction) {
this.direction = direction;
filledSlider = false;
}
// overridden to not fill in the track
public void paintTrack(Graphics g) {
boolean drawInverted = this.drawInverted();
Rectangle paintRect = avrGetPaintTrackRect();
g.translate(paintRect.x, paintRect.y);
int w = paintRect.width;
int h = paintRect.height;
g.setColor(MetalLookAndFeel.getPrimaryControlDarkShadow());
g.drawRect(0, 0, w - 1, h - 1);
g.translate(-paintRect.x, -paintRect.y);
}
// overridden to point the thumb to the left or the right
public void paintThumb(Graphics g) {
Rectangle knobBounds = thumbRect;
if(direction == LEFT) {
g.translate( knobBounds.x, knobBounds.y );
((Graphics2D)g).rotate(Math.PI, knobBounds.width / 2, knobBounds.height / 2);
vertThumbIcon.paintIcon( slider, g, 0, 0 );
((Graphics2D)g).rotate(-Math.PI, knobBounds.width / 2, knobBounds.height / 2);
g.translate( -knobBounds.x, -knobBounds.y );
} else {
g.translate( knobBounds.x, knobBounds.y );
vertThumbIcon.paintIcon( slider, g, 0, 0 );
g.translate( -knobBounds.x, -knobBounds.y );
}
}
// this method is private in the MetalSliderUI class, so I have recreated
// the method so I can use it
private Rectangle avrGetPaintTrackRect() {
int trackLeft = 0, trackRight = 0, trackTop = 0, trackBottom = 0;
trackBottom = (trackRect.height - 1) - getThumbOverhang();
trackTop = trackBottom - (getTrackWidth() - 1);
trackRight = trackRect.width - 1;
return new Rectangle(trackRect.x + trackLeft, trackRect.y + trackTop,
trackRight - trackLeft, trackBottom - trackTop);
}
}
}
private final class ConnectionHandler implements ConnectionListener {
public void connected(ConnectionEvent ce) {
sendAction.setEnabled(true);
}
public void disconnected(ConnectionEvent ce) {
sendAction.setEnabled(false);
}
}
private final class DataHandler extends DataAdapter {
private int[][] colorMap;
public DataHandler(int[][] colorMap) {
this.colorMap = colorMap;
}
public void ack() {
AVRSystem.DEVICE.setColorMap(colorMap);
reset();
SwingUtilities.getRootPane(messageP).getGlassPane().setVisible(false);
getRootPane().getGlassPane().setVisible(false);
AVRSystem.DEVICE.removeDataListener(this);
}
public void nck() {
getRootPane().getGlassPane().setVisible(false);
SwingUtilities.getRootPane(messageP).getGlassPane().setVisible(false);
AVRSystem.DEVICE.removeDataListener(this);
JOptionPane.showMessageDialog(getRootPane(), "Set Color Map NCK Received", "NCK Received", JOptionPane.ERROR_MESSAGE);
}
public void responseTimerExpired() {
getRootPane().getGlassPane().setVisible(false);
SwingUtilities.getRootPane(messageP).getGlassPane().setVisible(false);
AVRSystem.DEVICE.removeDataListener(this);
JOptionPane.showMessageDialog(messageP.getRootPane(), "Response Timer Expired", "Timer Expired", JOptionPane.ERROR_MESSAGE);
}
}
}