libjava/javax/swing/plaf/basic/BasicColorChooserUI.java

   1 /* BasicColorChooserUI.java --
   2    Copyright (C) 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.plaf.basic;
  40
  41 import java.awt.BorderLayout;
  42 import java.awt.Container;
  43 import java.beans.PropertyChangeEvent;
  44 import java.beans.PropertyChangeListener;
  45
  46 import javax.swing.JColorChooser;
  47 import javax.swing.JComponent;
  48 import javax.swing.JPanel;
  49 import javax.swing.JTabbedPane;
  50 import javax.swing.UIDefaults;
  51 import javax.swing.UIManager;
  52 import javax.swing.colorchooser.AbstractColorChooserPanel;
  53 import javax.swing.colorchooser.ColorChooserComponentFactory;
  54 import javax.swing.event.ChangeEvent;
  55 import javax.swing.event.ChangeListener;
  56 import javax.swing.plaf.ColorChooserUI;
  57 import javax.swing.plaf.ComponentUI;
  58
  59 /**
  60  * This is the UI Class for the JColorChooser in the Basic Look and Feel.
  61  */
  62 public class BasicColorChooserUI extends ColorChooserUI
  63 {
  64   /**
  65    * This helper class handles property changes from the JColorChooser.
  66    */
  67   public class PropertyHandler implements PropertyChangeListener
  68   {
  69     /**
  70      * This method is called when any of the properties of the JColorChooser
  71      * change.
  72      *
  73      * @param e The PropertyChangeEvent.
  74      */
  75     public void propertyChange(PropertyChangeEvent e)
  76     {
  77       if (e.getPropertyName() == JColorChooser.CHOOSER_PANELS_PROPERTY)
  78         makeTabs(chooser.getChooserPanels());
  79       else if (e.getPropertyName() == JColorChooser.PREVIEW_PANEL_PROPERTY)
  80         updatePreviewPanel(chooser.getPreviewPanel());
  81       else if (e.getPropertyName() == JColorChooser.SELECTION_MODEL_PROPERTY)
  82         ((AbstractColorChooserPanel) pane.getSelectedComponent())
  83         .updateChooser();
  84
  85       chooser.repaint();
  86     }
  87   }
  88
  89   /**
  90    * This is a helper class that listens to the Model of the JColorChooser for
  91    * color change events so it can update the preview panel.
  92    */
  93   private class PreviewListener implements ChangeListener
  94   {
  95     /**
  96      * This method is called whenever the JColorChooser's color changes.
  97      *
  98      * @param e The ChangeEvent.
  99      */
 100     public void stateChanged(ChangeEvent e)
 101     {
 102       if (pane != null)
 103         {
 104           AbstractColorChooserPanel panel = (AbstractColorChooserPanel) pane
 105                                             .getSelectedComponent();
 106           if (panel != null)
 107             panel.updateChooser();
 108         }
 109       chooser.repaint();
 110     }
 111   }
 112
 113   /**
 114    * This helper class listens to the JTabbedPane that is used for tab
 115    * changes.
 116    */
 117   private class TabPaneListener implements ChangeListener
 118   {
 119     /**
 120      * This method is called whenever a different tab is selected in the
 121      * JTabbedPane.
 122      *
 123      * @param e The ChangeEvent.
 124      */
 125     public void stateChanged(ChangeEvent e)
 126     {
 127       // Need to do this because we don't update all the tabs when they're not
 128       // visible, so they are not informed of new colors when they're hidden.
 129       AbstractColorChooserPanel comp = (AbstractColorChooserPanel) pane
 130                                        .getSelectedComponent();
 131       comp.updateChooser();
 132     }
 133   }
 134
 135   /** An array of default choosers to use in the JColorChooser. */
 136   protected AbstractColorChooserPanel[] defaultChoosers;
 137
 138   /** The listener for the preview panel. */
 139   protected ChangeListener previewListener;
 140
 141   /** The PropertyChangeListener for the JColorChooser. */
 142   protected PropertyChangeListener propertyChangeListener;
 143
 144   /** The JColorChooser. */
 145   private JColorChooser chooser;
 146
 147   /** The JTabbedPane that is used. */
 148   private JTabbedPane pane;
 149
 150   /** The Container that holds the preview panel. */
 151   private Container prevContainer;
 152
 153   /**
 154    * Creates a new BasicColorChooserUI object.
 155    */
 156   public BasicColorChooserUI()
 157   {
 158     super();
 159   }
 160
 161   /**
 162    * This method creates a new UI Component for the given JComponent.
 163    *
 164    * @param c The JComponent to create an UI for.
 165    *
 166    * @return A new BasicColorChooserUI.
 167    */
 168   public static ComponentUI createUI(JComponent c)
 169   {
 170     return new BasicColorChooserUI();
 171   }
 172
 173   /**
 174    * This method creates the default chooser panels for the JColorChooser.
 175    *
 176    * @return The default chooser panels.
 177    */
 178   protected AbstractColorChooserPanel[] createDefaultChoosers()
 179   {
 180     return ColorChooserComponentFactory.getDefaultChooserPanels();
 181   }
 182
 183   /**
 184    * This method installs the UI Component for the given JComponent.
 185    *
 186    * @param c The JComponent to install this UI for.
 187    */
 188   public void installUI(JComponent c)
 189   {
 190     if (c instanceof JColorChooser)
 191       {
 192         chooser = (JColorChooser) c;
 193         chooser.setLayout(new BorderLayout());
 194
 195         // Do this first, so we avoid doing work for property change events.
 196         defaultChoosers = createDefaultChoosers();
 197         chooser.setChooserPanels(defaultChoosers);
 198         pane = new JTabbedPane();
 199
 200         pane.addChangeListener(new ChangeListener()
 201             {
 202               public void stateChanged(ChangeEvent e)
 203               {
 204                 pane.repaint();
 205               }
 206             });
 207
 208         makeTabs(defaultChoosers);
 209
 210         chooser.add(pane, BorderLayout.NORTH);
 211
 212         installPreviewPanel();
 213
 214         installDefaults();
 215         installListeners();
 216       }
 217   }
 218
 219   /**
 220    * This method adds tabs to the JTabbedPane for the chooserPanels defined in
 221    * the JColorChooser.
 222    *
 223    * @param panels The Panels that need tabs to be made for them.
 224    */
 225   private void makeTabs(AbstractColorChooserPanel[] panels)
 226   {
 227     pane.removeAll();
 228     for (int i = 0; i < panels.length; i++)
 229       pane.addTab(panels[i].getDisplayName(), panels[i].getSmallDisplayIcon(),
 230                   panels[i]);
 231   }
 232
 233   /**
 234    * This method uninstalls this UI for the given JComponent.
 235    *
 236    * @param c The JComponent that will have this UI removed.
 237    */
 238   public void uninstallUI(JComponent c)
 239   {
 240     uninstallListeners();
 241     uninstallDefaults();
 242
 243     pane = null;
 244     chooser = null;
 245   }
 246
 247   /**
 248    * This method installs the preview panel for the JColorChooser.
 249    */
 250   protected void installPreviewPanel()
 251   {
 252     updatePreviewPanel(ColorChooserComponentFactory.getPreviewPanel());
 253   }
 254
 255   /**
 256    * This is a helper method that swaps the existing preview panel with the
 257    * given panel.
 258    *
 259    * @param preview The new preview panel.
 260    */
 261   private void updatePreviewPanel(JComponent preview)
 262   {
 263     if (prevContainer == null)
 264       {
 265         prevContainer = new JPanel();
 266         prevContainer.setLayout(new BorderLayout());
 267         chooser.add(prevContainer, BorderLayout.CENTER);
 268       }
 269     prevContainer.removeAll();
 270     prevContainer.add(preview, BorderLayout.CENTER);
 271   }
 272
 273   /**
 274    * This method installs the default properties given by the Basic Look and
 275    * Feel.
 276    */
 277   protected void installDefaults()
 278   {
 279     UIDefaults defaults = UIManager.getLookAndFeelDefaults();
 280
 281     chooser.setFont(defaults.getFont("ColorChooser.font"));
 282     chooser.setForeground(defaults.getColor("ColorChooser.foreground"));
 283     chooser.setBackground(defaults.getColor("ColorChooser.background"));
 284   }
 285
 286   /**
 287    * This method uninstalls the default properties given by the Basic Look and
 288    * Feel.
 289    */
 290   protected void uninstallDefaults()
 291   {
 292     chooser.setBackground(null);
 293     chooser.setForeground(null);
 294     chooser.setFont(null);
 295   }
 296
 297   /**
 298    * This method installs any listeners required for this UI to function.
 299    */
 300   protected void installListeners()
 301   {
 302     propertyChangeListener = createPropertyChangeListener();
 303     previewListener = new PreviewListener();
 304
 305     chooser.addPropertyChangeListener(propertyChangeListener);
 306     chooser.getSelectionModel().addChangeListener(previewListener);
 307
 308     pane.addChangeListener(new TabPaneListener());
 309   }
 310
 311   /**
 312    * This method creates the PropertyChangeListener used for listening to the
 313    * JColorChooser.
 314    *
 315    * @return A PropertyChangeListener.
 316    */
 317   protected PropertyChangeListener createPropertyChangeListener()
 318   {
 319     return new PropertyHandler();
 320   }
 321
 322   /**
 323    * This method uninstalls any listeners that were previously installed by
 324    * the UI.
 325    */
 326   protected void uninstallListeners()
 327   {
 328     chooser.removePropertyChangeListener(propertyChangeListener);
 329     chooser.getSelectionModel().removeChangeListener(previewListener);
 330
 331     previewListener = null;
 332     propertyChangeListener = null;
 333   }
 334 }