Subversion Repositories svnkaklik

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);

     }

  }

}