| /* DefaultRGHChooserPanel.java -- |
| Copyright (C) 2004, 2005 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package javax.swing.colorchooser; |
| |
| import java.awt.Color; |
| import java.awt.Graphics; |
| import java.awt.GridBagConstraints; |
| import java.awt.GridBagLayout; |
| |
| import javax.swing.Icon; |
| import javax.swing.JColorChooser; |
| import javax.swing.JLabel; |
| import javax.swing.JSlider; |
| import javax.swing.JSpinner; |
| import javax.swing.SpinnerNumberModel; |
| import javax.swing.SwingConstants; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| |
| /** |
| * This is the default RGB panel for the JColorChooser. The color is selected |
| * using three sliders that represent the RGB values. |
| */ |
| class DefaultRGBChooserPanel extends AbstractColorChooserPanel |
| { |
| /** |
| * This class handles the slider value changes for all three sliders. |
| */ |
| class SliderHandler implements ChangeListener |
| { |
| /** |
| * This method is called whenever any of the slider values change. |
| * |
| * @param e The ChangeEvent. |
| */ |
| public void stateChanged(ChangeEvent e) |
| { |
| if (updateChange) |
| return; |
| |
| int color = R.getValue() << 16 | G.getValue() << 8 | B.getValue(); |
| |
| sliderChange = true; |
| getColorSelectionModel().setSelectedColor(new Color(color)); |
| sliderChange = false; |
| } |
| } |
| |
| /** |
| * This class handles the Spinner values changing. |
| */ |
| class SpinnerHandler implements ChangeListener |
| { |
| /** |
| * This method is called whenever any of the JSpinners change values. |
| * |
| * @param e The ChangeEvent. |
| */ |
| public void stateChanged(ChangeEvent e) |
| { |
| if (updateChange) |
| return; |
| |
| int red = ((Number) RSpinner.getValue()).intValue(); |
| int green = ((Number) GSpinner.getValue()).intValue(); |
| int blue = ((Number) BSpinner.getValue()).intValue(); |
| |
| int color = red << 16 | green << 8 | blue; |
| |
| spinnerChange = true; |
| getColorSelectionModel().setSelectedColor(new Color(color)); |
| spinnerChange = false; |
| } |
| } |
| |
| /** Whether the color change was initiated by the spinners. */ |
| private transient boolean spinnerChange = false; |
| |
| /** Whether the color change was initiated by the sliders. */ |
| private transient boolean sliderChange = false; |
| |
| /** |
| * Whether the change was forced by the chooser (meaning the color has |
| * already been changed). |
| */ |
| private transient boolean updateChange = false; |
| |
| /** The ChangeListener for the sliders. */ |
| private transient ChangeListener colorChanger; |
| |
| /** The ChangeListener for the spinners. */ |
| private transient ChangeListener spinnerHandler; |
| |
| /** The slider that handles the red values. */ |
| private transient JSlider R; |
| |
| /** The slider that handles the green values. */ |
| private transient JSlider G; |
| |
| /** The slider that handles the blue values. */ |
| private transient JSlider B; |
| |
| /** The label for the red slider. */ |
| private transient JLabel RLabel; |
| |
| /** The label for the green slider. */ |
| private transient JLabel GLabel; |
| |
| /** The label for the blue slider. */ |
| private transient JLabel BLabel; |
| |
| /** The spinner that handles the red values. */ |
| private transient JSpinner RSpinner; |
| |
| /** The spinner that handles the green values. */ |
| private transient JSpinner GSpinner; |
| |
| /** The spinner that handles the blue values. */ |
| private transient JSpinner BSpinner; |
| |
| /** |
| * Creates a new DefaultRGBChooserPanel object. |
| */ |
| public DefaultRGBChooserPanel() |
| { |
| super(); |
| } |
| |
| /** |
| * This method returns the name displayed in the JTabbedPane. |
| * |
| * @return The name displayed in the JTabbedPane. |
| */ |
| public String getDisplayName() |
| { |
| return "RGB"; |
| } |
| |
| /** |
| * This method updates the chooser panel with the new color chosen in the |
| * JColorChooser. |
| */ |
| public void updateChooser() |
| { |
| Color c = getColorFromModel(); |
| int rgb = c.getRGB(); |
| |
| int red = rgb >> 16 & 0xff; |
| int green = rgb >> 8 & 0xff; |
| int blue = rgb & 0xff; |
| |
| updateChange = true; |
| |
| if (! sliderChange) |
| { |
| if (R != null) |
| R.setValue(red); |
| if (G != null) |
| G.setValue(green); |
| if (B != null) |
| B.setValue(blue); |
| } |
| if (! spinnerChange) |
| { |
| if (GSpinner != null) |
| GSpinner.setValue(new Integer(green)); |
| if (RSpinner != null) |
| RSpinner.setValue(new Integer(red)); |
| if (BSpinner != null) |
| BSpinner.setValue(new Integer(blue)); |
| } |
| |
| updateChange = false; |
| |
| revalidate(); |
| repaint(); |
| } |
| |
| /** |
| * This method builds the chooser panel. |
| */ |
| protected void buildChooser() |
| { |
| setLayout(new GridBagLayout()); |
| |
| RLabel = new JLabel("Red"); |
| RLabel.setDisplayedMnemonic('d'); |
| GLabel = new JLabel("Green"); |
| GLabel.setDisplayedMnemonic('n'); |
| BLabel = new JLabel("Blue"); |
| BLabel.setDisplayedMnemonic('B'); |
| |
| R = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 255); |
| G = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 255); |
| B = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 255); |
| |
| R.setPaintTicks(true); |
| R.setSnapToTicks(false); |
| G.setPaintTicks(true); |
| G.setSnapToTicks(false); |
| B.setPaintTicks(true); |
| B.setSnapToTicks(false); |
| |
| R.setLabelTable(R.createStandardLabels(85)); |
| R.setPaintLabels(true); |
| G.setLabelTable(G.createStandardLabels(85)); |
| G.setPaintLabels(true); |
| B.setLabelTable(B.createStandardLabels(85)); |
| B.setPaintLabels(true); |
| |
| R.setMajorTickSpacing(85); |
| G.setMajorTickSpacing(85); |
| B.setMajorTickSpacing(85); |
| |
| R.setMinorTickSpacing(17); |
| G.setMinorTickSpacing(17); |
| B.setMinorTickSpacing(17); |
| |
| RSpinner = new JSpinner(new SpinnerNumberModel(R.getValue(), |
| R.getMinimum(), |
| R.getMaximum(), 1)); |
| GSpinner = new JSpinner(new SpinnerNumberModel(G.getValue(), |
| G.getMinimum(), |
| G.getMaximum(), 1)); |
| BSpinner = new JSpinner(new SpinnerNumberModel(B.getValue(), |
| B.getMinimum(), |
| B.getMaximum(), 1)); |
| |
| RLabel.setLabelFor(R); |
| GLabel.setLabelFor(G); |
| BLabel.setLabelFor(B); |
| |
| GridBagConstraints bag = new GridBagConstraints(); |
| bag.fill = GridBagConstraints.VERTICAL; |
| |
| bag.gridx = 0; |
| bag.gridy = 0; |
| add(RLabel, bag); |
| |
| bag.gridx = 1; |
| add(R, bag); |
| |
| bag.gridx = 2; |
| add(RSpinner, bag); |
| |
| bag.gridx = 0; |
| bag.gridy = 1; |
| add(GLabel, bag); |
| |
| bag.gridx = 1; |
| add(G, bag); |
| |
| bag.gridx = 2; |
| add(GSpinner, bag); |
| |
| bag.gridx = 0; |
| bag.gridy = 2; |
| add(BLabel, bag); |
| |
| bag.gridx = 1; |
| add(B, bag); |
| |
| bag.gridx = 2; |
| add(BSpinner, bag); |
| |
| installListeners(); |
| } |
| |
| /** |
| * This method uninstalls the chooser panel from the JColorChooser. |
| * |
| * @param chooser The JColorChooser to remove this chooser panel from. |
| */ |
| public void uninstallChooserPanel(JColorChooser chooser) |
| { |
| uninstallListeners(); |
| removeAll(); |
| |
| R = null; |
| G = null; |
| B = null; |
| |
| RSpinner = null; |
| GSpinner = null; |
| BSpinner = null; |
| |
| super.uninstallChooserPanel(chooser); |
| } |
| |
| /** |
| * This method uninstalls any listeners that were added by the chooser |
| * panel. |
| */ |
| private void uninstallListeners() |
| { |
| R.removeChangeListener(colorChanger); |
| G.removeChangeListener(colorChanger); |
| B.removeChangeListener(colorChanger); |
| |
| colorChanger = null; |
| |
| RSpinner.removeChangeListener(spinnerHandler); |
| GSpinner.removeChangeListener(spinnerHandler); |
| BSpinner.removeChangeListener(spinnerHandler); |
| |
| spinnerHandler = null; |
| } |
| |
| /** |
| * This method installs any listeners that the chooser panel needs to |
| * operate. |
| */ |
| private void installListeners() |
| { |
| colorChanger = new SliderHandler(); |
| |
| R.addChangeListener(colorChanger); |
| G.addChangeListener(colorChanger); |
| B.addChangeListener(colorChanger); |
| |
| spinnerHandler = new SpinnerHandler(); |
| |
| RSpinner.addChangeListener(spinnerHandler); |
| GSpinner.addChangeListener(spinnerHandler); |
| BSpinner.addChangeListener(spinnerHandler); |
| } |
| |
| /** |
| * This method returns the small display icon. |
| * |
| * @return The small display icon. |
| */ |
| public Icon getSmallDisplayIcon() |
| { |
| return null; |
| } |
| |
| /** |
| * This method returns the large display icon. |
| * |
| * @return The large display icon. |
| */ |
| public Icon getLargeDisplayIcon() |
| { |
| return null; |
| } |
| |
| /** |
| * This method paints the default RGB chooser panel. |
| * |
| * @param g The Graphics object to paint with. |
| */ |
| public void paint(Graphics g) |
| { |
| super.paint(g); |
| } |
| } |