/[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

revision 48 by alfonx, Fri Apr 17 12:49:33 2009 UTC revision 141 by alfonx, Sun Jun 14 18:23:36 2009 UTC
# Line 12  import javax.swing.BorderFactory; Line 12  import javax.swing.BorderFactory;
12  import javax.swing.Icon;  import javax.swing.Icon;
13  import javax.swing.ImageIcon;  import javax.swing.ImageIcon;
14  import javax.swing.JButton;  import javax.swing.JButton;
15    import javax.swing.JComponent;
16  import javax.swing.JToggleButton;  import javax.swing.JToggleButton;
17  import javax.swing.JToolBar;  import javax.swing.JToolBar;
18    
# Line 27  import schmitzm.swing.SwingUtil; Line 28  import schmitzm.swing.SwingUtil;
28  import com.vividsolutions.jts.geom.Envelope;  import com.vividsolutions.jts.geom.Envelope;
29    
30  /**  /**
31   * A toolbar to controll a {@link JMapPane} (Atlas visualization). This contains two types   * A toolbar to control an {@link JMapPane} (Atlas visualization). This contains
32   * of buttons. A group of <i>tools</i> for the mouse actions on the map represented   * two types of buttons. A group of <i>tools</i> for the mouse actions on the
33   * by {@link JToggleButton JToggleButtons}, where only one tool can be activated   * map represented by {@link JToggleButton JToggleButtons}, where only one tool
34   * every time. And some (general) <i>actions</i>, represented by normal   * can be activated every time. And some (general) <i>actions</i>, represented
35   * {@link JButton JButtons}.   * by normal {@link JButton JButtons}.
36   * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)   *
37     * @author <a href="mailto:[email protected]">Martin Schmitz</a>
38     *         (University of Bonn/Germany)
39     * @version 1.2 Stefan Krüger
40   */   */
41  public class MapPaneToolBar extends JToolBar {  public class MapPaneToolBar extends JToolBar {
42          private static final Logger LOGGER = Logger.getLogger(MapPaneToolBar.class.getName());          private static final Logger LOGGER = Logger.getLogger(MapPaneToolBar.class
43                            .getName());
44          /** Constant for the tool "Panning" (10). */          /** Constant for the tool "Panning" (10). */
45          public static final int TOOL_PAN = 10;          public static final int TOOL_PAN = 10;
         /** Constant for the tool "Zoom In" (30). */  
         public static final int TOOL_ZOOMIN = 30;  
         /** Constant for the tool "Zoom Out" (40). */  
         public static final int TOOL_ZOOMOUT = 40;  
46          /** Constant for the tool "Info" (20). */          /** Constant for the tool "Info" (20). */
47          public static final int TOOL_INFO = 20;          public static final int TOOL_INFO = 20;
48            public static final int SEPERATOR0 = 99;
49    
50            /** Constant for the tool "Zoom In" (110). */
51            public static final int TOOL_ZOOMIN = 110;
52            /** Constant for the tool "Zoom Out" (120). */
53            public static final int TOOL_ZOOMOUT = 120;
54            /** Constant for the action "Zoom back" (130). */
55            public static final int ACTION_ZOOM_BACK = 130;
56            /** Constant for the action "Zoom forward" (140). */
57            public static final int ACTION_ZOOM_FORWARD = 140;
58            public static final int SEPERATOR1 = 199;
59    
60            /**
61             * Constant for the tool "Selection Reset" which clears the selection (240).
62             */
63            public static final int TOOL_SELECTION_CLEAR = 240;
64    
65            /**
66             * Constant for the tool "Select" which sets the Selection to the selected
67             * features (210).
68             */
69            public static final int TOOL_SELECTION_SET = 210;
70            /**
71             * Constant for the tool "Selection add" which adds the features to the
72             * Selection (220).
73             */
74            public static final int TOOL_SELECTION_ADD = 220;
75            /**
76             * Constant for the tool "Selection subtract" which removes the selected
77             * features from the selection (230).
78             */
79            public static final int TOOL_SELECTION_REMOVE = 230;
80    
81          /** Tool currently selected */          /** Tool currently selected */
82      protected int selectedTool = TOOL_ZOOMIN;          protected int selectedTool = TOOL_ZOOMIN;
     /** Holds the tool buttons of the tool bar. */  
     protected SortedMap<Integer, JToggleButton> toolButtons = null;  
     /** Controls that only one tool button is activated. */  
     protected ButtonGroup toolButtonGroup = null;  
     /** Constant for the action "Zoom back" (100). */  
     public static final int ACTION_ZOOM_BACK = 100;  
     /** Constant for the action "Zoom forward" (110). */  
     public static final int ACTION_ZOOM_FORWARD = 110;  
     /** Constant for the action "Search Labels" (120). */  
     public static final int ACTION_SEARCH = 120;  
83    
84      /** Holds the action buttons of the bar. */          /** Holds the tool buttons of the tool bar. */
85      protected SortedMap<Integer, JButton> actionButtons = null;          protected SortedMap<Integer, JComponent> toolAndActionButtons = null;
86            /** Controls that only one tool button is activated. */
87            protected ButtonGroup toolButtonGroup = null;
88    
89            // SK: Musste ich ändern damit man Tools und Actions in der Reihenfolge
90            // mischen kann.
91            // /** Holds the action buttons of the bar. */
92            // protected SortedMap<Integer, JButton> actionButtons = null;
93    
94          /** Holds the {@link JMapPane} this tool bar controls. */          /** Holds the {@link JMapPane} this tool bar controls. */
95          protected JMapPane mapPane = null;          protected JMapPane mapPane = null;
# Line 74  public class MapPaneToolBar extends JToo Line 104  public class MapPaneToolBar extends JToo
104    
105          /** Listener to sniff the zoom actions on the map. */          /** Listener to sniff the zoom actions on the map. */
106          protected JMapPaneListener mapPaneListener = null;          protected JMapPaneListener mapPaneListener = null;
107            
108          protected boolean zoomBackForwardButtonInAction;          protected boolean zoomBackForwardButtonInAction;
109    
110      /**          /**
111       * Creates a new toolbar. Notice: This toolbar does nothing           * Creates a new toolbar. Notice: This toolbar does nothing until
112       * until {@link #setMapPane(JMapPane)} is called!           * {@link #setMapPane(JMapPane)} is called!
113       */           */
114      public MapPaneToolBar() {          public MapPaneToolBar() {
115        this(null);                  this(null);
116      }          }
117        
118      /**          /**
119           * Creates a new tool bar.           * Creates a new tool bar.
120           * @param mapPane {@link JMapPane} the tool bar controls           *
121             * @param mapPane
122             *            {@link JMapPane} the tool bar controls
123           */           */
124          public MapPaneToolBar(JMapPane mapPane) {          public MapPaneToolBar(JMapPane mapPane) {
125            super("Control the map", JToolBar.HORIZONTAL);                  super("Control the map", JToolBar.HORIZONTAL);
126        this.toolButtons     = new TreeMap<Integer,JToggleButton>();                  this.toolAndActionButtons = new TreeMap<Integer, JComponent>();
127        this.toolButtonGroup = new ButtonGroup();                  this.toolButtonGroup = new ButtonGroup();
128        this.actionButtons   = new TreeMap<Integer,JButton>();                  // Create a Listener to sniff the zooms on the JMapPane
129        // Create a Listener to sniff the zooms on the JMapPane                  this.mapPaneListener = new JMapPaneListener() {
130        this.mapPaneListener = new JMapPaneListener() {                          public void performMapPaneEvent(JMapPaneEvent e) {
131            public void performMapPaneEvent(JMapPaneEvent e) {                                  if (!(e instanceof MapAreaChangedEvent))
132                if ( !(e instanceof MapAreaChangedEvent) )                                          return;
133                  return;  
134                                                    if (zoomBackForwardButtonInAction) {
135                if ( zoomBackForwardButtonInAction ) {                                          zoomBackForwardButtonInAction = false;
136                  zoomBackForwardButtonInAction = false;                                          return;
137                  return;                                  }
138                }  
139                                                Envelope oldMapArea = ((MapAreaChangedEvent) e).getOldMapArea();
140                Envelope oldMapArea = ((MapAreaChangedEvent)e).getOldMapArea();                                  if (lastZooms.size() == 0 && oldMapArea != null) {
141                if (lastZooms.size() == 0 && oldMapArea != null ) {                                          lastZooms.add(oldMapArea);
142                  lastZooms.add(oldMapArea);                                          zoomBackIndex = 1;
143                  zoomBackIndex = 1;                                  }
144                }  
145                                    final Envelope mapArea = ((MapAreaChangedEvent) e)
146                final Envelope mapArea = ((MapAreaChangedEvent)e).getNewMapArea();                                                  .getNewMapArea();
147                if (mapArea == null)                                  if (mapArea == null)
148                  return;                                          return;
149                  
150                if (lastZooms.size() > 0 && mapArea.equals(lastZooms.get(lastZooms.size() - 1))) {                                  if (lastZooms.size() > 0
151                  // LOGGER.debug("MapAreaChangedEvent ausgelassen bei der Zaehlung der Zoomschritt weil identisch");                                                  && mapArea.equals(lastZooms.get(lastZooms.size() - 1))) {
152                  return;                                          // LOGGER.debug("MapAreaChangedEvent ausgelassen bei der Zaehlung der Zoomschritt weil identisch");
153                }                                          return;
154                                    }
155                if (lastZooms.size() > 0)  
156                  while (zoomBackIndex < lastZooms.size())                                  if (lastZooms.size() > 0)
157                    lastZooms.remove(lastZooms.size() - 1);                                          while (zoomBackIndex < lastZooms.size())
158                                                    lastZooms.remove(lastZooms.size() - 1);
159                lastZooms.add(mapArea);  
160                zoomBackIndex = lastZooms.size();                                  lastZooms.add(mapArea);
161                setButtonEnabled(ACTION_ZOOM_BACK, lastZooms.size() > 1);                                  zoomBackIndex = lastZooms.size();
162                setButtonEnabled(ACTION_ZOOM_FORWARD, false);                                  setButtonEnabled(ACTION_ZOOM_BACK, lastZooms.size() > 1);
163            }                                  setButtonEnabled(ACTION_ZOOM_FORWARD, false);
164        };                              }
165                        };
166        setMapPane(mapPane);  
167            setFloatable(false);                  setMapPane(mapPane);
168            setRollover(true);                  setFloatable(false);
169                              setRollover(true);
170            init();  
171                    init();
172          }          }
173            
174          /**          /**
175           * Sets the {@link JMapPane} controlled by this tool bar.           * Sets the {@link JMapPane} controlled by this tool bar.
176           * @param mapPane {@link JMapPane} to control (if {@code null} this           *
177           *                tool bar controls NOTHING!)           * @param mapPane
178             *            {@link JMapPane} to control (if {@code null} this tool bar
179             *            controls NOTHING!)
180           */           */
181          public void setMapPane(JMapPane mapPane) {          public void setMapPane(JMapPane mapPane) {
182            // Remove listener from old MapPane                  // Remove listener from old MapPane
183            if ( this.mapPane != null )                  if (this.mapPane != null)
184              this.mapPane.removeMapPaneListener( mapPaneListener );                          this.mapPane.removeMapPaneListener(mapPaneListener);
185        this.mapPane = mapPane;                  this.mapPane = mapPane;
186        if ( this.mapPane != null && mapPaneListener != null )                  if (this.mapPane != null && mapPaneListener != null)
187          this.mapPane.addMapPaneListener( mapPaneListener );                          this.mapPane.addMapPaneListener(mapPaneListener);
188          }          }
189            
190          /**          /**
191           * Calls {@link #initTools()} and {@link #initActions()} and then puts           * Calls {@link #initToolsAndActions()} and {@link #initActions()} and then
192           * all tool buttons and all actions buttons to the tool bar.           * puts all tool buttons and all actions buttons to the tool bar.
193           */           */
194          protected void init() {          protected void init() {
195            initTools();                  initToolsAndActions();
196            initActions();  
197            initToolBar();                  addSeparator(SEPERATOR0, new JToolBar.Separator());
198          }                  addSeparator(SEPERATOR1, new JToolBar.Separator());
199    
200                    initToolBar();
201          /**          }
202           * Creates the tool buttons, adds them to {@link #toolButtons} and finally  
203           * creates a button group for all tools. So sub-classes which override this          /**
204           * method should FIRST add their new tool buttons to {@link #toolButtons}           * Creates the tool buttons and action buttons and seperators, adds them to
205           * before calling {@code super.initTools()}.           * {@link #toolAndActionButtons} and finally creates a button group for all
206           */           * tools. So sub-classes which override this method should FIRST add their
207          protected void initTools() {           * new tool buttons to {@link #toolAndActionButtons} before calling {@code
208        // Panning           * super.initTools()}.
209        addTool( new MapPaneToolBarAction(           */
210            TOOL_PAN,          protected void initToolsAndActions() {
211            this,                  // Panning
212            "",                  addTool(new MapPaneToolBarAction(TOOL_PAN, this, "", new ImageIcon(
213            new ImageIcon(MapView.class.getResource("pan.png"))                                  MapView.class.getResource("resource/icons/pan.png"))), false);
214        ), false );                  // Info
215        // Info                  addTool(new MapPaneToolBarAction(TOOL_INFO, this, "", new ImageIcon(
216        addTool( new MapPaneToolBarAction(                                  MapView.class.getResource("resource/icons/info.png"))), false);
217            TOOL_INFO,  
218            this,                  // Zoom in
219            "",                  addTool(new MapPaneToolBarAction(TOOL_ZOOMIN, this, "", new ImageIcon(
220            new ImageIcon(MapView.class.getResource("info.png"))                                  MapView.class.getResource("resource/icons/zoom_in.png"))),
221        ), false );                                  false);
222        // Zoom in                  // Zoom out
223        addTool( new MapPaneToolBarAction(                  addTool(new MapPaneToolBarAction(TOOL_ZOOMOUT, this, "", new ImageIcon(
224            TOOL_ZOOMIN,                                  MapView.class.getResource("resource/icons/zoom_out.png"))),
225            this,                                  false);
226            "",  
227            new ImageIcon(MapView.class.getResource("zoom_in.png"))                  // Action button to revert the last zoom
228        ), false );                  addAction(new MapPaneToolBarAction(ACTION_ZOOM_BACK, this, "",
229        // Zoom out                                  new ImageIcon(MapView.class
230        addTool( new MapPaneToolBarAction(                                                  .getResource("resource/icons/zoom_back.png"))), false);
231            TOOL_ZOOMOUT,                  setButtonEnabled(ACTION_ZOOM_BACK, false);
232            this,  
233            "",                  // Action button to redo the last zoom
234            new ImageIcon(MapView.class.getResource("zoom_out.png"))                  addAction(new MapPaneToolBarAction(ACTION_ZOOM_FORWARD, this, "",
235        ), false );                                  new ImageIcon(MapView.class
236                                                          .getResource("resource/icons/zoom_forward.png"))),
237            // set the selected tool enabled                                  false);
238        setSelectedTool(selectedTool);                  setButtonEnabled(ACTION_ZOOM_FORWARD, false);
239          
240          }                  // set the selected tool enabled
241                    setSelectedTool(selectedTool);
242      /**  
243       * Creates the action buttons and adds them to {@link #actionButtons}.          }
244       */  
245      protected void initActions() {          /**
246        // Action button to revert the last zoom           * Clears the GUI of all components and adds all tool and action buttons to
247        addAction( new MapPaneToolBarAction(           * the tool bar.
248            ACTION_ZOOM_BACK,           */
249            this,          public void initToolBar() {
250            "",                  setAlignmentY(1f);
251            new ImageIcon(MapView.class.getResource("zoom_back.png"))                  removeAll();
252        ), false);                  // Separator to the left of the tool actions to start
253        setButtonEnabled( ACTION_ZOOM_BACK, false );                  // the tool buttons with the map (not with the coordinate grid)
254                    Dimension dimension = new Dimension(49, 10);
255        // Action button to redo the last zoom                  addSeparator(dimension);
256        addAction( new MapPaneToolBarAction(                  // Tool buttons
257            ACTION_ZOOM_FORWARD,                  for (JComponent b : toolAndActionButtons.values())
258            this,                          add(b);
259            "",  
260            new ImageIcon(MapView.class.getResource("zoom_forward.png"))                  repaint();
261        ), false);  
262        setButtonEnabled( ACTION_ZOOM_FORWARD, false );                  if (!toolAndActionButtons.containsKey(selectedTool)) {
263                            /**
264      }                           * This might be a bit specific, but IF selection buttons are
265                                 * available, select one of them.. if not, select the INFO tool.
266      /**                           */
267       * Clears the GUI of all components and adds all tool and action buttons to the  
268       * tool bar.                          if (toolAndActionButtons.containsKey(TOOL_SELECTION_SET)) {
269       */                                  setSelectedTool(TOOL_SELECTION_SET);
270      protected void initToolBar() {                          } else if (toolAndActionButtons.containsKey(TOOL_INFO)) {
271        setAlignmentY( 1f );                                  setSelectedTool(TOOL_INFO);
272        removeAll();                          } else {
273        // Separator to the left of the tool actions to start                                  // TODO What to do now?!
274        // the tool buttons with the map (not with the coordinate grid)                                  setSelectedTool(null);
275        Dimension dimension = new Dimension( 49,10);                          }
276        addSeparator(dimension);  
277        // Tool buttons                  }
278        for (JToggleButton b : toolButtons.values())          }
279          add(b);  
280        // Space between tool buttons and action buttons          // Space between tool buttons and action buttons
281        Dimension dimension2 = new Dimension( 10,10);          // SK: Seperators are now als manages like actions and tools
282        this.addSeparator(dimension2);          // Dimension dimension2 = new Dimension( 10,10);
283        // Action buttons          // this.addSeparator(dimension2);
284        for (JButton b : actionButtons.values())  
285          add(b);          // // Action buttons
286      }          // for (JButton b : actionButtons.values())
287                // add(b);
288            // }
289    
290          /**          /**
291           * Performs the activation of a tool.           * Performs the activation of a tool.
292           * @param tool the tool to activate           *
293           * @param e    the event of the button           * @param tool
294             *            the tool to activate
295             * @param e
296             *            the event of the button
297           */           */
298          public void performToolButton(int tool, ActionEvent e) {          public void performToolButton(int tool, ActionEvent e) {
299            if ( mapPane == null )                  if (mapPane == null)
300              return;                          return;
301              
302            selectedTool = tool;                  selectedTool = tool;
303              
304        switch( tool ) {                  switch (tool) {
305          case TOOL_PAN:                  case TOOL_PAN:
306            // Set the mouse tool to "Panning"                          // Set the mouse tool to "Panning"
307            mapPane.setWindowSelectionState(JMapPane.NONE);                          mapPane.setWindowSelectionState(JMapPane.NONE);
308            mapPane.setState(JMapPane.PAN);                          mapPane.setState(JMapPane.PAN);
309            mapPane.setHighlight(false);                          mapPane.setHighlight(false);
310            mapPane.setNormalCursor(SwingUtil.PAN_CURSOR);                          mapPane.setNormalCursor(SwingUtil.PAN_CURSOR);
311            break;                          break;
312          case TOOL_INFO:                  case TOOL_INFO:
313            // Set the mouse tool to "Info"                          // Set the mouse tool to "Info"
314            mapPane.setWindowSelectionState(JMapPane.NONE);                          mapPane.setWindowSelectionState(JMapPane.NONE);
315            mapPane.setState(JMapPane.SELECT_TOP);                          mapPane.setState(JMapPane.SELECT_TOP); // Why not:
316            mapPane.setHighlight(true);                          // JMapPane.SELECT_TOP_ONEONLY
317            mapPane.setNormalCursor(SwingUtil.CROSSHAIR_CURSOR);                          mapPane.setHighlight(false);// SK: Was true, but since it not works
318            break;                          // properly removed it to save
319          case TOOL_ZOOMIN:                          // performance
320            // Set the mouse tool to "Zoom in"                          mapPane.setNormalCursor(SwingUtil.CROSSHAIR_CURSOR);
321            mapPane.setWindowSelectionState(JMapPane.ZOOM_IN);                          break;
322            mapPane.setState(JMapPane.ZOOM_IN);                  case TOOL_ZOOMIN:
323            mapPane.setHighlight(false);                          // Set the mouse tool to "Zoom in"
324            mapPane.setNormalCursor(SwingUtil.ZOOMIN_CURSOR);                          mapPane.setWindowSelectionState(JMapPane.ZOOM_IN);
325            break;                          mapPane.setState(JMapPane.ZOOM_IN);
326          case TOOL_ZOOMOUT:                          mapPane.setHighlight(false);
327            // Set the mouse tool to "Zoom out"                          mapPane.setNormalCursor(SwingUtil.ZOOMIN_CURSOR);
328            mapPane.setWindowSelectionState(JMapPane.NONE);                          break;
329            mapPane.setState(JMapPane.ZOOM_OUT);                  case TOOL_ZOOMOUT:
330            mapPane.setHighlight(false);                          // Set the mouse tool to "Zoom out"
331            mapPane.setNormalCursor(SwingUtil.ZOOMOUT_CURSOR);                          mapPane.setWindowSelectionState(JMapPane.NONE);
332            break;                          mapPane.setState(JMapPane.ZOOM_OUT);
333          default:                          mapPane.setHighlight(false);
334            // Set map actions to default                          mapPane.setNormalCursor(SwingUtil.ZOOMOUT_CURSOR);
335            mapPane.setWindowSelectionState(JMapPane.NONE);                          break;
336            mapPane.setState(JMapPane.NONE);                  default:
337            mapPane.setHighlight(false);                          // Set map actions to default
338            mapPane.setNormalCursor(null);                          mapPane.setWindowSelectionState(JMapPane.NONE);
339            break;                          mapPane.setState(JMapPane.NONE);
340        }                          mapPane.setHighlight(false);
341        mapPane.updateCursor();                          mapPane.setNormalCursor(null);
342          }                          break;
343                            }
344      /**                  mapPane.updateCursor();
345       * Performs the action of an action button.          }
346       * @param tool the action  
347       * @param e    the event of the button          /**
348       */           * @param id
349             *            The ID of the Component to remove. The change will not be
350             *            visible until {@link #initToolBar()} is called.
351             * @return <code>null</code> or the component that has been removed.
352             */
353            public JComponent removeId(int id) {
354                    return toolAndActionButtons.remove(id);
355            }
356    
357            /**
358             * Performs the action of an action button.
359             *
360             * @param tool
361             *            the action
362             * @param e
363             *            the event of the button
364             */
365          protected void performActionButton(int action, ActionEvent e) {          protected void performActionButton(int action, ActionEvent e) {
366        if ( mapPane == null )                  if (mapPane == null)
367          return;                          return;
368    
369                    // Perform the action "Zoom back": Revert the last zoom
370                    if (action == ACTION_ZOOM_BACK) {
371                            if (zoomBackIndex <= 1)
372                                    return;
373    
374                            zoomBackForwardButtonInAction = true;
375                            zoomBackIndex--;
376                            getButton(ACTION_ZOOM_FORWARD).setEnabled(true);
377                            getButton(ACTION_ZOOM_BACK).setEnabled(zoomBackIndex > 1);
378    
379                            mapPane.setMapArea(lastZooms.get(zoomBackIndex - 1));
380                            mapPane.refresh();
381                    }
382    
383                    // Perform the action "Zoom forward": Re-do the last zoom
384                    if (action == ACTION_ZOOM_FORWARD) {
385                            if (zoomBackIndex < lastZooms.size()) {
386                                    zoomBackForwardButtonInAction = true;
387                                    zoomBackIndex++;
388                                    getButton(ACTION_ZOOM_BACK).setEnabled(true);
389                                    getButton(ACTION_ZOOM_FORWARD).setEnabled(
390                                                    zoomBackIndex < lastZooms.size());
391    
392                                    mapPane.setMapArea(lastZooms.get(zoomBackIndex - 1));
393                                    mapPane.refresh();
394                            }
395                    }
396    
       // 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": Redo 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();  
         }  
       }  
397          }          }
398            
           
399          /**          /**
400           * Adds a tool to the tool bar. Does nothing if a tool or action with the           * Adds a tool to the tool bar. Does nothing if a tool or action with the
401           * specified ID already exists!           * specified ID already exists!
402           * @param buttonAction action for the toggle button           *
403           * @param resetToolBar indicates whether the toolbar GUI is reset after adding           * @param buttonAction
404           *                     the button (if adding several actions it useful only to           *            action for the toggle button
405           *                     reset the GUI for the last added tool)           * @param resetToolBar
406             *            indicates whether the toolbar GUI is reset after adding the
407             *            button (if adding several actions it useful only to reset the
408             *            GUI for the last added tool)
409           */           */
410          public void addTool(MapPaneToolBarAction buttonAction, boolean resetToolBar) {          public void addTool(MapPaneToolBarAction buttonAction, boolean resetToolBar) {
411            if ( isButtonIDUsed(buttonAction.getID()) ) {                  if (isButtonIDUsed(buttonAction.getID())) {
412              LOGGER.warn("addTool(.) ignored because ID already used for tool or action: "+buttonAction.getID());                          LOGGER
413              return;                                          .warn("addTool(.) ignored because ID already used for tool or action: "
414            }                                                          + buttonAction.getID());
415            JToggleButton button = new JToggleButton(buttonAction);                          return;
416            button.setBorder( BorderFactory.createRaisedBevelBorder() );                  }
417            toolButtonGroup.add(button);                  JToggleButton button = new JToggleButton(buttonAction);
418            toolButtons.put(buttonAction.getID(), button);                  button.setBorder(BorderFactory.createRaisedBevelBorder());
419            if ( resetToolBar )                  toolButtonGroup.add(button);
420              initToolBar();                  toolAndActionButtons.put(buttonAction.getID(), button);
421          }                  if (resetToolBar)
422                            initToolBar();
423      /**          }
424       * Adds a tool to the tool bar and resets the toolbar GUI.  
425       * @param buttonAction action for the toggle button          /**
426       */           * Adds a tool to the tool bar and resets the toolbar GUI.
427      public void addTool(MapPaneToolBarAction buttonAction) {           *
428        addTool(buttonAction, true);           * @param buttonAction
429      }           *            action for the toggle button
430             */
431      /**          public void addTool(MapPaneToolBarAction buttonAction) {
432       * Adds an action to the tool bar. Does nothing if a tool or action with the                  addTool(buttonAction, true);
433       * specified ID already exists!          }
434       * @param buttonAction action for the button  
435       * @param resetToolBar indicates whether the toolbar GUI is reset after adding          /**
436       *                     the button (if adding several actions it useful only to           * Adds an action to the tool bar. Does nothing if a tool or action with the
437       *                     reset the GUI for the last added tool)           * specified ID already exists!
438       */           *
439      public void addAction(MapPaneToolBarAction buttonAction, boolean resetToolBar) {           * @param buttonAction
440        if ( isButtonIDUsed(buttonAction.getID()) ) {           *            action for the button
441          LOGGER.warn("addAction(.) ignored because ID already used for tool or action: "+buttonAction.getID());           * @param resetToolBar
442          return;           *            indicates whether the toolbar GUI is reset after adding the
443        }           *            button (if adding several actions it useful only to reset the
444        JButton button = new JButton(buttonAction);           *            GUI for the last added tool)
445        actionButtons.put( buttonAction.getID(), button );           */
446        if ( resetToolBar )          public void addAction(MapPaneToolBarAction buttonAction,
447          initToolBar();                          boolean resetToolBar) {
448      }                  if (isButtonIDUsed(buttonAction.getID())) {
449                            LOGGER
450      /**                                          .warn("addAction(.) ignored because ID already used for tool or action: "
451       * Adds an action to the tool bar and resets the toolbar GUI.                                                          + buttonAction.getID());
452       * @param buttonAction action for the toggle button                          return;
453       */                  }
454      public void addAction(MapPaneToolBarAction buttonAction) {                  JButton button = new JButton(buttonAction);
455        addAction(buttonAction, true);                  button.setBorder(BorderFactory.createRaisedBevelBorder());
456      }                  toolAndActionButtons.put(buttonAction.getID(), button);
457                        if (resetToolBar)
458      /**                          initToolBar();
459       * Returns the button for a specific tool or action.          }
460       * @param id the constant for a tool  
461       * @return a {@link JButton} if {@code id} specifies an {@linkplain #getActionButton(int) action button}          public void addSeparator(int id, Separator separator) {
462       *         or {@link JToogleButton} if {@code id} specifies a {@linkplain #getToolButton(int) tool button}                  if (isButtonIDUsed(id)) {
463       */                          LOGGER
464      public AbstractButton getButton(int id) {                                          .warn("addSeparator(.) ignored because ID already used for tool or action. ");
465        AbstractButton button = toolButtons.get(id);                          return;
466        if ( button == null )                  }
467          button = actionButtons.get(id);                  toolAndActionButtons.put(id, separator);
468        if ( button == null )          }
469          LOGGER.warn("Unknown tool or action ID: "+id);  
470        return button;          /**
471      }           * Adds an action to the tool bar and resets the toolbar GUI.
472             *
473      /**           * @param buttonAction
474       * Returns the button for a specific tool.           *            action for the toggle button
475       * @param tool the constant for a tool           */
476       */          public void addAction(MapPaneToolBarAction buttonAction) {
477                    addAction(buttonAction, true);
478            }
479    
480            /**
481             * Returns the button for a specific tool or action.
482             *
483             * @param id
484             *            the constant for any button in the {@link MapPaneToolBar}
485             * @return a {@link JButton} if {@code id} specifies an
486             *         {@linkplain #getActionButton(int) action button} or
487             *         {@link JToogleButton} if {@code id} specifies a
488             *         {@linkplain #getToolButton(int) tool button}
489             */
490            public AbstractButton getButton(int id) {
491                    AbstractButton button = (AbstractButton) toolAndActionButtons.get(id);
492                    if (button == null)
493                            LOGGER.warn("Unknown tool or action ID: " + id);
494                    return button;
495            }
496    
497            /**
498             * Returns the button for a specific tool.
499             *
500             * @param tool
501             *            the constant for a tool
502             */
503          public JToggleButton getToolButton(int tool) {          public JToggleButton getToolButton(int tool) {
504        AbstractButton button = getButton(tool);                  AbstractButton button = getButton(tool);
505        if ( button != null && !(button instanceof JToggleButton) ) {                  if (button != null && !(button instanceof JToggleButton)) {
506          LOGGER.warn("ID specifies no tool: "+tool);                          LOGGER.warn("ID specifies no tool: " + tool);
507          button = null;                          button = null;
508        }                  }
509        return (JToggleButton)button;                  return (JToggleButton) button;
510      }          }
   
     /**  
      * 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;  
511    
512      }          /**
513             * Returns the button for a specific action.
514             *
515             * @param action
516             *            the constant an action
517             */
518            public JButton getActionButton(int action) {
519                    AbstractButton button = getButton(action);
520                    if (button != null && !(button instanceof JButton)) {
521                            LOGGER.warn("ID specifies no action: " + action);
522                            button = null;
523                    }
524                    return (JButton) button;
525    
526            }
527    
528          /**          /**
529           * Sets the selected tool.           * Sets the selected tool.
530           * @param tool ID of the tool           *
531             * @param tool
532             *            ID of the tool
533           */           */
534          public void setSelectedTool(Integer tool) {          public void setSelectedTool(Integer tool) {
535            if ( tool == null )                  if (tool == null)
536              toolButtonGroup.setUnselected();                          toolButtonGroup.setUnselected();
537              
538            JToggleButton button = getToolButton(tool);                  JToggleButton button = getToolButton(tool);
539            if ( button == null )                  if (button == null)
540              return;                          return;
541            button.setSelected( true );                  button.setSelected(true);
542            button.getAction().actionPerformed(null);                  button.getAction().actionPerformed(null);
543    
544                    selectedTool = tool;
545          }          }
546            
547          /**          /**
548           * Returns the selected tool.           * Returns the selected tool.
549             *
550           * @return -1 if no tool is active           * @return -1 if no tool is active
551           */           */
552          public int getSelectedTool() {          public int getSelectedTool() {
553            if ( toolButtonGroup.getSelectedButton() == null )                  if (toolButtonGroup.getSelectedButton() == null)
554              return -1;                          return -1;
555            return selectedTool;                  return selectedTool;
556          }          }
557            
558      /**          /**
559       * Sets whether a tool or action is activated or not. The visible property           * Sets whether a tool or action is activated or not. The visible property
560       * of the button is not affected.           * of the button is not affected.
561       * @param id tool or actionID           *
562       * @param enabled if {@code true} the tool becomes available           * @param id
563       */           *            tool or actionID
564      public void setButtonEnabled(int id, boolean enabled) {           * @param enabled
565        AbstractButton button = getButton(id);           *            if {@code true} the tool becomes available
566        if ( button == null )           */
567          return;          public void setButtonEnabled(int id, boolean enabled) {
568        button.setEnabled( enabled );                  AbstractButton button = getButton(id);
569      }                  if (button == null)
570                            return;
571      /**                  button.setEnabled(enabled);
572       * Sets whether a tool or action is activated or not.          }
573       * @param id tool or actionID  
574       * @param enabled if {@code true} the tool becomes available          /**
575       * @param hideOnDisable if {@code true} the button is also hidden if           * Sets whether a tool or action is activated or not.
576       *                      {@code enabled} is {@code false}           *
577       */           * @param id
578             *            tool or actionID
579             * @param enabled
580             *            if {@code true} the tool becomes available
581             * @param hideOnDisable
582             *            if {@code true} the button is also hidden if {@code enabled}
583             *            is {@code false}
584             */
585          public void setButtonEnabled(int id, boolean enabled, boolean hideOnDisable) {          public void setButtonEnabled(int id, boolean enabled, boolean hideOnDisable) {
586            AbstractButton button = getButton(id);                  AbstractButton button = getButton(id);
587            if ( button == null )                  if (button == null)
588              return;                          return;
589            button.setEnabled( enabled );                  button.setEnabled(enabled);
590            // if button is enabled, it becomes visible anyway                  // if button is enabled, it becomes visible anyway
591            // if button is disabled and the "hide" option is set, it is also hidden                  // if button is disabled and the "hide" option is set, it is also hidden
592            if ( enabled )                  if (enabled)
593              button.setVisible( true );                          button.setVisible(true);
594            else                  else
595              button.setVisible( !hideOnDisable );                          button.setVisible(!hideOnDisable);
596          }          }
597    
598      /**          /**
599       * Checks whether a ID is already used for a tool or action.           * Checks whether a ID is already used for a tool or action.
600       * @param tool tool ID           *
601       */           * @param tool
602      public boolean isButtonIDUsed(int id) {           *            tool ID
603        return toolButtons.get(id) != null || actionButtons.get(id) != null;           */
604      }          public boolean isButtonIDUsed(int id) {
605                    return toolAndActionButtons.get(id) != null;
606      /**          }
607       * Checks whether a tool is activated.  
608       * @param tool tool ID          /**
609       * @return {@code false} if an unknown ID is specified           * Checks whether a tool is activated.
610       */           *
611      public boolean isButtonEnabled(int id) {           * @param tool
612        AbstractButton button = getButton(id);           *            tool ID
613        if ( button != null )           * @return {@code false} if an unknown ID is specified
614          return button.isEnabled();           */
615        return false;          public boolean isButtonEnabled(int id) {
616      }                  AbstractButton button = getButton(id);
617                    if (button != null)
618      /**                          return button.isEnabled();
619       * Sets the activation for all tools.                  return false;
620       * @param enabled if {@code true} all tools becomes available          }
621       * @param hideOnDisable if {@code true} the buttons are also hidden if  
622       *                      {@code enabled} is {@code false}          /**
623       */           * Sets the activation for all tools.
624      public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {           *
625        for (int tool : toolButtons.keySet())           * @param enabled
626          setButtonEnabled(tool,enabled,hideOnDisable);           *            if {@code true} all tools becomes available
627      }             * @param hideOnDisable
628             *            if {@code true} the buttons are also hidden if {@code enabled}
629      /**           *            is {@code false}
630       * Sets the activation for all actions.           */
631       * @param enabled if {@code true} all actions becomes available          public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {
632       * @param hideOnDisable if {@code true} the buttons are also hidden if                  for (int tool : toolAndActionButtons.keySet())
633       *                      {@code enabled} is {@code false}                          setButtonEnabled(tool, enabled, hideOnDisable);
634       */          }
635      public void setAllActionsEnabled(boolean enabled, boolean hideOnDisable) {  
636        for (int tool : actionButtons.keySet())          /**
637          setButtonEnabled(tool,enabled,hideOnDisable);           * Sets the activation for all actions.
638      }             *
639                 * @param enabled
640      /**           *            if {@code true} all actions becomes available
641       * Returns the maximum ID of tools.           * @param hideOnDisable
642       */           *            if {@code true} the buttons are also hidden if {@code enabled}
643      public int getMaxToolID() {           *            is {@code false}
644        return toolButtons.lastKey();           */
645      }          public void setAllActionsEnabled(boolean enabled, boolean hideOnDisable) {
646                    for (int id : toolAndActionButtons.keySet()) {
647      /**                          if (toolAndActionButtons.get(id) instanceof JButton) {
648       * Returns the minimum ID of tools.                                  setButtonEnabled(id, enabled, hideOnDisable);
649       */                          }
650      public int getMinToolID() {                  }
651        return toolButtons.firstKey();  
652      }          }
653    
654      /**          /**
655       * Returns the maximum ID of actions.           * Returns the maximum ID of tools.
656       */           */
657      public int getMaxActionID() {          public int getMaxToolID() {
658        return actionButtons.lastKey();                  return toolAndActionButtons.lastKey();
659      }          }
660    
661      /**          /**
662       * Returns the minimum ID of actions.           * Returns the minimum ID of tools.
663       */           */
664      public int getMinActionID() {          public int getMinToolID() {
665        return actionButtons.firstKey();                  return toolAndActionButtons.firstKey();
666      }          }
667        
668      /**          /**
669       * Extends the {@link AbstractAction} with maintaining an ID and           * Extends the {@link AbstractAction} with maintaining an ID and the
670       * the {@link MapPaneToolBar} the actions controls.           * {@link MapPaneToolBar} the actions controls. Additionally this class
671       * Additionally this class automatically calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)}           * automatically calls
672       * or {@link MapPaneToolBar#performActionButton(int, ActionEvent)}           * {@link MapPaneToolBar#performToolButton(int, ActionEvent)} or
673       * depending on whether the action is added via {@link MapPaneToolBar#addTool(MapPaneToolBarAction)}           * {@link MapPaneToolBar#performActionButton(int, ActionEvent)} depending on
674       * or {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.           * whether the action is added via
675       * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)           * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)} or
676       */           * {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
677      public static class MapPaneToolBarAction extends AbstractAction {           *
678        /** The ID of the action */           * @author <a href="mailto:[email protected]">Martin Schmitz</a>
679        protected int id = -1;           *         (University of Bonn/Germany)
680        /** The tool bar, this action is made for. */           */
681        protected MapPaneToolBar toolBar = null;          public static class MapPaneToolBarAction extends AbstractAction {
682                    /** The ID of the action */
683        /**                  protected int id = -1;
684         * Creates a new action with a dummy description and no icon.                  /** The tool bar, this action is made for. */
685         * @param id      unique ID for the action                  protected MapPaneToolBar toolBar = null;
686         * @param toolBar toolbar this action is made for  
687         */                  /**
688        public MapPaneToolBarAction(int id, MapPaneToolBar toolBar) {                   * Creates a new action with a dummy description and no icon.
689          this(id,toolBar,""+id);                   *
690        }                   * @param id
691                     *            unique ID for the action
692        /**                   * @param toolBar
693         * Creates a new action without an icon.                   *            toolbar this action is made for
694         * @param id      unique ID for the action                   */
695         * @param toolBar toolbar this action is made for                  public MapPaneToolBarAction(int id, MapPaneToolBar toolBar) {
696         * @param name    description used for buttons or menus                          this(id, toolBar, "" + id);
697         */                  }
698        public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name) {  
699          this(id,toolBar,name,null);                  /**
700        }                   * Creates a new action without an icon.
701                     *
702        /**                   * @param id
703         * Creates a new action.                   *            unique ID for the action
704         * @param id      unique ID for the action                   * @param toolBar
705         * @param toolBar toolbar this action is made for                   *            toolbar this action is made for
706         * @param name    description used for buttons or menus                   * @param name
707         * @param icon    icon used for buttons or menus                   *            description used for buttons or menus
708         */                   */
709        public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name, Icon icon) {                  public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name) {
710          super(name,icon);                          this(id, toolBar, name, null);
711          this.id      = id;                  }
712          this.toolBar = toolBar;  
713        }                  /**
714                           * Creates a new action.
715        /**                   *
716         * Calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)}                   * @param id
717         * or {@link MapPaneToolBar#performActionButton(int, ActionEvent)}                   *            unique ID for the action
718         * depending on whether the action is added to the toolbar via                   * @param toolBar
719         * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)}                   *            toolbar this action is made for
720         * or {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.                   * @param name
721         */                   *            description used for buttons or menus
722        public void actionPerformed(ActionEvent e) {                   * @param icon
723          if ( toolBar.toolButtons.get(id) != null )                   *            icon used for buttons or menus
724            toolBar.performToolButton(id, e);                   */
725          if ( toolBar.actionButtons.get(id) != null )                  public MapPaneToolBarAction(int id, MapPaneToolBar toolBar,
726            toolBar.performActionButton(id, e);                                  String name, Icon icon) {
727        }                          super(name, icon);
728                                  this.id = id;
729        /**                          this.toolBar = toolBar;
730         * Returns the (unique) id of this action.                  }
731         * @return  
732         */                  /**
733        public int getID() {                   * Calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)} or
734          return id;                   * {@link MapPaneToolBar#performActionButton(int, ActionEvent)}
735        }                   * depending on whether the action is added to the toolbar via
736      }                   * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)} or
737                     * {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
738                     */
739                    public void actionPerformed(ActionEvent e) {
740                            if (toolBar.toolAndActionButtons.get(id) instanceof JToggleButton)
741                                    toolBar.performToolButton(id, e);
742                            else if (toolBar.toolAndActionButtons.get(id) instanceof JButton)
743                                    toolBar.performActionButton(id, e);
744                    }
745    
746                    /**
747                     * Returns the (unique) id of this action.
748                     *
749                     * @return
750                     */
751                    public int getID() {
752                            return id;
753                    }
754            }
755  }  }
Legend:
Removed from v.48  
changed lines
  Added in v.141
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26