skrueger/geotools/MapView.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 javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
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.SwingUtil;

import com.vividsolutions.jts.geom.Envelope;

/**
 * Achtung! Dieser code ist verwuestet
 */

/**
 * TODO DOKU und initialize schöner machen. SK
 */
public class MapView extends JPanel {
        private static final Logger LOGGER = Logger.getLogger(MapView.class);

        private final JSplitPane splitPane = new JSplitPane(
                        JSplitPane.HORIZONTAL_SPLIT);

        protected MapPaneStatusBar statusBar = null;
        
        /**
         * Komponente, in der die Karten, der Massstab und das Koordinaten-Raster
         * dargestellt werden
         */
        protected final GeoMapPane geoMapPane = new GeoMapPane();

//
//      /** This is the layered Pane that holds the buttons and maybe the flying logo * */
//      protected JLayeredPane layeredPane;

        protected boolean zoomBackForwardButtonInAction;

        private MapPaneToolBar jToolBar;

        /**
         * Creates a new {@link MapView}. A {@link MapView} is a combination of a
         * {@link GeoMapPane}, a {@link MapContextManagerInterface} on the left,
         * and some buttons floating over the {@link JMapPane}
         */
        public MapView(Window owner2, MapPaneToolBar toolBar) {
                super(new BorderLayout());
                // Call initialize() by yourself afterwards.
                // Needed because variables for the overwritten methods
                // are not yet set.
                getGeoMapPane().getMapPane().setWaitCursorComponent(owner2);
                if ( toolBar == null )
                  toolBar = new MapPaneToolBar(getMapPane());
                jToolBar = toolBar; 
        }

    /**
     * Creates a new {@link MapView}. A {@link MapView} is a combination of a
     * {@link GeoMapPane}, a {@link MapContextManagerInterface} on the left,
     * and some buttons floating over the {@link JMapPane}
     */
    public MapView(Window owner2) {
      this(owner2, null);
    }

    // /**
        // * Nuetzlich wenn die Componente gedruckt wird. Dann wird der Hintergrund
        // auf {@link Color#WHITE} gesetzt.zoomoutToggleButton
        // *
        // * @author <a href="mailto:[email protected]">Stefan Alfons
        // Kr&uuml;ger</a>
        // */
        // @Override
        // public void print(Graphics g) {
        //              
        // // SK: Ich habe keine Ahnung mehr, was das soll... Ich habs mal
        // auskommentiert.
        //
        // // wrap in try/finally so that we always restore the state
        // try {
        // panToggleButton.setVisible(false);
        // zoominToggleButton.setVisible(false);
        // zoomoutToggleButton.setVisible(false);
        // infoToggleButton.setVisible(false);
        //
        // super.print(g);
        // } finally {
        // panToggleButton.setVisible(true);
        // zoominToggleButton.setVisible(true);
        // zoomoutToggleButton.setVisible(true);
        // infoToggleButton.setVisible(true);
        // }
        // }

        /**
         * Calls #getSidePanel() which can be overwritten.
         * 
         * @see #adjustSizeOfGeoMapPane()
         */
        public void initialize() {
                // horizontales SplitPane initialisieren

                // Status-Zeile
                statusBar = new MapPaneStatusBar(getGeoMapPane()
                                .getMapPane());
                statusBar.setBorder(BorderFactory.createCompoundBorder(BorderFactory
                                .createLoweredBevelBorder(), BorderFactory.createEmptyBorder(2,
                                5, 2, 5)));
                this.add(statusBar, BorderLayout.SOUTH);

                splitPane.setDividerLocation(0.4);
                splitPane.setDividerSize(5);

                splitPane.add(getSidePane());

                /***********************************************************************
                 * To the right side we now add a JPanel that consists of a toolbar and
                 * a gmp
                 */
                JPanel newRight = new JPanel(new BorderLayout());
                newRight.add(getToolBar(), BorderLayout.NORTH);
                newRight.add(getGeoMapPane(), BorderLayout.CENTER);
                splitPane.add(newRight);

                // gpSize = new Dimension(40,50);
                // getGeoMapPane().setSize(gpSize);

                // layeredPane = new JLayeredPane();
                // layeredPane.add(getGeoMapPane(), JLayeredPane.DEFAULT_LAYER);
                // createMapButtons(layeredPane);

                // //****************************************************************************
                // // The JLayeredPane doesn't manage the size of its layers.. we do it
                // // This listener will actually correct the size of the JLayeredPane
                // //****************************************************************************
                // splitPane.addPropertyChangeListener(new PropertyChangeListener() {
                //
                // public void propertyChange(final PropertyChangeEvent evt) {
                // final JSplitPane sp = (JSplitPane) evt.getSource();
                //
                // adjustSizeOfGeoMapPane();
                //
                // }
                //
                // });

                this.add(splitPane, BorderLayout.CENTER);
        }

