skrueger/geotools/MapPaneToolBar.java

package skrueger.geotools;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.SortedMap;
import java.util.TreeMap;

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

import org.apache.log4j.Logger;

import schmitzm.geotools.gui.JMapPane;
import schmitzm.geotools.map.event.JMapPaneEvent;
import schmitzm.geotools.map.event.JMapPaneListener;
import schmitzm.geotools.map.event.MapAreaChangedEvent;
import schmitzm.swing.ButtonGroup;
import schmitzm.swing.SwingUtil;

import com.vividsolutions.jts.geom.Envelope;

/**
 * A toolbar to controll a {@link JMapPane} (Atlas visualization). This contains two types
 * of buttons. A group of <i>tools</i> for the mouse actions on the map represented
 * by {@link JToggleButton JToggleButtons}, where only one tool can be activated
 * every time. And some (general) <i>actions</i>, represented by normal
 * {@link JButton JButtons}. 
 * @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)
 */
public class MapPaneToolBar extends JToolBar {
        private static final Logger LOGGER = Logger.getLogger(MapPaneToolBar.class.getName());
        /** Constant for the tool "Panning" (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;
        /** Constant for the tool "Info" (20). */
        public static final int TOOL_INFO = 20;

        /** Tool currently selected */
    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;

    /** Holds the action buttons of the bar. */
    protected SortedMap<Integer, JButton> actionButtons = null;

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

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

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

    /**
     * Creates a new toolbar. Notice: This toolbar does nothing
     * until {@link #setMapPane(JMapPane)} is called!
     */
    public MapPaneToolBar() {
      this(null);
    }
    
    /**
         * Creates a new tool bar.
         * @param mapPane {@link JMapPane} the tool bar controls
         */
        public MapPaneToolBar(JMapPane mapPane) {
          super("Control the map", JToolBar.HORIZONTAL);
      this.toolButtons     = new TreeMap<Integer,JToggleButton>();
      this.toolButtonGroup = new ButtonGroup();
      this.actionButtons   = new TreeMap<Integer,JButton>();
      // Create a Listener to sniff the zooms on the JMapPane
      this.mapPaneListener = new JMapPaneListener() {
          public void performMapPaneEvent(JMapPaneEvent e) {
              if ( !(e instanceof MapAreaChangedEvent) )
                return;
                
              if ( zoomBackForwardButtonInAction ) {
                zoomBackForwardButtonInAction = false;
                return;
              }
             
              Envelope oldMapArea = ((MapAreaChangedEvent)e).getOldMapArea();
              if (lastZooms.size() == 0 && oldMapArea != null ) {
                lastZooms.add(oldMapArea);
                zoomBackIndex = 1;
              }

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

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

              lastZooms.add(mapArea);
              zoomBackIndex = lastZooms.size();
              setButtonEnabled(ACTION_ZOOM_BACK, lastZooms.size() > 1);
              setButtonEnabled(ACTION_ZOOM_FORWARD, false);
          }
      };    
     
      setMapPane(mapPane);
          setFloatable(false);
          setRollover(true);
          
          init();
        }
        
        /**
         * Sets the {@link JMapPane} controlled by this tool bar.
         * @param mapPane {@link JMapPane} to control (if {@code null} this
         *                tool bar controls NOTHING!)
         */
        public void setMapPane(JMapPane mapPane) {
          // Remove listener from old MapPane
          if ( this.mapPane != null )
            this.mapPane.removeMapPaneListener( mapPaneListener );
      this.mapPane = mapPane;
      if ( this.mapPane != null && mapPaneListener != null )
        this.mapPane.addMapPaneListener( mapPaneListener );
        }
        
        /**
         * Calls {@link #initTools()} and {@link #initActions()} and then puts
         * all tool buttons and all actions buttons to the tool bar.
         */
        protected void init() {
          initTools();
          initActions();
          initToolBar();
        }


