skrueger/geotools/MapPaneToolBar.java

/*******************************************************************************
 * Copyright (c) 2009 Martin O. J. Schmitz.
 * 
 * This file is part of the SCHMITZM library - a collection of utility 
 * classes based on Java 1.6, focusing (not only) on Java Swing 
 * and the Geotools library.
 * 
 * The SCHMITZM project is hosted at:
 * http://wald.intevation.org/projects/schmitzm/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License (license.txt)
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 * or try this link: http://www.gnu.org/licenses/lgpl.html
 * 
 * Contributors:
 *     Martin O. J. Schmitz - initial API and implementation
 *     Stefan A. Tzeggai - additional utility classes
 ******************************************************************************/
package skrueger.geotools;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

import javax.swing.AbstractAction;
import javax.swing.AbstractButton;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JToggleButton;
import javax.swing.JToolBar;

import org.apache.log4j.Logger;

import schmitzm.geotools.gui.GeotoolsGUIUtil;
import schmitzm.geotools.gui.SelectableXMapPane;
import schmitzm.geotools.gui.XMapPaneEvent;
import schmitzm.geotools.gui.XMapPaneTool;
import schmitzm.geotools.map.event.JMapPaneListener;
import schmitzm.geotools.map.event.MapAreaChangedEvent;
import schmitzm.swing.ButtonGroup;
import skrueger.swing.SmallButton;
import skrueger.swing.SmallToggleButton;

import com.vividsolutions.jts.geom.Envelope;

/**
 * A toolbar to control an {@link SelectableXMapPane} (Atlas visualization). This contains
 * two types of buttons. A group of <i>tools</i> for the mouse actions on the
 * map represented by {@link JToggleButton JToggleButtons}, where only one tool
 * can be activated every time. And some (general) <i>actions</i>, represented
 * by normal {@link JButton JButtons}.
 * 
 * @author <a href="mailto:[email protected]">Martin Schmitz</a>
 *         (University of Bonn/Germany)
 * @version 1.2 Stefan Tzeggai
 */
public class MapPaneToolBar extends JToolBar {
        private static final Logger LOGGER = Logger.getLogger(MapPaneToolBar.class
                        .getName());

        public static String R(String key, Object... values) {
                return GeotoolsGUIUtil.R(key, values);
        }

        /** Constant for the tool "Panning" (10). */
        public static final int TOOL_PAN = 10;
        /** Constant for the tool "Info" (20). */
        public static final int TOOL_INFO = 20;
        public static final int SEPERATOR0 = 99;

        /** Constant for the tool "Zoom In" (110). */
        public static final int TOOL_ZOOMIN = 110;
        public static final int ACTION_ZOOM_DEFAULT = 150;
        /** Constant for the tool "Zoom Out" (120). */
        public static final int TOOL_ZOOMOUT = 120;
        /** Constant for the action "Zoom back" (130). */
        public static final int ACTION_ZOOM_BACK = 130;
        /** Constant for the action "Zoom forward" (140). */
        public static final int ACTION_ZOOM_FORWARD = 140;
        public static final int SEPERATOR1 = 199;

        /**
         * Constant for the tool "Selection Reset" which clears the selection (240).
         */
        public static final int TOOL_SELECTION_CLEAR = 240;

        /**
         * Constant for the tool "Select" which sets the Selection to the selected
         * features (210).
         */
        public static final int TOOL_SELECTION_SET = 210;
        /**
         * Constant for the tool "Selection add" which adds the features to the
         * Selection (220).
         */
        public static final int TOOL_SELECTION_ADD = 220;
        /**
         * Constant for the tool "Selection subtract" which removes the selected
         * features from the selection (230).
         */
        public static final int TOOL_SELECTION_REMOVE = 230;

        public static final int ACTION_CHARTS = 401;

        /** Tool currently selected */
        protected int selectedTool = TOOL_ZOOMIN;

