skrueger/geotools/MapPaneToolBar.java

package skrueger.geotools;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

import javax.swing.AbstractAction;
import javax.swing.AbstractButton;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.JToggleButton;
import javax.swing.JToolBar;

import org.apache.log4j.Logger;

import schmitzm.geotools.gui.GeoMapPane;
import schmitzm.geotools.gui.JMapPane;
import schmitzm.geotools.gui.MapContextControlPane;
import schmitzm.geotools.gui.MapPaneStatusBar;
import schmitzm.geotools.map.event.JMapPaneEvent;
import schmitzm.geotools.map.event.JMapPaneListener;
import schmitzm.geotools.map.event.MapAreaChangedEvent;
import schmitzm.geotools.styling.ColorMapManager;
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;

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