/ - Diff - Application: gvSIG desktop - gvSIG

trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.swing/org.gvsig.expressionevaluator.swing.api/src/main/java/org/gvsig/expressionevaluator/swing/ExpressionPickerController.java
9	9	*/
10	10	public interface ExpressionPickerController
11	11	extends PickerController<Expression>, ExpressionBuilderConfig {
12
	12
	13	public void unbind();
13	14	}

     package org.gvsig.expressionevaluator.swing.impl;
     import java.awt.MenuItem;
     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import java.net.URL;
-...
     import javax.swing.Action;
     import javax.swing.ImageIcon;
     import javax.swing.JButton;
     import javax.swing.JMenuItem;
     import javax.swing.JPopupMenu;
     import javax.swing.text.JTextComponent;
     import org.apache.commons.lang3.StringUtils;
-...
         private Expression value;
         private ExpressionBuilderConfig config;
         private final ExpressionEvaluatorSwingManager manager;
         private final ActionListener buttonAction;
         private final JMenuItem menuItem;
         public DefaultExpressionPickerController(ExpressionEvaluatorSwingManager manager, JTextComponent text, JButton button) {
             ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();
-...
             this.button = button;
             this.value = ExpressionEvaluatorLocator.getManager().createExpression();
             this.button.setIcon(this.getIcon("picker-expression"));
             this.button.addActionListener(new ActionListener() {
             this.buttonAction = new ActionListener() {
                 @Override
                 public void actionPerformed(ActionEvent e) {
                     doSelectExpression();
+                }
             });
             };
             this.button.addActionListener(this.buttonAction);
             swingManager.addClearButton(this.text);
             swingManager.setDefaultPopupMenu(this.text);
             JPopupMenu popupMenu = this.text.getComponentPopupMenu();
             Action showExpressionBuilderAction = new AbstractAction(i18n.getTranslation("_Show_expression_builder")) {
                 @Override
                 public void actionPerformed(ActionEvent e) {
                     doSelectExpression();
+                }
             };
             popupMenu.addSeparator();
             popupMenu.add(showExpressionBuilderAction);
             this.menuItem = new JMenuItem(i18n.getTranslation("_Show_expression_builder"));
             this.menuItem.addActionListener(buttonAction);
             popupMenu.add(this.menuItem);
+        }
         @Override
         public void unbind() {
             this.button.removeActionListener(this.buttonAction);
             JPopupMenu popupMenu = this.text.getComponentPopupMenu();
             popupMenu.remove(this.menuItem);
+        }
         private void doSelectExpression() {
             this.value.setPhrase(this.text.getText());

     	public void setDefaultGeometry(Geometry geom);
             public void setDefautltTime(Time time);
             public void setDefaultTime(Time time);
     	public boolean isNull(int i);

     import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.timesupport.Time;
     /**
      * Envuelve un FeatureProvider en memoria para que muestre un FeautureType
-...
+     *
      */
     public class MemoryFeatureProviderAttributeMapper implements FeatureProvider {
     	private DefaultFeatureProvider original;
     	private FeatureType myFeatureType;
     	private final DefaultFeatureProvider original;
     	private final FeatureType myFeatureType;
     	/**
     	 * Default constructor.
-...
     		original.setOID(oid);
+    	}
         @Override
         public Time getDefaultTime() {
             return original.getDefaultTime();
+        }
         @Override
         public void setDefaultTime(Time time) {
             original.setDefaultTime(time);
+        }
+    }

     import org.gvsig.fmap.dal.feature.FeatureAttributeEmulator;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.timesupport.RelativeInterval;
     import org.gvsig.timesupport.TimeSupportLocator;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.dynobject.DynStruct;
     import org.gvsig.tools.persistence.PersistenceManager;
-...
     import org.gvsig.tools.persistence.exception.PersistenceException;
     @SuppressWarnings("UseSpecificCatch")
     public class DALFile implements Persistent {
         private static final String DALFILE_PERSISTENCE_DEFINITION_NAME = "DALFile";
         private static final String CALCULATEDATTRIBUTE_PERSISTENCE_DEFINITION_NAME = "DALFileCalculatedAttribute";
         private static final String ATTRIBUTE_PERSISTENCE_DEFINITION_NAME = "DALFileAttribute";
         public static DALFile getDALFile() {
             DALFile f = new DALFile();
-...
                     null,
                     null
                 );
                 definition.addDynFieldList("calculatedAttributes")
                     .setClassOfItems(CalculatedAttribute.class)
                 definition.addDynFieldList("attributes")
                     .setClassOfItems(Attribute.class)
                     .setMandatory(true)
                     .setPersistent(true);
+            }
             if (manager.getDefinition(CALCULATEDATTRIBUTE_PERSISTENCE_DEFINITION_NAME) == null) {
             if (manager.getDefinition(ATTRIBUTE_PERSISTENCE_DEFINITION_NAME) == null) {
                 DynStruct definition = manager.addDefinition(
                     CalculatedAttribute.class,
                     CALCULATEDATTRIBUTE_PERSISTENCE_DEFINITION_NAME,
                     CALCULATEDATTRIBUTE_PERSISTENCE_DEFINITION_NAME + " Persistent definition",
                     Attribute.class,
                     ATTRIBUTE_PERSISTENCE_DEFINITION_NAME,
                     ATTRIBUTE_PERSISTENCE_DEFINITION_NAME + " Persistent definition",
                     null,
                     null
                 );
-...
+        }
         public static class CalculatedAttribute implements Persistent {
         public static class Attribute implements Persistent {
             private String name;
             private int type;
             private FeatureAttributeEmulator emulator;
             private int featureTypeIndex;
             private RelativeInterval interval;
             public CalculatedAttribute() {
             public Attribute() {
+            }
             private CalculatedAttribute(int featureTypeIndex, FeatureAttributeDescriptor attrdesc) {
             private Attribute(int featureTypeIndex, FeatureAttributeDescriptor attrdesc) {
                 this.featureTypeIndex = featureTypeIndex;
                 this.name = attrdesc.getName();
                 this.type = attrdesc.getType();
                 this.emulator = attrdesc.getFeatureAttributeEmulator();
                 if( attrdesc.getInterval().isRelative() ) {
                     this.interval = (RelativeInterval) attrdesc.getInterval();
                 } else {
                     this.interval = null;
+                }
+            }
             public boolean needPersist() {
                 if( emulator!= null && emulator instanceof Persistent ) {
                     return true;
+                }
                 if( this.interval!=null ) {
                     return true;
+                }
                 return false;
+            }
             @Override
             public void saveToState(PersistentState state) throws PersistenceException {
                 state.set("name", name);
                 state.set("type", type);
                 state.set("featureTypeIndex", featureTypeIndex);
                 state.set("emulator", emulator);
                 if( this.interval!=null ) {
                     state.set("intervalStart", interval.getStart().toMillis());
                     state.set("intervalEnd", interval.getEnd().toMillis());
                 } else {
                     state.setNull("intervalStart");
                     state.setNull("intervalEnd");
+                }
+            }
             @Override
-...
                 this.type = state.getInt("type");
                 this.featureTypeIndex = state.getInt("featureTypeIndex");
                 this.emulator = (FeatureAttributeEmulator) state.get("emulator");
                 if( state.get("intervalStart")!=null ) {
                     this.interval = TimeSupportLocator.getManager().createRelativeInterval(
                             state.getLong("intervalStart"),
                             state.getLong("intervalEnd")
                     );
+                }
+            }
             private void fetch(DefaultFeatureAttributeDescriptor attrdesc) {
                 attrdesc.setDataType(this.type);
                 attrdesc.setName(this.name);
                 attrdesc.setFeatureAttributeEmulator(this.emulator);
                 attrdesc.setInterval(this.interval);
+            }
+        }
         private final List<CalculatedAttribute> calculatedAttributes;
         private final List<Attribute> attributes;
         public DALFile() {
             this.calculatedAttributes = new ArrayList<>();
             this.attributes = new ArrayList<>();
+        }
         public boolean isEmpty() {
             if( CollectionUtils.isEmpty(this.calculatedAttributes) ) {
             if( CollectionUtils.isEmpty(this.attributes) ) {
                 return true;
+            }
             return false;
-...
+            }
+        }
         @SuppressWarnings("UseSpecificCatch")
         public void read(File f) {
             FileInputStream in = null;
             try {
                 PersistenceManager manager = ToolsLocator.getPersistenceManager();
                 in = new FileInputStream(f);
                 DALFile x = (DALFile) manager.getObject(in);
                 this.calculatedAttributes.clear();
                 this.calculatedAttributes.addAll(x.calculatedAttributes);
                 this.attributes.clear();
                 this.attributes.addAll(x.attributes);
             } catch(Exception ex) {
                 throw new RuntimeException("Can't read DAL file.",ex);
             } finally {
-...
+        }
         public void setStore(FeatureStore store) throws DataException {
             this.calculatedAttributes.clear();
             this.attributes.clear();
             List<FeatureType> types = store.getFeatureTypes();
             for( int n=0; n<types.size(); n++ ) {
                 FeatureType type = types.get(n);
                     for (FeatureAttributeDescriptor attrdesc : type) {
                         FeatureAttributeEmulator emulator = attrdesc.getFeatureAttributeEmulator();
                         if( emulator!= null && emulator instanceof Persistent ) {
                             CalculatedAttribute calculatedAttribute = new CalculatedAttribute(n,attrdesc);
                             this.calculatedAttributes.add(calculatedAttribute);
                         Attribute attribute = new Attribute(n,attrdesc);
                         if( attribute.needPersist() ) {
                             this.attributes.add(attribute);
+                        }
+                }
+            }
-...
             List<FeatureType> types = store.getFeatureTypes();
             Set<DefaultFeatureType> needFixTypes = new HashSet<>();
             for (CalculatedAttribute calculatedAttribute : calculatedAttributes) {
                 DefaultFeatureType ft = (DefaultFeatureType) types.get(calculatedAttribute.featureTypeIndex);
                 DefaultFeatureAttributeDescriptor attrdesc = new DefaultFeatureAttributeDescriptor(ft);
                 attrdesc.setDataType(calculatedAttribute.type);
                 attrdesc.setName(calculatedAttribute.name);
                 attrdesc.setFeatureAttributeEmulator(calculatedAttribute.emulator);
                 ft.add(attrdesc);
             for (Attribute attribute : this.attributes) {
                 DefaultFeatureType ft = (DefaultFeatureType) types.get(attribute.featureTypeIndex);
                 DefaultFeatureAttributeDescriptor attrdesc = (DefaultFeatureAttributeDescriptor) ft.get(attribute.name);
                 if( ft.get(attribute.name)==null ) {
                     attrdesc = new DefaultFeatureAttributeDescriptor(ft);
                     attribute.fetch(attrdesc);
                     ft.add(attrdesc);
                 } else {
                     attribute.fetch(attrdesc);
+                }
                 needFixTypes.add(ft);
+            }
             for (DefaultFeatureType type : needFixTypes) {
-...
         @Override
         public void saveToState(PersistentState state) throws PersistenceException {
             state.set("calculatedAttributes", calculatedAttributes);
             state.set("attributes", attributes);
+        }
         @Override
         public void loadFromState(PersistentState state) throws PersistenceException {
             this.calculatedAttributes.clear();
             Iterator<CalculatedAttribute> it = state.getIterator("calculatedAttributes");
             this.attributes.clear();
             Iterator<Attribute> it = state.getIterator("attributes");
             while( it.hasNext() ) {
                 CalculatedAttribute calculatedAttribute = it.next();
                 this.calculatedAttributes.add(calculatedAttribute);
                 Attribute attribute = it.next();
                 this.attributes.add(attribute);
+            }
+        }

             while (iter.hasNext()) {
                 attr = (DefaultFeatureAttributeDescriptor) iter.next();
                 attr.setIndex(i++);
                 if (attr instanceof DefaultEditableFeatureAttributeDescriptor) {
                     ((DefaultEditableFeatureAttributeDescriptor) attr).fixAll();
+                }
                 attr.fixAll();
                 if (attr.getEvaluator() != null) {
                     this.hasEvaluators = true;
+                }

     import org.apache.commons.lang3.StringUtils;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.dal.DataTypes;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
         private static Logger logger = LoggerFactory.getLogger(
             DefaultEditableFeatureAttributeDescriptor.class);
         private DefaultFeatureAttributeDescriptor source;
         private final DefaultFeatureAttributeDescriptor source;
         private boolean hasStrongChanges;
         private String originalName = null;
-...
         public DefaultFeatureAttributeDescriptor getSource() {
             return this.source;
+        }
         public void fixAll() {
             switch(this.getType()) {
                 case DataTypes.INSTANT:
                 case DataTypes.INTERVAL:
                 case DataTypes.DATE:
                     if( this.getInterval()!=null ) {
                         this.isTime = true;
+                    }
                     break;
+            }
             super.fixAll();
+        }
         public void checkIntegrity() throws AttributeFeatureTypeIntegrityException {
             AttributeFeatureTypeIntegrityException ex =
                 new AttributeFeatureTypeIntegrityException(getName());
-...
+        }
         public EditableFeatureAttributeDescriptor setInterval(Interval interval) {
             this.interval = interval;
             super.setInterval(interval);
             if (!isComputed()) {
                 hasStrongChanges = true;
+            }

     import org.gvsig.fmap.crs.CRSFactory;
     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureAttributeEmulator;
     import org.gvsig.fmap.dal.feature.FeatureAttributeGetter;
-...
+            }
             return (FeatureType) this.typeRef.get();
+        }
         public FeatureAttributeDescriptor setInterval(Interval interval) {
             this.interval = interval;
             return this;
+        }
         public void fixAll() {
             switch(this.getType()) {
                 case DataTypes.INSTANT:
                 case DataTypes.INTERVAL:
                 case DataTypes.DATE:
                     if( this.getInterval()!=null ) {
                         this.isTime = true;
+                    }
                     break;
+            }
+        }
+    }

                 this.clean();
                 return;
+            }
             if (!(descriptor instanceof EditableFeatureAttributeDescriptor)) {
                 this.setEditable(false);
             ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();
             if( this.pickerVirtualField!=null ) {
                 this.pickerVirtualField.unbind();
+            }
             ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();
             this.pickerVirtualField = ExpressionEvaluatorSwingLocator.getManager()
                     .createExpressionPickerController(txtVirtualField, btnVirtualField);
             if( descriptor.getFeatureType()!=null && descriptor.getFeatureType().getStore()!=null ) {
-...
+                    )
                 );
+            }
             if (!(descriptor instanceof EditableFeatureAttributeDescriptor)) {
                 this.setEditable(false);
+            }
             this.pickerDefaultValue.set(descriptor.getDefaultValue());
             this.pickerFieldName.set(descriptor.getName());

Application: gvSIG desktop

Revision 44094