| /* |
| * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.swing; |
| |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.io.*; |
| import java.util.*; |
| |
| import javax.swing.colorchooser.*; |
| import javax.swing.plaf.ColorChooserUI; |
| import javax.accessibility.*; |
| |
| import sun.swing.SwingUtilities2; |
| |
| |
| /** |
| * <code>JColorChooser</code> provides a pane of controls designed to allow |
| * a user to manipulate and select a color. |
| * For information about using color choosers, see |
| * <a |
| href="http://java.sun.com/docs/books/tutorial/uiswing/components/colorchooser.html">How to Use Color Choosers</a>, |
| * a section in <em>The Java Tutorial</em>. |
| * |
| * <p> |
| * |
| * This class provides three levels of API: |
| * <ol> |
| * <li>A static convenience method which shows a modal color-chooser |
| * dialog and returns the color selected by the user. |
| * <li>A static convenience method for creating a color-chooser dialog |
| * where <code>ActionListeners</code> can be specified to be invoked when |
| * the user presses one of the dialog buttons. |
| * <li>The ability to create instances of <code>JColorChooser</code> panes |
| * directly (within any container). <code>PropertyChange</code> listeners |
| * can be added to detect when the current "color" property changes. |
| * </ol> |
| * <p> |
| * <strong>Warning:</strong> Swing is not thread safe. For more |
| * information see <a |
| * href="package-summary.html#threading">Swing's Threading |
| * Policy</a>. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans<sup><font size="-2">TM</font></sup> |
| * has been added to the <code>java.beans</code> package. |
| * Please see {@link java.beans.XMLEncoder}. |
| * |
| * |
| * @beaninfo |
| * attribute: isContainer false |
| * description: A component that supports selecting a Color. |
| * |
| * |
| * @author James Gosling |
| * @author Amy Fowler |
| * @author Steve Wilson |
| */ |
| public class JColorChooser extends JComponent implements Accessible { |
| |
| /** |
| * @see #getUIClassID |
| * @see #readObject |
| */ |
| private static final String uiClassID = "ColorChooserUI"; |
| |
| private ColorSelectionModel selectionModel; |
| |
| private JComponent previewPanel = ColorChooserComponentFactory.getPreviewPanel(); |
| |
| private AbstractColorChooserPanel[] chooserPanels = new AbstractColorChooserPanel[0]; |
| |
| private boolean dragEnabled; |
| |
| /** |
| * The selection model property name. |
| */ |
| public static final String SELECTION_MODEL_PROPERTY = "selectionModel"; |
| |
| /** |
| * The preview panel property name. |
| */ |
| public static final String PREVIEW_PANEL_PROPERTY = "previewPanel"; |
| |
| /** |
| * The chooserPanel array property name. |
| */ |
| public static final String CHOOSER_PANELS_PROPERTY = "chooserPanels"; |
| |
| |
| /** |
| * Shows a modal color-chooser dialog and blocks until the |
| * dialog is hidden. If the user presses the "OK" button, then |
| * this method hides/disposes the dialog and returns the selected color. |
| * If the user presses the "Cancel" button or closes the dialog without |
| * pressing "OK", then this method hides/disposes the dialog and returns |
| * <code>null</code>. |
| * |
| * @param component the parent <code>Component</code> for the dialog |
| * @param title the String containing the dialog's title |
| * @param initialColor the initial Color set when the color-chooser is shown |
| * @return the selected color or <code>null</code> if the user opted out |
| * @exception HeadlessException if GraphicsEnvironment.isHeadless() |
| * returns true. |
| * @see java.awt.GraphicsEnvironment#isHeadless |
| */ |
| public static Color showDialog(Component component, |
| String title, Color initialColor) throws HeadlessException { |
| |
| final JColorChooser pane = new JColorChooser(initialColor != null? |
| initialColor : Color.white); |
| |
| ColorTracker ok = new ColorTracker(pane); |
| JDialog dialog = createDialog(component, title, true, pane, ok, null); |
| |
| dialog.addComponentListener(new ColorChooserDialog.DisposeOnClose()); |
| |
| dialog.show(); // blocks until user brings dialog down... |
| |
| return ok.getColor(); |
| } |
| |
| |
| /** |
| * Creates and returns a new dialog containing the specified |
| * <code>ColorChooser</code> pane along with "OK", "Cancel", and "Reset" |
| * buttons. If the "OK" or "Cancel" buttons are pressed, the dialog is |
| * automatically hidden (but not disposed). If the "Reset" |
| * button is pressed, the color-chooser's color will be reset to the |
| * color which was set the last time <code>show</code> was invoked on the |
| * dialog and the dialog will remain showing. |
| * |
| * @param c the parent component for the dialog |
| * @param title the title for the dialog |
| * @param modal a boolean. When true, the remainder of the program |
| * is inactive until the dialog is closed. |
| * @param chooserPane the color-chooser to be placed inside the dialog |
| * @param okListener the ActionListener invoked when "OK" is pressed |
| * @param cancelListener the ActionListener invoked when "Cancel" is pressed |
| * @return a new dialog containing the color-chooser pane |
| * @exception HeadlessException if GraphicsEnvironment.isHeadless() |
| * returns true. |
| * @see java.awt.GraphicsEnvironment#isHeadless |
| */ |
| public static JDialog createDialog(Component c, String title, boolean modal, |
| JColorChooser chooserPane, ActionListener okListener, |
| ActionListener cancelListener) throws HeadlessException { |
| |
| Window window = JOptionPane.getWindowForComponent(c); |
| ColorChooserDialog dialog; |
| if (window instanceof Frame) { |
| dialog = new ColorChooserDialog((Frame)window, title, modal, c, chooserPane, |
| okListener, cancelListener); |
| } else { |
| dialog = new ColorChooserDialog((Dialog)window, title, modal, c, chooserPane, |
| okListener, cancelListener); |
| } |
| dialog.getAccessibleContext().setAccessibleDescription(title); |
| return dialog; |
| } |
| |
| /** |
| * Creates a color chooser pane with an initial color of white. |
| */ |
| public JColorChooser() { |
| this(Color.white); |
| } |
| |
| /** |
| * Creates a color chooser pane with the specified initial color. |
| * |
| * @param initialColor the initial color set in the chooser |
| */ |
| public JColorChooser(Color initialColor) { |
| this( new DefaultColorSelectionModel(initialColor) ); |
| |
| } |
| |
| /** |
| * Creates a color chooser pane with the specified |
| * <code>ColorSelectionModel</code>. |
| * |
| * @param model the <code>ColorSelectionModel</code> to be used |
| */ |
| public JColorChooser(ColorSelectionModel model) { |
| selectionModel = model; |
| updateUI(); |
| dragEnabled = false; |
| } |
| |
| /** |
| * Returns the L&F object that renders this component. |
| * |
| * @return the <code>ColorChooserUI</code> object that renders |
| * this component |
| */ |
| public ColorChooserUI getUI() { |
| return (ColorChooserUI)ui; |
| } |
| |
| /** |
| * Sets the L&F object that renders this component. |
| * |
| * @param ui the <code>ColorChooserUI</code> L&F object |
| * @see UIDefaults#getUI |
| * |
| * @beaninfo |
| * bound: true |
| * hidden: true |
| * description: The UI object that implements the color chooser's LookAndFeel. |
| */ |
| public void setUI(ColorChooserUI ui) { |
| super.setUI(ui); |
| } |
| |
| /** |
| * Notification from the <code>UIManager</code> that the L&F has changed. |
| * Replaces the current UI object with the latest version from the |
| * <code>UIManager</code>. |
| * |
| * @see JComponent#updateUI |
| */ |
| public void updateUI() { |
| setUI((ColorChooserUI)UIManager.getUI(this)); |
| } |
| |
| /** |
| * Returns the name of the L&F class that renders this component. |
| * |
| * @return the string "ColorChooserUI" |
| * @see JComponent#getUIClassID |
| * @see UIDefaults#getUI |
| */ |
| public String getUIClassID() { |
| return uiClassID; |
| } |
| |
| /** |
| * Gets the current color value from the color chooser. |
| * By default, this delegates to the model. |
| * |
| * @return the current color value of the color chooser |
| */ |
| public Color getColor() { |
| return selectionModel.getSelectedColor(); |
| } |
| |
| /** |
| * Sets the current color of the color chooser to the specified color. |
| * The <code>ColorSelectionModel</code> will fire a <code>ChangeEvent</code> |
| * @param color the color to be set in the color chooser |
| * @see JComponent#addPropertyChangeListener |
| * |
| * @beaninfo |
| * bound: false |
| * hidden: false |
| * description: The current color the chooser is to display. |
| */ |
| public void setColor(Color color) { |
| selectionModel.setSelectedColor(color); |
| |
| } |
| |
| /** |
| * Sets the current color of the color chooser to the |
| * specified RGB color. Note that the values of red, green, |
| * and blue should be between the numbers 0 and 255, inclusive. |
| * |
| * @param r an int specifying the amount of Red |
| * @param g an int specifying the amount of Green |
| * @param b an int specifying the amount of Blue |
| * @exception IllegalArgumentException if r,g,b values are out of range |
| * @see java.awt.Color |
| */ |
| public void setColor(int r, int g, int b) { |
| setColor(new Color(r,g,b)); |
| } |
| |
| /** |
| * Sets the current color of the color chooser to the |
| * specified color. |
| * |
| * @param c an integer value that sets the current color in the chooser |
| * where the low-order 8 bits specify the Blue value, |
| * the next 8 bits specify the Green value, and the 8 bits |
| * above that specify the Red value. |
| */ |
| public void setColor(int c) { |
| setColor((c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF); |
| } |
| |
| /** |
| * Sets the <code>dragEnabled</code> property, |
| * which must be <code>true</code> to enable |
| * automatic drag handling (the first part of drag and drop) |
| * on this component. |
| * The <code>transferHandler</code> property needs to be set |
| * to a non-<code>null</code> value for the drag to do |
| * anything. The default value of the <code>dragEnabled</code> |
| * property |
| * is <code>false</code>. |
| * |
| * <p> |
| * |
| * When automatic drag handling is enabled, |
| * most look and feels begin a drag-and-drop operation |
| * when the user presses the mouse button over the preview panel. |
| * Some look and feels might not support automatic drag and drop; |
| * they will ignore this property. You can work around such |
| * look and feels by modifying the component |
| * to directly call the <code>exportAsDrag</code> method of a |
| * <code>TransferHandler</code>. |
| * |
| * @param b the value to set the <code>dragEnabled</code> property to |
| * @exception HeadlessException if |
| * <code>b</code> is <code>true</code> and |
| * <code>GraphicsEnvironment.isHeadless()</code> |
| * returns <code>true</code> |
| * |
| * @since 1.4 |
| * |
| * @see java.awt.GraphicsEnvironment#isHeadless |
| * @see #getDragEnabled |
| * @see #setTransferHandler |
| * @see TransferHandler |
| * |
| * @beaninfo |
| * description: Determines whether automatic drag handling is enabled. |
| * bound: false |
| */ |
| public void setDragEnabled(boolean b) { |
| if (b && GraphicsEnvironment.isHeadless()) { |
| throw new HeadlessException(); |
| } |
| dragEnabled = b; |
| } |
| |
| /** |
| * Gets the value of the <code>dragEnabled</code> property. |
| * |
| * @return the value of the <code>dragEnabled</code> property |
| * @see #setDragEnabled |
| * @since 1.4 |
| */ |
| public boolean getDragEnabled() { |
| return dragEnabled; |
| } |
| |
| /** |
| * Sets the current preview panel. |
| * This will fire a <code>PropertyChangeEvent</code> for the property |
| * named "previewPanel". |
| * |
| * @param preview the <code>JComponent</code> which displays the current color |
| * @see JComponent#addPropertyChangeListener |
| * |
| * @beaninfo |
| * bound: true |
| * hidden: true |
| * description: The UI component which displays the current color. |
| */ |
| public void setPreviewPanel(JComponent preview) { |
| |
| if (previewPanel != preview) { |
| JComponent oldPreview = previewPanel; |
| previewPanel = preview; |
| firePropertyChange(JColorChooser.PREVIEW_PANEL_PROPERTY, oldPreview, preview); |
| } |
| } |
| |
| /** |
| * Returns the preview panel that shows a chosen color. |
| * |
| * @return a <code>JComponent</code> object -- the preview panel |
| */ |
| public JComponent getPreviewPanel() { |
| return previewPanel; |
| } |
| |
| /** |
| * Adds a color chooser panel to the color chooser. |
| * |
| * @param panel the <code>AbstractColorChooserPanel</code> to be added |
| */ |
| public void addChooserPanel( AbstractColorChooserPanel panel ) { |
| AbstractColorChooserPanel[] oldPanels = getChooserPanels(); |
| AbstractColorChooserPanel[] newPanels = new AbstractColorChooserPanel[oldPanels.length+1]; |
| System.arraycopy(oldPanels, 0, newPanels, 0, oldPanels.length); |
| newPanels[newPanels.length-1] = panel; |
| setChooserPanels(newPanels); |
| } |
| |
| /** |
| * Removes the Color Panel specified. |
| * |
| * @param panel a string that specifies the panel to be removed |
| * @return the color panel |
| * @exception IllegalArgumentException if panel is not in list of |
| * known chooser panels |
| */ |
| public AbstractColorChooserPanel removeChooserPanel( AbstractColorChooserPanel panel ) { |
| |
| |
| int containedAt = -1; |
| |
| for (int i = 0; i < chooserPanels.length; i++) { |
| if (chooserPanels[i] == panel) { |
| containedAt = i; |
| break; |
| } |
| } |
| if (containedAt == -1) { |
| throw new IllegalArgumentException("chooser panel not in this chooser"); |
| } |
| |
| AbstractColorChooserPanel[] newArray = new AbstractColorChooserPanel[chooserPanels.length-1]; |
| |
| if (containedAt == chooserPanels.length-1) { // at end |
| System.arraycopy(chooserPanels, 0, newArray, 0, newArray.length); |
| } |
| else if (containedAt == 0) { // at start |
| System.arraycopy(chooserPanels, 1, newArray, 0, newArray.length); |
| } |
| else { // in middle |
| System.arraycopy(chooserPanels, 0, newArray, 0, containedAt); |
| System.arraycopy(chooserPanels, containedAt+1, |
| newArray, containedAt, (chooserPanels.length - containedAt - 1)); |
| } |
| |
| setChooserPanels(newArray); |
| |
| return panel; |
| } |
| |
| |
| /** |
| * Specifies the Color Panels used to choose a color value. |
| * |
| * @param panels an array of <code>AbstractColorChooserPanel</code> |
| * objects |
| * |
| * @beaninfo |
| * bound: true |
| * hidden: true |
| * description: An array of different chooser types. |
| */ |
| public void setChooserPanels( AbstractColorChooserPanel[] panels) { |
| AbstractColorChooserPanel[] oldValue = chooserPanels; |
| chooserPanels = panels; |
| firePropertyChange(CHOOSER_PANELS_PROPERTY, oldValue, panels); |
| } |
| |
| /** |
| * Returns the specified color panels. |
| * |
| * @return an array of <code>AbstractColorChooserPanel</code> objects |
| */ |
| public AbstractColorChooserPanel[] getChooserPanels() { |
| return chooserPanels; |
| } |
| |
| /** |
| * Returns the data model that handles color selections. |
| * |
| * @return a <code>ColorSelectionModel</code> object |
| */ |
| public ColorSelectionModel getSelectionModel() { |
| return selectionModel; |
| } |
| |
| |
| /** |
| * Sets the model containing the selected color. |
| * |
| * @param newModel the new <code>ColorSelectionModel</code> object |
| * |
| * @beaninfo |
| * bound: true |
| * hidden: true |
| * description: The model which contains the currently selected color. |
| */ |
| public void setSelectionModel(ColorSelectionModel newModel ) { |
| ColorSelectionModel oldModel = selectionModel; |
| selectionModel = newModel; |
| firePropertyChange(JColorChooser.SELECTION_MODEL_PROPERTY, oldModel, newModel); |
| } |
| |
| |
| /** |
| * See <code>readObject</code> and <code>writeObject</code> in |
| * <code>JComponent</code> for more |
| * information about serialization in Swing. |
| */ |
| private void writeObject(ObjectOutputStream s) throws IOException { |
| s.defaultWriteObject(); |
| if (getUIClassID().equals(uiClassID)) { |
| byte count = JComponent.getWriteObjCounter(this); |
| JComponent.setWriteObjCounter(this, --count); |
| if (count == 0 && ui != null) { |
| ui.installUI(this); |
| } |
| } |
| } |
| |
| |
| /** |
| * Returns a string representation of this <code>JColorChooser</code>. |
| * This method |
| * is intended to be used only for debugging purposes, and the |
| * content and format of the returned string may vary between |
| * implementations. The returned string may be empty but may not |
| * be <code>null</code>. |
| * |
| * @return a string representation of this <code>JColorChooser</code> |
| */ |
| protected String paramString() { |
| StringBuffer chooserPanelsString = new StringBuffer(""); |
| for (int i=0; i<chooserPanels.length; i++) { |
| chooserPanelsString.append("[" + chooserPanels[i].toString() |
| + "]"); |
| } |
| String previewPanelString = (previewPanel != null ? |
| previewPanel.toString() : ""); |
| |
| return super.paramString() + |
| ",chooserPanels=" + chooserPanelsString.toString() + |
| ",previewPanel=" + previewPanelString; |
| } |
| |
| ///////////////// |
| // Accessibility support |
| //////////////// |
| |
| protected AccessibleContext accessibleContext = null; |
| |
| /** |
| * Gets the AccessibleContext associated with this JColorChooser. |
| * For color choosers, the AccessibleContext takes the form of an |
| * AccessibleJColorChooser. |
| * A new AccessibleJColorChooser instance is created if necessary. |
| * |
| * @return an AccessibleJColorChooser that serves as the |
| * AccessibleContext of this JColorChooser |
| */ |
| public AccessibleContext getAccessibleContext() { |
| if (accessibleContext == null) { |
| accessibleContext = new AccessibleJColorChooser(); |
| } |
| return accessibleContext; |
| } |
| |
| /** |
| * This class implements accessibility support for the |
| * <code>JColorChooser</code> class. It provides an implementation of the |
| * Java Accessibility API appropriate to color chooser user-interface |
| * elements. |
| */ |
| protected class AccessibleJColorChooser extends AccessibleJComponent { |
| |
| /** |
| * Get the role of this object. |
| * |
| * @return an instance of AccessibleRole describing the role of the |
| * object |
| * @see AccessibleRole |
| */ |
| public AccessibleRole getAccessibleRole() { |
| return AccessibleRole.COLOR_CHOOSER; |
| } |
| |
| } // inner class AccessibleJColorChooser |
| } |
| |
| |
| /* |
| * Class which builds a color chooser dialog consisting of |
| * a JColorChooser with "Ok", "Cancel", and "Reset" buttons. |
| * |
| * Note: This needs to be fixed to deal with localization! |
| */ |
| class ColorChooserDialog extends JDialog { |
| private Color initialColor; |
| private JColorChooser chooserPane; |
| private JButton cancelButton; |
| |
| public ColorChooserDialog(Dialog owner, String title, boolean modal, |
| Component c, JColorChooser chooserPane, |
| ActionListener okListener, ActionListener cancelListener) |
| throws HeadlessException { |
| super(owner, title, modal); |
| initColorChooserDialog(c, chooserPane, okListener, cancelListener); |
| } |
| |
| public ColorChooserDialog(Frame owner, String title, boolean modal, |
| Component c, JColorChooser chooserPane, |
| ActionListener okListener, ActionListener cancelListener) |
| throws HeadlessException { |
| super(owner, title, modal); |
| initColorChooserDialog(c, chooserPane, okListener, cancelListener); |
| } |
| |
| protected void initColorChooserDialog(Component c, JColorChooser chooserPane, |
| ActionListener okListener, ActionListener cancelListener) { |
| //setResizable(false); |
| |
| this.chooserPane = chooserPane; |
| |
| Locale locale = getLocale(); |
| String okString = UIManager.getString("ColorChooser.okText", locale); |
| String cancelString = UIManager.getString("ColorChooser.cancelText", locale); |
| String resetString = UIManager.getString("ColorChooser.resetText", locale); |
| |
| Container contentPane = getContentPane(); |
| contentPane.setLayout(new BorderLayout()); |
| contentPane.add(chooserPane, BorderLayout.CENTER); |
| |
| /* |
| * Create Lower button panel |
| */ |
| JPanel buttonPane = new JPanel(); |
| buttonPane.setLayout(new FlowLayout(FlowLayout.CENTER)); |
| JButton okButton = new JButton(okString); |
| getRootPane().setDefaultButton(okButton); |
| okButton.getAccessibleContext().setAccessibleDescription(okString); |
| okButton.setActionCommand("OK"); |
| okButton.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| hide(); |
| } |
| }); |
| if (okListener != null) { |
| okButton.addActionListener(okListener); |
| } |
| buttonPane.add(okButton); |
| |
| cancelButton = new JButton(cancelString); |
| cancelButton.getAccessibleContext().setAccessibleDescription(cancelString); |
| |
| // The following few lines are used to register esc to close the dialog |
| Action cancelKeyAction = new AbstractAction() { |
| public void actionPerformed(ActionEvent e) { |
| ((AbstractButton)e.getSource()).fireActionPerformed(e); |
| } |
| }; |
| KeyStroke cancelKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0); |
| InputMap inputMap = cancelButton.getInputMap(JComponent. |
| WHEN_IN_FOCUSED_WINDOW); |
| ActionMap actionMap = cancelButton.getActionMap(); |
| if (inputMap != null && actionMap != null) { |
| inputMap.put(cancelKeyStroke, "cancel"); |
| actionMap.put("cancel", cancelKeyAction); |
| } |
| // end esc handling |
| |
| cancelButton.setActionCommand("cancel"); |
| cancelButton.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| hide(); |
| } |
| }); |
| if (cancelListener != null) { |
| cancelButton.addActionListener(cancelListener); |
| } |
| buttonPane.add(cancelButton); |
| |
| JButton resetButton = new JButton(resetString); |
| resetButton.getAccessibleContext().setAccessibleDescription(resetString); |
| resetButton.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| reset(); |
| } |
| }); |
| int mnemonic = SwingUtilities2.getUIDefaultsInt("ColorChooser.resetMnemonic", locale, -1); |
| if (mnemonic != -1) { |
| resetButton.setMnemonic(mnemonic); |
| } |
| buttonPane.add(resetButton); |
| contentPane.add(buttonPane, BorderLayout.SOUTH); |
| |
| if (JDialog.isDefaultLookAndFeelDecorated()) { |
| boolean supportsWindowDecorations = |
| UIManager.getLookAndFeel().getSupportsWindowDecorations(); |
| if (supportsWindowDecorations) { |
| getRootPane().setWindowDecorationStyle(JRootPane.COLOR_CHOOSER_DIALOG); |
| } |
| } |
| applyComponentOrientation(((c == null) ? getRootPane() : c).getComponentOrientation()); |
| |
| pack(); |
| setLocationRelativeTo(c); |
| |
| this.addWindowListener(new Closer()); |
| } |
| |
| public void show() { |
| initialColor = chooserPane.getColor(); |
| super.show(); |
| } |
| |
| public void reset() { |
| chooserPane.setColor(initialColor); |
| } |
| |
| class Closer extends WindowAdapter implements Serializable{ |
| public void windowClosing(WindowEvent e) { |
| cancelButton.doClick(0); |
| Window w = e.getWindow(); |
| w.hide(); |
| } |
| } |
| |
| static class DisposeOnClose extends ComponentAdapter implements Serializable{ |
| public void componentHidden(ComponentEvent e) { |
| Window w = (Window)e.getComponent(); |
| w.dispose(); |
| } |
| } |
| |
| } |
| |
| class ColorTracker implements ActionListener, Serializable { |
| JColorChooser chooser; |
| Color color; |
| |
| public ColorTracker(JColorChooser c) { |
| chooser = c; |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| color = chooser.getColor(); |
| } |
| |
| public Color getColor() { |
| return color; |
| } |
| } |
