001/* MetalToolBarUI.java 002 Copyright (C) 2005 Free Software Foundation, Inc. 003 004This file is part of GNU Classpath. 005 006GNU Classpath is free software; you can redistribute it and/or modify 007it under the terms of the GNU General Public License as published by 008the Free Software Foundation; either version 2, or (at your option) 009any later version. 010 011GNU Classpath is distributed in the hope that it will be useful, but 012WITHOUT ANY WARRANTY; without even the implied warranty of 013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014General Public License for more details. 015 016You should have received a copy of the GNU General Public License 017along with GNU Classpath; see the file COPYING. If not, write to the 018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 01902110-1301 USA. 020 021Linking this library statically or dynamically with other modules is 022making a combined work based on this library. Thus, the terms and 023conditions of the GNU General Public License cover the whole 024combination. 025 026As a special exception, the copyright holders of this library give you 027permission to link this library with independent modules to produce an 028executable, regardless of the license terms of these independent 029modules, and to copy and distribute the resulting executable under 030terms of your choice, provided that you also meet, for each linked 031independent module, the terms and conditions of the license of that 032module. An independent module is a module which is not derived from 033or based on this library. If you modify this library, you may extend 034this exception to your version of the library, but you are not 035obligated to do so. If you do not wish to do so, delete this 036exception statement from your version. */ 037 038 039package javax.swing.plaf.metal; 040 041import java.awt.Graphics; 042import java.awt.Point; 043import java.awt.event.ContainerListener; 044import java.awt.event.MouseEvent; 045 046import java.beans.PropertyChangeListener; 047 048import javax.swing.JComponent; 049import javax.swing.JToolBar; 050import javax.swing.SwingConstants; 051import javax.swing.UIManager; 052import javax.swing.border.Border; 053import javax.swing.event.MouseInputListener; 054import javax.swing.plaf.ComponentUI; 055import javax.swing.plaf.basic.BasicToolBarUI; 056 057/** 058 * A UI delegate for the {@link JToolBar} component. 059 */ 060public class MetalToolBarUI extends BasicToolBarUI 061{ 062 063 /** 064 * A listener (no longer used) that responds when components are added to or 065 * removed from the {@link JToolBar}. The required behaviour is now 066 * handled in the super class. 067 * 068 * @see MetalToolBarUI#createContainerListener() 069 */ 070 protected class MetalContainerListener 071 extends BasicToolBarUI.ToolBarContListener 072 { 073 /** 074 * Creates a new instance. 075 */ 076 protected MetalContainerListener() 077 { 078 // Nothing to do here. 079 } 080 } 081 082 /** 083 * A listener (no longer used) that responds to property change events in a 084 * {@link JToolBar} component. The required behaviour is now handled in the 085 * super class. 086 * 087 * @see MetalToolBarUI#createRolloverListener() 088 */ 089 protected class MetalRolloverListener 090 extends BasicToolBarUI.PropertyListener 091 { 092 /** 093 * Creates a new instance. 094 */ 095 protected MetalRolloverListener() 096 { 097 // Nothing to do here. 098 } 099 } 100 101 /** 102 * The container listener (an implementation specific field, according to the 103 * spec, and not used in GNU Classpath). 104 */ 105 protected ContainerListener contListener; 106 107 /** 108 * The rollover listener (an implementation specific field, according to the 109 * spec, and not used in GNU Classpath). 110 */ 111 protected PropertyChangeListener rolloverListener; 112 113 /** 114 * Creates a new instance of this UI delegate. 115 */ 116 public MetalToolBarUI() 117 { 118 super(); 119 } 120 121 /** 122 * Returns a new instance of <code>MetalToolBarUI</code>. 123 * 124 * @param component the component for which we return an UI instance 125 * 126 * @return A new instance of <code>MetalToolBarUI</code>. 127 */ 128 public static ComponentUI createUI(JComponent component) 129 { 130 return new MetalToolBarUI(); 131 } 132 133 /** 134 * Returns <code>null</code> as permitted by recent versions of the API 135 * specification. Originally it seems this method returned a new instance of 136 * {@link MetalRolloverListener}, but this is now redundant. 137 * 138 * @return <code>null</code>. 139 */ 140 protected PropertyChangeListener createRolloverListener() 141 { 142 return null; 143 } 144 145 /** 146 * Returns <code>null</code> as permitted by recent versions of the API 147 * specification. Originally it seems this method returned a new instance of 148 * {@link MetalContainerListener}, but this is now redundant. 149 * 150 * @return <code>null</code>. 151 */ 152 protected ContainerListener createContainerListener() 153 { 154 return null; 155 } 156 157 /** 158 * Returns a border with no rollover effect for buttons in the tool bar. 159 * 160 * @return A border. 161 * 162 * @see MetalBorders#getToolbarButtonBorder() 163 */ 164 protected Border createNonRolloverBorder() 165 { 166 return MetalBorders.getToolbarButtonBorder(); 167 } 168 169 /** 170 * Sets the offset for the window used for dragging the toolbar. 171 * It is set as long as the window is not null (it has been installed). 172 */ 173 protected void setDragOffset(Point p) 174 { 175 if (dragWindow != null) 176 dragWindow.setOffset(p); 177 } 178 179 /** 180 * Creates and returns an instance of MetalDockingListener. 181 * 182 * @return an instance of MetalDockingListener. 183 */ 184 protected MouseInputListener createDockingListener() 185 { 186 return new MetalDockingListener(toolBar); 187 } 188 189 /** 190 * This is the MouseHandler class that allows the user to drag the JToolBar 191 * in and out of the parent and dock it if it can. 192 */ 193 protected class MetalDockingListener extends BasicToolBarUI.DockingListener 194 { 195 /** 196 * Creates a new DockingListener object. 197 * 198 * @param t The JToolBar this DockingListener is being used for. 199 */ 200 public MetalDockingListener(JToolBar t) 201 { 202 super(t); 203 } 204 205 /** 206 * This method is called when the mouse is pressed in the JToolBar. If the 207 * press doesn't occur in a place where it causes the JToolBar to be 208 * dragged, it returns. Otherwise, it starts a drag session. 209 * 210 * @param e The MouseEvent. 211 */ 212 public void mousePressed(MouseEvent e) 213 { 214 super.mousePressed(e); 215 setDragOffset(new Point(e.getX(), e.getY())); 216 } 217 218 /** 219 * This method is called when the mouse is dragged. It delegates the drag 220 * painting to the dragTo method. 221 * 222 * @param e The MouseEvent. 223 */ 224 public void mouseDragged(MouseEvent e) 225 { 226 // Does not do anything differently than dragging 227 // BasicToolBarUI.DockingListener 228 super.mouseDragged(e); 229 } 230 } 231 232 /** 233 * Installs the UI on the toolbar. This calls super and sets the rollover 234 * property according to the <code>UIManager</code> property 235 * "ToolBar.isRollover". 236 * 237 * @param c the component to install the UI on 238 */ 239 public void installUI(JComponent c) 240 { 241 super.installUI(c); 242 if (c instanceof JToolBar) 243 { 244 JToolBar tb = (JToolBar) c; 245 tb.setRollover(UIManager.getBoolean("ToolBar.isRollover")); 246 } 247 } 248 249 /** 250 * Uninstalls the UI from the toolbar. This calls super and resets the 251 * rollover property. 252 * 253 * @param c the component to uninstall the UI from 254 */ 255 public void uninstallUI(JComponent c) 256 { 257 if (c instanceof JToolBar) 258 { 259 JToolBar tb = (JToolBar) c; 260 tb.setRollover(false); 261 } 262 super.uninstallUI(c); 263 } 264 265 /** 266 * Paints the background of the component if necessary and then calls 267 * <code>paint(g, c)</code>. 268 * 269 * This is overridden to implement the OceanTheme gradient when an OceanTheme 270 * is installed. 271 * 272 * @param g the graphics to use 273 * @param c the component to paint. 274 * 275 * @since 1.5 276 */ 277 public void update(Graphics g, JComponent c) 278 { 279 // TODO: Sun's implementation uses the MenuBar.gradient here. 280 // I would consider this a bug, but implement it like this 281 // for compatibility. 282 if (MetalLookAndFeel.getCurrentTheme() instanceof OceanTheme 283 && UIManager.get("MenuBar.gradient") != null) 284 { 285 if (c.isOpaque()) 286 { 287 MetalUtils.paintGradient(g, 0, 0, c.getWidth(), c.getHeight(), 288 SwingConstants.VERTICAL, 289 "MenuBar.gradient"); 290 } 291 paint(g, c); 292 } 293 else 294 { 295 super.update(g, c); 296 } 297 } 298}