        /**
         * Creates the tool buttons, adds them to {@link #toolButtons} and finally
         * creates a button group for all tools. So sub-classes which override this
         * method should FIRST add their new tool buttons to {@link #toolButtons}
         * before calling {@code super.initTools()}.
         */
        protected void initTools() {
      // Panning
      addTool( new MapPaneToolBarAction(
          TOOL_PAN,
          this,
          "",
          new ImageIcon(MapView.class.getResource("pan.png"))
      ), false );
      // Info
      addTool( new MapPaneToolBarAction(
          TOOL_INFO, 
          this, 
          "",
          new ImageIcon(MapView.class.getResource("info.png"))
      ), false );
      // Zoom in
      addTool( new MapPaneToolBarAction(
          TOOL_ZOOMIN,
          this,
          "",
          new ImageIcon(MapView.class.getResource("zoom_in.png"))
      ), false );
      // Zoom out
      addTool( new MapPaneToolBarAction(
          TOOL_ZOOMOUT,
          this,
          "",
          new ImageIcon(MapView.class.getResource("zoom_out.png"))
      ), false );
      
          // set the selected tool enabled
      setSelectedTool(selectedTool);
      
        }

    /**
     * Creates the action buttons and adds them to {@link #actionButtons}.
     */
    protected void initActions() {
      // Action button to revert the last zoom
      addAction( new MapPaneToolBarAction(
          ACTION_ZOOM_BACK,
          this,
          "",
          new ImageIcon(MapView.class.getResource("zoom_back.png"))
      ), false);
      setButtonEnabled( ACTION_ZOOM_BACK, false );

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

    }
    
    /**
     * Clears the GUI of all components and adds all tool and action buttons to the
     * tool bar.
     */
    protected void initToolBar() {
      setAlignmentY( 1f );
      removeAll();
      // Separator to the left of the tool actions to start
      // the tool buttons with the map (not with the coordinate grid)
      Dimension dimension = new Dimension( 49,10);
      addSeparator(dimension);
      // Tool buttons
      for (JToggleButton b : toolButtons.values())
        add(b);
      // Space between tool buttons and action buttons
      Dimension dimension2 = new Dimension( 10,10);
      this.addSeparator(dimension2);
      // Action buttons
      for (JButton b : actionButtons.values())
        add(b);
    }
    
        /**
         * Performs the activation of a tool.
         * @param tool the tool to activate
         * @param e    the event of the button
         */
        public void performToolButton(int tool, ActionEvent e) {
          if ( mapPane == null )
            return;
          
          selectedTool = tool;
          
      switch( tool ) {
        case TOOL_PAN:
          // Set the mouse tool to "Panning"
          mapPane.setWindowSelectionState(JMapPane.NONE);
          mapPane.setState(JMapPane.PAN);
          mapPane.setHighlight(false);
          mapPane.setNormalCursor(SwingUtil.PAN_CURSOR);
          break;
        case TOOL_INFO: 
          // Set the mouse tool to "Info"
          mapPane.setWindowSelectionState(JMapPane.NONE);
          mapPane.setState(JMapPane.SELECT_TOP);
          mapPane.setHighlight(true);
          mapPane.setNormalCursor(SwingUtil.CROSSHAIR_CURSOR);
          break;
        case TOOL_ZOOMIN:
          // Set the mouse tool to "Zoom in"
          mapPane.setWindowSelectionState(JMapPane.ZOOM_IN);
          mapPane.setState(JMapPane.ZOOM_IN);
          mapPane.setHighlight(false);
          mapPane.setNormalCursor(SwingUtil.ZOOMIN_CURSOR);
          break;
        case TOOL_ZOOMOUT:
          // Set the mouse tool to "Zoom out"
          mapPane.setWindowSelectionState(JMapPane.NONE);
          mapPane.setState(JMapPane.ZOOM_OUT);
          mapPane.setHighlight(false);
          mapPane.setNormalCursor(SwingUtil.ZOOMOUT_CURSOR);
          break;
        default:
          // Set map actions to default
          mapPane.setWindowSelectionState(JMapPane.NONE);
          mapPane.setState(JMapPane.NONE);
          mapPane.setHighlight(false);
          mapPane.setNormalCursor(null);
          break;
      }
      mapPane.updateCursor();
        }
        
