libjava/classpath/javax/swing/plaf/basic/BasicMenuBarUI.java

   1 /* BasicMenuBarUI.java --
   2    Copyright (C) 2002, 2004, 2005  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., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 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 gnu.classpath.NotImplementedException;
  42
  43 import java.awt.Dimension;
  44 import java.awt.event.ContainerEvent;
  45 import java.awt.event.ContainerListener;
  46 import java.awt.event.MouseEvent;
  47 import java.beans.PropertyChangeEvent;
  48 import java.beans.PropertyChangeListener;
  49
  50 import javax.swing.BoxLayout;
  51 import javax.swing.JComponent;
  52 import javax.swing.JMenu;
  53 import javax.swing.JMenuBar;
  54 import javax.swing.LookAndFeel;
  55 import javax.swing.MenuElement;
  56 import javax.swing.event.ChangeEvent;
  57 import javax.swing.event.ChangeListener;
  58 import javax.swing.event.MouseInputListener;
  59 import javax.swing.plaf.ComponentUI;
  60 import javax.swing.plaf.MenuBarUI;
  61
  62 /**
  63  * UI Delegate for JMenuBar.
  64  */
  65 public class BasicMenuBarUI extends MenuBarUI
  66 {
  67   protected ChangeListener changeListener;
  68
  69   /*ContainerListener that listens to the ContainerEvents fired from menu bar*/
  70   protected ContainerListener containerListener;
  71
  72   /*Property change listeners that listener to PropertyChangeEvent from menu bar*/
  73   private PropertyChangeListener propertyChangeListener;
  74
  75   /* menu bar for which this UI delegate is for*/
  76   protected JMenuBar menuBar;
  77
  78   /* MouseListener that listens to the mouseEvents fired from menu bar*/
  79   private MouseInputListener mouseListener;
  80
  81   /**
  82    * Creates a new BasicMenuBarUI object.
  83    */
  84   public BasicMenuBarUI()
  85   {
  86     changeListener = createChangeListener();
  87     containerListener = createContainerListener();
  88     propertyChangeListener = new PropertyChangeHandler();
  89     mouseListener = new MouseInputHandler();
  90   }
  91
  92   /**
  93    * Creates ChangeListener
  94    *
  95    * @return The ChangeListener
  96    */
  97   protected ChangeListener createChangeListener()
  98   {
  99     return new ChangeHandler();
 100   }
 101
 102   /**
 103    * Creates ContainerListener() to listen for ContainerEvents
 104    * fired by JMenuBar.
 105    *
 106    * @return The ContainerListener
 107    */
 108   protected ContainerListener createContainerListener()
 109   {
 110     return new ContainerHandler();
 111   }
 112
 113   /**
 114    * Factory method to create a BasicMenuBarUI for the given {@link
 115    * JComponent}, which should be a {@link JMenuBar}.
 116    *
 117    * @param x The {@link JComponent} a UI is being created for.
 118    *
 119    * @return A BasicMenuBarUI for the {@link JComponent}.
 120    */
 121   public static ComponentUI createUI(JComponent x)
 122   {
 123     return new BasicMenuBarUI();
 124   }
 125
 126   /**
 127    * Returns maximum size for the specified menu bar
 128    *
 129    * @param c component for which to get maximum size
 130    *
 131    * @return  Maximum size for the specified menu bar
 132    */
 133   public Dimension getMaximumSize(JComponent c)
 134   {
 135     // let layout manager calculate its size
 136     return null;
 137   }
 138
 139   /**
 140    * Returns maximum allowed size of JMenuBar.
 141    *
 142    * @param c menuBar for which to return maximum size
 143    *
 144    * @return Maximum size of the give menu bar.
 145    */
 146   public Dimension getMinimumSize(JComponent c)
 147   {
 148     // let layout manager calculate its size
 149     return null;
 150   }
 151
 152   /**
 153    * Returns preferred size of JMenuBar.
 154    *
 155    * @param c menuBar for which to return preferred size
 156    *
 157    * @return Preferred size of the give menu bar.
 158    */
 159   public Dimension getPreferredSize(JComponent c)
 160   {
 161     // let layout manager calculate its size
 162     return null;
 163   }
 164
 165   /**
 166    * Initializes any default properties that this UI has from the defaults for
 167    * the Basic look and feel.
 168    */
 169   protected void installDefaults()
 170   {
 171     LookAndFeel.installBorder(menuBar, "MenuBar.border");
 172     LookAndFeel.installColorsAndFont(menuBar, "MenuBar.background",
 173                                      "MenuBar.foreground", "MenuBar.font");
 174     menuBar.setOpaque(true);
 175   }
 176
 177   /**
 178    * This method installs the keyboard actions for the JMenuBar.
 179    */
 180   protected void installKeyboardActions()
 181     throws NotImplementedException
 182   {
 183     // FIXME: implement
 184   }
 185
 186   /**
 187    * This method installs the listeners needed for this UI to function.
 188    */
 189   protected void installListeners()
 190   {
 191     menuBar.addContainerListener(containerListener);
 192     menuBar.addPropertyChangeListener(propertyChangeListener);
 193     menuBar.addMouseListener(mouseListener);
 194   }
 195
 196   /**
 197   * Installs and initializes all fields for this UI delegate. Any properties
 198   * of the UI that need to be initialized and/or set to defaults will be
 199   * done now. It will also install any listeners necessary.
 200   *
 201   * @param c The {@link JComponent} that is having this UI installed.
 202   */
 203   public void installUI(JComponent c)
 204   {
 205     super.installUI(c);
 206     menuBar = (JMenuBar) c;
 207     menuBar.setLayout(new BoxLayout(menuBar, BoxLayout.X_AXIS));
 208     installDefaults();
 209     installListeners();
 210     installKeyboardActions();
 211   }
 212
 213   /**
 214    * This method uninstalls the defaults and nulls any objects created during
 215    * install.
 216    */
 217   protected void uninstallDefaults()
 218   {
 219     menuBar.setBackground(null);
 220     menuBar.setBorder(null);
 221     menuBar.setFont(null);
 222     menuBar.setForeground(null);
 223   }
 224
 225   /**
 226    * This method reverses the work done in installKeyboardActions.
 227    */
 228   protected void uninstallKeyboardActions()
 229     throws NotImplementedException
 230   {
 231     // FIXME: implement.
 232   }
 233
 234   /**
 235    * Unregisters all the listeners that this UI delegate was using.
 236    */
 237   protected void uninstallListeners()
 238   {
 239     menuBar.removeContainerListener(containerListener);
 240     menuBar.removePropertyChangeListener(propertyChangeListener);
 241     menuBar.removeMouseListener(mouseListener);
 242   }
 243
 244   /**
 245    * Performs the opposite of installUI. Any properties or resources that need
 246    * to be cleaned up will be done now. It will also uninstall any listeners
 247    * it has. In addition, any properties of this UI will be nulled.
 248    *
 249    * @param c The {@link JComponent} that is having this UI uninstalled.
 250    */
 251   public void uninstallUI(JComponent c)
 252   {
 253     uninstallDefaults();
 254     uninstallListeners();
 255     uninstallKeyboardActions();
 256     menuBar = null;
 257   }
 258
 259   private class ChangeHandler implements ChangeListener
 260   {
 261     public void stateChanged(ChangeEvent event)
 262     {
 263       // TODO: What should be done here, if anything?
 264     }
 265   }
 266
 267   /**
 268    * This class handles ContainerEvents fired by JMenuBar. It revalidates
 269    * and repaints menu bar whenever menu is added or removed from it.
 270    */
 271   private class ContainerHandler implements ContainerListener
 272   {
 273     /**
 274      * This method is called whenever menu is added to the menu bar
 275      *
 276      * @param e The ContainerEvent.
 277      */
 278     public void componentAdded(ContainerEvent e)
 279     {
 280       menuBar.revalidate();
 281       menuBar.repaint();
 282     }
 283
 284     /**
 285      * This method is called whenever menu is removed from the menu bar.
 286      *
 287      * @param e The ContainerEvent.
 288      */
 289     public void componentRemoved(ContainerEvent e)
 290     {
 291       menuBar.revalidate();
 292       menuBar.repaint();
 293     }
 294   }
 295
 296   /**
 297    * This class handles PropertyChangeEvents fired from the JMenuBar
 298    */
 299   private class PropertyChangeHandler implements PropertyChangeListener
 300   {
 301     /**
 302      * This method is called whenever one of the properties of the MenuBar
 303      * changes.
 304      *
 305      * @param e The PropertyChangeEvent.
 306      */
 307     public void propertyChange(PropertyChangeEvent e)
 308     {
 309       if (e.getPropertyName().equals("borderPainted"))
 310         menuBar.repaint();
 311       if (e.getPropertyName().equals("margin"))
 312         menuBar.repaint();
 313     }
 314   }
 315
 316   private class MouseInputHandler implements MouseInputListener
 317   {
 318     /**
 319      * Handles mouse clicked event
 320      *
 321      * @param e Mouse event
 322      */
 323     public void mouseClicked(MouseEvent e)
 324     {
 325       MenuElement[] me = menuBar.getSubElements();
 326
 327       for (int i = 0; i < me.length; i++)
 328         {
 329           JMenu menu = menuBar.getMenu(i);
 330           if (menu != null)
 331             menu.setSelected(false);
 332         }
 333     }
 334
 335     /**
 336      * Handles mouse pressed event
 337      *
 338      * @param e Mouse event
 339      */
 340     public void mousePressed(MouseEvent e)
 341     {
 342       // TODO: What should be done here, if anything?
 343     }
 344
 345     /**
 346      * Handles mouse released event
 347      *
 348      * @param e Mouse event
 349      */
 350     public void mouseReleased(MouseEvent e)
 351     {
 352       // TODO: What should be done here, if anything?
 353     }
 354
 355     /**
 356      * Handles mouse exited event
 357      *
 358      * @param e Mouse event
 359      */
 360     public void mouseExited(MouseEvent e)
 361     {
 362       // TODO: What should be done here, if anything?
 363     }
 364
 365     /**
 366      * Handles mouse dragged event
 367      *
 368      * @param e Mouse event
 369      */
 370     public void mouseDragged(MouseEvent e)
 371     {
 372       // TODO: What should be done here, if anything?
 373     }
 374
 375     /**
 376      * Handles mouse moved event
 377      *
 378      * @param e Mouse event
 379      */
 380     public void mouseMoved(MouseEvent e)
 381     {
 382       // TODO: What should be done here, if anything?
 383     }
 384
 385     /**
 386      * Handles mouse entered event
 387      *
 388      * @param e Mouse event
 389      */
 390     public void mouseEntered(MouseEvent e)
 391     {
 392       // TODO: What should be done here, if anything?
 393     }
 394   }
 395 }