| 0,0 → 1,975 |
|---|
| 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); |
| } |
| |
| } |
| |
| |
| |
| } |