        /**
         * Returns the tool bar which controls the active mouse actions on the map.
         * @return
         */
        public MapPaneToolBar getToolBar() {
          return jToolBar;
        }

        /**
         * Returns the split pane which divides the layer list from the map panel.
         */
        public JSplitPane getSplitPane() {
                return this.splitPane;
        }

        //
        // /**
        // * Called by the listerner. Calculates the exact size of the {@link
        // GeoMapPane} and sets it.
        // */
        // private void adjustSizeOfGeoMapPane() {
        // final int newWidth = (int) (splitPane.getSize().getWidth()
        // - splitPane.getComponent(1).getSize().getWidth()
        // - splitPane.getComponent(0).getSize().getWidth())
        // - 4;
        // final int newHeight = (int) splitPane.getComponent(1).getSize()
        // .getHeight();
        //
        // if (newWidth <= 20 )
        // return;
        //
        // gpSize.setSize(newWidth, newHeight);
        //
        // getGeoMapPane().getMapPane().setWaitCursorDuringNextRepaint(true);
        //
        // getGeoMapPane().setSize( gpSize );
        // // getGeoMapPane().refreshMap(); nicht nötig .. schön
        //
        // positionLayeredObjects();
        // }
//
//      /**
//       * Adds the floating Map Contol Buttons to the {@link JLayeredPane}, with Z =
//       * 10
//       * 
//       * @param lp
//       *            {@link JLayeredPane} that contains the {@link GeoMapPane}
//       */
//      private void createMapButtons(final JLayeredPane lp) {
//
//              final Integer zlayer = new Integer(10);
//
//              toggleButtonsList = new LinkedList<JToggleButton>();
//              toggleButtonsList.add(infoToggleButton);
//              toggleButtonsList.add(panToggleButton);
//              toggleButtonsList.add(zoominToggleButton);
//              toggleButtonsList.add(zoomoutToggleButton);
//
//
//              positionLayeredObjects();
//
//              final ButtonGroup bg = new ButtonGroup();
//              for (final JToggleButton b : toggleButtonsList) {
//                      // final FontMetrics fm = b.getFontMetrics( b.getFont() );
//                      // final int w = fm.stringWidth( b.getText() );
//
//                      // b.setBorder( BorderFactory.createRaisedBevelBorder() );
//                      b.setBorder(BorderFactory.createEmptyBorder());
//                      b.setSize(new Dimension(32, 32));
//                      bg.add(b);
//                      lp.add(b, zlayer);
//              }
//
//              zoomBackButton.setSize(32, 32);
//              zoomBackButton.setBorder(BorderFactory.createEmptyBorder());
//              lp.add(zoomBackButton, zlayer);
//
//              zoomForwardButton.setSize(32, 32);
//              zoomForwardButton.setBorder(BorderFactory.createEmptyBorder());
//              lp.add(zoomForwardButton, zlayer);
//      }

//      /**
//       * This method will update the
//       */
//      public void updateIconsForButtons() {
//              if (zoomoutToggleButton.isSelected())
//                      zoomoutToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("zoom_out.png")));
//              else
//                      zoomoutToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("zoom_out.png")));
//
//              if (zoominToggleButton.isSelected())
//                      zoominToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("zoom_in.png")));
//              else
//                      zoominToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("zoom_in.png")));
//
//              if (infoToggleButton.isSelected())
//                      infoToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("info.png")));
//              else
//                      infoToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("info_aus.png")));
//
//              if (panToggleButton.isSelected())
//                      panToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("pan.png")));
//              else
//                      panToggleButton.setIcon(new ImageIcon(MapView.class
//                                      .getResource("pan_aus.png")));
//
//      }

        /**
         * Sets the active tool.
         * Simply calls {@link MapPaneToolBar#setSelectedTool(Integer)}.
         * @param tool
         *            One of {@link #TOOL_INFO}, {@link #TOOL_PAN} .. constants
         */
        public void setSelectedTool(Integer tool) {
          jToolBar.setSelectedTool(tool);
        }
        