        /** Holds the tool buttons of the tool bar. */
        final protected SortedMap<Integer, JComponent> toolAndActionButtons = new TreeMap<Integer, JComponent>();
        /** Controls that only one tool button is activated. */
        protected ButtonGroup toolButtonGroup = null;

        // SK: Musste ich ändern damit man Tools und Actions in der Reihenfolge
        // mischen kann.
        // /** Holds the action buttons of the bar. */
        // protected SortedMap<Integer, JButton> actionButtons = null;

        /** Holds the {@link SelectableXMapPane} this tool bar controls. */
        protected SelectableXMapPane mapPane = null;

        /**
         * A List to remember the last Envelopes that have been watched. Used for
         * the zoomBack- and zoomForwardButtons *
         */
        protected ArrayList<Envelope> lastZooms = new ArrayList<Envelope>();
        /** Holds the index to the current element in {@link #lastZooms}. */
        protected int zoomBackIndex = 0;

        /** Listener to sniff the zoom actions on the map. */
        protected JMapPaneListener mapPaneListener = null;

        protected boolean zoomBackForwardButtonInAction;

        /** Listeners what want to be informed about a change of the selected tool **/
        protected Set<MapPaneToolSelectedListener> toolSelectionListeners = new HashSet<MapPaneToolSelectedListener>();

