001    /* ========================================================================
002     * JCommon : a free general purpose class library for the Java(tm) platform
003     * ========================================================================
004     *
005     * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
006     * 
007     * Project Info:  http://www.jfree.org/jcommon/index.html
008     *
009     * This library is free software; you can redistribute it and/or modify it 
010     * under the terms of the GNU Lesser General Public License as published by 
011     * the Free Software Foundation; either version 2.1 of the License, or 
012     * (at your option) any later version.
013     *
014     * This library is distributed in the hope that it will be useful, but 
015     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
016     * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
017     * License for more details.
018     *
019     * You should have received a copy of the GNU Lesser General Public
020     * License along with this library; if not, write to the Free Software
021     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
022     * USA.  
023     *
024     * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
025     * in the United States and other countries.]
026     * 
027     * -----------------
028     * ActionButton.java
029     * -----------------
030     * (C)opyright 2002-2004, by Thomas Morgner and Contributors.
031     *
032     * Original Author:  Thomas Morgner;
033     * Contributor(s):   David Gilbert (for Object Refinery Limited);
034     *
035     * $Id: ActionButton.java,v 1.5 2005/10/18 13:22:13 mungady Exp $
036     *
037     * ChangeLog
038     * ---------
039     * 30-Aug-2002 : Initial version
040     * 01-Sep-2002 : Documentation
041     * 10-Dec-2002 : Minor Javadoc updates (DG);
042     * 07-Jun-2004 : Corrected source headers (DG);
043     *
044     */
045    
046    package org.jfree.ui.action;
047    
048    import java.beans.PropertyChangeEvent;
049    import java.beans.PropertyChangeListener;
050    
051    import javax.swing.Action;
052    import javax.swing.Icon;
053    import javax.swing.JButton;
054    import javax.swing.KeyStroke;
055    
056    import org.jfree.util.Log;
057    
058    /**
059     * The ActionButton is used to connect an Action and its properties to a Button. This functionality
060     * is already implemented in JDK 1.3 but needed for JDK 1.2.2 compatibility.
061     *
062     * @author Thomas Morgner
063     */
064    public class ActionButton extends JButton {
065    
066        /**
067         * The action.
068         */
069        private Action action;
070    
071        /**
072         * The property change handler.
073         */
074        private ActionEnablePropertyChangeHandler propertyChangeHandler;
075    
076        /**
077         * Helperclass to handle the property change event raised by the action. Changed properties in
078         * the action will affect the button.
079         */
080        private class ActionEnablePropertyChangeHandler implements PropertyChangeListener {
081    
082            /**
083             * Default constructor.
084             */
085            public ActionEnablePropertyChangeHandler() {
086            }
087    
088            /**
089             * Receives notification of a property change event.
090             *
091             * @param event the property change event.
092             */
093            public void propertyChange(final PropertyChangeEvent event) {
094                try {
095                    if (event.getPropertyName().equals("enabled")) {
096                        setEnabled(getAction().isEnabled());
097                    }
098                    else if (event.getPropertyName().equals(Action.SMALL_ICON)) {
099                        setIcon((Icon) getAction().getValue(Action.SMALL_ICON));
100                    }
101                    else if (event.getPropertyName().equals(Action.NAME)) {
102                        setText((String) getAction().getValue
103                            (Action.NAME));
104                    }
105                    else if (event.getPropertyName().equals(Action.SHORT_DESCRIPTION)) {
106                        ActionButton.this.setToolTipText((String)
107                            getAction().getValue(Action.SHORT_DESCRIPTION));
108                    }
109    
110                    final Action ac = getAction();
111                    if (event.getPropertyName().equals(ActionDowngrade.ACCELERATOR_KEY)) {
112                        final KeyStroke oldVal = (KeyStroke) event.getOldValue();
113                        if (oldVal != null) {
114                            unregisterKeyboardAction
115                                (oldVal);
116                        }
117                        final Object o = ac.getValue(ActionDowngrade.ACCELERATOR_KEY);
118                        if (o instanceof KeyStroke) {
119                            final KeyStroke k = (KeyStroke) o;
120                            registerKeyboardAction(ac, k, WHEN_IN_FOCUSED_WINDOW);
121                        }
122                    }
123                    else if (event.getPropertyName().equals(ActionDowngrade.MNEMONIC_KEY)) {
124                        final Object o = ac.getValue(ActionDowngrade.MNEMONIC_KEY);
125                        if (o != null) {
126                            if (o instanceof Character) {
127                                final Character c = (Character) o;
128                                setMnemonic(c.charValue());
129                            }
130                            else if (o instanceof Integer) {
131                                final Integer c = (Integer) o;
132                                setMnemonic(c.intValue());
133                            }
134                        }
135                    }
136                }
137                catch (Exception e) {
138                    Log.warn("Error on PropertyChange in ActionButton: ", e);
139                }
140            }
141        }
142    
143        /**
144         * Creates a Button without any text and without an assigned Action.
145         */
146        public ActionButton() {
147            super();
148        }
149    
150        /**
151         * Creates a Button and set the given text as label.
152         *
153         * @param text the label for the new button.
154         */
155        public ActionButton(final String text) {
156            super(text);
157        }
158    
159        /**
160         * Creates an ActionButton and sets the given text and icon on the button.
161         *
162         * @param text the label for the new button.
163         * @param icon the icon for the button.
164         */
165        public ActionButton(final String text, final Icon icon) {
166            super(text, icon);
167        }
168    
169    
170        /**
171         * Creates an ActionButton and sets the given icon on the button.
172         *
173         * @param icon the icon for the button.
174         */
175        public ActionButton(final Icon icon) {
176            super(icon);
177        }
178    
179        /**
180         * Nreates an ActionButton and assigns the given action with the button.
181         *
182         * @param action the action.
183         */
184        public ActionButton(final Action action) {
185            setAction(action);
186        }
187    
188        /**
189         * Returns the assigned action or null if no action has been assigned.
190         *
191         * @return the action (possibly null).
192         */
193        public Action getAction() {
194            return this.action;
195        }
196    
197    
198        /**
199         * Returns and initializes the PropertyChangehandler for this ActionButton.
200         * The PropertyChangeHandler monitors the action and updates the button if necessary.
201         *
202         * @return the property change handler.
203         */
204        private ActionEnablePropertyChangeHandler getPropertyChangeHandler() {
205            if (this.propertyChangeHandler == null) {
206                this.propertyChangeHandler = new ActionEnablePropertyChangeHandler();
207            }
208            return this.propertyChangeHandler;
209        }
210    
211        /**
212         * Enables and disables this button and if an action is assigned to this button the
213         * propertychange is forwarded to the assigned action.
214         *
215         * @param b the new enable-state of this button
216         */
217        public void setEnabled(final boolean b) {
218            super.setEnabled(b);
219            if (getAction() != null) {
220                getAction().setEnabled(b);
221            }
222        }
223    
224        /**
225         * Assigns the given action to this button. The properties of the action will be assigned to
226         * the button. If an previous action was set, the old action is unregistered.
227         * <p/>
228         * <ul>
229         * <li>NAME - specifies the button text
230         * <li>SMALL_ICON - specifies the buttons icon
231         * <li>MNEMONIC_KEY - specifies the buttons mnemonic key
232         * <li>ACCELERATOR_KEY - specifies the buttons accelerator
233         * </ul>
234         *
235         * @param newAction the new action
236         */
237        public void setAction(final Action newAction) {
238            final Action oldAction = getAction();
239            if (oldAction != null) {
240                removeActionListener(oldAction);
241                oldAction.removePropertyChangeListener(getPropertyChangeHandler());
242    
243                final Object o = oldAction.getValue(ActionDowngrade.ACCELERATOR_KEY);
244                if (o instanceof KeyStroke) {
245                    final KeyStroke k = (KeyStroke) o;
246                    unregisterKeyboardAction(k);
247                }
248            }
249            this.action = newAction;
250            if (this.action != null) {
251                addActionListener(newAction);
252                newAction.addPropertyChangeListener(getPropertyChangeHandler());
253    
254                setText((String) (newAction.getValue(Action.NAME)));
255                setToolTipText((String) (newAction.getValue(Action.SHORT_DESCRIPTION)));
256                setIcon((Icon) newAction.getValue(Action.SMALL_ICON));
257                setEnabled(this.action.isEnabled());
258    
259                Object o = newAction.getValue(ActionDowngrade.MNEMONIC_KEY);
260                if (o != null) {
261                    if (o instanceof Character) {
262                        final Character c = (Character) o;
263                        setMnemonic(c.charValue());
264                    }
265                    else if (o instanceof Integer) {
266                        final Integer c = (Integer) o;
267                        setMnemonic(c.intValue());
268                    }
269                }
270                o = newAction.getValue(ActionDowngrade.ACCELERATOR_KEY);
271                if (o instanceof KeyStroke) {
272                    final KeyStroke k = (KeyStroke) o;
273                    registerKeyboardAction(newAction, k, WHEN_IN_FOCUSED_WINDOW);
274                }
275            }
276        }
277    }
278