libjava/javax/swing/JColorChooser.java

   1 /* JColorChooser.java --
   2    Copyright (C) 2002, 2004 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing;
  40
  41 import java.awt.AWTError;
  42 import java.awt.BorderLayout;
  43 import java.awt.Color;
  44 import java.awt.Component;
  45 import java.awt.Dialog;
  46 import java.awt.FlowLayout;
  47 import java.awt.Frame;
  48 import java.awt.event.ActionEvent;
  49 import java.awt.event.ActionListener;
  50
  51 import javax.accessibility.Accessible;
  52 import javax.accessibility.AccessibleContext;
  53 import javax.accessibility.AccessibleRole;
  54 import javax.swing.colorchooser.AbstractColorChooserPanel;
  55 import javax.swing.colorchooser.ColorSelectionModel;
  56 import javax.swing.colorchooser.DefaultColorSelectionModel;
  57 import javax.swing.plaf.ColorChooserUI;
  58
  59
  60 /**
  61  * The JColorChooser is a Swing widget that offers users different ways to
  62  * select a color. By default, three different panels are presented to the
  63  * user that are capable of changing the selected color. There are three ways
  64  * to utilize JColorChooser. The first is to build a JColorChooser and add it
  65  * to the content pane. The second is to use the createDialog method to
  66  * create a JDialog that holds a JColorChooser. The third is to show a
  67  * JColorChooser in a JDialog directly using the showDialog method.
  68  */
  69 public class JColorChooser extends JComponent implements Accessible
  70 {
  71   /** DOCUMENT ME! */
  72   private static final long serialVersionUID = 9168066781620640889L;
  73
  74   /**
  75    * AccessibleJColorChooser
  76    */
  77   protected class AccessibleJColorChooser
  78     extends JComponent.AccessibleJComponent
  79   {
  80     /** DOCUMENT ME! */
  81     private static final long serialVersionUID = -2038297864782299082L;
  82
  83     /**
  84      * Constructor AccessibleJColorChooser
  85      */
  86     protected AccessibleJColorChooser()
  87     {
  88     }
  89
  90     /**
  91      * getAccessibleRole
  92      *
  93      * @return AccessibleRole
  94      */
  95     public AccessibleRole getAccessibleRole()
  96     {
  97       return AccessibleRole.COLOR_CHOOSER;
  98     } // getAccessibleRole()
  99   } // AccessibleJColorChooser
 100
 101   /** The model used with the JColorChooser. */
 102   private ColorSelectionModel selectionModel;
 103
 104   /** The preview panel associated with the JColorChooser. */
 105   private JComponent previewPanel;
 106
 107   /**
 108    * The set of AbstractColorChooserPanels associated with the JColorChooser.
 109    */
 110   private AbstractColorChooserPanel[] chooserPanels;
 111
 112   /** A Drag and Drop property. */
 113   private boolean dragEnabled;
 114
 115   /**
 116    * The property fired by the JColorChooser when the selectionModel property
 117    * changes.
 118    */
 119   public static final String SELECTION_MODEL_PROPERTY = "selectionModel";
 120
 121   /**
 122    * The property fired by the JColorChooser when the previewPanel property
 123    * changes.
 124    */
 125   public static final String PREVIEW_PANEL_PROPERTY = "previewPanel";
 126
 127   /**
 128    * The property fired by the JColorChooser when the chooserPanels property
 129    * changes.
 130    */
 131   public static final String CHOOSER_PANELS_PROPERTY = "chooserPanels";
 132
 133   /** accessibleContext */
 134   protected AccessibleContext accessibleContext;
 135
 136   /**
 137    * This method creates a new JColorChooser with the default initial color.
 138    */
 139   public JColorChooser()
 140   {
 141     this(new DefaultColorSelectionModel());
 142   } // JColorChooser()
 143
 144   /**
 145    * This method creates a new JColorChooser with the given initial color.
 146    *
 147    * @param initial The initial color.
 148    */
 149   public JColorChooser(Color initial)
 150   {
 151     this(new DefaultColorSelectionModel(initial));
 152   } // JColorChooser()
 153
 154   /**
 155    * This method creates a new JColorChooser with the given model. The model
 156    * will dictate what the initial color for the JColorChooser is.
 157    *
 158    * @param model The Model to use with the JColorChooser.
 159    */
 160   public JColorChooser(ColorSelectionModel model)
 161   {
 162     if (model == null)
 163       model = new DefaultColorSelectionModel();
 164     selectionModel = model;
 165     updateUI();
 166   } // JColorChooser()
 167
 168   /**
 169    * This method sets the current color for the JColorChooser.
 170    *
 171    * @param color The new color for the JColorChooser.
 172    */
 173   public void setColor(Color color)
 174   {
 175     if (color != null)
 176       selectionModel.setSelectedColor(color);
 177   } // setColor()
 178
 179   /**
 180    * This method sets the current color for the JColorChooser using RGB
 181    * values.
 182    *
 183    * @param r The red value.
 184    * @param g The green value.
 185    * @param b The blue value.
 186    */
 187   public void setColor(int r, int g, int b)
 188   {
 189     selectionModel.setSelectedColor(new Color(r, g, b));
 190   } // setColor()
 191
 192   /**
 193    * This method sets the current color for the JColorChooser using the
 194    * integer value. Bits 0-7 represent the blue value. Bits 8-15 represent
 195    * the green value. Bits 16-23 represent the red value.
 196    *
 197    * @param color The new current color of the JColorChooser.
 198    */
 199   public void setColor(int color)
 200   {
 201     setColor(new Color(color, false));
 202   } // setColor()
 203
 204   /**
 205    * This method shows a JColorChooser inside a JDialog. The JDialog will
 206    * block until it is hidden. The JDialog comes with three buttons: OK,
 207    * Cancel, and Reset. Pressing OK or Cancel hide the JDialog. Pressing
 208    * Reset will reset the JColorChooser to its initial value.
 209    *
 210    * @param component The Component that parents the JDialog.
 211    * @param title The title displayed in the JDialog.
 212    * @param initial The initial color.
 213    *
 214    * @return The selected color.
 215    */
 216   public static Color showDialog(Component component, String title,
 217                                  Color initial)
 218   {
 219     JColorChooser choose = new JColorChooser(initial);
 220
 221     JDialog dialog = createDialog(component, title, true, choose, null, null);
 222
 223     dialog.getContentPane().add(choose);
 224     dialog.pack();
 225     dialog.show();
 226
 227     return choose.getColor();
 228   } // showDialog()
 229
 230   /**
 231    * This is a helper method to make the given JDialog block until it is
 232    * hidden.
 233    *
 234    * @param dialog The JDialog to block.
 235    */
 236   private static void makeModal(JDialog dialog)
 237   {
 238     try
 239       {
 240         synchronized (dialog)
 241           {
 242             while (dialog.isVisible())
 243               dialog.wait();
 244           }
 245       }
 246     catch (InterruptedException e)
 247       {
 248       }
 249   }
 250
 251   /**
 252    * This is a helper method to find the first Frame or Dialog ancestor of the
 253    * given Component.
 254    *
 255    * @param c The Component to find ancestors for.
 256    *
 257    * @return A Frame or Dialog ancestor. Null if none are found.
 258    */
 259   private static Component findParent(Component c)
 260   {
 261     Component parent = SwingUtilities.getAncestorOfClass(Frame.class, c);
 262     if (parent != null)
 263       return parent;
 264     parent = SwingUtilities.getAncestorOfClass(Dialog.class, c);
 265     return parent;
 266   }
 267
 268   /**
 269    * This method will take the given JColorChooser and place it in a JDialog
 270    * with the given modal property. Three buttons are displayed in the
 271    * JDialog: OK, Cancel and Reset. If OK or Cancel are pressed, the JDialog
 272    * is hidden. If Reset is pressed, then the JColorChooser will take on its
 273    * default color value. The given okListener will be registered to the OK
 274    * button and the cancelListener will be registered to the Cancel button.
 275    * If the modal property is set, then the JDialog will block until it is
 276    * hidden.
 277    *
 278    * @param component The Component that will parent the JDialog.
 279    * @param title The title displayed in the JDialog.
 280    * @param modal The modal property.
 281    * @param chooserPane The JColorChooser to place in the JDialog.
 282    * @param okListener The ActionListener to register to the OK button.
 283    * @param cancelListener The ActionListener to register to the Cancel
 284    *        button.
 285    *
 286    * @return A JDialog with the JColorChooser inside of it.
 287    *
 288    * @throws AWTError If the component is not a suitable parent.
 289    */
 290   public static JDialog createDialog(Component component, String title,
 291                                      boolean modal, JColorChooser chooserPane,
 292                                      ActionListener okListener,
 293                                      ActionListener cancelListener)
 294   {
 295     Component parent = findParent(component);
 296     if (parent == null)
 297       throw new AWTError("No suitable parent found for Component.");
 298     JDialog dialog;
 299     if (parent instanceof Frame)
 300       dialog = new ModalDialog((Frame) parent, title);
 301     else
 302       dialog = new ModalDialog((Dialog) parent, title);
 303     dialog.setModal(modal);
 304
 305     dialog.getContentPane().setLayout(new BorderLayout());
 306
 307     JPanel panel = new JPanel();
 308     panel.setLayout(new FlowLayout());
 309
 310     ActionListener al = new DefaultOKCancelListener(dialog);
 311
 312     JButton ok = new JButton("OK");
 313     ok.addActionListener(okListener);
 314     ok.addActionListener(al);
 315
 316     JButton cancel = new JButton("Cancel");
 317     cancel.addActionListener(cancelListener);
 318     cancel.addActionListener(al);
 319
 320     JButton reset = new JButton("Reset");
 321     reset.addActionListener(new DefaultResetListener(chooserPane));
 322
 323     dialog.getContentPane().add(chooserPane, BorderLayout.NORTH);
 324
 325     panel.add(ok);
 326     panel.add(cancel);
 327     panel.add(reset);
 328
 329     dialog.getContentPane().add(panel, BorderLayout.SOUTH);
 330
 331     return dialog;
 332   } // createDialog()
 333
 334   /**
 335    * This method returns the UI Component used for this JColorChooser.
 336    *
 337    * @return The UI Component for this JColorChooser.
 338    */
 339   public ColorChooserUI getUI()
 340   {
 341     return (ColorChooserUI) ui;
 342   } // getUI()
 343
 344   /**
 345    * This method sets the UI Component used for this JColorChooser.
 346    *
 347    * @param ui The UI Component to use with this JColorChooser.
 348    */
 349   public void setUI(ColorChooserUI ui)
 350   {
 351     super.setUI(ui);
 352   } // setUI()
 353
 354   /**
 355    * This method resets the UI Component property to the Look and Feel
 356    * default.
 357    */
 358   public void updateUI()
 359   {
 360     setUI((ColorChooserUI) UIManager.getUI(this));
 361     revalidate();
 362   } // updateUI()
 363
 364   /**
 365    * This method returns a String identifier for the UI Class to be used with
 366    * the JColorChooser.
 367    *
 368    * @return The String identifier for the UI Class.
 369    */
 370   public String getUIClassID()
 371   {
 372     return "ColorChooserUI";
 373   } // getUIClassID()
 374
 375   /**
 376    * This method returns the current color for the JColorChooser.
 377    *
 378    * @return The current color for the JColorChooser.
 379    */
 380   public Color getColor()
 381   {
 382     return selectionModel.getSelectedColor(); // TODO
 383   } // getColor()
 384
 385   /**
 386    * This method changes the previewPanel property for the JTabbedPane. The
 387    * previewPanel is responsible for indicating the current color of the
 388    * JColorChooser.
 389    *
 390    * @param component The Component that will act as the previewPanel.
 391    */
 392   public void setPreviewPanel(JComponent component)
 393   {
 394     if (component != previewPanel)
 395       {
 396         JComponent old = previewPanel;
 397         previewPanel = component;
 398         firePropertyChange(PREVIEW_PANEL_PROPERTY, old, previewPanel);
 399       }
 400   } // setPreviewPanel()
 401
 402   /**
 403    * This method returns the current previewPanel used with this
 404    * JColorChooser.
 405    *
 406    * @return The current previewPanel.
 407    */
 408   public JComponent getPreviewPanel()
 409   {
 410     return previewPanel; // TODO
 411   } // getPreviewPanel()
 412
 413   /**
 414    * This method adds the given AbstractColorChooserPanel to the list of the
 415    * JColorChooser's chooserPanels.
 416    *
 417    * @param panel The AbstractColorChooserPanel to add.
 418    */
 419   public void addChooserPanel(AbstractColorChooserPanel panel)
 420   {
 421     if (panel == null)
 422       return;
 423     AbstractColorChooserPanel[] old = chooserPanels;
 424     AbstractColorChooserPanel[] newPanels = new AbstractColorChooserPanel[(old == null)
 425                                                                           ? 1
 426                                                                           : old.length
 427                                                                           + 1];
 428     if (old != null)
 429       System.arraycopy(old, 0, newPanels, 0, old.length);
 430     newPanels[newPanels.length - 1] = panel;
 431     chooserPanels = newPanels;
 432     panel.installChooserPanel(this);
 433     firePropertyChange(CHOOSER_PANELS_PROPERTY, old, newPanels);
 434   } // addChooserPanel()
 435
 436   /**
 437    * This method removes the given AbstractColorChooserPanel from the
 438    * JColorChooser's list of chooserPanels.
 439    *
 440    * @param panel The AbstractColorChooserPanel to remove.
 441    *
 442    * @return The AbstractColorChooserPanel that was removed.
 443    */
 444   public AbstractColorChooserPanel removeChooserPanel(AbstractColorChooserPanel panel)
 445   {
 446     int index = -1;
 447     for (int i = 0; i < chooserPanels.length; i++)
 448       if (panel == chooserPanels[i])
 449         {
 450           index = i;
 451           break;
 452         }
 453
 454     if (index == -1)
 455       return null;
 456
 457     AbstractColorChooserPanel[] old = chooserPanels;
 458     if (chooserPanels.length == 1)
 459       chooserPanels = null;
 460     else
 461       {
 462         AbstractColorChooserPanel[] newPanels = new AbstractColorChooserPanel[chooserPanels.length
 463                                                 - 1];
 464         System.arraycopy(chooserPanels, 0, newPanels, 0, index);
 465         System.arraycopy(chooserPanels, index, newPanels, index - 1,
 466                          chooserPanels.length - index);
 467         chooserPanels = newPanels;
 468       }
 469     panel.uninstallChooserPanel(this);
 470     firePropertyChange(CHOOSER_PANELS_PROPERTY, old, chooserPanels);
 471     return panel;
 472   }
 473
 474   /**
 475    * This method sets the chooserPanels property for this JColorChooser.
 476    *
 477    * @param panels The new set of AbstractColorChooserPanels to use.
 478    */
 479   public void setChooserPanels(AbstractColorChooserPanel[] panels)
 480   {
 481     if (panels != chooserPanels)
 482       {
 483         if (chooserPanels != null)
 484           for (int i = 0; i < chooserPanels.length; i++)
 485             if (chooserPanels[i] != null)
 486               chooserPanels[i].uninstallChooserPanel(this);
 487
 488         AbstractColorChooserPanel[] old = chooserPanels;
 489         chooserPanels = panels;
 490
 491         if (panels != null)
 492           for (int i = 0; i < panels.length; i++)
 493             if (panels[i] != null)
 494               panels[i].installChooserPanel(this);
 495
 496         firePropertyChange(CHOOSER_PANELS_PROPERTY, old, chooserPanels);
 497       }
 498   } // setChooserPanels()
 499
 500   /**
 501    * This method returns the AbstractColorChooserPanels used with this
 502    * JColorChooser.
 503    *
 504    * @return The AbstractColorChooserPanels used with this JColorChooser.
 505    */
 506   public AbstractColorChooserPanel[] getChooserPanels()
 507   {
 508     return chooserPanels;
 509   } // getChooserPanels()
 510
 511   /**
 512    * This method returns the ColorSelectionModel used with this JColorChooser.
 513    *
 514    * @return The ColorSelectionModel.
 515    */
 516   public ColorSelectionModel getSelectionModel()
 517   {
 518     return selectionModel;
 519   } // getSelectionModel()
 520
 521   /**
 522    * This method sets the ColorSelectionModel to be used with this
 523    * JColorChooser.
 524    *
 525    * @param model The ColorSelectionModel to be used with this JColorChooser.
 526    *
 527    * @throws AWTError If the given model is null.
 528    */
 529   public void setSelectionModel(ColorSelectionModel model)
 530   {
 531     if (model == null)
 532       throw new AWTError("ColorSelectionModel is not allowed to be null.");
 533     selectionModel = model;
 534   } // setSelectionModel()
 535
 536   /**
 537    * DOCUMENT ME!
 538    *
 539    * @return DOCUMENT ME!
 540    */
 541   public boolean getDragEnabled()
 542   {
 543     return dragEnabled;
 544   }
 545
 546   /**
 547    * DOCUMENT ME!
 548    *
 549    * @param b DOCUMENT ME!
 550    */
 551   public void setDragEnabled(boolean b)
 552   {
 553     dragEnabled = b;
 554   }
 555
 556   /**
 557    * This method returns a String describing the JColorChooser.
 558    *
 559    * @return A String describing the JColorChooser.
 560    */
 561   protected String paramString()
 562   {
 563     return "JColorChooser";
 564   } // paramString()
 565
 566   /**
 567    * getAccessibleContext
 568    *
 569    * @return AccessibleContext
 570    */
 571   public AccessibleContext getAccessibleContext()
 572   {
 573     if (accessibleContext == null)
 574       accessibleContext = new AccessibleJColorChooser();
 575
 576     return accessibleContext;
 577   }
 578
 579   /**
 580    * A helper class that hides a JDialog when the action is performed.
 581    */
 582   static class DefaultOKCancelListener implements ActionListener
 583   {
 584     /** The JDialog to hide. */
 585     private JDialog dialog;
 586
 587     /**
 588      * Creates a new DefaultOKCancelListener with the given JDialog to hide.
 589      *
 590      * @param dialog The JDialog to hide.
 591      */
 592     public DefaultOKCancelListener(JDialog dialog)
 593     {
 594       super();
 595       this.dialog = dialog;
 596     }
 597
 598     /**
 599      * This method hides the JDialog when called.
 600      *
 601      * @param e The ActionEvent.
 602      */
 603     public void actionPerformed(ActionEvent e)
 604     {
 605       dialog.hide();
 606     }
 607   }
 608
 609   /**
 610    * This method resets the JColorChooser color to the initial color when the
 611    * action is performed.
 612    */
 613   static class DefaultResetListener implements ActionListener
 614   {
 615     /** The JColorChooser to reset. */
 616     private JColorChooser chooser;
 617
 618     /** The initial color. */
 619     private Color init;
 620
 621     /**
 622      * Creates a new DefaultResetListener with the given JColorChooser.
 623      *
 624      * @param chooser The JColorChooser to reset.
 625      */
 626     public DefaultResetListener(JColorChooser chooser)
 627     {
 628       super();
 629       this.chooser = chooser;
 630       init = chooser.getColor();
 631     }
 632
 633     /**
 634      * This method resets the JColorChooser to its initial color.
 635      *
 636      * @param e The ActionEvent.
 637      */
 638     public void actionPerformed(ActionEvent e)
 639     {
 640       chooser.setColor(init);
 641     }
 642   }
 643
 644   /**
 645    * This is a custom JDialog that will notify when it is hidden and the modal
 646    * property is set.
 647    */
 648   static class ModalDialog extends JDialog
 649   {
 650     /** The modal property. */
 651     private boolean modal;
 652
 653     /**
 654      * Creates a new ModalDialog object with the given parent and title.
 655      *
 656      * @param parent The parent of the JDialog.
 657      * @param title The title of the JDialog.
 658      */
 659     public ModalDialog(Frame parent, String title)
 660     {
 661       super(parent, title);
 662     }
 663
 664     /**
 665      * Creates a new ModalDialog object with the given parent and title.
 666      *
 667      * @param parent The parent of the JDialog.
 668      * @param title The title of the JDialog.
 669      */
 670     public ModalDialog(Dialog parent, String title)
 671     {
 672       super(parent, title);
 673     }
 674
 675     /**
 676      * This method sets the modal property.
 677      *
 678      * @param modal The modal property.
 679      */
 680     public void setModal(boolean modal)
 681     {
 682       this.modal = modal;
 683     }
 684
 685     /**
 686      * This method shows the ModalDialog.
 687      */
 688     public void show()
 689     {
 690       super.show();
 691       if (modal)
 692         makeModal(this);
 693     }
 694
 695     /**
 696      * This method hides the ModalDialog.
 697      */
 698     public synchronized void hide()
 699     {
 700       super.hide();
 701       notifyAll();
 702     }
 703   }
 704 }