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

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

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

revision 2 by mojays, Tue Feb 24 22:43:52 2009 UTC revision 226 by alfonx, Thu Jul 16 07:37:43 2009 UTC
# Line 1  Line 1 
1  package skrueger.geotools;  package skrueger.geotools;
2    
3  import java.awt.BorderLayout;  import java.awt.BorderLayout;
4  import java.awt.Dimension;  import java.awt.Component;
 import java.awt.Window;  
 import java.awt.event.ActionEvent;  
 import java.util.ArrayList;  
 import java.util.LinkedList;  
5    
 import javax.swing.AbstractAction;  
6  import javax.swing.BorderFactory;  import javax.swing.BorderFactory;
 import javax.swing.ButtonGroup;  
 import javax.swing.ImageIcon;  
 import javax.swing.JButton;  
7  import javax.swing.JComponent;  import javax.swing.JComponent;
 import javax.swing.JLabel;  
8  import javax.swing.JPanel;  import javax.swing.JPanel;
9  import javax.swing.JSplitPane;  import javax.swing.JSplitPane;
 import javax.swing.JToggleButton;  
 import javax.swing.JToolBar;  
10    
11  import org.apache.log4j.Logger;  import org.apache.log4j.Logger;
12    import org.geotools.renderer.lite.StreamingRenderer;
13    import org.geotools.renderer.shape.TransitionShapefileRenderer;
14    
15  import schmitzm.geotools.gui.GeoMapPane;  import schmitzm.geotools.gui.GeoMapPane;
16  import schmitzm.geotools.gui.JMapPane;  import schmitzm.geotools.gui.JMapPane;
17  import schmitzm.geotools.gui.MapContextControlPane;  import schmitzm.geotools.gui.MapContextControlPane;
18  import schmitzm.geotools.gui.MapPaneStatusBar;  import schmitzm.geotools.gui.MapPaneStatusBar;
 import schmitzm.geotools.map.event.JMapPaneEvent;  
 import schmitzm.geotools.map.event.JMapPaneListener;  
 import schmitzm.geotools.map.event.MapAreaChangedEvent;  
19  import schmitzm.geotools.styling.ColorMapManager;  import schmitzm.geotools.styling.ColorMapManager;
 import schmitzm.swing.SwingUtil;  
   
 import com.vividsolutions.jts.geom.Envelope;  
20    
21  /**  /**
22   * Achtung! Dieser code ist verwuestet   * Achtung! Dieser code ist verwuestet TODO DOKU und initialize schöner machen.
23   */   * SK
   
 /**  
  * TODO DOKU und initialize schöner machen. SK  
24   */   */
25  public class MapView extends JPanel {  public class MapView extends JPanel {
26          private static final Logger LOGGER = Logger.getLogger(MapView.class);          private static final Logger LOGGER = Logger.getLogger(MapView.class);
# Line 47  public class MapView extends JPanel { Line 29  public class MapView extends JPanel {
29                          JSplitPane.HORIZONTAL_SPLIT);                          JSplitPane.HORIZONTAL_SPLIT);
30    
31          protected MapPaneStatusBar statusBar = null;          protected MapPaneStatusBar statusBar = null;
32            
33          /**          /**
34           * Komponente, in der die Karten, der Massstab und das Koordinaten-Raster           * Komponente, in der die Karten, der Massstab und das Koordinaten-Raster
35           * dargestellt werden           * dargestellt werden.
36           */           */
         protected final GeoMapPane geoMapPane = new GeoMapPane();  