    /**
     * Performs the action of an action button.
     * @param tool the action
     * @param e    the event of the button
     */
        protected void performActionButton(int action, ActionEvent e) {
      if ( mapPane == null )
        return;

      // Perform the action "Zoom back": Revert the last zoom
      if ( action == ACTION_ZOOM_BACK ) {
            if (zoomBackIndex <= 1)
          return;
  
        zoomBackForwardButtonInAction = true;
        zoomBackIndex--;
        getButton(ACTION_ZOOM_FORWARD).setEnabled(true);
        getButton(ACTION_ZOOM_BACK).setEnabled( zoomBackIndex > 1 );
  
        mapPane.setMapArea( lastZooms.get(zoomBackIndex-1) );
        mapPane.refresh();
      }

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

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

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

    /**
     * Adds an action to the tool bar and resets the toolbar GUI.
     * @param buttonAction action for the toggle button
     */
    public void addAction(MapPaneToolBarAction buttonAction) {
      addAction(buttonAction, true);
    }
    
    /**
     * Returns the button for a specific tool or action.
     * @param id the constant for a tool
     * @return a {@link JButton} if {@code id} specifies an {@linkplain #getActionButton(int) action button}
     *         or {@link JToogleButton} if {@code id} specifies a {@linkplain #getToolButton(int) tool button}
     */
    public AbstractButton getButton(int id) {
      AbstractButton button = toolButtons.get(id);
      if ( button == null )
        button = actionButtons.get(id);
      if ( button == null )
        LOGGER.warn("Unknown tool or action ID: "+id);
      return button;
    }

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

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

    }

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

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

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

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

    /**
     * Sets the activation for all tools.
     * @param enabled if {@code true} all tools becomes available
     * @param hideOnDisable if {@code true} the buttons are also hidden if
     *                      {@code enabled} is {@code false}
     */
    public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {
      for (int tool : toolButtons.keySet())
        setButtonEnabled(tool,enabled,hideOnDisable);
    }   

    /**
     * Sets the activation for all actions.
     * @param enabled if {@code true} all actions becomes available
     * @param hideOnDisable if {@code true} the buttons are also hidden if
     *                      {@code enabled} is {@code false}
     */
    public void setAllActionsEnabled(boolean enabled, boolean hideOnDisable) {
      for (int tool : actionButtons.keySet())
        setButtonEnabled(tool,enabled,hideOnDisable);
    }   
    
    /**
     * Returns the maximum ID of tools. 
     */
    public int getMaxToolID() {
      return toolButtons.lastKey();
    }

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

    /**
     * Returns the maximum ID of actions. 
     */
    public int getMaxActionID() {
      return actionButtons.lastKey();
    }

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

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

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

