/[schmitzm]/trunk/src/skrueger/geotools/MapPaneToolBar.java
ViewVC logotype

Diff of /trunk/src/skrueger/geotools/MapPaneToolBar.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/src/skrueger/geotools/MapPaneToolBar.java revision 111 by alfonx, Tue May 12 23:33:14 2009 UTC branches/2.0-RC2/src/skrueger/geotools/MapPaneToolBar.java revision 621 by alfonx, Thu Jan 28 10:06:05 2010 UTC
# Line 1  Line 1 
1  package skrueger.geotools;  /*******************************************************************************
2     * Copyright (c) 2009 Martin O. J. Schmitz.
3  import java.awt.Dimension;   *
4  import java.awt.event.ActionEvent;   * This file is part of the SCHMITZM library - a collection of utility
5  import java.util.ArrayList;   * classes based on Java 1.6, focusing (not only) on Java Swing
6  import java.util.SortedMap;   * and the Geotools library.
7  import java.util.TreeMap;   *
8     * The SCHMITZM project is hosted at:
9  import javax.swing.AbstractAction;   * http://wald.intevation.org/projects/schmitzm/
10  import javax.swing.AbstractButton;   *
11  import javax.swing.BorderFactory;   * This program is free software; you can redistribute it and/or
12  import javax.swing.Icon;   * modify it under the terms of the GNU Lesser General Public License
13  import javax.swing.ImageIcon;   * as published by the Free Software Foundation; either version 3
14  import javax.swing.JButton;   * of the License, or (at your option) any later version.
15  import javax.swing.JComponent;   *
16  import javax.swing.JToggleButton;   * This program is distributed in the hope that it will be useful,
17  import javax.swing.JToolBar;   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  import javax.swing.JToolBar.Separator;   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19     * GNU General Public License for more details.
20  import jj2000.j2k.NotImplementedError;   *
21     * You should have received a copy of the GNU Lesser General Public License (license.txt)
22  import org.apache.log4j.Logger;   * along with this program; if not, write to the Free Software
23     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24  import schmitzm.geotools.gui.JMapPane;   * or try this link: http://www.gnu.org/licenses/lgpl.html
25  import schmitzm.geotools.map.event.JMapPaneEvent;   *
26  import schmitzm.geotools.map.event.JMapPaneListener;   * Contributors:
27  import schmitzm.geotools.map.event.MapAreaChangedEvent;   *     Martin O. J. Schmitz - initial API and implementation
28  import schmitzm.swing.ButtonGroup;   *     Stefan A. Krüger - additional utility classes
29  import schmitzm.swing.SwingUtil;   ******************************************************************************/
30    package skrueger.geotools;
31  import com.vividsolutions.jts.geom.Envelope;  
32    import java.awt.Color;
33  /**  import java.awt.Graphics;
34   * A toolbar to control an {@link JMapPane} (Atlas visualization). This contains two types  import java.awt.event.ActionEvent;
35   * of buttons. A group of <i>tools</i> for the mouse actions on the map represented  import java.awt.event.ActionListener;
36   * by {@link JToggleButton JToggleButtons}, where only one tool can be activated  import java.util.ArrayList;
37   * every time. And some (general) <i>actions</i>, represented by normal  import java.util.HashSet;
38   * {@link JButton JButtons}.  import java.util.Locale;
39   * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)  import java.util.Set;
40   * @version 1.2 Stefan Krüger  import java.util.SortedMap;
41   */  import java.util.TreeMap;
42  public class MapPaneToolBar extends JToolBar {  
43          private static final Logger LOGGER = Logger.getLogger(MapPaneToolBar.class.getName());  import javax.swing.AbstractAction;
44          /** Constant for the tool "Panning" (10). */  import javax.swing.AbstractButton;
45          public static final int TOOL_PAN = 10;  import javax.swing.Action;
46          /** Constant for the tool "Info" (20). */  import javax.swing.Icon;
47          public static final int TOOL_INFO = 20;  import javax.swing.ImageIcon;
48          public static final int SEPERATOR0 = 99;  import javax.swing.JButton;
49            import javax.swing.JComponent;
50          /** Constant for the tool "Zoom In" (110). */  import javax.swing.JToggleButton;
51          public static final int TOOL_ZOOMIN = 110;  import javax.swing.JToolBar;
52          /** Constant for the tool "Zoom Out" (120). */  
53          public static final int TOOL_ZOOMOUT = 120;  import org.apache.log4j.Logger;
54          /** Constant for the action "Zoom back" (130). */  
55          public static final int ACTION_ZOOM_BACK = 130;  import schmitzm.geotools.gui.SelectableXMapPane;
56          /** Constant for the action "Zoom forward" (140). */  import schmitzm.geotools.map.event.JMapPaneListener;
57          public static final int ACTION_ZOOM_FORWARD = 140;  import schmitzm.geotools.map.event.MapAreaChangedEvent;
58          public static final int SEPERATOR1 = 199;  import schmitzm.geotools.map.event.MapPaneEvent;
59            import schmitzm.lang.LangUtil;
60          /** Constant for the tool "Select" which sets the Selection to the selected features (210). */  import schmitzm.lang.ResourceProvider;
61          public static final int TOOL_SELECTION_SET = 210;  import schmitzm.swing.ButtonGroup;
62          /** Constant for the tool "Selection add" which adds the features to the Selection (220). */  import skrueger.swing.SmallButton;
63          public static final int TOOL_SELECTION_ADD = 220;  import skrueger.swing.SmallToggleButton;
64          /** Constant for the tool "Selection subtract" which removes the selected features from the selection (230). */  
65          public static final int TOOL_SELECTION_REMOVE = 230;  import com.vividsolutions.jts.geom.Envelope;
66          /** Constant for the tool "Selection Reset" which clears the selection (240). */  
67          public static final int TOOL_SELECTION_CLEAR = 240;  /**
68          public static final int SEPERATOR2 = 299;   * A toolbar to control an {@link SelectableXMapPane} (Atlas visualization). This contains
69     * two types of buttons. A group of <i>tools</i> for the mouse actions on the
70          /** Constant for the action "Search Labels" (120). */   * map represented by {@link JToggleButton JToggleButtons}, where only one tool
71          public static final int ACTION_SEARCH = 300;   * can be activated every time. And some (general) <i>actions</i>, represented
72     * by normal {@link JButton JButtons}.
73          /** Tool currently selected */   *
74      protected int selectedTool = TOOL_ZOOMIN;   * @author <a href="mailto:[email protected]">Martin Schmitz</a>
75         *         (University of Bonn/Germany)
76      /** Holds the tool buttons of the tool bar. */   * @version 1.2 Stefan Krüger
77      protected SortedMap<Integer, JComponent> toolAndActionButtons = null;   */
78      /** Controls that only one tool button is activated. */  public class MapPaneToolBar extends JToolBar {
79      protected ButtonGroup toolButtonGroup = null;          private static final Logger LOGGER = Logger.getLogger(MapPaneToolBar.class
80                            .getName());
81  // SK: Musste ich ändern damit man Tools und Actions in der Reihenfolge mischen kann.      
82  //    /** Holds the action buttons of the bar. */          public static ResourceProvider RESOURCE = new ResourceProvider(LangUtil
83  //    protected SortedMap<Integer, JButton> actionButtons = null;                          .extendPackagePath(MapPaneToolBar.class,
84                                            "resource.locales.mapPaneToolbar"), Locale.ENGLISH);
85          /** Holds the {@link JMapPane} this tool bar controls. */  
86          protected JMapPane mapPane = null;          public static String R(String key, Object... values) {
87                    return RESOURCE.getString(key, values);
88          /**          }
89           * A List to remember the last Envelopes that have been watched. Used for  
90           * the zoomBack- and zoomForwardButtons *          /** Constant for the tool "Panning" (10). */
91           */          public static final int TOOL_PAN = 10;
92          protected ArrayList<Envelope> lastZooms = new ArrayList<Envelope>();          /** Constant for the tool "Info" (20). */
93          /** Holds the index to the current element in {@link #lastZooms}. */          public static final int TOOL_INFO = 20;
94          protected int zoomBackIndex = 0;          public static final int SEPERATOR0 = 99;
95    
96          /** Listener to sniff the zoom actions on the map. */          /** Constant for the tool "Zoom In" (110). */
97          protected JMapPaneListener mapPaneListener = null;          public static final int TOOL_ZOOMIN = 110;
98                    /** Constant for the tool "Zoom Out" (120). */
99          protected boolean zoomBackForwardButtonInAction;          public static final int TOOL_ZOOMOUT = 120;
100            /** Constant for the action "Zoom back" (130). */
101      /**          public static final int ACTION_ZOOM_BACK = 130;
102       * Creates a new toolbar. Notice: This toolbar does nothing          /** Constant for the action "Zoom forward" (140). */
103       * until {@link #setMapPane(JMapPane)} is called!          public static final int ACTION_ZOOM_FORWARD = 140;
104       */          public static final int SEPERATOR1 = 199;
105      public MapPaneToolBar() {  
106        this(null);          /**
107      }           * Constant for the tool "Selection Reset" which clears the selection (240).
108                 */
109      /**          public static final int TOOL_SELECTION_CLEAR = 240;
110           * Creates a new tool bar.  
111           * @param mapPane {@link JMapPane} the tool bar controls          /**
112           */           * Constant for the tool "Select" which sets the Selection to the selected
113          public MapPaneToolBar(JMapPane mapPane) {           * features (210).
114            super("Control the map", JToolBar.HORIZONTAL);           */
115        this.toolAndActionButtons  = new TreeMap<Integer,JComponent>();          public static final int TOOL_SELECTION_SET = 210;
116        this.toolButtonGroup = new ButtonGroup();          /**
117        // Create a Listener to sniff the zooms on the JMapPane           * Constant for the tool "Selection add" which adds the features to the
118        this.mapPaneListener = new JMapPaneListener() {           * Selection (220).
119            public void performMapPaneEvent(JMapPaneEvent e) {           */
120                if ( !(e instanceof MapAreaChangedEvent) )          public static final int TOOL_SELECTION_ADD = 220;
121                  return;          /**
122                             * Constant for the tool "Selection subtract" which removes the selected
123                if ( zoomBackForwardButtonInAction ) {           * features from the selection (230).
124                  zoomBackForwardButtonInAction = false;           */
125                  return;          public static final int TOOL_SELECTION_REMOVE = 230;
126                }  
127                        public static final int ACTION_CHARTS = 401;
128                Envelope oldMapArea = ((MapAreaChangedEvent)e).getOldMapArea();  
129                if (lastZooms.size() == 0 && oldMapArea != null ) {          /** Tool currently selected */
130                  lastZooms.add(oldMapArea);          protected int selectedTool = TOOL_ZOOMIN;
131                  zoomBackIndex = 1;  
132                }          /** Holds the tool buttons of the tool bar. */
133            final protected SortedMap<Integer, JComponent> toolAndActionButtons = new TreeMap<Integer, JComponent>();
134                final Envelope mapArea = ((MapAreaChangedEvent)e).getNewMapArea();          /** Controls that only one tool button is activated. */
135                if (mapArea == null)          protected ButtonGroup toolButtonGroup = null;
136                  return;  
137                          // SK: Musste ich ändern damit man Tools und Actions in der Reihenfolge
138                if (lastZooms.size() > 0 && mapArea.equals(lastZooms.get(lastZooms.size() - 1))) {          // mischen kann.
139                  // LOGGER.debug("MapAreaChangedEvent ausgelassen bei der Zaehlung der Zoomschritt weil identisch");          // /** Holds the action buttons of the bar. */
140                  return;          // protected SortedMap<Integer, JButton> actionButtons = null;
141                }  
142            /** Holds the {@link SelectableXMapPane} this tool bar controls. */
143                if (lastZooms.size() > 0)          protected SelectableXMapPane mapPane = null;
144                  while (zoomBackIndex < lastZooms.size())  
145                    lastZooms.remove(lastZooms.size() - 1);          /**
146             * A List to remember the last Envelopes that have been watched. Used for
147                lastZooms.add(mapArea);           * the zoomBack- and zoomForwardButtons *
148                zoomBackIndex = lastZooms.size();           */
149                setButtonEnabled(ACTION_ZOOM_BACK, lastZooms.size() > 1);          protected ArrayList<Envelope> lastZooms = new ArrayList<Envelope>();
150                setButtonEnabled(ACTION_ZOOM_FORWARD, false);          /** Holds the index to the current element in {@link #lastZooms}. */
151            }          protected int zoomBackIndex = 0;
152        };      
153                /** Listener to sniff the zoom actions on the map. */
154        setMapPane(mapPane);          protected JMapPaneListener mapPaneListener = null;
155            setFloatable(false);  
156            setRollover(true);          protected boolean zoomBackForwardButtonInAction;
157              
158            init();          /** Listeners what want to be informed about a change of the selected tool **/
159          }          protected Set<MapPaneToolSelectedListener> toolSelectionListeners = new HashSet<MapPaneToolSelectedListener>();
160            
161          /**          /** This listener is added to all {@link JToggleButton} **/
162           * Sets the {@link JMapPane} controlled by this tool bar.          private final ActionListener toolSelectedListener = new ActionListener() {
163           * @param mapPane {@link JMapPane} to control (if {@code null} this  
164           *                tool bar controls NOTHING!)                  @Override
165           */                  public void actionPerformed(ActionEvent e) {
166          public void setMapPane(JMapPane mapPane) {                          JToggleButton tb = (JToggleButton) e.getSource();
167            // Remove listener from old MapPane  
168            if ( this.mapPane != null )                          // Inform the listeners about a newly selected tool
169              this.mapPane.removeMapPaneListener( mapPaneListener );                          for (MapPaneToolSelectedListener l : toolSelectionListeners) {
170        this.mapPane = mapPane;                                  l.toolSelected(Integer.valueOf(tb.getName()));
171        if ( this.mapPane != null && mapPaneListener != null )                          }
172          this.mapPane.addMapPaneListener( mapPaneListener );                  }
173          }  
174                    };
175          /**  
176           * Calls {@link #initToolsAndActions()} and {@link #initActions()} and then puts          /**
177           * all tool buttons and all actions buttons to the tool bar.           * Creates a new toolbar. Notice: This toolbar does nothing until
178           */           * {@link #setMapPane(SelectableXMapPane)} is called!
179          protected void init() {           */
180            initToolsAndActions();          public MapPaneToolBar() {
181                          this(null);
182            addSeparator(SEPERATOR0, new JToolBar.Separator());          }
183        addSeparator(SEPERATOR1, new JToolBar.Separator());  
184        addSeparator(SEPERATOR2, new JToolBar.Separator());          public void addButtonSelectedListener(MapPaneToolSelectedListener listener) {
185                          toolSelectionListeners.add(listener);
186            initToolBar();          }
187          }  
188            public void removeButtonSelectedListener(
189                            MapPaneToolSelectedListener listener) {
190          /**                  toolSelectionListeners.remove(listener);
191           * Creates the tool buttons and action buttons and seperators, adds them to          }
192           * {@link #toolAndActionButtons} and finally creates a button group for all tools.  
193           * So sub-classes which override this method should FIRST add their new tool          /**
194           * buttons to {@link #toolAndActionButtons} before calling {@code super.initTools()}.           * Creates a new tool bar.
195           */           *
196          protected void initToolsAndActions() {           * @param mapPane
197        // Panning           *            {@link SelectableXMapPane} the tool bar controls
198        addTool( new MapPaneToolBarAction(           */
199            TOOL_PAN,          public MapPaneToolBar(SelectableXMapPane mapPane) {
200            this,                  super("Control the map", JToolBar.HORIZONTAL);
201            "",  
202            new ImageIcon(MapView.class.getResource("resource/icons/pan.png"))                  // I want to see nothing on the background
203        ), false );                  setOpaque(false);
204        // Info                  setBorder(null);
205        addTool( new MapPaneToolBarAction(  
206            TOOL_INFO,                  this.toolButtonGroup = new ButtonGroup();
207            this,  
208            "",                  // Create a Listener to listen to the zooms on the JMapPane
209            new ImageIcon(MapView.class.getResource("resource/icons/info.png"))                  this.mapPaneListener = new JMapPaneListener() {
210        ), false );                          public void performMapPaneEvent(MapPaneEvent e) {
211                                          if (!(e instanceof MapAreaChangedEvent))
212        // Set Selection                                          return;
213        addTool( new MapPaneToolBarAction(  
214            TOOL_SELECTION_SET,                                  if (zoomBackForwardButtonInAction) {
215            this,                                          zoomBackForwardButtonInAction = false;
216            "",                                          return;
217            new ImageIcon(MapView.class.getResource("resource/icons/selection_set.png"))                                  }
218        ), false );  
219                                    final MapAreaChangedEvent mapAreaChangedEvent = (MapAreaChangedEvent) e;
220        // Add Selection                                  Envelope oldMapArea = mapAreaChangedEvent.getOldMapArea();
221        addTool( new MapPaneToolBarAction(  
222                    TOOL_SELECTION_ADD,                                  final Envelope mapArea = mapAreaChangedEvent.getNewMapArea();
223                    this,                                  if (mapArea == null || mapArea.equals(oldMapArea)
224                    "",                                                  || Double.isNaN(mapArea.getMinX())
225                    new ImageIcon(MapView.class.getResource("resource/icons/selection_add.png"))                                                  || Double.isNaN(mapArea.getMaxX())
226        ), false );                                                  || Double.isNaN(mapArea.getMinY())
227                                                    || Double.isNaN(mapArea.getMaxY())) {
228        // Remove Selection                                          // If the MapArea didn't change... we don't want to register
229        addTool( new MapPaneToolBarAction(                                          // it as a zoom action.
230                    TOOL_SELECTION_REMOVE,                                          return;
231                    this,                                  }
232                    "",  
233                    new ImageIcon(MapView.class.getResource("resource/icons/selection_remove.png"))                                  if (lastZooms.size() == 0
234        ), false );                                                  && oldMapArea != null
235                                                          && !oldMapArea.isNull()
236        // ResetSelection                                                  && !(Double.isNaN(oldMapArea.getMinX())
237        addAction( new MapPaneToolBarAction(                                                                  || Double.isNaN(oldMapArea.getMaxX())
238                    TOOL_SELECTION_CLEAR,                                                                  || Double.isNaN(oldMapArea.getMinY()) || Double
239                    this,                                                                  .isNaN(oldMapArea.getMaxY()))) {
240                    "",                                          lastZooms.add(oldMapArea);
241                    new ImageIcon(MapView.class.getResource("resource/icons/selection_clear.png"))                                          zoomBackIndex = 1;
242        ), false );                                  }
243                                          if (mapArea == null)
244        // Zoom in                                          return;
245        addTool( new MapPaneToolBarAction(  
246            TOOL_ZOOMIN,                                  if (lastZooms.size() > 0
247            this,                                                  && mapArea.equals(lastZooms.get(lastZooms.size() - 1))) {
248            "",                                          // LOGGER.debug("MapAreaChangedEvent ausgelassen bei der Zaehlung der Zoomschritt weil identisch");
249            new ImageIcon(MapView.class.getResource("resource/icons/zoom_in.png"))                                          return;
250        ), false );                                  }
251        // Zoom out  
252        addTool( new MapPaneToolBarAction(                                  if (lastZooms.size() > 0)
253            TOOL_ZOOMOUT,                                          while (zoomBackIndex < lastZooms.size())
254            this,                                                  lastZooms.remove(lastZooms.size() - 1);
255            "",  
256            new ImageIcon(MapView.class.getResource("resource/icons/zoom_out.png"))                                  lastZooms.add(mapArea);
257        ), false );                                  zoomBackIndex = lastZooms.size();
258                                          setButtonEnabled(ACTION_ZOOM_BACK, lastZooms.size() > 1);
259        // Action button to revert the last zoom                                  setButtonEnabled(ACTION_ZOOM_FORWARD, false);
260        addAction( new MapPaneToolBarAction(                          }
261            ACTION_ZOOM_BACK,                  };
262            this,  
263            "",                  setMapPane(mapPane);
264            new ImageIcon(MapView.class.getResource("resource/icons/zoom_back.png"))                  setFloatable(false);
265        ), false);                  setRollover(true);
266        setButtonEnabled( ACTION_ZOOM_BACK, false );  
267                    init();
268        // Action button to redo the last zoom          }
269        addAction( new MapPaneToolBarAction(  
270            ACTION_ZOOM_FORWARD,          /**
271            this,           * Sets the {@link SelectableXMapPane} controlled by this tool bar.
272            "",           *
273            new ImageIcon(MapView.class.getResource("resource/icons/zoom_forward.png"))           * @param mapPane
274        ), false);           *            {@link SelectableXMapPane} to control (if {@code null} this tool bar
275        setButtonEnabled( ACTION_ZOOM_FORWARD, false );           *            controls NOTHING!)
276                   */
277                  public void setMapPane(SelectableXMapPane mapPane) {
278            // set the selected tool enabled                  // Remove listener from old MapPane
279        setSelectedTool(selectedTool);                  if (this.mapPane != null)
280                                  this.mapPane.removeMapPaneListener(mapPaneListener);
281          }                  this.mapPane = mapPane;
282                    if (this.mapPane != null && mapPaneListener != null)
283                            this.mapPane.addMapPaneListener(mapPaneListener);
284          /**          }
285       * Clears the GUI of all components and adds all tool and action buttons to the  
286       * tool bar.          /**
287       */           * Calls {@link #initToolsAndActions()} and {@link #initActions()} and then
288      protected void initToolBar() {           * puts all tool buttons and all actions buttons to the tool bar.
289        setAlignmentY( 1f );           */
290        removeAll();          protected void init() {
291        // Separator to the left of the tool actions to start  
292        // the tool buttons with the map (not with the coordinate grid)                  initToolsAndActions();
293        Dimension dimension = new Dimension( 49,10);  
294        addSeparator(dimension);                  addSeparator(SEPERATOR0, new JToolBar.Separator());
295        // Tool buttons                  addSeparator(SEPERATOR1, new JToolBar.Separator());
296        for (JComponent b : toolAndActionButtons.values())  
297          add(b);                  initToolBar();
298      }          }
299        // Space between tool buttons and action buttons  
300  // SK: Seperators are now als manages like actions and tools                /**
301  //      Dimension dimension2 = new Dimension( 10,10);           * Creates the tool buttons and action buttons and seperators, adds them to
302  //      this.addSeparator(dimension2);           * {@link #toolAndActionButtons} and finally creates a button group for all
303                   * tools. So sub-classes which override this method should FIRST add their
304  //      // Action buttons           * new tool buttons to {@link #toolAndActionButtons} before calling {@code
305  //      for (JButton b : actionButtons.values())           * super.initTools()}.
306  //        add(b);           */
307  //    }          protected void initToolsAndActions() {
308                        // Panning
309          /**                  addTool(new MapPaneToolBarAction(TOOL_PAN, this, "", new ImageIcon(
310           * Performs the activation of a tool.                                  MapView.class.getResource("resource/icons/pan.png")),
311           * @param tool the tool to activate                                  R("MapPaneButtons.Pan.TT")), false);
312           * @param e    the event of the button                  // Info
313           */                  addTool(new MapPaneToolBarAction(TOOL_INFO, this, "", new ImageIcon(
314          public void performToolButton(int tool, ActionEvent e) {                                  MapView.class.getResource("resource/icons/info.png")),
315            if ( mapPane == null )                                  R("MapPaneButtons.Info.TT")), false);
316              return;  
317                              // Zoom in
318            selectedTool = tool;                  addTool(new MapPaneToolBarAction(TOOL_ZOOMIN, this, "", new ImageIcon(
319                                              MapView.class.getResource("resource/icons/zoom_in.png")),
320        switch( tool ) {                                  R("MapPaneButtons.ZoomIn.TT")), false);
321          case TOOL_PAN:                  // Zoom out
322            // Set the mouse tool to "Panning"                  addTool(new MapPaneToolBarAction(TOOL_ZOOMOUT, this, "", new ImageIcon(
323            mapPane.setWindowSelectionState(JMapPane.NONE);                                  MapView.class.getResource("resource/icons/zoom_out.png")),
324            mapPane.setState(JMapPane.PAN);                                  R("MapPaneButtons.ZoomOut.TT")), false);
325            mapPane.setHighlight(false);  
326            mapPane.setNormalCursor(SwingUtil.PAN_CURSOR);                  // Action button to revert the last zoom
327            break;                  addAction(new MapPaneToolBarAction(ACTION_ZOOM_BACK, this, "",
328          case TOOL_INFO:                                  new ImageIcon(MapView.class
329            // Set the mouse tool to "Info"                                                  .getResource("resource/icons/zoom_back.png")),
330            mapPane.setWindowSelectionState(JMapPane.NONE);                                  R("MapPaneButtons.LastZoom.TT")), false);
331            mapPane.setState(JMapPane.SELECT_TOP); // Why not: JMapPane.SELECT_TOP_ONEONLY                  setButtonEnabled(ACTION_ZOOM_BACK, false);
332            mapPane.setHighlight(false);// SK: Was true, but since it not works properly removed it to save performance  
333            mapPane.setNormalCursor(SwingUtil.CROSSHAIR_CURSOR);                  // Action button to redo the last zoom
334            break;                  addAction(new MapPaneToolBarAction(ACTION_ZOOM_FORWARD, this, "",
335          case TOOL_SELECTION_SET:                                  new ImageIcon(MapView.class
336          case TOOL_SELECTION_ADD:                                                  .getResource("resource/icons/zoom_forward.png")),
337          case TOOL_SELECTION_REMOVE:                                  R("MapPaneButtons.NextZoom.TT")), false);
338                  // Set the mouse tool to "Select"                  setButtonEnabled(ACTION_ZOOM_FORWARD, false);
339                  mapPane.setWindowSelectionState(JMapPane.SELECT_TOP);  
340                  mapPane.setState(JMapPane.SELECT_TOP);                  // set the selected tool enabled
341                  mapPane.setHighlight(false);                  setSelectedTool(selectedTool);
342                  mapPane.setNormalCursor(SwingUtil.CROSSHAIR_CURSOR); // TODO Select Cursor  
343                  break;          }
344          case TOOL_ZOOMIN:  
345            // Set the mouse tool to "Zoom in"          @Override
346            mapPane.setWindowSelectionState(JMapPane.ZOOM_IN);          public void paint(Graphics g) {
347            mapPane.setState(JMapPane.ZOOM_IN);                  super.paint(g);
348            mapPane.setHighlight(false);          }
349            mapPane.setNormalCursor(SwingUtil.ZOOMIN_CURSOR);  
350            break;          /**
351          case TOOL_ZOOMOUT:           * Clears the GUI of all components and adds all tool and action buttons to
352            // Set the mouse tool to "Zoom out"           * the tool bar.
353            mapPane.setWindowSelectionState(JMapPane.NONE);           */
354            mapPane.setState(JMapPane.ZOOM_OUT);          public void initToolBar() {
355            mapPane.setHighlight(false);                  // setOpaque(true);
356            mapPane.setNormalCursor(SwingUtil.ZOOMOUT_CURSOR);                  //              
357            break;                  // setAlignmentY(1f);
358          default:                  // setAlignmentX(0.5f);
359            // Set map actions to default                  removeAll();
360            mapPane.setWindowSelectionState(JMapPane.NONE);  
361            mapPane.setState(JMapPane.NONE);                  // // Separator to the left of the tool actions to start
362            mapPane.setHighlight(false);                  // // the tool buttons with the map (not with the coordinate grid)
363            mapPane.setNormalCursor(null);                  // Dimension dimension = new Dimension(49, 10);
364            break;                  // addSeparator(dimension);
365        }  
366        mapPane.updateCursor();                  // Tool buttons
367          }                  for (Integer bKey : toolAndActionButtons.keySet()) {
368            
369      /**                          JComponent b = toolAndActionButtons.get(bKey);
370       * Performs the action of an action button.  
371       * @param tool the action                          if (b instanceof JToggleButton) {
372       * @param e    the event of the button                                  JToggleButton tb = (JToggleButton) b;
373       */                                  tb.setName(bKey.toString());
374          protected void performActionButton(int action, ActionEvent e) {                                  tb.addActionListener(toolSelectedListener);
375        if ( mapPane == null )                          }
376          return;  
377                            add(b);
378        // Perform the action "Zoom back": Revert the last zoom                  }
379        if ( action == ACTION_ZOOM_BACK ) {  
380              if (zoomBackIndex <= 1)                  if (!toolAndActionButtons.containsKey(selectedTool)) {
381            return;                          /**
382                               * This might be a bit specific, but IF selection buttons are
383          zoomBackForwardButtonInAction = true;                           * available, select one of them.. if not, select the INFO tool.
384          zoomBackIndex--;                           */
385          getButton(ACTION_ZOOM_FORWARD).setEnabled(true);  
386          getButton(ACTION_ZOOM_BACK).setEnabled( zoomBackIndex > 1 );                          if (toolAndActionButtons.containsKey(TOOL_SELECTION_SET)) {
387                                      setSelectedTool(TOOL_SELECTION_SET);
388          mapPane.setMapArea( lastZooms.get(zoomBackIndex-1) );                          } else if (toolAndActionButtons.containsKey(TOOL_INFO)) {
389          mapPane.refresh();                                  setSelectedTool(TOOL_INFO);
390        }                          } else {
391                                    // TODO What to do now?!
392        // Perform the action "Zoom forward": Redo the last zoom                                  setSelectedTool(null);
393        if ( action == ACTION_ZOOM_FORWARD ) {                          }
394          if (zoomBackIndex < lastZooms.size()) {  
395            zoomBackForwardButtonInAction = true;                  }
396            zoomBackIndex++;  
397            getButton(ACTION_ZOOM_BACK).setEnabled(true);                  revalidate();
398            getButton(ACTION_ZOOM_FORWARD).setEnabled(zoomBackIndex < lastZooms.size());                  repaint();
399            }
400            mapPane.setMapArea( lastZooms.get(zoomBackIndex-1) );  
401            mapPane.refresh();          // Space between tool buttons and action buttons
402          }          // SK: Seperators are now als manages like actions and tools
403        }          // Dimension dimension2 = new Dimension( 10,10);
404          }          // this.addSeparator(dimension2);
405            
406                    // // Action buttons
407          /**          // for (JButton b : actionButtons.values())
408           * Adds a tool to the tool bar. Does nothing if a tool or action with the          // add(b);
409           * specified ID already exists!          // }
410           * @param buttonAction action for the toggle button  
411           * @param resetToolBar indicates whether the toolbar GUI is reset after adding          /**
412           *                     the button (if adding several actions it useful only to           * Performs the activation of a tool.
413           *                     reset the GUI for the last added tool)           *
414           */           * @param tool
415          public void addTool(MapPaneToolBarAction buttonAction, boolean resetToolBar) {           *            the tool to activate
416            if ( isButtonIDUsed(buttonAction.getID()) ) {           * @param e
417              LOGGER.warn("addTool(.) ignored because ID already used for tool or action: "+buttonAction.getID());           *            the event of the button
418              return;           */
419            }          public void performToolButton(int tool, ActionEvent e) {
420            JToggleButton button = new JToggleButton(buttonAction);                  if (mapPane == null)
421            button.setBorder( BorderFactory.createRaisedBevelBorder() );                          return;
422            toolButtonGroup.add(button);  
423            toolAndActionButtons.put(buttonAction.getID(), button);                  selectedTool = tool;
424            if ( resetToolBar )  
425              initToolBar();                  switch (tool) {
426          }                  case TOOL_PAN:
427                            // Set the mouse tool to "Panning"
428      /**                          mapPane.setState(SelectableXMapPane.PAN);
429       * Adds a tool to the tool bar and resets the toolbar GUI.  //                      mapPane.setNormalCursor(SwingUtil.PAN_CURSOR);
430       * @param buttonAction action for the toggle button                          break;
431       */                  case TOOL_INFO:
432      public void addTool(MapPaneToolBarAction buttonAction) {                          // Set the mouse tool to "Info"
433        addTool(buttonAction, true);                          mapPane.setState(SelectableXMapPane.SELECT_ONE_FROM_TOP);
434      }  //                      mapPane.setNormalCursor(SwingUtil.CROSSHAIR_CURSOR);
435                            break;
436      /**                  case TOOL_ZOOMIN:
437       * Adds an action to the tool bar. Does nothing if a tool or action with the                          // Set the mouse tool to "Zoom in"
438       * specified ID already exists!                          mapPane.setState(SelectableXMapPane.ZOOM_IN);
439       * @param buttonAction action for the button  //                      mapPane.setNormalCursor(SwingUtil.ZOOMIN_CURSOR);
440       * @param resetToolBar indicates whether the toolbar GUI is reset after adding                          break;
441       *                     the button (if adding several actions it useful only to                  case TOOL_ZOOMOUT:
442       *                     reset the GUI for the last added tool)                          // Set the mouse tool to "Zoom out"
443       */                          mapPane.setState(SelectableXMapPane.ZOOM_OUT);
444      public void addAction(MapPaneToolBarAction buttonAction, boolean resetToolBar) {  //                      mapPane.setNormalCursor(SwingUtil.ZOOMOUT_CURSOR);
445        if ( isButtonIDUsed(buttonAction.getID()) ) {                          break;
446          LOGGER.warn("addAction(.) ignored because ID already used for tool or action: "+buttonAction.getID());                  default:
447          return;                          // Set map actions to default
448        }                          mapPane.setState(SelectableXMapPane.NONE);
449        JButton button = new JButton(buttonAction);  //                      mapPane.setNormalCursor(null);
450        button.setBorder( BorderFactory.createRaisedBevelBorder() );                          break;
451        toolAndActionButtons.put( buttonAction.getID(), button );                  }
452        if ( resetToolBar )  //              mapPane.updateCursorAndRepaintTimer();
453          initToolBar();          }
454      }  
455                /**
456             * @param id
457      private void addSeparator(int id, Separator separator) {           *            The ID of the Component to remove. The change will not be
458          if ( isButtonIDUsed(id) ) {           *            visible until {@link #initToolBar()} is called.
459              LOGGER.warn("addSeparator(.) ignored because ID already used for tool or action. ");           * @return <code>null</code> or the component that has been removed.
460              return;           */
461            }          public JComponent removeId(int id) {
462            toolAndActionButtons.put( id, separator);                  return toolAndActionButtons.remove(id);
463          }          }
464    
465      /**          /**
466       * Adds an action to the tool bar and resets the toolbar GUI.           * Performs the action of an action button.
467       * @param buttonAction action for the toggle button           *
468       */           * @param tool
469      public void addAction(MapPaneToolBarAction buttonAction) {           *            the action
470        addAction(buttonAction, true);           * @param e
471      }           *            the event of the button
472                 */
473      /**          protected void performActionButton(int action, ActionEvent e) {
474       * Returns the button for a specific tool or action.                  if (mapPane == null)
475       * @param id the constant for any button in the {@link MapPaneToolBar}                          return;
476       * @return a {@link JButton} if {@code id} specifies an {@linkplain #getActionButton(int) action button}  
477       *         or {@link JToogleButton} if {@code id} specifies a {@linkplain #getToolButton(int) tool button}                  // Perform the action "Zoom back": Revert the last zoom
478       */                  if (action == ACTION_ZOOM_BACK) {
479      public AbstractButton getButton(int id) {                          if (zoomBackIndex <= 1)
480        AbstractButton button = (AbstractButton)toolAndActionButtons.get(id);                                  return;
481        if ( button == null )  
482          LOGGER.warn("Unknown tool or action ID: "+id);                          zoomBackForwardButtonInAction = true;
483        return button;                          zoomBackIndex--;
484      }                          getButton(ACTION_ZOOM_FORWARD).setEnabled(true);
485                            getButton(ACTION_ZOOM_BACK).setEnabled(zoomBackIndex > 1);
486      /**  
487       * Returns the button for a specific tool.                          mapPane.setMapArea(lastZooms.get(zoomBackIndex - 1));
488       * @param tool the constant for a tool                          mapPane.refresh();
489       */                  }
490          public JToggleButton getToolButton(int tool) {  
491        AbstractButton button = getButton(tool);                  // Perform the action "Zoom forward": Re-do the last zoom
492        if ( button != null && !(button instanceof JToggleButton) ) {                  if (action == ACTION_ZOOM_FORWARD) {
493          LOGGER.warn("ID specifies no tool: "+tool);                          if (zoomBackIndex < lastZooms.size()) {
494          button = null;                                  zoomBackForwardButtonInAction = true;
495        }                                  zoomBackIndex++;
496        return (JToggleButton)button;                                  getButton(ACTION_ZOOM_BACK).setEnabled(true);
497      }                                  getButton(ACTION_ZOOM_FORWARD).setEnabled(
498                                                    zoomBackIndex < lastZooms.size());
499      /**  
500       * Returns the button for a specific action.                                  mapPane.setMapArea(lastZooms.get(zoomBackIndex - 1));
501       * @param action the constant an action                                  mapPane.refresh();
502       */                          }
503      public JButton getActionButton(int action) {                  }
504        AbstractButton button = getButton(action);          }
505        if ( button != null && !(button instanceof JButton) ) {  
506          LOGGER.warn("ID specifies no action: "+action);          /**
507          button = null;           * Adds a tool to the tool bar. Does nothing if a tool or action with the
508        }           * specified ID already exists!
509        return (JButton)button;           *
510             * @param buttonAction
511      }           *            action for the toggle button
512             * @param resetToolBar
513          /**           *            indicates whether the toolbar GUI is reset after adding the
514           * Sets the selected tool.           *            button (if adding several actions it useful only to reset the
515           * @param tool ID of the tool           *            GUI for the last added tool)
516           */           */
517          public void setSelectedTool(Integer tool) {          public void addTool(MapPaneToolBarAction buttonAction, boolean resetToolBar) {
518            if ( tool == null )                  if (isButtonIDUsed(buttonAction.getID())) {
519              toolButtonGroup.setUnselected();                          LOGGER
520                                                      .warn("addTool(.) ignored because ID already used for tool or action: "
521            JToggleButton button = getToolButton(tool);                                                          + buttonAction.getID());
522            if ( button == null )                          return;
523              return;                  }
524            button.setSelected( true );                  JToggleButton button = new SmallToggleButton(buttonAction);
525            button.getAction().actionPerformed(null);                  
526          }  //              button.setBorder(BorderFactory.createRaisedBevelBorder());
527                            toolButtonGroup.add(button);
528          /**                  toolAndActionButtons.put(buttonAction.getID(), button);
529           * Returns the selected tool.                  if (resetToolBar)
530           * @return -1 if no tool is active                          initToolBar();
531           */          }
532          public int getSelectedTool() {  
533            if ( toolButtonGroup.getSelectedButton() == null )          /**
534              return -1;           * Adds a tool to the tool bar and resets the toolbar GUI.
535            return selectedTool;           *
536          }           * @param buttonAction
537                     *            action for the toggle button
538      /**           */
539       * Sets whether a tool or action is activated or not. The visible property          public void addTool(MapPaneToolBarAction buttonAction) {
540       * of the button is not affected.                  addTool(buttonAction, true);
541       * @param id tool or actionID          }
542       * @param enabled if {@code true} the tool becomes available  
543       */          /**
544      public void setButtonEnabled(int id, boolean enabled) {           * Adds an action to the tool bar. Does nothing if a tool or action with the
545        AbstractButton button = getButton(id);           * specified ID already exists!
546        if ( button == null )           *
547          return;           * @param buttonAction
548        button.setEnabled( enabled );           *            action for the button
549      }           * @param resetToolBar
550             *            indicates whether the toolbar GUI is reset after adding the
551      /**           *            button (if adding several actions it useful only to reset the
552       * Sets whether a tool or action is activated or not.           *            GUI for the last added tool)
553       * @param id tool or actionID           */
554       * @param enabled if {@code true} the tool becomes available          public void addAction(MapPaneToolBarAction buttonAction,
555       * @param hideOnDisable if {@code true} the button is also hidden if                          boolean resetToolBar) {
556       *                      {@code enabled} is {@code false}                  if (isButtonIDUsed(buttonAction.getID())) {
557       */                          LOGGER
558          public void setButtonEnabled(int id, boolean enabled, boolean hideOnDisable) {                                          .warn("addAction(.) ignored because ID already used for tool or action: "
559            AbstractButton button = getButton(id);                                                          + buttonAction.getID());
560            if ( button == null )                          return;
561              return;                  }
562            button.setEnabled( enabled );                  JButton button = new SmallButton(buttonAction);
563            // if button is enabled, it becomes visible anyway  //              button.setBorder(BorderFactory.createRaisedBevelBorder());
564            // if button is disabled and the "hide" option is set, it is also hidden                  toolAndActionButtons.put(buttonAction.getID(), button);
565            if ( enabled )                  if (resetToolBar)
566              button.setVisible( true );                          initToolBar();
567            else          }
568              button.setVisible( !hideOnDisable );  
569          }          /**
570             * Adds any JComponent to the tool bar. Does nothing if a tool or action
571      /**           * with the specified ID already exists!
572       * Checks whether a ID is already used for a tool or action.           *
573       * @param tool tool ID           * @param component
574       */           *            A {@link JComponent} that shall be added
575      public boolean isButtonIDUsed(int id) {           * @param id
576        return toolAndActionButtons.get(id) != null;           *            The ID associaded with the {@link JComponent}
577      }           * @param resetToolBar
578             *            indicates whether the toolbar GUI is reset after adding the
579      /**           *            button (if adding several actions it useful only to reset the
580       * Checks whether a tool is activated.           *            GUI for the last added tool)
581       * @param tool tool ID           */
582       * @return {@code false} if an unknown ID is specified          public void addJComponent(JComponent component, int id, boolean resetToolBar) {
583       */  
584      public boolean isButtonEnabled(int id) {                  if (isButtonIDUsed(id)) {
585        AbstractButton button = getButton(id);                          LOGGER
586        if ( button != null )                                          .warn("addAction(.) ignored because ID already used for tool or action: "
587          return button.isEnabled();                                                          + id);
588        return false;                          return;
589      }                  }
590    
591      /**                  toolAndActionButtons.put(id, component);
592       * Sets the activation for all tools.                  if (resetToolBar)
593       * @param enabled if {@code true} all tools becomes available                          initToolBar();
594       * @param hideOnDisable if {@code true} the buttons are also hidden if          }
595       *                      {@code enabled} is {@code false}  
596       */          public void addSeparator(int id, Separator separator) {
597      public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {                  if (isButtonIDUsed(id)) {
598        for (int tool : toolAndActionButtons.keySet())                          LOGGER
599          setButtonEnabled(tool,enabled,hideOnDisable);                                          .warn("addSeparator(.) ignored because ID already used for tool or action. ");
600      }                            return;
601                    }
602      /**                  toolAndActionButtons.put(id, separator);
603       * Sets the activation for all actions.          }
604       * @param enabled if {@code true} all actions becomes available  
605       * @param hideOnDisable if {@code true} the buttons are also hidden if          /**
606       *                      {@code enabled} is {@code false}           * Adds an action to the tool bar and resets the toolbar GUI.
607       */           *
608      public void setAllActionsEnabled(boolean enabled, boolean hideOnDisable) {           * @param buttonAction
609        for (int id : toolAndActionButtons.keySet()){           *            action for the toggle button
610            if (toolAndActionButtons.get(id) instanceof JButton){           */
611                    setButtonEnabled(id,enabled,hideOnDisable);          public void addAction(MapPaneToolBarAction buttonAction) {
612            }                  addAction(buttonAction, true);
613        }          }
614            
615      }            /**
616                 * Returns the button for a specific tool or action.
617      /**           *
618       * Returns the maximum ID of tools.           * @param id
619       */           *            the constant for any button in the {@link MapPaneToolBar}
620      public int getMaxToolID() {           * @return a {@link JButton} if {@code id} specifies an
621        return toolAndActionButtons.lastKey();           *         {@linkplain #getActionButton(int) action button} or
622      }           *         {@link JToogleButton} if {@code id} specifies a
623             *         {@linkplain #getToolButton(int) tool button}
624      /**           */
625       * Returns the minimum ID of tools.          public AbstractButton getButton(int id) {
626       */                  AbstractButton button = (AbstractButton) toolAndActionButtons.get(id);
627      public int getMinToolID() {                  if (button == null)
628        return toolAndActionButtons.firstKey();                          LOGGER.warn("Unknown tool or action ID: " + id);
629      }                  return button;
630  //          }
631  //    /**  
632  //     * Returns the maximum ID of actions.          /**
633  //     */           * Returns the button for a specific tool.
634  //    public int getMaxActionID() {           *
635  //      return actionButtons.lastKey();           * @param tool
636  //    }           *            the constant for a tool
637  //           */
638  //    /**          public JToggleButton getToolButton(int tool) {
639  //     * Returns the minimum ID of actions.                  AbstractButton button = getButton(tool);
640  //     */                  if (button != null && !(button instanceof JToggleButton)) {
641  //    public int getMinActionID() {                          LOGGER.warn("ID specifies no tool: " + tool);
642  //      return actionButtons.firstKey();                          button = null;
643  //    }                  }
644                        return (JToggleButton) button;
645      /**          }
646       * Extends the {@link AbstractAction} with maintaining an ID and  
647       * the {@link MapPaneToolBar} the actions controls.          /**
648       * Additionally this class automatically calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)}           * Returns the button for a specific action.
649       * or {@link MapPaneToolBar#performActionButton(int, ActionEvent)}           *
650       * depending on whether the action is added via {@link MapPaneToolBar#addTool(MapPaneToolBarAction)}           * @param action
651       * or {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.           *            the constant an action
652       * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)           */
653       */          public JButton getActionButton(int action) {
654      public static class MapPaneToolBarAction extends AbstractAction {                  AbstractButton button = getButton(action);
655        /** The ID of the action */                  if (button != null && !(button instanceof JButton)) {
656        protected int id = -1;                          LOGGER.warn("ID specifies no action: " + action);
657        /** The tool bar, this action is made for. */                          button = null;
658        protected MapPaneToolBar toolBar = null;                  }
659                    return (JButton) button;
660        /**  
661         * Creates a new action with a dummy description and no icon.          }
662         * @param id      unique ID for the action  
663         * @param toolBar toolbar this action is made for          /**
664         */           * Sets the selected tool.
665        public MapPaneToolBarAction(int id, MapPaneToolBar toolBar) {           *
666          this(id,toolBar,""+id);           * @param tool
667        }           *            ID of the tool
668             */
669        /**          public void setSelectedTool(Integer tool) {
670         * Creates a new action without an icon.                  if (tool == null)
671         * @param id      unique ID for the action                          toolButtonGroup.setUnselected();
672         * @param toolBar toolbar this action is made for  
673         * @param name    description used for buttons or menus                  JToggleButton button = getToolButton(tool);
674         */                  if (button == null)
675        public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name) {                          return;
676          this(id,toolBar,name,null);                  button.setSelected(true);
677        }                  button.getAction().actionPerformed(null);
678    
679        /**                  selectedTool = tool;
680         * Creates a new action.          }
681         * @param id      unique ID for the action  
682         * @param toolBar toolbar this action is made for          /**
683         * @param name    description used for buttons or menus           * Returns the selected tool.
684         * @param icon    icon used for buttons or menus           *
685         */           * @return -1 if no tool is active
686        public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name, Icon icon) {           */
687          super(name,icon);          public int getSelectedTool() {
688          this.id      = id;                  if (toolButtonGroup.getSelectedButton() == null)
689          this.toolBar = toolBar;                          return -1;
690        }                  return selectedTool;
691                  }
692        /**  
693         * Calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)}          /**
694         * or {@link MapPaneToolBar#performActionButton(int, ActionEvent)}           * Sets whether a tool or action is activated or not. The visible property
695         * depending on whether the action is added to the toolbar via           * of the button is not affected.
696         * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)}           *
697         * or {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.           * @param id
698         */           *            tool or actionID
699        public void actionPerformed(ActionEvent e) {           * @param enabled
700          if ( toolBar.toolAndActionButtons.get(id) instanceof JToggleButton)           *            if {@code true} the tool becomes available
701            toolBar.performToolButton(id, e);           */
702          else if ( toolBar.toolAndActionButtons.get(id) instanceof JButton )          public void setButtonEnabled(int id, boolean enabled) {
703            toolBar.performActionButton(id, e);                  AbstractButton button = getButton(id);
704        }                  if (button == null)
705                                  return;
706        /**                  button.setEnabled(enabled);
707         * Returns the (unique) id of this action.          }
708         * @return  
709         */          /**
710        public int getID() {           * Sets whether a tool or action is activated or not.
711          return id;           *
712        }           * @param id
713      }           *            tool or actionID
714  }           * @param enabled
715             *            if {@code true} the tool becomes available
716             * @param hideOnDisable
717             *            if {@code true} the button is also hidden if {@code enabled}
718             *            is {@code false}
719             */
720            public void setButtonEnabled(int id, boolean enabled, boolean hideOnDisable) {
721                    AbstractButton button = getButton(id);
722                    if (button == null)
723                            return;
724                    button.setEnabled(enabled);
725                    // if button is enabled, it becomes visible anyway
726                    // if button is disabled and the "hide" option is set, it is also hidden
727                    if (enabled)
728                            button.setVisible(true);
729                    else
730                            button.setVisible(!hideOnDisable);
731            }
732    
733            /**
734             * Checks whether a ID is already used for a tool or action.
735             *
736             * @param tool
737             *            tool ID
738             */
739            public boolean isButtonIDUsed(int id) {
740                    return toolAndActionButtons.get(id) != null;
741            }
742    
743            /**
744             * Checks whether a tool is activated.
745             *
746             * @param tool
747             *            tool ID
748             * @return {@code false} if an unknown ID is specified
749             */
750            public boolean isButtonEnabled(int id) {
751                    AbstractButton button = getButton(id);
752                    if (button != null)
753                            return button.isEnabled();
754                    return false;
755            }
756    
757            /**
758             * Sets the activation for all tools.
759             *
760             * @param enabled
761             *            if {@code true} all tools becomes available
762             * @param hideOnDisable
763             *            if {@code true} the buttons are also hidden if {@code enabled}
764             *            is {@code false}
765             */
766            public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {
767                    for (int tool : toolAndActionButtons.keySet())
768                            setButtonEnabled(tool, enabled, hideOnDisable);
769            }
770    
771            /**
772             * Sets the activation for all actions.
773             *
774             * @param enabled
775             *            if {@code true} all actions becomes available
776             * @param hideOnDisable
777             *            if {@code true} the buttons are also hidden if {@code enabled}
778             *            is {@code false}
779             */
780            public void setAllActionsEnabled(boolean enabled, boolean hideOnDisable) {
781                    for (int id : toolAndActionButtons.keySet()) {
782                            if (toolAndActionButtons.get(id) instanceof JButton) {
783                                    setButtonEnabled(id, enabled, hideOnDisable);
784                            }
785                    }
786    
787            }
788    
789            /**
790             * Returns the maximum ID of tools.
791             */
792            public int getMaxToolID() {
793                    return toolAndActionButtons.lastKey();
794            }
795    
796            /**
797             * Returns the minimum ID of tools.
798             */
799            public int getMinToolID() {
800                    return toolAndActionButtons.firstKey();
801            }
802    
803            /**
804             * Extends the {@link AbstractAction} with maintaining an ID and the
805             * {@link MapPaneToolBar} the actions controls. Additionally this class
806             * automatically calls
807             * {@link MapPaneToolBar#performToolButton(int, ActionEvent)} or
808             * {@link MapPaneToolBar#performActionButton(int, ActionEvent)} depending on
809             * whether the action is added via
810             * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)} or
811             * {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
812             *
813             * @author <a href="mailto:[email protected]">Martin Schmitz</a>
814             *         (University of Bonn/Germany)
815             */
816            public static class MapPaneToolBarAction extends AbstractAction {
817                    /** The ID of the action */
818                    protected int id = -1;
819                    /** The tool bar, this action is made for. */
820                    protected MapPaneToolBar toolBar = null;
821    
822                    /**
823                     * Creates a new action with a dummy description and no icon.
824                     *
825                     * @param id
826                     *            unique ID for the action
827                     * @param toolBar
828                     *            toolbar this action is made for
829                     */
830                    public MapPaneToolBarAction(int id, MapPaneToolBar toolBar) {
831                            this(id, toolBar, "" + id);
832                    }
833    
834                    /**
835                     * Creates a new action without an icon.
836                     *
837                     * @param id
838                     *            unique ID for the action
839                     * @param toolBar
840                     *            toolbar this action is made for
841                     * @param name
842                     *            description used for buttons or menus
843                     */
844                    public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name) {
845                            this(id, toolBar, name, null);
846                    }
847    
848                    /**
849                     * Creates a new action.
850                     *
851                     * @param id
852                     *            unique ID for the action
853                     * @param toolBar
854                     *            toolbar this action is made for
855                     * @param name
856                     *            description used for buttons or menus
857                     * @param icon
858                     *            icon used for buttons or menus
859                     */
860                    public MapPaneToolBarAction(int id, MapPaneToolBar toolBar,
861                                    String name, Icon icon) {
862                            this(id, toolBar, name, icon, null);
863                    }
864    
865                    /**
866                     * Creates a new action.
867                     *
868                     * @param id
869                     *            unique ID for the action
870                     * @param toolBar
871                     *            The {@link MapPaneToolBar} this action is made for
872                     * @param name
873                     *            description used for buttons or menus
874                     * @param icon
875                     *            icon used for buttons or menus
876                     * @param toolTip
877                     *            Tooltip to use for the button or menu
878                     */
879                    public MapPaneToolBarAction(int id, MapPaneToolBar toolBar,
880                                    String name, Icon icon, String toolTip) {
881                            super(name, icon);
882    
883                            if (toolTip != null && !toolTip.trim().isEmpty()) {
884                                    putValue(Action.SHORT_DESCRIPTION, toolTip);
885                            }
886    
887                            this.id = id;
888                            this.toolBar = toolBar;
889                    }
890    
891                    /**
892                     * Calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)} or
893                     * {@link MapPaneToolBar#performActionButton(int, ActionEvent)}
894                     * depending on whether the action is added to the toolbar via
895                     * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)} or
896                     * {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
897                     */
898                    public void actionPerformed(ActionEvent e) {
899                            if (toolBar.toolAndActionButtons.get(id) instanceof JToggleButton)
900                                    toolBar.performToolButton(id, e);
901                            else if (toolBar.toolAndActionButtons.get(id) instanceof JButton)
902                                    toolBar.performActionButton(id, e);
903                    }
904    
905                    /**
906                     * Returns the (unique) id of this action.
907                     *
908                     * @return
909                     */
910                    public int getID() {
911                            return id;
912                    }
913            }
914    
915            /**
916             * Nuetzlich wenn die Componente gedruckt (z.B. wenn ein Screenshot gemacht
917             * wird) wird. Dann werden wird der Hintergrund auf WEISS gesetzt.
918             *
919             * @author <a href="mailto:[email protected]">Stefan Alfons
920             *         Kr&uuml;ger</a>
921             */
922            @Override
923            public void print(Graphics g) {
924                    Color orig = getBackground();
925                    setBackground(Color.WHITE);
926                    // wrap in try/finally so that we always restore the state
927                    try {
928                            super.print(g);
929                    } finally {
930                            setBackground(orig);
931                    }
932            }
933    
934    }

Legend:
Removed from v.111  
changed lines
  Added in v.621

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26