/ - Diff - Application: gvSIG desktop - gvSIG

     import org.gvsig.app.project.documents.view.ViewDocument;
     import org.gvsig.app.project.documents.view.gui.IView;
     import org.gvsig.fmap.dal.serverexplorer.filesystem.swing.FilesystemExplorerAddLayerWizardPanel;
     import org.gvsig.fmap.mapcontext.MapContext;
     import org.gvsig.fmap.mapcontext.ViewPort;
     import org.gvsig.fmap.mapcontext.layers.FLayer;
     import org.gvsig.fmap.mapcontext.layers.FLayers;
-...
+         *
          * @return FOpenDialog
          */
         private AddLayerDialog createFOpenDialog(MapControl mapControl) {
         private AddLayerDialog createFOpenDialog(MapControl mapControl, MapContext mapContext) {
             AddLayerDialog fopen = new AddLayerDialog();
             for (int i = 0; i < wizardStack.size(); i++) {
                 WizardPanel wp;
                 try {
                     wp = AddLayer.getInstance(i, mapControl);
                     Class<? extends WizardPanel> wpClass = AddLayer.wizardStack.get(i);
                     Object[] params = {};
                     wp = wpClass.getConstructor()
                             .newInstance(params);
                     wp.setMapCtrl(mapControl);
                     wp.setMapContext(mapContext);
                     wp.initWizard();
                     fopen.addWizardTab(wp.getTabName(), wp);
                 } catch (Exception e) {
-...
          * @param wizardPanel WizardPanel where user selected the layers to load
          * @return
          */
         private boolean loadGenericWizardPanelLayers(MapControl mapControl, WizardPanel wp) {
             wp.setMapCtrl(mapControl);
             wp.execute();
         private boolean loadGenericWizardPanelLayers(MapContext mapContext, WizardPanel wp, boolean mapControlAvailable) {
             wp.setMapContext(mapContext);
             wp.executeWizard();
             return true;
+        }
         /**
          * Abre dialogo para a�adir capas y las a�ade en mapControl
          * Opens the AddLayer dialog, and adds the selected layers to the provided
          * MapContext.
+         *
          * Devuelve true si se han a�adido capas.
          * @param mapControl
          * @return
          * This method is useful when we want to add a layer but we don't have an
          * associated View. If a View or a MapControl is available, you will
          * usually prefer the {@link #addLayers(MapControl)} method.
+         *
          * @param mapContext The MapContext to add the layers to
          * @return <code>true</code> if any layer has been added.
          */
         public boolean addLayers(MapContext mapContext) {
         	return doAddLayers(null, mapContext);
+        }
         /**
          * Opens the AddLayer dialog, and adds the selected layers to the provided
          * mapControl.
+         *
          * @param mapControl The MapControl to add the layers to
+         *
          * @return <code>true</code> if any layer has been added.
          */
         public boolean addLayers(MapControl mapControl) {
             // create and show the modal fopen dialog
         	return doAddLayers(mapControl, mapControl.getMapContext());
+        }
         private boolean doAddLayers(MapControl mapControl, MapContext mapContext) {
             AddLayerDialog fopen = null;
             try {
                 fopen = createFOpenDialog(mapControl);
                 fopen = createFOpenDialog(mapControl, mapContext);
                 PluginServices.getMDIManager().addWindow(fopen);
                 if (fopen.isAccepted()) {
                     if (fopen.getSelectedTab() instanceof WizardPanel) {
                         WizardPanel wp = (WizardPanel) fopen.getSelectedTab();
                         return loadGenericWizardPanelLayers(mapControl, wp);
                         wp.execute();
                         return true;
                     } else {
                         JOptionPane.showMessageDialog((Component) PluginServices
                                 .getMainFrame(), PluginServices.getText(this, "ninguna_capa_seleccionada"));

     import org.gvsig.fmap.mapcontrol.MapControl;
     /**
      * Object containing the context to prepare the loading process
      * of a layer.
+     *
      * @author jmvivo
+     *
      * @see PrepareContextView_1
      */
     public interface PrepareContextView extends PrepareContext {
     	/**
+    	 *
+    	 *
     	 * @return
     	 */
         /**
          * You can use it to interact with the MapControl component that will
          * receive the new layer, in order to get user feedback
          * (for instance a bounding box). Check the
          * {@link PrepareContextView_v1#isMapControlAvailable()} method before
          * accessing the MapControl
          * because it may not be available (for instance when adding layers
          * to a MapContext not associated with a View).
+         *
          * For the moment, this method will return a non-null MapControl for
          * compatibility reasons, but you should still check
          * {@link PrepareContextView_v1#isMapControlAvailable()} to be sure it
          * is a valid one, as it could only be a fake MapControl.
+         *
          * It is recommended to use {@link PrepareContextView_v1#getMapContext()}
          * method when no interaction is needed with the map user interface
          * (for instance to get the active projection, visible extent, etc)
+         *
          * @return Returns the mapCtrl.
          */
     	MapControl getMapControl();
+    }

     import org.gvsig.app.gui.wizards.WizardListener;
     import org.gvsig.app.gui.wizards.WizardListenerSupport;
     import org.gvsig.app.prepareAction.PrepareContextView;
     import org.gvsig.app.prepareAction.PrepareContextView_v1;
     import org.gvsig.fmap.dal.DataStoreParameters;
     import org.gvsig.fmap.mapcontext.MapContext;
     import org.gvsig.fmap.mapcontext.MapContextLocator;
-...
         private String tabName = "TabName";
         private MapControl mapCtrl = null;
         private WizardListenerSupport listenerSupport = new WizardListenerSupport();
     	private MapContext mapContext;
     	private boolean b_isMapControlAvailable = false;
         public void addWizardListener(WizardListener listener) {
             listenerSupport.addWizardListener(listener);
-...
         abstract public DataStoreParameters[] getParameters();
         /**
          * You can use it to extract information from
          * the mapControl that will receive the new layer.
          * For example, projection to use, or visible extent.
          * You can use it to interact with the MapControl component that will
          * receive the new layer, in order to get user feedback
          * (for instance a bounding box). Check the
          * {@link #isMapControlAvailable()} method before accessing the MapControl
          * because it may not be available (for instance when adding layers
          * to a MapContext not associated with a View).
+         *
          * For the moment, this method will return a non-null MapControl for
          * compatibility reasons, but you should still check
          * {@link #isMapControlAvailable()} to be sure it is a valid one,
          * as it could only be a fake MapControl.
+         *
          * It is recommended to use {@link #getMapContext()} method
          * when no interaction is needed with the map user interface
          * (for instance to get the active projection, visible extent, etc)
+         *
          * @return Returns the mapCtrl.
          */
         public MapControl getMapCtrl() {
             return mapCtrl;
         	if (mapCtrl!=null) {
         		return mapCtrl;
+        	}
         	else if (mapContext!=null) {
         		// if MapContext has been set, create a fake MapControl
         		// for compatibility purposes
         		MapControl mc = new MapControl();
         		mc.setMapContext(mapContext);
         		mapCtrl=mc;
+        	}
         	return mapCtrl;
+        }
         /**
          * Sets the MapControl that will receive the new layer
          * @param mapCtrl
          *            The mapCtrl to set.
          */
         public void setMapCtrl(MapControl mapCtrl) {
             this.mapCtrl = mapCtrl;
             b_isMapControlAvailable = (mapCtrl!=null);
+        }
         /**
          * You can use it to extract information from
          * the MapContext that will receive the new layer.
          * For example, projection to use, or visible extent.
+         *
          * @return Returns the MapContext.
          */
         public MapContext getMapContext() {
         	if (this.mapContext!=null || this.mapCtrl==null) {
         		return this.mapContext;
+        	}
         	else {
         		return this.mapCtrl.getMapContext();
+        	}
+        }
         protected void doAddLayer(final MapControl mapControl,
             final String layerName, final DataStoreParameters parameters) {
             final ApplicationManager application = ApplicationLocator.getManager();
         /**
          * Sets the MapContext that will receive the new layer
          * @param mapContext
          *            The mapContext to set.
          */
         public void setMapContext(MapContext mapContext) {
             this.mapContext = mapContext;
+        }
         /**
          * Checks whether the MapControl is available.
          * The MapControl may not be available in some circumstances, for instance
          * when adding layers to a MapContext not associated with a View.
+         *
          * A MapContext should always be available on the {@link #getMapContext()}
          * method.
+         *
          * @return true if the MapControl is available, false otherwise
          */
         public boolean isMapControlAvailable() {
         	return b_isMapControlAvailable ;
+        }
         protected void doAddLayer(
                 final String layerName, final DataStoreParameters parameters) {
         	final boolean b_isMapControlAvail = this.isMapControlAvailable();
         	final MapControl mapControl = this.getMapCtrl();
         	final MapContext mapContext = this.getMapContext();
         	final ApplicationManager application = ApplicationLocator.getManager();
             final MapContextManager manager =
                 MapContextLocator.getMapContextManager();
             final MapContext mapContext = mapControl.getMapContext();
             logger.info("addLayer('{}','{}')", layerName, parameters.toString());
             Thread task = new Thread(new Runnable() {
-...
                         layer = manager.createLayer(layerName, parameters);
                         preparedLayer =
                             application.prepareOpenLayer(layer,
                                 new PrepareContextView() {
                                 new PrepareContextView_v1() {
                                     public Window getOwnerWindow() {
                                         return null;
-...
+                                    }
     								public IProjection getViewProjection() {
     									return mapControl.getProjection();
     									return mapContext.getProjection();
+    								}
     								public MapContext getMapContext() {
     									return mapContext;
+    								}
     								public boolean isMapControlAvailable() {
     									return b_isMapControlAvail;
+    								}
                                 });
                         if (preparedLayer != null) {
                             mapContext.getLayers().addLayer(preparedLayer);
-...
+                }
             });
             task.start();
+        }
         /**
+         *
          * @param mapControl
          * @param layerName
          * @param parameters
          * @deprecated Use {@link #doAddLayer(String, DataStoreParameters)}
          * in combination with {@link #setMapCtrl(MapControl)} if you need
          * to set the MapControl. Note that MapControl is automatically initialized
          * when creating the panel from the AddLayer extension.
          */
         protected void doAddLayer(final MapControl mapControl,
             final String layerName, final DataStoreParameters parameters) {
         	this.setMapCtrl(mapControl);
         	doAddLayer(layerName, parameters);
+        }
         /**
          * This method is called for example when user changes
          * tab in add layer dialog (new tab's settings are valid?)
+         *

+    	}
     	private void closeWindow() {
     //		JTabbedPane tabbed = getJTabbedPane();
     //		for (int i = 0; i < tabbed.getTabCount(); i++) {
     //			Component component = tabbed.getComponentAt(i);
     //			if (component instanceof WizardPanel) {
     //				((WizardPanel) component).close();
     //			}
     //		}
     		if (PluginServices.getMainFrame() == null) {
     			((JDialog) (getParent().getParent().getParent().getParent())).dispose();
     		} else {

     	 */
     	protected void processErrorsOfLayer(FLayer lyr, MapControl mapControl) {
     		// List errors = lyr.getErrors();
     		// wp.callError(null);
     		mapControl.getMapContext().callNewErrorEvent(null);
     		this.getMapContext().callNewErrorEvent(null);
+    	}
     	private void removeSettingsPanels() {
-...
+    				}
     				public IProjection getViewProjection() {
     					return null;
     					return WizardDB.this.getMapContext().getProjection();
+    				}
     			};

Application: gvSIG desktop

Revision 41434