    /**
     * Sets whether a tool is activated or not.
     * Simply calls {@link MapPaneToolBar#setButtonEnabled(int, boolean, boolean)}.
     * @param tool tool ID
     * @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 setToolEnabled(Integer tool, boolean enabled, boolean hideOnDisable) {
           jToolBar.setButtonEnabled(tool,enabled,hideOnDisable);
        }

    /**
     * Sets the activation for all tools.
     * Simply calls {@link MapPaneToolBar#setAllToolsEnabled(boolean, boolean)}.
     * @param enabled if {@code true} all tool 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) {
      jToolBar.setAllToolsEnabled(enabled, hideOnDisable);
    }   

    /**
         * Checks whether a tool is activated.
     * Simply calls {@link MapPaneToolBar#isButtonEnabled(Integer)}.
         * @param tool tool ID
         * @return {@code false} if an unknown ID is specified
         */
        public boolean isToolEnabled(Integer tool) {
          return jToolBar.isButtonEnabled(tool);
        }
//
//      /**
//       * Positions the Map Control Buttons on top of the {@link GeoMapPane}
//       * 
//       * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
//       * 
//       */
//      protected void positionLayeredObjects() {
//
//              // Abstand zwischen den Buttons und Button zu Rand
//              final int gap = 10;
//
//              // 45 entspicht der breite des Grids/ der Gradanzeige
//              // TODO den wert aus der geomappane auslesen...
//              int x = GridPanel.VERT_WIDTH;
//
//              for (final JToggleButton b : toggleButtonsList) {
//                      x += gap;
//                      // final FontMetrics fm = b.getFontMetrics( b.getFont() );
//                      b.setLocation(x, 10);
//
//                      final int w = 32;
//                      x += w;
//                      // y += b.getWidth();
//              }
//
//              // Und noch die zwei ZoomBackup und ZoomForward Buttons
//              zoomBackButton.setLocation(x + 32 + gap, 10);
//              zoomForwardButton.setLocation(x + 64 + gap * 2, 10);
//      }

        /**
         * called by initialize() to fill the left of the XULUMapView Supposed to be
         * overwritten by AtlasMapView or DesignMapView
         */
        public JComponent getSidePane() {
                return new MapContextControlPane(getGeoMapPane().getMapPane(),
                                new ColorMapManager());
        }

        /**
         * Liefert die Status-Zeile, in der die Koordinaten und Raster-Werte
         * angezeigt werden. 
         */
        public MapPaneStatusBar getStatusBar() {
          return this.statusBar;
        }
        
        /**
         * Liefert den Karten-Bereich der Komponente.
         */
        public final JMapPane getMapPane() {
                return getGeoMapPane().getMapPane();
        }

        // /**
        // * Liefert das in einem Layer dargestellte Objekt.
        // *
        // * @param layer
        // * ein Layer
        // */
        // public Object getMapObject(final MapLayer layer) {
        // // return layerObjects.get(layer);
        // return null;
        // }

        public GeoMapPane getGeoMapPane() {
                return geoMapPane;
        }

