/ - Diff - Application: gvSIG desktop - gvSIG

Revision 44257

         public abstract void setFontStyle(int style);
         public abstract void setFontStyleField(String field);
         public abstract void setFontStyle(Expression expression);
         public abstract void setTextField(String textFieldName);
         public abstract void setText(Expression expression);
         public abstract void setRotationField(String rotationFieldName);
         public abstract void setRotation(Expression expression);
         /**
          * Sets the field that contains the size of the text. The size is computed
          * in meters. To use any other unit, call setUnit(int) with the scale factor
          * from meters (for centimeters, call <b>setUnitFactor(0.01))</b>.
+         *
          * @param heightFieldName
          */
         public abstract void setHeightField(String heightFieldName);
         public abstract void setHeight(Expression expression);
         public abstract void setColorField(String colorFieldName);
         public abstract void setColor(Expression expression);
         public abstract void setUsesFixedSize(boolean b);
-...
         public abstract void setFont(Font selFont);
         public abstract void setFontField(String fontField);
         public abstract void setFont(Expression expression);
         public abstract void setReferenceSystem(Expression expression);
         public abstract void setUnit(Expression expression);
+    }

         @Override
         public void setFeature(Feature feat) {
             feature = feat;
             if (featureSymbolTable == null) {
                 getFeatureSymbolTable();
+            }
             featureSymbolTable.setFeature(feat);
+        }
-...
                 MutableSymbolTable s = ExpressionEvaluatorLocator.getManager().createSymbolTable();
                 FeatureSymbolTable fst = DALLocator.getDataManager().createFeatureSymbolTable();
                 s.addSymbolTable(fst);
                 fst.setFeature(feature);
                 if (feature != null) {
                     fst.setFeature(feature);
+                }
                 symbolTable = s;
+            }
-...
+        }
+    }

      */
     package org.gvsig.symbology.fmap.mapcontext.rendering.dynamiclegend;
     import java.awt.Color;
     import java.awt.Font;
     import java.awt.Graphics2D;
