GNU Classpath (0.91) | |
Frames | No Frames |
1: /* BasicRootPaneUI.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., 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 java.awt.event.ActionEvent; 42: import java.beans.PropertyChangeEvent; 43: import java.beans.PropertyChangeListener; 44: 45: import javax.swing.AbstractAction; 46: import javax.swing.ButtonModel; 47: import javax.swing.InputMap; 48: import javax.swing.JButton; 49: import javax.swing.JComponent; 50: import javax.swing.JRootPane; 51: import javax.swing.LookAndFeel; 52: import javax.swing.SwingUtilities; 53: import javax.swing.UIManager; 54: import javax.swing.plaf.ActionMapUIResource; 55: import javax.swing.plaf.ComponentInputMapUIResource; 56: import javax.swing.plaf.ComponentUI; 57: import javax.swing.plaf.RootPaneUI; 58: 59: public class BasicRootPaneUI extends RootPaneUI 60: implements PropertyChangeListener 61: { 62: 63: /** 64: * Performed when the user activates the default button inside the JRootPane, 65: * usually by pressing 'ENTER'. 66: */ 67: private class DefaultPressAction 68: extends AbstractAction 69: { 70: /** 71: * The JRootPane for which this action should be installed. 72: */ 73: private JRootPane rootPane; 74: 75: /** 76: * Creates a new DefaultPressAction for the specified JRootPane. 77: */ 78: DefaultPressAction(JRootPane rp) 79: { 80: rootPane = rp; 81: } 82: 83: /** 84: * Performes the action. 85: */ 86: public void actionPerformed(ActionEvent ev) 87: { 88: JButton b = rootPane.getDefaultButton(); 89: if (b != null) 90: { 91: ButtonModel m = b.getModel(); 92: m.setArmed(true); 93: m.setPressed(true); 94: } 95: } 96: } 97: 98: /** 99: * Performed when the user activates the default button inside the JRootPane, 100: * usually by releasing 'ENTER'. 101: */ 102: private class DefaultReleaseAction 103: extends AbstractAction 104: { 105: /** 106: * The JRootPane for which this action should be installed. 107: */ 108: private JRootPane rootPane; 109: 110: /** 111: * Creates a new DefaultReleaseAction for the specified JRootPane. 112: */ 113: DefaultReleaseAction(JRootPane rp) 114: { 115: rootPane = rp; 116: } 117: 118: /** 119: * Performes the action. 120: */ 121: public void actionPerformed(ActionEvent ev) 122: { 123: JButton b = rootPane.getDefaultButton(); 124: if (b != null) 125: { 126: ButtonModel m = b.getModel(); 127: m.setPressed(false); 128: m.setArmed(false); 129: } 130: } 131: } 132: 133: public static ComponentUI createUI(JComponent x) 134: { 135: return new BasicRootPaneUI(); 136: } 137: 138: public void installUI(JComponent c) 139: { 140: super.installUI(c); 141: if (c instanceof JRootPane) 142: { 143: JRootPane rp = (JRootPane) c; 144: installDefaults(rp); 145: installComponents(rp); 146: installListeners(rp); 147: installKeyboardActions(rp); 148: } 149: } 150: 151: /** 152: * Installs the look and feel defaults for JRootPane. 153: * 154: * @param rp the root pane to install the defaults to 155: */ 156: protected void installDefaults(JRootPane rp) 157: { 158: // TODO: What to do here, if anything? (might be a hook method) 159: } 160: 161: /** 162: * Installs additional look and feel components to the root pane. 163: * 164: * @param rp the root pane to install the components to 165: */ 166: protected void installComponents(JRootPane rp) 167: { 168: // All components are initialized in the JRootPane constructor, and since 169: // the createXXXPane methods are protected, I see no reasonable way, 170: // and no need to initialize them here. This method is here anyway 171: // for compatibility and to provide the necessary hooks to subclasses. 172: } 173: 174: /** 175: * Installs any look and feel specific listeners on the root pane. 176: * 177: * @param rp the root pane to install the listeners to 178: */ 179: protected void installListeners(JRootPane rp) 180: { 181: rp.addPropertyChangeListener(this); 182: } 183: 184: /** 185: * Installs look and feel keyboard actions on the root pane. 186: * 187: * @param rp the root pane to install the keyboard actions to 188: */ 189: protected void installKeyboardActions(JRootPane rp) 190: { 191: // Install the keyboard actions. 192: ActionMapUIResource am = new ActionMapUIResource(); 193: am.put("press", new DefaultPressAction(rp)); 194: am.put("release", new DefaultReleaseAction(rp)); 195: SwingUtilities.replaceUIActionMap(rp, am); 196: 197: // Install the input map from the UIManager. It seems like the actual 198: // bindings are installed in the JRootPane only when the defaultButton 199: // property receives a value. So we also only install an empty 200: // input map here, and fill it in propertyChange. 201: ComponentInputMapUIResource im = new ComponentInputMapUIResource(rp); 202: SwingUtilities.replaceUIInputMap(rp, JComponent.WHEN_IN_FOCUSED_WINDOW, 203: im); 204: } 205: 206: public void propertyChange(PropertyChangeEvent event) 207: { 208: JRootPane source = (JRootPane) event.getSource(); 209: String propertyName = event.getPropertyName(); 210: if (propertyName.equals("defaultButton")) 211: { 212: Object newValue = event.getNewValue(); 213: InputMap im = 214: SwingUtilities.getUIInputMap(source, 215: JComponent.WHEN_IN_FOCUSED_WINDOW); 216: if (newValue != null) 217: { 218: Object[] keybindings = 219: (Object[]) UIManager.get 220: ("RootPane.defaultButtonWindowKeyBindings"); 221: LookAndFeel.loadKeyBindings(im, keybindings); 222: } 223: else 224: { 225: im.clear(); 226: } 227: } 228: } 229: 230: /** 231: * Uninstalls this UI from the root pane. This calls 232: * {@link #uninstallDefaults}, {@link #uninstallComponents}, 233: * {@link #uninstallListeners}, {@link #uninstallKeyboardActions} 234: * in this order. 235: * 236: * @param c the root pane to uninstall the UI from 237: */ 238: public void uninstallUI(JComponent c) 239: { 240: super.uninstallUI(c); 241: if (c instanceof JRootPane) 242: { 243: JRootPane rp = (JRootPane) c; 244: uninstallDefaults(rp); 245: uninstallComponents(rp); 246: uninstallListeners(rp); 247: uninstallKeyboardActions(rp); 248: } 249: } 250: 251: /** 252: * Uninstalls the look and feel defaults that have been installed in 253: * {@link #installDefaults}. 254: * 255: * @param rp the root pane to uninstall the defaults from 256: */ 257: protected void uninstallDefaults(JRootPane rp) 258: { 259: // We do nothing here. 260: } 261: 262: /** 263: * Uninstalls look and feel components from the root pane. 264: * 265: * @param rp the root pane to uninstall the components from 266: */ 267: protected void uninstallComponents(JRootPane rp) 268: { 269: // We do nothing here. 270: } 271: 272: /** 273: * Uninstalls any look and feel specific listeners from the root pane. 274: * 275: * @param rp the root pane to uninstall the listeners from 276: */ 277: protected void uninstallListeners(JRootPane rp) 278: { 279: rp.removePropertyChangeListener(this); 280: } 281: 282: /** 283: * Uninstalls look and feel keyboard actions from the root pane. 284: * 285: * @param rp the root pane to uninstall the keyboard actions from 286: */ 287: protected void uninstallKeyboardActions(JRootPane rp) 288: { 289: SwingUtilities.replaceUIActionMap(rp, null); 290: SwingUtilities.replaceUIInputMap(rp, JComponent.WHEN_IN_FOCUSED_WINDOW, 291: null); 292: } 293: }
GNU Classpath (0.91) |