        /** This listener is added to all {@link JToggleButton} **/
        private final ActionListener toolSelectedListener = new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent e) {
                        JToggleButton tb = (JToggleButton) e.getSource();

                        // Inform the listeners about a newly selected tool
                        for (MapPaneToolSelectedListener l : toolSelectionListeners) {
                                l.toolSelected(Integer.valueOf(tb.getName()));
                        }
                }

        };

        /**
         * Creates a new toolbar. Notice: This toolbar does nothing until
         * {@link #setMapPane(SelectableXMapPane)} is called!
         */
        public MapPaneToolBar() {
                this(null);
        }

        public void addButtonSelectedListener(MapPaneToolSelectedListener listener) {
                toolSelectionListeners.add(listener);
        }

        public void removeButtonSelectedListener(
                        MapPaneToolSelectedListener listener) {
                toolSelectionListeners.remove(listener);
        }

        /**
         * Creates a new tool bar.
         * 
         * @param mapPane
         *            {@link SelectableXMapPane} the tool bar controls
         */
        public MapPaneToolBar(SelectableXMapPane mapPane) {
                super("Control the map", JToolBar.HORIZONTAL);

                // I want to see nothing on the background
                setOpaque(false);
                setBorder(null);

                this.toolButtonGroup = new ButtonGroup();

                // Create a Listener to listen to the zooms on the JMapPane
                this.mapPaneListener = new JMapPaneListener() {
                        public void performMapPaneEvent(XMapPaneEvent e) {
                                if (!(e instanceof MapAreaChangedEvent))
                                        return;

                                if (zoomBackForwardButtonInAction) {
                                        zoomBackForwardButtonInAction = false;
                                        return;
                                }

                                final MapAreaChangedEvent mapAreaChangedEvent = (MapAreaChangedEvent) e;
                                Envelope oldMapArea = mapAreaChangedEvent.getOldMapArea();

                                final Envelope mapArea = mapAreaChangedEvent.getNewMapArea();
                                if (mapArea == null || mapArea.equals(oldMapArea)
                                                || Double.isNaN(mapArea.getMinX())
                                                || Double.isNaN(mapArea.getMaxX())
                                                || Double.isNaN(mapArea.getMinY())
                                                || Double.isNaN(mapArea.getMaxY())) {
                                        // If the MapArea didn't change... we don't want to register
                                        // it as a zoom action.
                                        return;
                                }

                                if (lastZooms.size() == 0
                                                && oldMapArea != null
                                                && !oldMapArea.isNull()
                                                && !(Double.isNaN(oldMapArea.getMinX())
                                                                || Double.isNaN(oldMapArea.getMaxX())
                                                                || Double.isNaN(oldMapArea.getMinY()) || Double
                                                                .isNaN(oldMapArea.getMaxY()))) {
                                        lastZooms.add(oldMapArea);
                                        zoomBackIndex = 1;
                                }
                                if (mapArea == null)
                                        return;

                                if (lastZooms.size() > 0
                                                && mapArea.equals(lastZooms.get(lastZooms.size() - 1))) {
                                        // LOGGER.debug("MapAreaChangedEvent ausgelassen bei der Zaehlung der Zoomschritt weil identisch");
                                        return;
                                }

                                if (lastZooms.size() > 0)
                                        while (zoomBackIndex < lastZooms.size())
                                                lastZooms.remove(lastZooms.size() - 1);

                                lastZooms.add(mapArea);
                                zoomBackIndex = lastZooms.size();
                                setButtonEnabled(ACTION_ZOOM_BACK, lastZooms.size() > 1);
                                setButtonEnabled(ACTION_ZOOM_FORWARD, false);
                        }
                };

                setMapPane(mapPane);
                setFloatable(false);
                setRollover(true);

                init();
        }

        /**
         * Sets the {@link SelectableXMapPane} controlled by this tool bar.
         * 
         * @param mapPane
         *            {@link SelectableXMapPane} to control (if {@code null} this tool bar
         *            controls NOTHING!)
         */
        public void setMapPane(SelectableXMapPane mapPane) {
                // Remove listener from old MapPane
                if (this.mapPane != null)
                        this.mapPane.removeMapPaneListener(mapPaneListener);
                this.mapPane = mapPane;
                if (this.mapPane != null && mapPaneListener != null)
                        this.mapPane.addMapPaneListener(mapPaneListener);
        }

        /**
         * Calls {@link #initToolsAndActions()} and {@link #initActions()} and then
         * puts all tool buttons and all actions buttons to the tool bar.
         */
        protected void init() {

                initToolsAndActions();

                addSeparator(SEPERATOR0, new JToolBar.Separator());
                addSeparator(SEPERATOR1, new JToolBar.Separator());

                initToolBar();
        }

        /**
         * Creates the tool buttons and action buttons and seperators, adds them to
         * {@link #toolAndActionButtons} and finally creates a button group for all
         * tools. So sub-classes which override this method should FIRST add their
         * new tool buttons to {@link #toolAndActionButtons} before calling {@code
         * super.initTools()}.
         */
        protected void initToolsAndActions() {
                // Pan
                addTool(new MapPaneToolBarAction(TOOL_PAN, this, XMapPaneTool.PAN), false);
                
                // Info
                addTool(new MapPaneToolBarAction(TOOL_INFO, this, XMapPaneTool.INFO), false);

                // Zoom in
                addTool(new MapPaneToolBarAction(TOOL_ZOOMIN, this, XMapPaneTool.ZOOM_IN), false);
                
                // Zoom out
                addTool(new MapPaneToolBarAction(TOOL_ZOOMOUT, this, XMapPaneTool.ZOOM_OUT), false);
                
                // Action button to revert the last zoom
                addAction(new MapPaneToolBarAction(ACTION_ZOOM_BACK, this, "",
                                new ImageIcon(MapView.class
                                                .getResource("resource/icons/zoom_back.png")),
                                R("MapPaneButtons.LastZoom.TT")), false);
                setButtonEnabled(ACTION_ZOOM_BACK, false);

                // Action button to redo the last zoom
                addAction(new MapPaneToolBarAction(ACTION_ZOOM_FORWARD, this, "",
                                new ImageIcon(MapView.class
                                                .getResource("resource/icons/zoom_forward.png")),
                                R("MapPaneButtons.NextZoom.TT")), false);
                setButtonEnabled(ACTION_ZOOM_FORWARD, false);

                // set the selected tool enabled
                setSelectedTool(selectedTool);

        }

        @Override
        public void paint(Graphics g) {
                super.paint(g);
        }

        /**
         * Clears the GUI of all components and adds all tool and action buttons to
         * the tool bar.
         */
        public void initToolBar() {
                removeAll();

                // // Separator to the left of the tool actions to start
                // // the tool buttons with the map (not with the coordinate grid)
                // Dimension dimension = new Dimension(49, 10);
                // addSeparator(dimension);

                // Tool buttons
                for (Integer bKey : toolAndActionButtons.keySet()) {

                        JComponent b = toolAndActionButtons.get(bKey);

                        if (b instanceof JToggleButton) {
                                JToggleButton tb = (JToggleButton) b;
                                tb.setName(bKey.toString());
                                tb.addActionListener(toolSelectedListener);
                        }

                        add(b);
                }

                if (!toolAndActionButtons.containsKey(selectedTool)) {
                        /**
                         * This might be a bit specific, but IF selection buttons are
                         * available, select one of them.. if not, select the INFO tool.
                         */

                        if (toolAndActionButtons.containsKey(TOOL_SELECTION_SET)) {
                                setSelectedTool(TOOL_SELECTION_SET);
                        } else if (toolAndActionButtons.containsKey(TOOL_INFO)) {
                                setSelectedTool(TOOL_INFO);
                        } else {
                                // TODO What to do now?!
                                setSelectedTool(null);
                        }

                }

                revalidate();
                repaint();
        }

        /**
         * Performs the activation of a tool.
         * 
         * @param tool
         *            the tool to activate
         * @param e
         *            the event of the button
         */
        public void performToolButton(int tool, ActionEvent e) {
                if (mapPane == null)
                        return;

                selectedTool = tool;

                switch (tool) {
                case TOOL_PAN:
                        mapPane.setTool(XMapPaneTool.PAN);
                        break;
                case TOOL_INFO:
                        mapPane.setTool(XMapPaneTool.INFO);
                        break;
                case TOOL_ZOOMIN:
                        mapPane.setTool(XMapPaneTool.ZOOM_IN);
                        break;
                case TOOL_ZOOMOUT:
                        mapPane.setTool(XMapPaneTool.ZOOM_OUT);
                        break;
                }
        }

        /**
         * @param id
         *            The ID of the Component to remove. The change will not be
         *            visible until {@link #initToolBar()} is called.
         * @return <code>null</code> or the component that has been removed.
         */
        public JComponent removeId(int id) {
                return toolAndActionButtons.remove(id);
        }

        /**
         * Performs the action of an action button.
         * 
         * @param tool
         *            the action
         * @param e
         *            the event of the button
         */
        protected void performActionButton(int action, ActionEvent e) {
                if (mapPane == null)
                        return;
                
                // Perform the action "Zoom back": Revert the last zoom
                if (action == ACTION_ZOOM_BACK) {
                        if (zoomBackIndex <= 1)
                                return;

                        zoomBackForwardButtonInAction = true;
                        zoomBackIndex--;
                        getButton(ACTION_ZOOM_FORWARD).setEnabled(true);
                        getButton(ACTION_ZOOM_BACK).setEnabled(zoomBackIndex > 1);

                        mapPane.setMapArea(lastZooms.get(zoomBackIndex - 1));
                        mapPane.refresh();
                }

                // Perform the action "Zoom forward": Re-do the last zoom
                if (action == ACTION_ZOOM_FORWARD) {
                        if (zoomBackIndex < lastZooms.size()) {
                                zoomBackForwardButtonInAction = true;
                                zoomBackIndex++;
                                getButton(ACTION_ZOOM_BACK).setEnabled(true);
                                getButton(ACTION_ZOOM_FORWARD).setEnabled(
                                                zoomBackIndex < lastZooms.size());

                                mapPane.setMapArea(lastZooms.get(zoomBackIndex - 1));
                                mapPane.refresh();
                        }
                }
        }

        /**
         * Adds a tool to the tool bar. Does nothing if a tool or action with the
         * specified ID already exists!
         * 
         * @param buttonAction
         *            action for the toggle button
         * @param resetToolBar
         *            indicates whether the toolbar GUI is reset after adding the
         *            button (if adding several actions it useful only to reset the
         *            GUI for the last added tool)
         */
        public void addTool(MapPaneToolBarAction buttonAction, boolean resetToolBar) {
                if (isButtonIDUsed(buttonAction.getID())) {
                        LOGGER
                                        .warn("addTool(.) ignored because ID already used for tool or action: "
                                                        + buttonAction.getID());
                        return;
                }
                JToggleButton button = new SmallToggleButton(buttonAction);
                
                toolButtonGroup.add(button);
                toolAndActionButtons.put(buttonAction.getID(), button);
                if (resetToolBar)
                        initToolBar();
        }

        /**
         * Adds a tool to the tool bar and resets the toolbar GUI.
         * 
         * @param buttonAction
         *            action for the toggle button
         */
        public void addTool(MapPaneToolBarAction buttonAction) {
                addTool(buttonAction, true);
        }

        /**
         * Adds an action to the tool bar. Does nothing if a tool or action with the
         * specified ID already exists!
         * 
         * @param buttonAction
         *            action for the button
         * @param resetToolBar
         *            indicates whether the toolbar GUI is reset after adding the
         *            button (if adding several actions it useful only to reset the
         *            GUI for the last added tool)
         */
        public void addAction(MapPaneToolBarAction buttonAction,
                        boolean resetToolBar) {
                if (isButtonIDUsed(buttonAction.getID())) {
                        LOGGER
                                        .warn("addAction(.) ignored because ID already used for tool or action: "
                                                        + buttonAction.getID());
                        return;
                }
                JButton button = new SmallButton(buttonAction);
                toolAndActionButtons.put(buttonAction.getID(), button);
                if (resetToolBar)
                        initToolBar();
        }

        /**
         * Adds any JComponent to the tool bar. Does nothing if a tool or action
         * with the specified ID already exists!
         * 
         * @param component
         *            A {@link JComponent} that shall be added
         * @param id
         *            The ID associaded with the {@link JComponent}
         * @param resetToolBar
         *            indicates whether the toolbar GUI is reset after adding the
         *            button (if adding several actions it useful only to reset the
         *            GUI for the last added tool)
         */
        public void addJComponent(JComponent component, int id, boolean resetToolBar) {

                if (isButtonIDUsed(id)) {
                        LOGGER
                                        .warn("addAction(.) ignored because ID already used for tool or action: "
                                                        + id);
                        return;
                }

                toolAndActionButtons.put(id, component);
                if (resetToolBar)
                        initToolBar();
        }

        public void addSeparator(int id, Separator separator) {
                if (isButtonIDUsed(id)) {
                        LOGGER
                                        .warn("addSeparator(.) ignored because ID already used for tool or action. ");
                        return;
                }
                toolAndActionButtons.put(id, separator);
        }

        /**
         * Adds an action to the tool bar and resets the toolbar GUI.
         * 
         * @param buttonAction
         *            action for the toggle button
         */
        public void addAction(MapPaneToolBarAction buttonAction) {
                addAction(buttonAction, true);
        }

        /**
         * Returns the button for a specific tool or action.
         * 
         * @param id
         *            the constant for any button in the {@link MapPaneToolBar}
         * @return a {@link JButton} if {@code id} specifies an
         *         {@linkplain #getActionButton(int) action button} or
         *         {@link JToogleButton} if {@code id} specifies a
         *         {@linkplain #getToolButton(int) tool button}
         */
        public AbstractButton getButton(int id) {
                
                //ACHUTNG: Das ist ein SK QUICK FIX! TODO 
                if (!(toolAndActionButtons.get(id) instanceof AbstractButton)) return null;
                
                AbstractButton button = (AbstractButton) toolAndActionButtons.get(id);
                if (button == null)
                        LOGGER.warn("Unknown tool or action ID: " + id);
                return button;
        }

        /**
         * Returns the button for a specific tool.
         * 
         * @param tool
         *            the constant for a tool
         */
        public JToggleButton getToolButton(int tool) {
                AbstractButton button = getButton(tool);
                if (button != null && !(button instanceof JToggleButton)) {
                        LOGGER.warn("ID specifies no tool: " + tool);
                        button = null;
                }
                return (JToggleButton) button;
        }

        /**
         * Returns the button for a specific action.
         * 
         * @param action
         *            the constant an action
         */
        public JButton getActionButton(int action) {
                AbstractButton button = getButton(action);
                if (button != null && !(button instanceof JButton)) {
                        LOGGER.warn("ID specifies no action: " + action);
                        button = null;
                }
                return (JButton) button;

        }

        /**
         * Sets the selected tool.
         * 
         * @param tool
         *            ID of the tool
         */
        public void setSelectedTool(Integer tool) {
                if (tool == null)
                        toolButtonGroup.setUnselected();

                JToggleButton button = getToolButton(tool);
                if (button == null)
                        return;
                button.setSelected(true);
                button.getAction().actionPerformed(null);

                selectedTool = tool;
        }

        /**
         * Returns the selected tool.
         * 
         * @return -1 if no tool is active
         */
        public int getSelectedTool() {
                if (toolButtonGroup.getSelectedButton() == null)
                        return -1;
                return selectedTool;
        }
        
        /**
         * Sets whether a tool or action is activated or not. The visible property
         * of the button is not affected.
         * 
         * @param id
         *            tool or actionID
         * @param enabled
         *            if {@code true} the tool becomes available
         */
        public void setButtonEnabled(int id, boolean enabled) {
                AbstractButton button = getButton(id);
                if (button == null)
                        return;
                button.setEnabled(enabled);
        }

        /**
         * Sets whether a tool or action is activated or not.
         * 
         * @param id
         *            tool or actionID
         * @param enabled
         *            if {@code true} the tool becomes available
         * @param hideOnDisable
         *            if {@code true} the button is also hidden if {@code enabled}
         *            is {@code false}
         */
        public void setButtonEnabled(int id, boolean enabled, boolean hideOnDisable) {
                AbstractButton button = getButton(id);
                if (button == null)
                        return;
                button.setEnabled(enabled);
                // if button is enabled, it becomes visible anyway
                // if button is disabled and the "hide" option is set, it is also hidden
                if (enabled)
                        button.setVisible(true);
                else
                        button.setVisible(!hideOnDisable);
        }

        /**
         * Checks whether a ID is already used for a tool or action.
         * 
         * @param tool
         *            tool ID
         */
        public boolean isButtonIDUsed(int id) {
                return toolAndActionButtons.get(id) != null;
        }

        /**
         * Checks whether a tool is activated.
         * 
         * @param tool
         *            tool ID
         * @return {@code false} if an unknown ID is specified
         */
        public boolean isButtonEnabled(int id) {
                AbstractButton button = getButton(id);
                if (button != null)
                        return button.isEnabled();
                return false;
        }

        /**
         * Sets the activation for all tools.
         * 
         * @param enabled
         *            if {@code true} all tools becomes available
         * @param hideOnDisable
         *            if {@code true} the buttons are also hidden if {@code enabled}
         *            is {@code false}
         */
        public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {
                for (int id : toolAndActionButtons.keySet()) {
                        if (toolAndActionButtons.get(id) instanceof JToggleButton) {
                        setButtonEnabled(id, enabled, hideOnDisable);
                        }
                }
        }
        
        /**
         * Sets the activation for all actions.
         * 
         * @param enabled
         *            if {@code true} all actions becomes available
         * @param hideOnDisable
         *            if {@code true} the buttons are also hidden if {@code enabled}
         *            is {@code false}
         */
        public void setAllActionsEnabled(boolean enabled, boolean hideOnDisable) {
                for (int id : toolAndActionButtons.keySet()) {
                        if (toolAndActionButtons.get(id) instanceof JButton) {
                                setButtonEnabled(id, enabled, hideOnDisable);
                        }
                }

        }

        /**
         * Returns the maximum ID of tools.
         */
        public int getMaxToolID() {
                return toolAndActionButtons.lastKey();
        }

        /**
         * Returns the minimum ID of tools.
         */
        public int getMinToolID() {
                return toolAndActionButtons.firstKey();
        }

        /**
         * Extends the {@link AbstractAction} with maintaining an ID and the
         * {@link MapPaneToolBar} the actions controls. Additionally this class
         * automatically calls
         * {@link MapPaneToolBar#performToolButton(int, ActionEvent)} or
         * {@link MapPaneToolBar#performActionButton(int, ActionEvent)} depending on
         * whether the action is added via
         * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)} or
         * {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
         * 
         * @author <a href="mailto:[email protected]">Martin Schmitz</a>
         *         (University of Bonn/Germany)
         */
        public static class MapPaneToolBarAction extends AbstractAction {
                /** The ID of the action */
                protected int id = -1;
                /** The tool bar, this action is made for. */
                protected MapPaneToolBar toolBar = null;

                /**
                 * Creates a new action with a dummy description and no icon.
                 * 
                 * @param id
                 *            unique ID for the action
                 * @param toolBar
                 *            toolbar this action is made for
                 */
                public MapPaneToolBarAction(int id, MapPaneToolBar toolBar) {
                        this(id, toolBar, "" + id);
                }

                /**
                 * Creates a new action without an icon.
                 * 
                 * @param id
                 *            unique ID for the action
                 * @param toolBar
                 *            toolbar this action is made for
                 * @param name
                 *            description used for buttons or menus
                 */
                public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name) {
                        this(id, toolBar, name, null);
                }

                /**
                 * Creates a new action.
                 * 
                 * @param id
                 *            unique ID for the action
                 * @param toolBar
                 *            toolbar this action is made for
                 * @param name
                 *            description used for buttons or menus
                 * @param icon
                 *            icon used for buttons or menus
                 */
                public MapPaneToolBarAction(int id, MapPaneToolBar toolBar,
                                String name, Icon icon) {
                        this(id, toolBar, name, icon, null);
                }

                /**
                 * Creates a new action.
                 * 
                 * @param id
                 *            unique ID for the action
                 * @param toolBar
                 *            The {@link MapPaneToolBar} this action is made for
                 * @param name
                 *            description used for buttons or menus
                 * @param icon
                 *            icon used for buttons or menus
                 * @param toolTip
                 *            Tooltip to use for the button or menu
                 */
                public MapPaneToolBarAction(int id, MapPaneToolBar toolBar,
                                String name, Icon icon, String toolTip) {
                        super(name, icon);

                        if (toolTip != null && !toolTip.trim().isEmpty()) {
                                putValue(Action.SHORT_DESCRIPTION, toolTip);
                        }

                        this.id = id;
                        this.toolBar = toolBar;
                }

                public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, XMapPaneTool tool) {
                        this(id, toolBar, "", tool.getIcon(), tool.getToolTip());
                }

                /**
                 * Calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)} or
                 * {@link MapPaneToolBar#performActionButton(int, ActionEvent)}
                 * depending on whether the action is added to the toolbar via
                 * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)} or
                 * {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
                 */
                public void actionPerformed(ActionEvent e) {
                        if (toolBar.toolAndActionButtons.get(id) instanceof JToggleButton)
                                toolBar.performToolButton(id, e);
                        else if (toolBar.toolAndActionButtons.get(id) instanceof JButton)
                                toolBar.performActionButton(id, e);
                }

                /**
                 * Returns the (unique) id of this action.
                 * 
                 * @return
                 */
                public int getID() {
                        return id;
                }
        }

        /**
         * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot gemacht
         * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
         * 
         * @author <a href="mailto:[email protected]">Stefan Alfons
         *         Tzeggai</a>
         */
        @Override
        public void print(Graphics g) {
                Color orig = getBackground();
                setBackground(Color.WHITE);
                // wrap in try/finally so that we always restore the state
                try {
                        super.print(g);
                } finally {
                        setBackground(orig);
                }
        }

}