-...
     public class DefaultDynamicLabelingStrategy extends DynamicLabelingStrategy {
         private Feature feature;
         public  String LROTATION = "LROTATION";
         public  String LTEXT = "LTEXT";
         public  String LHEIGHT = "LHEIGHT";
         public  String LCOLOR = "LCOLOR";
         public  String LFONT = "LFONT";
         public  String LFONTSTYLE = "LFONTS";
         public String LROTATION = "LROTATION";
         public String LTEXT = "LTEXT";
         public String LHEIGHT = "LHEIGHT";
         public String LCOLOR = "LCOLOR";
         public String LFONT = "LFONT";
         public String LFONTSTYLE = "LFONTS";
         public static Expression expRotation = null;
         public static Expression expText = null;
         public static Expression expHeight = null;
         public static Expression expColor = null;
         public static Expression expFont = null;
         public static Expression expFontStyle = null;
         public static Expression expUnit;
         public static Expression expReferenceSystem;
         private MutableSymbolTable symbolTable = null;
         private FeatureSymbolTable featureSymbolTable = null;
         private FLyrVect layer;
         private List<Geometry> drawnGeometryLabels;
         private boolean printMode = false;
-...
         public SymbolTable getFeatureSymbolTable() {
             if (symbolTable == null) {
                 MutableSymbolTable s = ExpressionEvaluatorLocator.getManager().createSymbolTable();
                 FeatureSymbolTable fst = DALLocator.getDataManager().createFeatureSymbolTable();
                 s.addSymbolTable(fst);
                 fst.setFeature(feature);
                 featureSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();
                 s.addSymbolTable(featureSymbolTable);
                 if (feature!=null) {
                     featureSymbolTable.setFeature(feature);
+                }
                 symbolTable = s;
+            }
             return symbolTable;
+        }
         private Expression getExpressionFromString(String value) {
             Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();
             expression.setPhrase(value);
             return expression;
+        }
     //    private Expression getExpressionFromString(String value) {
     //        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();
     //        expression.setPhrase(value);
     //        return expression;
     //    }
         private Object getValueFromExpression(Expression exp) {
             if (exp == null) {
                 return null;
-...
         @Override
         public Expression getRotation() {
             String value = feature.get(LROTATION).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expRotation;
+        }
         @Override
-...
         @Override
         public Expression getText() {
             if (feature == null) {
                 return null;
+            }
             String value = feature.get(LTEXT).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expText;
+        }
         @Override
-...
         @Override
         public Expression getHeight() {
             String value = feature.get(LHEIGHT).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expHeight;
+        }
         @Override
-...
         @Override
         public Expression getColor() {
             String value = feature.get(LCOLOR).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expColor;
+        }
         @Override
-...
         @Override
         public Expression getFixedSize() {
             String value = feature.get(LHEIGHT).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expHeight;
+        }
         @Override
-...
+        }
         @Override
         public void setTextField(String textFieldName) {
             this.LTEXT=textFieldName;
         public void setText(Expression expression) {
             expText = expression;
+        }
         @Override
         public void setRotationField(String rotationFieldName) {
              this.LROTATION=rotationFieldName;
         public void setRotation(Expression expression) {
             expRotation = expression;
+        }
         @Override
         public void setHeightField(String heightFieldName) {
             this.LHEIGHT=heightFieldName;
         public void setHeight(Expression expression) {
             expHeight = expression;
+        }
         @Override
         public void setColorField(String colorFieldName) {
              this.LCOLOR=colorFieldName;
         public void setColor(Expression expression) {
             expColor = expression;
+        }
         @Override
-...
         @Override
         public Expression getFixedColor() {
             String value = feature.get(LCOLOR).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expColor;
+        }
         @Override
-...
         @Override
         public Expression getColorFont() {
             String value = feature.get(LCOLOR).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expColor;
+        }
         @Override
-...
         @Override
         public Expression getFont() {
             String value = feature.get(LFONT).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expFont;
+        }
         @Override
-...
         @Override
         public Expression getFontStyle() {
             String value = feature.get(LFONTSTYLE).toString();
             Expression exp = getExpressionFromString(value);
             return exp;
             return expFontStyle;
+        }
         @Override
-...
+        }
         @Override
         public void setFontStyle(int selFont) {
             throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
         public void setFontStyle(Expression expression) {
             expFontStyle = expression;
+        }
         public void setFeature(Feature f) {
             feature = f;
             if (featureSymbolTable==null) {
                 getFeatureSymbolTable();
+            }
             featureSymbolTable.setFeature(f);
+        }
         @Override
-...
         @Override
         public Expression getUnitExp() {
             String value = "-1";
             Expression exp = getExpressionFromString(value);
             return exp;
     //        String value = "-1";
     //        Expression exp = getExpressionFromString(value);
     //        return exp;
             return expUnit;
+        }
         public Expression getReferenceSystemExp() {
             String value = "0";
             Expression exp = getExpressionFromString(value);
             return exp;
     //        String value = "0";
     //        Expression exp = getExpressionFromString(value);
             return expReferenceSystem;
+        }
         private org.gvsig.fmap.geom.primitive.Point createLabelPoint(org.gvsig.fmap.geom.Geometry geom)
-...
                             SimpleTextSymbol sym = new SimpleTextSymbol();
                             sym.setFont(getComputedFont());
                             sym.setUnit(getComputedUnit());
                             sym.setReferenceSystem(getComputedReferenceSystemExp());
                             sym.setReferenceSystem(getComputedReferenceSystem());
                             if (this.usesFixedSize()) { //(useFixedSize) {
                                 // uses fixed size
                                 size = getComputedFixedSize();// * fontScaleFactor;
-...
             throw new UnsupportedOperationException("Not supported yet.");
+        }
         public void setUnit(Expression expression) {
             expUnit = expression;
+        }
         @Override
         public int getUnit() {
             return getComputedUnitExp();
-...
             return value;
+        }
         public int getComputedReferenceSystemExp() {
         public int getComputedReferenceSystem() {
             int value = (int) getValueFromExpression(getReferenceSystemExp());
             return value;
+        }
         @Override
         public int getReferenceSystem() {
             return 0;
             return getComputedReferenceSystem();
+        }
         @Override
         public void setReferenceSystem(int referenceSystem) {
             this.referenceSystem = referenceSystem;
     //        this.referenceSystem = referenceSystem;
+        }
         @Override
-...
+        }
         @Override
         public void setFontField(String fontField) {
             this.LFONT = fontField;
         public void setFont(Expression expression) {
             expFont = expression;
+        }
         @Override
         public void setFontStyleField(String field) {
             this.LFONTSTYLE=field;
         public void setFontStyle(int style) {
+        }
         @Override
         public void setReferenceSystem(Expression expression) {
             expReferenceSystem = expression;
+        }
+    }

     package org.gvsig.symbology.fmap.mapcontext.rendering.dynamiclegend;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.List;
     import java.util.logging.Level;
     import org.gvsig.expressionevaluator.Expression;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
-...
         public static final String LEGEND_NAME = "DynamicSymbol";
         private ISymbol defaultSymbol;
         private int shapeType = Geometry.TYPES.SURFACE; // Por defecto, tipo pol?gono
         public static final String FIELD_OUTLINECOLOR = "COUTLINE";
         public static final String FIELD_FILLCOLOR = "CFILL";
         public static final String FIELD_SIZE = "CSIZE";
         public static final String FIELD_ROTATION = "CROTATION";
         public static Expression expOutlineColor = null;
         public static Expression expFillColor = null;
         public static Expression expSize = null;
         public static Expression expRotation = null;
         public static String[] requiredAttributes = null;
     //    public static final String FIELD_OUTLINECOLOR = "COUTLINE";
     //    public static final String FIELD_FILLCOLOR = "CFILL";
     //    public static final String FIELD_SIZE = "CSIZE";
     //    public static final String FIELD_ROTATION = "CROTATION";
         /**
          * Constructor method, needed by persistence.
          */
-...
             return expression;
+        }
         public void setOutlineColor(Expression expression) {
             expOutlineColor = expression;
+        }
         public void setFillColor(Expression expression) {
             expFillColor = expression;
+        }
         public void setSize(Expression expression) {
             expSize = expression;
+        }
         public void setRotation(Expression expression) {
             expRotation = expression;
+        }
         @Override
         public ISymbol getSymbolByFeature(Feature feat) {
             DynamicSymbol symbol = (DynamicSymbol) getDefaultSymbol();
             String fillcolor = feat.get(FIELD_FILLCOLOR).toString();
             Expression expFill = getExpressionFromString(fillcolor);
             symbol.setFillColor(expFill);
             symbol.setFillColor(expFillColor);
             String outlinecolor = feat.get(FIELD_OUTLINECOLOR).toString();
             Expression expOutlinecolor = getExpressionFromString(outlinecolor);
             symbol.setOutlineColor(expOutlinecolor);
             symbol.setOutlineColor(expOutlineColor);
             String size = feat.get(FIELD_SIZE).toString();
             Expression expSize = getExpressionFromString(size);
             symbol.setSize(expSize);
             String rotation = feat.get(FIELD_ROTATION).toString();
             Expression expRotation = getExpressionFromString(rotation);
             symbol.setRotation(expRotation);
             //OFFSET TODO
             Point pointOffset = null;
             String value = "";
-...
             Expression offset = getExpressionFromString(value);
             symbol.setOffset(offset);
             try {
                 String[] strList = this.getRequiredFeatureAttributeNames((FeatureStore) feat.getStore());
                 List<String> reqAttr = new ArrayList<>();
                 reqAttr.addAll(Arrays.asList(strList));
                 symbol.setRequiredFeatureAttributesNames(reqAttr);
             } catch (DataException ex) {
                 java.util.logging.Logger.getLogger(DefaultDynamicVectorLegend.class.getName()).log(Level.SEVERE, null, ex);
+            }
             List<String> requiredAttributes = new ArrayList<>();
             requiredAttributes.add(FIELD_OUTLINECOLOR);
             requiredAttributes.add(FIELD_FILLCOLOR);
             requiredAttributes.add(FIELD_ROTATION);
             requiredAttributes.add(FIELD_SIZE);
             symbol.setRequiredFeatureAttributesNames(requiredAttributes);
             symbol.setFeature(feat);
             return symbol;
+        }
-...
         @Override
         protected String[] getRequiredFeatureAttributeNames(
                 //TODO: Optimizar por obtener solo los campos que usan las expresiones
                 FeatureStore featureStore) throws DataException {
             // We only need the default Geometry to draw
             return new String[]{featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()};
             if (requiredAttributes == null) {
                 requiredAttributes = new String[]{};
                 for (int i = 0; i < featureStore.getDefaultFeatureType().size(); i++) {
                     FeatureAttributeDescriptor att = featureStore.getDefaultFeatureType().get(i);
                     requiredAttributes[i] = att.getName();
+                }
+            }
             return requiredAttributes;
+        }
         @Override

Also available in: Unified diff