        public int getSelectedTool() {
                return jToolBar.getSelectedTool();
        }

}
1	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
10	import javax.swing.AbstractAction;
11	import javax.swing.BorderFactory;
12	import javax.swing.ButtonGroup;
13	import javax.swing.ImageIcon;
14	import javax.swing.JButton;
15	import javax.swing.JComponent;
16	import javax.swing.JLabel;
17	import javax.swing.JPanel;
18	import javax.swing.JSplitPane;
19	import javax.swing.JToggleButton;
20	import javax.swing.JToolBar;
21
22	import org.apache.log4j.Logger;
23
24	import schmitzm.geotools.gui.GeoMapPane;
25	import schmitzm.geotools.gui.JMapPane;
26	import schmitzm.geotools.gui.MapContextControlPane;
27	import schmitzm.geotools.gui.MapPaneStatusBar;
28	import schmitzm.geotools.map.event.JMapPaneEvent;
29	import schmitzm.geotools.map.event.JMapPaneListener;
30	import schmitzm.geotools.map.event.MapAreaChangedEvent;
31	import schmitzm.geotools.styling.ColorMapManager;
32	import schmitzm.swing.SwingUtil;
33
34	import com.vividsolutions.jts.geom.Envelope;
35
36	/**
37	* Achtung! Dieser code ist verwuestet
38	*/
39
40	/**
41	* TODO DOKU und initialize schöner machen. SK
42	*/
43	public class MapView extends JPanel {
44	private static final Logger LOGGER = Logger.getLogger(MapView.class);
45
46	private final JSplitPane splitPane = new JSplitPane(
47	JSplitPane.HORIZONTAL_SPLIT);
48
49	protected MapPaneStatusBar statusBar = null;
50
51	/**
52	* Komponente, in der die Karten, der Massstab und das Koordinaten-Raster
53	* dargestellt werden
54	*/
55	protected final GeoMapPane geoMapPane = new GeoMapPane();
56
57	//
58	// /** This is the layered Pane that holds the buttons and maybe the flying logo * */
59	// protected JLayeredPane layeredPane;
60
61	protected boolean zoomBackForwardButtonInAction;
62
63	private MapPaneToolBar jToolBar;
64
65	/**
66	* Creates a new {@link MapView}. A {@link MapView} is a combination of a
67	* {@link GeoMapPane}, a {@link MapContextManagerInterface} on the left,
68	* and some buttons floating over the {@link JMapPane}
69	*/
70	public MapView(Window owner2, MapPaneToolBar toolBar) {
71	super(new BorderLayout());
72	// Call initialize() by yourself afterwards.
73	// Needed because variables for the overwritten methods
74	// are not yet set.
75	getGeoMapPane().getMapPane().setWaitCursorComponent(owner2);
76	if ( toolBar == null )
77	toolBar = new MapPaneToolBar(getMapPane());
78	jToolBar = toolBar;
79	}
80
81	/**
82	* Creates a new {@link MapView}. A {@link MapView} is a combination of a
83	* {@link GeoMapPane}, a {@link MapContextManagerInterface} on the left,
84	* and some buttons floating over the {@link JMapPane}
85	*/
86	public MapView(Window owner2) {
87	this(owner2, null);
88	}
89
90	// /**
91	// * Nuetzlich wenn die Componente gedruckt wird. Dann wird der Hintergrund
92	// auf {@link Color#WHITE} gesetzt.zoomoutToggleButton
93	// *
94	// * @author <a href="mailto:[email protected]">Stefan Alfons
95	// Krüger</a>
96	// */
97	// @Override
98	// public void print(Graphics g) {
99	//
100	// // SK: Ich habe keine Ahnung mehr, was das soll... Ich habs mal
101	// auskommentiert.
102	//
103	// // wrap in try/finally so that we always restore the state
104	// try {
105	// panToggleButton.setVisible(false);
106	// zoominToggleButton.setVisible(false);
107	// zoomoutToggleButton.setVisible(false);
108	// infoToggleButton.setVisible(false);
109	//
110	// super.print(g);
111	// } finally {
112	// panToggleButton.setVisible(true);
113	// zoominToggleButton.setVisible(true);
114	// zoomoutToggleButton.setVisible(true);
115	// infoToggleButton.setVisible(true);
116	// }
117	// }
118
119	/**
120	* Calls #getSidePanel() which can be overwritten.
121	*
122	* @see #adjustSizeOfGeoMapPane()
123	*/
124	public void initialize() {
125	// horizontales SplitPane initialisieren
126
127	// Status-Zeile
128	statusBar = new MapPaneStatusBar(getGeoMapPane()
129	.getMapPane());
130	statusBar.setBorder(BorderFactory.createCompoundBorder(BorderFactory
131	.createLoweredBevelBorder(), BorderFactory.createEmptyBorder(2,
132	5, 2, 5)));
133	this.add(statusBar, BorderLayout.SOUTH);
134
135	splitPane.setDividerLocation(0.4);
136	splitPane.setDividerSize(5);
137
138	splitPane.add(getSidePane());
139
140	/***********************************************************************
141	* To the right side we now add a JPanel that consists of a toolbar and
142	* a gmp
143	*/
144	JPanel newRight = new JPanel(new BorderLayout());
145	newRight.add(getToolBar(), BorderLayout.NORTH);
146	newRight.add(getGeoMapPane(), BorderLayout.CENTER);
147	splitPane.add(newRight);
148
149	// gpSize = new Dimension(40,50);
150	// getGeoMapPane().setSize(gpSize);
151
152	// layeredPane = new JLayeredPane();
153	// layeredPane.add(getGeoMapPane(), JLayeredPane.DEFAULT_LAYER);
154	// createMapButtons(layeredPane);
155
156	// //****************************************************************************
157	// // The JLayeredPane doesn't manage the size of its layers.. we do it
158	// // This listener will actually correct the size of the JLayeredPane
159	// //****************************************************************************
160	// splitPane.addPropertyChangeListener(new PropertyChangeListener() {
161	//
162	// public void propertyChange(final PropertyChangeEvent evt) {
163	// final JSplitPane sp = (JSplitPane) evt.getSource();
164	//
165	// adjustSizeOfGeoMapPane();
166	//
167	// }
168	//
169	// });
170
171	this.add(splitPane, BorderLayout.CENTER);
172	}
173
174	/**
175	* Returns the tool bar which controls the active mouse actions on the map.
176	* @return
177	*/
178	public MapPaneToolBar getToolBar() {
179	return jToolBar;
180	}
181
182	/**
183	* Returns the split pane which divides the layer list from the map panel.
184	*/
185	public JSplitPane getSplitPane() {
186	return this.splitPane;
187	}
188
189	//
190	// /**
191	// * Called by the listerner. Calculates the exact size of the {@link
192	// GeoMapPane} and sets it.
193	// */
194	// private void adjustSizeOfGeoMapPane() {
195	// final int newWidth = (int) (splitPane.getSize().getWidth()
196	// - splitPane.getComponent(1).getSize().getWidth()
197	// - splitPane.getComponent(0).getSize().getWidth())
198	// - 4;
199	// final int newHeight = (int) splitPane.getComponent(1).getSize()
200	// .getHeight();
201	//
202	// if (newWidth <= 20 )
203	// return;
204	//
205	// gpSize.setSize(newWidth, newHeight);
206	//
207	// getGeoMapPane().getMapPane().setWaitCursorDuringNextRepaint(true);
208	//
209	// getGeoMapPane().setSize( gpSize );
210	// // getGeoMapPane().refreshMap(); nicht nötig .. schön
211	//
212	// positionLayeredObjects();
213	// }
214	//
215	// /**
216	// * Adds the floating Map Contol Buttons to the {@link JLayeredPane}, with Z =
217	// * 10
218	// *
219	// * @param lp
220	// * {@link JLayeredPane} that contains the {@link GeoMapPane}
221	// */
222	// private void createMapButtons(final JLayeredPane lp) {
223	//
224	// final Integer zlayer = new Integer(10);
225	//
226	// toggleButtonsList = new LinkedList<JToggleButton>();
227	// toggleButtonsList.add(infoToggleButton);
228	// toggleButtonsList.add(panToggleButton);
229	// toggleButtonsList.add(zoominToggleButton);
230	// toggleButtonsList.add(zoomoutToggleButton);
231	//
232	//
233	// positionLayeredObjects();
234	//
235	// final ButtonGroup bg = new ButtonGroup();
236	// for (final JToggleButton b : toggleButtonsList) {
237	// // final FontMetrics fm = b.getFontMetrics( b.getFont() );
238	// // final int w = fm.stringWidth( b.getText() );
239	//
240	// // b.setBorder( BorderFactory.createRaisedBevelBorder() );
241	// b.setBorder(BorderFactory.createEmptyBorder());
242	// b.setSize(new Dimension(32, 32));
243	// bg.add(b);
244	// lp.add(b, zlayer);
245	// }
246	//
247	// zoomBackButton.setSize(32, 32);
248	// zoomBackButton.setBorder(BorderFactory.createEmptyBorder());
249	// lp.add(zoomBackButton, zlayer);
250	//
251	// zoomForwardButton.setSize(32, 32);
252	// zoomForwardButton.setBorder(BorderFactory.createEmptyBorder());
253	// lp.add(zoomForwardButton, zlayer);
254	// }
255
256	// /**
257	// * This method will update the
258	// */
259	// public void updateIconsForButtons() {
260	// if (zoomoutToggleButton.isSelected())
261	// zoomoutToggleButton.setIcon(new ImageIcon(MapView.class
262	// .getResource("zoom_out.png")));
263	// else
264	// zoomoutToggleButton.setIcon(new ImageIcon(MapView.class
265	// .getResource("zoom_out.png")));
266	//
267	// if (zoominToggleButton.isSelected())
268	// zoominToggleButton.setIcon(new ImageIcon(MapView.class
269	// .getResource("zoom_in.png")));
270	// else
271	// zoominToggleButton.setIcon(new ImageIcon(MapView.class
272	// .getResource("zoom_in.png")));
273	//
274	// if (infoToggleButton.isSelected())
275	// infoToggleButton.setIcon(new ImageIcon(MapView.class
276	// .getResource("info.png")));
277	// else
278	// infoToggleButton.setIcon(new ImageIcon(MapView.class
279	// .getResource("info_aus.png")));
280	//
281	// if (panToggleButton.isSelected())
282	// panToggleButton.setIcon(new ImageIcon(MapView.class
283	// .getResource("pan.png")));
284	// else
285	// panToggleButton.setIcon(new ImageIcon(MapView.class
286	// .getResource("pan_aus.png")));
287	//
288	// }
289
290	/**
291	* Sets the active tool.
292	* Simply calls {@link MapPaneToolBar#setSelectedTool(Integer)}.
293	* @param tool
294	* One of {@link #TOOL_INFO}, {@link #TOOL_PAN} .. constants
295	*/
296	public void setSelectedTool(Integer tool) {
297	jToolBar.setSelectedTool(tool);
298	}
299
300	/**
301	* Sets whether a tool is activated or not.
302	* Simply calls {@link MapPaneToolBar#setButtonEnabled(int, boolean, boolean)}.
303	* @param tool tool ID
304	* @param enabled if {@code true} the tool becomes available
305	* @param hideOnDisable if {@code true} the button is also hidden if
306	* {@code enabled} is {@code false}
307	*/
308	public void setToolEnabled(Integer tool, boolean enabled, boolean hideOnDisable) {
309	jToolBar.setButtonEnabled(tool,enabled,hideOnDisable);
310	}
311
312	/**
313	* Sets the activation for all tools.
314	* Simply calls {@link MapPaneToolBar#setAllToolsEnabled(boolean, boolean)}.
315	* @param enabled if {@code true} all tool becomes available
316	* @param hideOnDisable if {@code true} the buttons are also hidden if
317	* {@code enabled} is {@code false}
318	*/
319	public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {
320	jToolBar.setAllToolsEnabled(enabled, hideOnDisable);
321	}
322
323	/**
324	* Checks whether a tool is activated.
325	* Simply calls {@link MapPaneToolBar#isButtonEnabled(Integer)}.
326	* @param tool tool ID
327	* @return {@code false} if an unknown ID is specified
328	*/
329	public boolean isToolEnabled(Integer tool) {
330	return jToolBar.isButtonEnabled(tool);
331	}
332	//
333	// /**
334	// * Positions the Map Control Buttons on top of the {@link GeoMapPane}
335	// *
336	// * @author <a href="mailto:[email protected]">Stefan Alfons Krüger</a>
337	// *
338	// */
339	// protected void positionLayeredObjects() {
340	//
341	// // Abstand zwischen den Buttons und Button zu Rand
342	// final int gap = 10;
343	//
344	// // 45 entspicht der breite des Grids/ der Gradanzeige
345	// // TODO den wert aus der geomappane auslesen...
346	// int x = GridPanel.VERT_WIDTH;
347	//
348	// for (final JToggleButton b : toggleButtonsList) {
349	// x += gap;
350	// // final FontMetrics fm = b.getFontMetrics( b.getFont() );
351	// b.setLocation(x, 10);
352	//
353	// final int w = 32;
354	// x += w;
355	// // y += b.getWidth();
356	// }
357	//
358	// // Und noch die zwei ZoomBackup und ZoomForward Buttons
359	// zoomBackButton.setLocation(x + 32 + gap, 10);
360	// zoomForwardButton.setLocation(x + 64 + gap * 2, 10);
361	// }
362
363	/**
364	* called by initialize() to fill the left of the XULUMapView Supposed to be
365	* overwritten by AtlasMapView or DesignMapView
366	*/
367	public JComponent getSidePane() {
368	return new MapContextControlPane(getGeoMapPane().getMapPane(),
369	new ColorMapManager());
370	}
371
372	/**
373	* Liefert die Status-Zeile, in der die Koordinaten und Raster-Werte
374	* angezeigt werden.
375	*/
376	public MapPaneStatusBar getStatusBar() {
377	return this.statusBar;
378	}
379
380	/**
381	* Liefert den Karten-Bereich der Komponente.
382	*/
383	public final JMapPane getMapPane() {
384	return getGeoMapPane().getMapPane();
385	}
386
387	// /**
388	// * Liefert das in einem Layer dargestellte Objekt.
389	// *
390	// * @param layer
391	// * ein Layer
392	// */
393	// public Object getMapObject(final MapLayer layer) {
394	// // return layerObjects.get(layer);
395	// return null;
396	// }
397
398	public GeoMapPane getGeoMapPane() {
399	return geoMapPane;
400	}
401
402	public int getSelectedTool() {
403	return jToolBar.getSelectedTool();
404	}
405
406	}