37    
38  //          /**
39  //      /** This is the layered Pane that holds the buttons and maybe the flying logo * */           * SK: 21.6.09: ShapeFileRenderer is supposed to be about 5x faster on
40  //      protected JLayeredPane layeredPane;           * ShapeFiles. The ShapeFileRenderer falls back to the StreamingRenderer.
41             */
42          protected boolean zoomBackForwardButtonInAction;          // Old code:
43            // protected final GeoMapPane geoMapPane = new
44            // GeoMapPane(null,null,null,null, new StreamingRenderer());
45            // New Code uses Streaming renderer.
46            protected final GeoMapPane geoMapPane = new GeoMapPane(null, null, null,
47                            null, new TransitionShapefileRenderer());
48    
49          private MapPaneToolBar jToolBar;          private MapPaneToolBar jToolBar;
50    
51          /**          /**
52           * Creates a new {@link MapView}. A {@link MapView} is a combination of a           * Creates a new {@link MapView}. A {@link MapView} is a combination of a
53           * {@link GeoMapPane}, a {@link MapContextManagerInterface} on the left,           * {@link GeoMapPane}, a {@link MapContextManagerInterface} on the left, and
54           * and some buttons floating over the {@link JMapPane}           * some buttons floating over the {@link JMapPane}
55           */           */
56          public MapView(Window owner2, MapPaneToolBar toolBar) {          public MapView(Component parentGui, MapPaneToolBar toolBar) {
57                  super(new BorderLayout());                  super(new BorderLayout());
58                  // Call initialize() by yourself afterwards.                  // Call initialize() by yourself afterwards.
59                  // Needed because variables for the overwritten methods                  // Needed because variables for the overwritten methods
60                  // are not yet set.                  // are not yet set.
61                  getGeoMapPane().getMapPane().setWaitCursorComponent(owner2);                  getGeoMapPane().getMapPane().setWaitCursorComponent(parentGui);
62                  if ( toolBar == null )                  if (toolBar == null)
63                    toolBar = new MapPaneToolBar(getMapPane());                          toolBar = new MapPaneToolBar(getMapPane());
64                  jToolBar = toolBar;                  jToolBar = toolBar;
65          }          }
   
     /**  
      * 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);  
         // }  
         // }  
66    
67          /**          /**
68           * Calls #getSidePanel() which can be overwritten.           * Creates a new {@link MapView}. A {@link MapView} is a combination of a
69             * {@link GeoMapPane}, a {@link MapContextManagerInterface} on the left, and
70             * some buttons floating over the {@link JMapPane}
71             */
72            public MapView(Component parentGui) {
73                    this(parentGui, null);
74            }
75    
76            /**
77             * This routine creates the main components of the GUI: The left Side and
78             * the map on the right side.<br/>
79             * Calls #getSidePanel() which can be overwritten (call super!).<br/>
80             *
81             * This method initialized the variables {@link #statusBar} and
82             * {@link #splitPane}
83           *           *
84           * @see #adjustSizeOfGeoMapPane()           * @see #adjustSizeOfGeoMapPane()
85           */           */
86          public void initialize() {          public void initialize() {
87                  // horizontales SplitPane initialisieren                  // horizontales SplitPane initialisieren
88    
89                  // Status-Zeile                  // Status-Line to show Coordinates and Rastervalues.
90                  statusBar = new MapPaneStatusBar(getGeoMapPane()                  statusBar = new MapPaneStatusBar(getGeoMapPane().getMapPane());
                                 .getMapPane());  
91                  statusBar.setBorder(BorderFactory.createCompoundBorder(BorderFactory                  statusBar.setBorder(BorderFactory.createCompoundBorder(BorderFactory
92                                  .createLoweredBevelBorder(), BorderFactory.createEmptyBorder(2,                                  .createLoweredBevelBorder(), BorderFactory.createEmptyBorder(2,
93                                  5, 2, 5)));                                  5, 2, 5)));
94                  this.add(statusBar, BorderLayout.SOUTH);                  this.add(statusBar, BorderLayout.SOUTH);
95    
96                  splitPane.setDividerLocation(0.4);                  /**
97                  splitPane.setDividerSize(5);                   * The layout of the split pane can be configured in the atlas.
98                     * setDividerLocation(-1); has no effect here because the component is
99                     * not visible yet.
100                     */
101                    getSplitPane().setDividerSize(5);
102    
103                  splitPane.add(getSidePane());                  getSplitPane().setResizeWeight(0.0);
104                    getSplitPane().add(getSidePane());
105    
106                  /***********************************************************************                  /***********************************************************************
107                   * To the right side we now add a JPanel that consists of a toolbar and                   * To the right side we now add a JPanel that consists of a toolbar and
# Line 144  public class MapView extends JPanel { Line 110  public class MapView extends JPanel {
110                  JPanel newRight = new JPanel(new BorderLayout());                  JPanel newRight = new JPanel(new BorderLayout());
111                  newRight.add(getToolBar(), BorderLayout.NORTH);                  newRight.add(getToolBar(), BorderLayout.NORTH);
112                  newRight.add(getGeoMapPane(), BorderLayout.CENTER);                  newRight.add(getGeoMapPane(), BorderLayout.CENTER);
113                  splitPane.add(newRight);                  getSplitPane().add(newRight);
   
                 // gpSize = new Dimension(40,50);  
                 // getGeoMapPane().setSize(gpSize);  
114    
115                  // layeredPane = new JLayeredPane();                  this.add(getSplitPane(), BorderLayout.CENTER);
                 // 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);  
116          }          }
117    
118          /**          /**
119           * Returns the tool bar which controls the active mouse actions on the map.           * Returns the tool bar which controls the active mouse actions on the map.
120             *
121           * @return           * @return
122           */           */
123          public MapPaneToolBar getToolBar() {          public MapPaneToolBar getToolBar() {
124            return jToolBar;                  return jToolBar;
125          }          }
126    
127          /**          /**
128           * Returns the split pane which divides the layer list from the map panel.           * Returns the split pane which divides the layer list from the map panel.
129           */           */
130          public JSplitPane getSplitPane() {          public JSplitPane getSplitPane() {
131                  return this.splitPane;                  return splitPane;
132          }          }
133    
         //  
         // /**  
         // * 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")));  
 //  
 //      }  
   
134          /**          /**
135           * Sets the active tool.           * Sets the active tool. Simply calls
136           * Simply calls {@link MapPaneToolBar#setSelectedTool(Integer)}.           * {@link MapPaneToolBar#setSelectedTool(Integer)}.
137             *
138           * @param tool           * @param tool
139           *            One of {@link #TOOL_INFO}, {@link #TOOL_PAN} .. constants           *            One of {@link #TOOL_INFO}, {@link #TOOL_PAN} .. constants
140           */           */
141          public void setSelectedTool(Integer tool) {          public void setSelectedTool(Integer tool) {
142            jToolBar.setSelectedTool(tool);                  jToolBar.setSelectedTool(tool);
143            }
144    
145            /**
146             * Sets whether a tool is activated or not. Simply calls
147             * {@link MapPaneToolBar#setButtonEnabled(int, boolean, boolean)}.
148             *
149             * @param tool
150             *            tool ID
151             * @param enabled
152             *            if {@code true} the tool becomes available
153             * @param hideOnDisable
154             *            if {@code true} the button is also hidden if {@code enabled}
155             *            is {@code false}
156             */
157            public void setToolEnabled(Integer tool, boolean enabled,
158                            boolean hideOnDisable) {
159                    jToolBar.setButtonEnabled(tool, enabled, hideOnDisable);
160          }          }
161            
162      /**          /**
163       * Sets whether a tool is activated or not.           * Sets the activation for all tools. Simply calls
164       * Simply calls {@link MapPaneToolBar#setButtonEnabled(int, boolean, boolean)}.           * {@link MapPaneToolBar#setAllToolsEnabled(boolean, boolean)}.
165       * @param tool tool ID           *
166       * @param enabled if {@code true} the tool becomes available           * @param enabled
167       * @param hideOnDisable if {@code true} the button is also hidden if           *            if {@code true} all tool becomes available
168       *                      {@code enabled} is {@code false}           * @param hideOnDisable
169       */           *            if {@code true} the buttons are also hidden if {@code enabled}
170          public void setToolEnabled(Integer tool, boolean enabled, boolean hideOnDisable) {           *            is {@code false}
171             jToolBar.setButtonEnabled(tool,enabled,hideOnDisable);           */
172          }          public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {
173                    jToolBar.setAllToolsEnabled(enabled, hideOnDisable);
174      /**          }
175       * Sets the activation for all tools.  
176       * Simply calls {@link MapPaneToolBar#setAllToolsEnabled(boolean, boolean)}.          /**
177       * @param enabled if {@code true} all tool becomes available           * Checks whether a tool is activated. Simply calls
178       * @param hideOnDisable if {@code true} the buttons are also hidden if           * {@link MapPaneToolBar#isButtonEnabled(Integer)}.
179       *                      {@code enabled} is {@code false}           *
180       */           * @param tool
181      public void setAllToolsEnabled(boolean enabled, boolean hideOnDisable) {           *            tool ID
       jToolBar.setAllToolsEnabled(enabled, hideOnDisable);  
     }    
   
     /**  
          * Checks whether a tool is activated.  
      * Simply calls {@link MapPaneToolBar#isButtonEnabled(Integer)}.  
          * @param tool tool ID  
182           * @return {@code false} if an unknown ID is specified           * @return {@code false} if an unknown ID is specified
183           */           */
184          public boolean isToolEnabled(Integer tool) {          public boolean isToolEnabled(Integer tool) {
185            return jToolBar.isButtonEnabled(tool);                  return jToolBar.isButtonEnabled(tool);
186          }          }
 //  
 //      /**  
 //       * 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);  
 //      }  
187    
188          /**          /**
189           * called by initialize() to fill the left of the XULUMapView Supposed to be           * called by initialize() to fill the left of the XULUMapView Supposed to be
# Line 371  public class MapView extends JPanel { Line 196  public class MapView extends JPanel {
196    
197          /**          /**
198           * Liefert die Status-Zeile, in der die Koordinaten und Raster-Werte           * Liefert die Status-Zeile, in der die Koordinaten und Raster-Werte
199           * angezeigt werden.           * angezeigt werden.
200           */           */
201          public MapPaneStatusBar getStatusBar() {          public MapPaneStatusBar getStatusBar() {
202            return this.statusBar;                  return this.statusBar;
203          }          }
204            
205          /**          /**
206           * Liefert den Karten-Bereich der Komponente.           * Liefert den Karten-Bereich der Komponente.
207           */           */
# Line 384  public class MapView extends JPanel { Line 209  public class MapView extends JPanel {
209                  return getGeoMapPane().getMapPane();                  return getGeoMapPane().getMapPane();
210          }          }
211    
         // /**  
         // * Liefert das in einem Layer dargestellte Objekt.  
         // *  
         // * @param layer  
         // * ein Layer  
         // */  
         // public Object getMapObject(final MapLayer layer) {  
         // // return layerObjects.get(layer);  
         // return null;  
         // }  
   
212          public GeoMapPane getGeoMapPane() {          public GeoMapPane getGeoMapPane() {
213                  return geoMapPane;                  return geoMapPane;
214          }          }
Legend:
Removed from v.2  
changed lines
  Added in v.226
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26