      /**
       * Creates a new action.
       * @param id      unique ID for the action
       * @param toolBar toolbar this action is made for
       * @param name    description used for buttons or menus 
       * @param icon    icon used for buttons or menus 
       */
      public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name, Icon icon) {
        super(name,icon);
        this.id      = id;
        this.toolBar = toolBar;
      }
      
      /**
       * Calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)}
       * or {@link MapPaneToolBar#performActionButton(int, ActionEvent)}
       * depending on whether the action is added to the toolbar via
       * {@link MapPaneToolBar#addTool(MapPaneToolBarAction)}
       * or {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
       */
      public void actionPerformed(ActionEvent e) {
        if ( toolBar.toolButtons.get(id) != null )
          toolBar.performToolButton(id, e);
        if ( toolBar.actionButtons.get(id) != null )
          toolBar.performActionButton(id, e);
      }
      
      /**
       * Returns the (unique) id of this action.
       * @return
       */
      public int getID() {
        return id;
      }
    }
}
1	mojays	2	package skrueger.geotools;
2
3			import java.awt.Dimension;
4			import java.awt.event.ActionEvent;
5			import java.util.ArrayList;
6			import java.util.SortedMap;
7			import java.util.TreeMap;
8
9			import javax.swing.AbstractAction;
10			import javax.swing.AbstractButton;
11			import javax.swing.BorderFactory;
12			import javax.swing.Icon;
13			import javax.swing.ImageIcon;
14			import javax.swing.JButton;
15			import javax.swing.JToggleButton;
16			import javax.swing.JToolBar;
17
18			import org.apache.log4j.Logger;
19
20			import schmitzm.geotools.gui.JMapPane;
21			import schmitzm.geotools.map.event.JMapPaneEvent;
22			import schmitzm.geotools.map.event.JMapPaneListener;
23			import schmitzm.geotools.map.event.MapAreaChangedEvent;
24			import schmitzm.swing.ButtonGroup;
25			import schmitzm.swing.SwingUtil;
26
27			import com.vividsolutions.jts.geom.Envelope;
28
29			/**
30			* A toolbar to controll a {@link JMapPane} (Atlas visualization). This contains two types
31			* of buttons. A group of <i>tools</i> for the mouse actions on the map represented
32			* by {@link JToggleButton JToggleButtons}, where only one tool can be activated
33			* every time. And some (general) <i>actions</i>, represented by normal
34			* {@link JButton JButtons}.
35			* @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)
36			*/
37			public class MapPaneToolBar extends JToolBar {
38			private static final Logger LOGGER = Logger.getLogger(MapPaneToolBar.class.getName());
39			/** Constant for the tool "Panning" (10). */
40			public static final int TOOL_PAN = 10;
41			/** Constant for the tool "Zoom In" (30). */
42			public static final int TOOL_ZOOMIN = 30;
43			/** Constant for the tool "Zoom Out" (40). */
44			public static final int TOOL_ZOOMOUT = 40;
45			/** Constant for the tool "Info" (20). */
46			public static final int TOOL_INFO = 20;
47
48			/** Tool currently selected */
49			protected int selectedTool = TOOL_ZOOMIN;
50			/** Holds the tool buttons of the tool bar. */
51			protected SortedMap<Integer, JToggleButton> toolButtons = null;
52			/** Controls that only one tool button is activated. */
53			protected ButtonGroup toolButtonGroup = null;
54			/** Constant for the action "Zoom back" (100). */
55			public static final int ACTION_ZOOM_BACK = 100;
56			/** Constant for the action "Zoom forward" (110). */
57			public static final int ACTION_ZOOM_FORWARD = 110;
58	alfonx	48	/** Constant for the action "Search Labels" (120). */
59			public static final int ACTION_SEARCH = 120;
60	mojays	2
61			/** Holds the action buttons of the bar. */
62			protected SortedMap<Integer, JButton> actionButtons = null;
63
64			/** Holds the {@link JMapPane} this tool bar controls. */
65			protected JMapPane mapPane = null;
66
67			/**
68			* A List to remember the last Envelopes that have been watched. Used for
69			* the zoomBack- and zoomForwardButtons *
70			*/
71			protected ArrayList<Envelope> lastZooms = new ArrayList<Envelope>();
72			/** Holds the index to the current element in {@link #lastZooms}. */
73			protected int zoomBackIndex = 0;
74
75			/** Listener to sniff the zoom actions on the map. */
76			protected JMapPaneListener mapPaneListener = null;
77
78			protected boolean zoomBackForwardButtonInAction;
79
80			/**
81			* Creates a new toolbar. Notice: This toolbar does nothing
82			* until {@link #setMapPane(JMapPane)} is called!
83			*/
84			public MapPaneToolBar() {
85			this(null);
86			}
87
88			/**
89			* Creates a new tool bar.
90			* @param mapPane {@link JMapPane} the tool bar controls
91			*/
92			public MapPaneToolBar(JMapPane mapPane) {
93			super("Control the map", JToolBar.HORIZONTAL);
94			this.toolButtons = new TreeMap<Integer,JToggleButton>();
95			this.toolButtonGroup = new ButtonGroup();
96			this.actionButtons = new TreeMap<Integer,JButton>();
97			// Create a Listener to sniff the zooms on the JMapPane
98			this.mapPaneListener = new JMapPaneListener() {
99			public void performMapPaneEvent(JMapPaneEvent e) {
100			if ( !(e instanceof MapAreaChangedEvent) )
101			return;
102
103			if ( zoomBackForwardButtonInAction ) {
104			zoomBackForwardButtonInAction = false;
105			return;
106			}
107
108			Envelope oldMapArea = ((MapAreaChangedEvent)e).getOldMapArea();
109			if (lastZooms.size() == 0 && oldMapArea != null ) {
110			lastZooms.add(oldMapArea);
111			zoomBackIndex = 1;
112			}
113
114			final Envelope mapArea = ((MapAreaChangedEvent)e).getNewMapArea();
115			if (mapArea == null)
116			return;
117
118			if (lastZooms.size() > 0 && mapArea.equals(lastZooms.get(lastZooms.size() - 1))) {
119			// LOGGER.debug("MapAreaChangedEvent ausgelassen bei der Zaehlung der Zoomschritt weil identisch");
120			return;
121			}
122
123			if (lastZooms.size() > 0)
124			while (zoomBackIndex < lastZooms.size())
125			lastZooms.remove(lastZooms.size() - 1);
126
127			lastZooms.add(mapArea);
128			zoomBackIndex = lastZooms.size();
129			setButtonEnabled(ACTION_ZOOM_BACK, lastZooms.size() > 1);
130			setButtonEnabled(ACTION_ZOOM_FORWARD, false);
131			}
132			};
133
134			setMapPane(mapPane);
135			setFloatable(false);
136			setRollover(true);
137
138			init();
139			}
140
141			/**
142			* Sets the {@link JMapPane} controlled by this tool bar.
143			* @param mapPane {@link JMapPane} to control (if {@code null} this
144			* tool bar controls NOTHING!)
145			*/
146			public void setMapPane(JMapPane mapPane) {
147			// Remove listener from old MapPane
148			if ( this.mapPane != null )
149			this.mapPane.removeMapPaneListener( mapPaneListener );
150			this.mapPane = mapPane;
151			if ( this.mapPane != null && mapPaneListener != null )
152			this.mapPane.addMapPaneListener( mapPaneListener );
153			}
154
155			/**
156			* Calls {@link #initTools()} and {@link #initActions()} and then puts
157			* all tool buttons and all actions buttons to the tool bar.
158			*/
159			protected void init() {
160			initTools();
161			initActions();
162			initToolBar();
163			}
164
165
166			/**
167			* Creates the tool buttons, adds them to {@link #toolButtons} and finally
168			* creates a button group for all tools. So sub-classes which override this
169			* method should FIRST add their new tool buttons to {@link #toolButtons}
170			* before calling {@code super.initTools()}.
171			*/
172			protected void initTools() {
173			// Panning
174			addTool( new MapPaneToolBarAction(
175			TOOL_PAN,
176			this,
177			"",
178			new ImageIcon(MapView.class.getResource("pan.png"))
179			), false );
180			// Info
181			addTool( new MapPaneToolBarAction(
182			TOOL_INFO,
183			this,
184			"",
185			new ImageIcon(MapView.class.getResource("info.png"))
186			), false );
187			// Zoom in
188			addTool( new MapPaneToolBarAction(
189			TOOL_ZOOMIN,
190			this,
191			"",
192			new ImageIcon(MapView.class.getResource("zoom_in.png"))
193			), false );
194			// Zoom out
195			addTool( new MapPaneToolBarAction(
196			TOOL_ZOOMOUT,
197			this,
198			"",
199			new ImageIcon(MapView.class.getResource("zoom_out.png"))
200			), false );
201
202			// set the selected tool enabled
203			setSelectedTool(selectedTool);
204
205			}
206
207			/**
208			* Creates the action buttons and adds them to {@link #actionButtons}.
209			*/
210			protected void initActions() {
211			// Action button to revert the last zoom
212			addAction( new MapPaneToolBarAction(
213			ACTION_ZOOM_BACK,
214			this,
215			"",
216			new ImageIcon(MapView.class.getResource("zoom_back.png"))
217			), false);
218			setButtonEnabled( ACTION_ZOOM_BACK, false );
219
220			// Action button to redo the last zoom
221			addAction( new MapPaneToolBarAction(
222			ACTION_ZOOM_FORWARD,
223			this,
224			"",
225			new ImageIcon(MapView.class.getResource("zoom_forward.png"))
226			), false);
227			setButtonEnabled( ACTION_ZOOM_FORWARD, false );
228	alfonx	48
229	mojays	2	}
230
231			/**
232			* Clears the GUI of all components and adds all tool and action buttons to the
233			* tool bar.
234			*/
235			protected void initToolBar() {
236			setAlignmentY( 1f );
237			removeAll();
238			// Separator to the left of the tool actions to start
239			// the tool buttons with the map (not with the coordinate grid)
240			Dimension dimension = new Dimension( 49,10);
241			addSeparator(dimension);
242			// Tool buttons
243			for (JToggleButton b : toolButtons.values())
244			add(b);
245			// Space between tool buttons and action buttons
246			Dimension dimension2 = new Dimension( 10,10);
247			this.addSeparator(dimension2);
248			// Action buttons
249			for (JButton b : actionButtons.values())
250			add(b);
251			}
252
253			/**
254			* Performs the activation of a tool.
255			* @param tool the tool to activate
256			* @param e the event of the button
257			*/
258			public void performToolButton(int tool, ActionEvent e) {
259			if ( mapPane == null )
260			return;
261
262			selectedTool = tool;
263
264			switch( tool ) {
265			case TOOL_PAN:
266			// Set the mouse tool to "Panning"
267			mapPane.setWindowSelectionState(JMapPane.NONE);
268			mapPane.setState(JMapPane.PAN);
269			mapPane.setHighlight(false);
270			mapPane.setNormalCursor(SwingUtil.PAN_CURSOR);
271			break;
272			case TOOL_INFO:
273			// Set the mouse tool to "Info"
274			mapPane.setWindowSelectionState(JMapPane.NONE);
275			mapPane.setState(JMapPane.SELECT_TOP);
276			mapPane.setHighlight(true);
277			mapPane.setNormalCursor(SwingUtil.CROSSHAIR_CURSOR);
278			break;
279			case TOOL_ZOOMIN:
280			// Set the mouse tool to "Zoom in"
281			mapPane.setWindowSelectionState(JMapPane.ZOOM_IN);
282			mapPane.setState(JMapPane.ZOOM_IN);
283			mapPane.setHighlight(false);
284			mapPane.setNormalCursor(SwingUtil.ZOOMIN_CURSOR);
285			break;
286			case TOOL_ZOOMOUT:
287			// Set the mouse tool to "Zoom out"
288			mapPane.setWindowSelectionState(JMapPane.NONE);
289			mapPane.setState(JMapPane.ZOOM_OUT);
290			mapPane.setHighlight(false);
291			mapPane.setNormalCursor(SwingUtil.ZOOMOUT_CURSOR);
292			break;
293			default:
294			// Set map actions to default
295			mapPane.setWindowSelectionState(JMapPane.NONE);
296			mapPane.setState(JMapPane.NONE);
297			mapPane.setHighlight(false);
298			mapPane.setNormalCursor(null);
299			break;
300			}
301			mapPane.updateCursor();
302			}
303
304			/**
305			* Performs the action of an action button.
306			* @param tool the action
307			* @param e the event of the button
308			*/
309			protected void performActionButton(int action, ActionEvent e) {
310			if ( mapPane == null )
311			return;
312
313			// Perform the action "Zoom back": Revert the last zoom
314			if ( action == ACTION_ZOOM_BACK ) {
315			if (zoomBackIndex <= 1)
316			return;
317
318			zoomBackForwardButtonInAction = true;
319			zoomBackIndex--;
320			getButton(ACTION_ZOOM_FORWARD).setEnabled(true);
321			getButton(ACTION_ZOOM_BACK).setEnabled( zoomBackIndex > 1 );
322
323			mapPane.setMapArea( lastZooms.get(zoomBackIndex-1) );
324			mapPane.refresh();
325			}
326
327			// Perform the action "Zoom forward": Redo the last zoom
328			if ( action == ACTION_ZOOM_FORWARD ) {
329			if (zoomBackIndex < lastZooms.size()) {
330			zoomBackForwardButtonInAction = true;
331			zoomBackIndex++;
332			getButton(ACTION_ZOOM_BACK).setEnabled(true);
333			getButton(ACTION_ZOOM_FORWARD).setEnabled(zoomBackIndex < lastZooms.size());
334
335			mapPane.setMapArea( lastZooms.get(zoomBackIndex-1) );
336			mapPane.refresh();
337			}
338			}
339			}
340
341
342			/**
343			* Adds a tool to the tool bar. Does nothing if a tool or action with the
344			* specified ID already exists!
345			* @param buttonAction action for the toggle button
346			* @param resetToolBar indicates whether the toolbar GUI is reset after adding
347			* the button (if adding several actions it useful only to
348			* reset the GUI for the last added tool)
349			*/
350			public void addTool(MapPaneToolBarAction buttonAction, boolean resetToolBar) {
351			if ( isButtonIDUsed(buttonAction.getID()) ) {
352			LOGGER.warn("addTool(.) ignored because ID already used for tool or action: "+buttonAction.getID());
353			return;
354			}
355			JToggleButton button = new JToggleButton(buttonAction);
356			button.setBorder( BorderFactory.createRaisedBevelBorder() );
357			toolButtonGroup.add(button);
358			toolButtons.put(buttonAction.getID(), button);
359			if ( resetToolBar )
360			initToolBar();
361			}
362
363			/**
364			* Adds a tool to the tool bar and resets the toolbar GUI.
365			* @param buttonAction action for the toggle button
366			*/
367			public void addTool(MapPaneToolBarAction buttonAction) {
368			addTool(buttonAction, true);
369			}
370
371			/**
372			* Adds an action to the tool bar. Does nothing if a tool or action with the
373			* specified ID already exists!
374			* @param buttonAction action for the button
375			* @param resetToolBar indicates whether the toolbar GUI is reset after adding
376			* the button (if adding several actions it useful only to
377			* reset the GUI for the last added tool)
378			*/
379			public void addAction(MapPaneToolBarAction buttonAction, boolean resetToolBar) {
380			if ( isButtonIDUsed(buttonAction.getID()) ) {
381			LOGGER.warn("addAction(.) ignored because ID already used for tool or action: "+buttonAction.getID());
382			return;
383			}
384			JButton button = new JButton(buttonAction);
385			actionButtons.put( buttonAction.getID(), button );
386			if ( resetToolBar )
387			initToolBar();
388			}
389
390			/**
391			* Adds an action to the tool bar and resets the toolbar GUI.
392			* @param buttonAction action for the toggle button
393			*/
394			public void addAction(MapPaneToolBarAction buttonAction) {
395			addAction(buttonAction, true);
396			}
397
398			/**
399			* Returns the button for a specific tool or action.
400			* @param id the constant for a tool
401			* @return a {@link JButton} if {@code id} specifies an {@linkplain #getActionButton(int) action button}
402			* or {@link JToogleButton} if {@code id} specifies a {@linkplain #getToolButton(int) tool button}
403			*/
404			public AbstractButton getButton(int id) {
405			AbstractButton button = toolButtons.get(id);
406			if ( button == null )
407			button = actionButtons.get(id);
408			if ( button == null )
409			LOGGER.warn("Unknown tool or action ID: "+id);
410			return button;
411			}
412
413			/**
414			* Returns the button for a specific tool.
415			* @param tool the constant for a tool
416			*/
417			public JToggleButton getToolButton(int tool) {
418			AbstractButton button = getButton(tool);
419			if ( button != null && !(button instanceof JToggleButton) ) {
420			LOGGER.warn("ID specifies no tool: "+tool);
421			button = null;
422			}
423			return (JToggleButton)button;
424			}
425
426			/**
427			* Returns the button for a specific action.
428			* @param action the constant an action
429			*/
430			public JButton getActionButton(int action) {
431			AbstractButton button = getButton(action);
432			if ( button != null && !(button instanceof JButton) ) {
433			LOGGER.warn("ID specifies no action: "+action);
434			button = null;
435			}
436			return (JButton)button;
437
438			}
439
440			/**
441			* Sets the selected tool.
442			* @param tool ID of the tool
443			*/
444			public void setSelectedTool(Integer tool) {
445			if ( tool == null )
446			toolButtonGroup.setUnselected();
447
448			JToggleButton button = getToolButton(tool);
449			if ( button == null )
450			return;
451			button.setSelected( true );
452			button.getAction().actionPerformed(null);
453			}
454
455			/**
456			* Returns the selected tool.
457			* @return -1 if no tool is active
458			*/
459			public int getSelectedTool() {
460			if ( toolButtonGroup.getSelectedButton() == null )
461			return -1;
462			return selectedTool;
463			}
464
465			/**
466			* Sets whether a tool or action is activated or not. The visible property
467			* of the button is not affected.
468			* @param id tool or actionID
469			* @param enabled if {@code true} the tool becomes available
470			*/
471			public void setButtonEnabled(int id, boolean enabled) {
472			AbstractButton button = getButton(id);
473			if ( button == null )
474			return;
475			button.setEnabled( enabled );
476			}
477
478			/**
479			* Sets whether a tool or action is activated or not.
480			* @param id tool or actionID
481			* @param enabled if {@code true} the tool becomes available
482			* @param hideOnDisable if {@code true} the button is also hidden if
483			* {@code enabled} is {@code false}
484			*/
485			public void setButtonEnabled(int id, boolean enabled, boolean hideOnDisable) {
486			AbstractButton button = getButton(id);
487			if ( button == null )
488			return;
489			button.setEnabled( enabled );
490			// if button is enabled, it becomes visible anyway
491			// if button is disabled and the "hide" option is set, it is also hidden
492			if ( enabled )
493			button.setVisible( true );
494			else
495			button.setVisible( !hideOnDisable );
496			}
497
498			/**
499			* Checks whether a ID is already used for a tool or action.
500			* @param tool tool ID
501			*/
502			public boolean isButtonIDUsed(int id) {
503			return toolButtons.get(id) != null \|\| actionButtons.get(id) != null;
504			}
505
506			/**
507			* Checks whether a tool is activated.
508			* @param tool tool ID
509			* @return {@code false} if an unknown ID is specified
510			*/
511			public boolean isButtonEnabled(int id) {
512			AbstractButton button = getButton(id);
513			if ( button != null )
514			return button.isEnabled();
515			return false;
516			}
517
518			/**
519			* Sets the activation for all tools.
520			* @param enabled if {@code true} all tools becomes available
521			* @param hideOnDisable if {@code true} the buttons are also hidden if
522			* {@code enabled} is {@code false}
523			*/
524			public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {
525			for (int tool : toolButtons.keySet())
526			setButtonEnabled(tool,enabled,hideOnDisable);
527			}
528
529			/**
530			* Sets the activation for all actions.
531			* @param enabled if {@code true} all actions becomes available
532			* @param hideOnDisable if {@code true} the buttons are also hidden if
533			* {@code enabled} is {@code false}
534			*/
535			public void setAllActionsEnabled(boolean enabled, boolean hideOnDisable) {
536			for (int tool : actionButtons.keySet())
537			setButtonEnabled(tool,enabled,hideOnDisable);
538			}
539
540			/**
541			* Returns the maximum ID of tools.
542			*/
543			public int getMaxToolID() {
544			return toolButtons.lastKey();
545			}
546
547			/**
548			* Returns the minimum ID of tools.
549			*/
550			public int getMinToolID() {
551			return toolButtons.firstKey();
552			}
553
554			/**
555			* Returns the maximum ID of actions.
556			*/
557			public int getMaxActionID() {
558			return actionButtons.lastKey();
559			}
560
561			/**
562			* Returns the minimum ID of actions.
563			*/
564			public int getMinActionID() {
565			return actionButtons.firstKey();
566			}
567
568			/**
569			* Extends the {@link AbstractAction} with maintaining an ID and
570			* the {@link MapPaneToolBar} the actions controls.
571			* Additionally this class automatically calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)}
572			* or {@link MapPaneToolBar#performActionButton(int, ActionEvent)}
573			* depending on whether the action is added via {@link MapPaneToolBar#addTool(MapPaneToolBarAction)}
574			* or {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
575			* @author <a href="mailto:[email protected]">Martin Schmitz</a> (University of Bonn/Germany)
576			*/
577			public static class MapPaneToolBarAction extends AbstractAction {
578			/** The ID of the action */
579			protected int id = -1;
580			/** The tool bar, this action is made for. */
581			protected MapPaneToolBar toolBar = null;
582
583			/**
584			* Creates a new action with a dummy description and no icon.
585			* @param id unique ID for the action
586			* @param toolBar toolbar this action is made for
587			*/
588			public MapPaneToolBarAction(int id, MapPaneToolBar toolBar) {
589			this(id,toolBar,""+id);
590			}
591
592			/**
593			* Creates a new action without an icon.
594			* @param id unique ID for the action
595			* @param toolBar toolbar this action is made for
596			* @param name description used for buttons or menus
597			*/
598			public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name) {
599			this(id,toolBar,name,null);
600			}
601
602			/**
603			* Creates a new action.
604			* @param id unique ID for the action
605			* @param toolBar toolbar this action is made for
606			* @param name description used for buttons or menus
607			* @param icon icon used for buttons or menus
608			*/
609			public MapPaneToolBarAction(int id, MapPaneToolBar toolBar, String name, Icon icon) {
610			super(name,icon);
611			this.id = id;
612			this.toolBar = toolBar;
613			}
614	alfonx	48
615	mojays	2	/**
616			* Calls {@link MapPaneToolBar#performToolButton(int, ActionEvent)}
617			* or {@link MapPaneToolBar#performActionButton(int, ActionEvent)}
618			* depending on whether the action is added to the toolbar via
619			* {@link MapPaneToolBar#addTool(MapPaneToolBarAction)}
620			* or {@link MapPaneToolBar#addAction(MapPaneToolBarAction)}.
621			*/
622			public void actionPerformed(ActionEvent e) {
623			if ( toolBar.toolButtons.get(id) != null )
624			toolBar.performToolButton(id, e);
625			if ( toolBar.actionButtons.get(id) != null )
626			toolBar.performActionButton(id, e);
627			}
628
629			/**
630			* Returns the (unique) id of this action.
631			* @return
632			*/
633			public int getID() {
634			return id;
635			}
636			}
637			}