    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