/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 40390

     	private static final String FIELD_KEYS = "keys";
     	private static final String FIELD_INTERVAL_TYPE = "intervalType";
     	private static final String FIELD_USE_DEFAULT_SYMBOL = "useDefaultSymbol";
     	private static final String FIELD_NULL_INTERVAL_SYMBOL =
     			"nullIntervalSymbol";
     	private static final String FIELD_SYMBOLS = "symbols";
     	protected List<Object> keys = new ArrayList<Object>(); // <Object>
-...
     	protected int intervalType = NATURAL_INTERVALS;
     	protected boolean useDefaultSymbol = false;
     	private ISymbol nullIntervalSymbol = null;
     	// private ISymbol nullIntervalSymbol = null;
     	public static final int EQUAL_INTERVALS = 0;
     	public static final int NATURAL_INTERVALS = 1;
-...
     	public void addSymbol(Object key, ISymbol symbol) {
     		if (key == null) {
     			nullIntervalSymbol = symbol;
+    		}
     		else {
     		    // why did we use this?
     			// nullIntervalSymbol = symbol;
     		    logger.info(
     		        "Warning: tried to add symbol with null key.",
     		        new Exception("Key is NULL"));
     		} else {
     			symbols.put(key, symbol);
     			keys.add(key);
     			fireClassifiedSymbolChangeEvent(new SymbolLegendEvent(null, symbol));
+    		}
     		fireClassifiedSymbolChangeEvent(new SymbolLegendEvent(null, symbol));
+    	}
     	/*
-...
         public ISymbol getSymbolByInterval(IInterval key) {
     		if (key == null){
     			if (nullIntervalSymbol != null) {
     				return nullIntervalSymbol;
+    			}
     			else if (isUseDefaultSymbol()) {
     			if (isUseDefaultSymbol()) {
     				return defaultSymbol;
+    			}
     			return null;
-...
     	public ISymbol[] getSymbols() {
     		ISymbol[] symbolList;
     		if (nullIntervalSymbol == null) {
     			symbolList = new ISymbol[symbols.size()];
     			return (ISymbol[]) symbols.values().toArray(symbolList);
+    		}
     		else {
     			symbolList = new ISymbol[symbols.size() + 1];
     			symbolList[0] = nullIntervalSymbol;
     			int i = 1;
     			for (Iterator<ISymbol> iterator = symbols.values().iterator(); iterator.hasNext();) {
     				symbolList[i] = iterator.next();
     				i++;
+    			}
     			return symbolList;
+    		}
             symbolList = new ISymbol[symbols.size()];
             return (ISymbol[]) symbols.values().toArray(symbolList);
+    	}
     	public void setDefaultSymbol(ISymbol s) {
-...
     	public IInterval getInterval(Object v) {
     		if (v != null ) {
     			for (int i = 0; i < keys.size(); i++) {
     				if (((IInterval) keys.get(i)).isInInterval(v)) {
     					return (IInterval) keys.get(i);
+    				}
     			    Object obj_key = keys.get(i);
     			    if (obj_key instanceof IInterval) {
     	                if (((IInterval) obj_key).isInInterval(v)) {
     	                    return (IInterval) obj_key;
+    	                }
+    			    }
+    			}
+    		}
-...
     	public Object clone() throws CloneNotSupportedException {
     		AbstractIntervalLegend clone = (AbstractIntervalLegend) super.clone();
     		// Clone null interval symbol
     		if (nullIntervalSymbol != null) {
     			clone.nullIntervalSymbol = (ISymbol) nullIntervalSymbol.clone();
+    		}
     		// Clone default symbol
     		if (defaultSymbol != null) {
     			clone.defaultSymbol = (ISymbol) defaultSymbol.clone();
-...
     			for (Iterator<Entry<Object, ISymbol>> iterator =
     					symbols.entrySet().iterator(); iterator.hasNext();) {
     				Entry<Object, ISymbol> entry = iterator.next();
     				IInterval intervalClone =
     						(IInterval) ((IInterval) entry.getKey()).clone();
     				Object key = entry.getKey();
     				IInterval key_interval = null;
     				if (key instanceof IInterval) {
     				    key_interval = (IInterval) key;
     				    key = key_interval.clone();
+    				}
     				ISymbol symbolClone =
     						(ISymbol) ((ISymbol) entry.getValue()).clone();
     				clone.addSymbol(intervalClone, symbolClone);
     				clone.addSymbol(key, symbolClone);
+    			}
+    		}
-...
     		// Set own properties
     		setIntervalType(state.getInt(FIELD_INTERVAL_TYPE));
     		keys = new ArrayList<Object>(state.getList(FIELD_KEYS));
     		nullIntervalSymbol = (ISymbol) state.get(FIELD_NULL_INTERVAL_SYMBOL);
     		useDefaultSymbol(state.getBoolean(FIELD_USE_DEFAULT_SYMBOL));
     		Map persistedSymbolMap = (Map) state.get(FIELD_SYMBOLS);
     		if (persistedSymbolMap != null) {
-...
     		// Save own properties
     		state.set(FIELD_INTERVAL_TYPE, getIntervalType());
     		state.set(FIELD_KEYS, keys);
     		state.set(FIELD_NULL_INTERVAL_SYMBOL, nullIntervalSymbol);
     		state.set(FIELD_USE_DEFAULT_SYMBOL, isUseDefaultSymbol());
     		state.set(FIELD_SYMBOLS, symbols);
+    	}
-...
     				// Keys
     				definition.addDynFieldList(FIELD_KEYS)
     					.setClassOfItems(int.class);
     				// Null interval symbol
     				definition.addDynFieldObject(FIELD_NULL_INTERVAL_SYMBOL)
     					.setClassOfValue(ISymbol.class)
     					.setMandatory(false);
     				// Use default symbol?
     				definition.addDynFieldBoolean(FIELD_USE_DEFAULT_SYMBOL);
     				// Symbols
-...
     		(new Comparator<Object>() {
     					public int compare(Object o1, Object o2) {
     						if ((o1 != null) && (o2 != null)) {
     							// if (o1 instanceof NullIntervalValue &&
     							// o2 instanceof NullIntervalValue) {
     							// return 0;
     							// }
     							//
     							// if (o2 instanceof NullIntervalValue) {
     							// return 1;
     							// }
     							//
     							// if (o1 instanceof NullIntervalValue) {
     							// return -1;
     							// }
     						    boolean o1_inte = (o1 instanceof FInterval);
                                 boolean o2_inte = (o2 instanceof FInterval);
                                 if (!o1_inte && !o2_inte) {
                                     return 0;
                                 } else {
                                     if (o1_inte && !o2_inte) {
                                         return 1;
                                     } else {
                                         if (!o1_inte && o2_inte) {
                                             return -1;
+                                        }
+                                    }
+                                }
     							FInterval i2 = (FInterval) o2;
     							FInterval i1 = (FInterval) o1;

     		String fieldName = (String) cmbField.getSelectedItem();
     		auxLegend.setClassifyingFieldNames(new String[] {fieldName});
     		auxLegend.useDefaultSymbol(chkdefaultvalues.isSelected());
     		ISymbol defsym = null;
             if (chkdefaultvalues.isSelected() && defaultSymbolPrev.getSymbol() != null) {
                 defsym = (ISymbol) defaultSymbolPrev.getSymbol();
                 String description = PluginServices.getText(this,"default");
                 defsym.setDescription(description);
                 auxLegend.setDefaultSymbol(defsym);
                 auxLegend.useDefaultSymbol(true);
             } else {
                 auxLegend.useDefaultSymbol(false);
+            }
     		FeatureStore rs;
     		try {
     			rs = ((FLyrVect) layer).getFeatureStore();
     //			rs.start();
     			FeatureType featureType=rs.getDefaultFeatureType();
     			auxLegend
     					.setClassifyingFieldTypes(new int[] { new Integer(
     							featureType.getAttributeDescriptor(fieldName)
     									.getType()) });
     			logger.debug("rs.start()");
     //			rs.stop();
     		} catch (DataException e) {
     			NotificationManager.addError(PluginServices.getText(this, "recovering_recordset"), e);
-...
     		for (int row = 0; row < symbolTable.getRowCount(); row++) {
     			if (!(symbolTable.getFieldValue(row, 1) instanceof FInterval)) {
     				theSymbol = (ISymbol) symbolTable.getFieldValue(row, 0);
     				theSymbol.setDescription((String) symbolTable.getFieldValue(
     						row, 2));
     				auxLegend.addSymbol(null, theSymbol);
     			} else {
     			if (symbolTable.getFieldValue(row, 1) instanceof FInterval) {
     				theInterval = (IInterval) symbolTable.getFieldValue(row, 1);
     				theSymbol = (ISymbol) symbolTable.getFieldValue(row, 0);
     				theSymbol.setDescription((String) symbolTable.getFieldValue(
-...
     				auxLegend.addSymbol(theInterval, theSymbol);
+    			}
+    		}
     		if(chkdefaultvalues.isSelected()){
     			if(defaultSymbolPrev.getSymbol() != null){
     				String description = PluginServices.getText(this,"default");
     				defaultSymbolPrev.getSymbol().setDescription(description);
     				auxLegend.addSymbol(null, defaultSymbolPrev.getSymbol());
+    			}
     		if (auxLegend.isUseDefaultSymbol()) {
     		    theSymbol = auxLegend.getDefaultSymbol();
     		    auxLegend.addSymbol(theSymbol.getDescription(), theSymbol);
+    		}
+    	}
         /**

Also available in: Unified diff