/ - Diff - Application: gvSIG desktop - gvSIG

Revision 42980

+                        }
                         break;
                     case IGeneralPathX.SEG_CLOSE:
                         coordinates.add(coordinates.get(0));
                         if(!coordinates.get(0).equals(coordinates.get(coordinates.size()-1))){
                             coordinates.add(coordinates.get(0));
+                        }
                         break;
                     default:
                         String message = StringUtils.replace("The general path has a gap in segment %(segment)s.","%(segment)s",String.valueOf(i));

     import java.awt.geom.Point2D;
     import java.awt.image.BufferedImage;
     import java.util.ArrayList;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import java.util.TreeMap;
     import java.util.TreeSet;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.compat.print.PrintAttributes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.ReadException;
-...
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.aggregate.MultiPrimitive;
     import org.gvsig.fmap.geom.exception.CreateEnvelopeException;
     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;
     import org.gvsig.fmap.geom.primitive.Envelope;
-...
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.tools.dynobject.DynStruct;
     import org.gvsig.tools.locator.LocatorException;
     import org.gvsig.tools.persistence.PersistenceManager;
     import org.gvsig.tools.persistence.PersistentState;
     import org.gvsig.tools.persistence.exception.PersistenceException;
     import org.gvsig.tools.task.Cancellable;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
+     *
      * GeneralLabelingStrategy.java
-...
     										 * print product (PDF, PS, ...)
     										 */
     	private List<Geometry> drawnGeometryLabels;
     	public GeneralLabelingStrategy() {
     		method = SymbologyLocator.getSymbologyManager()
     				.createDefaultLabelingMethod();
-...
+    		}
+    	}
     	public void draw(BufferedImage mapImage, Graphics2D mapGraphics,
     			double scale, ViewPort viewPort, Cancellable cancel, double dpi)
     			throws ReadException {
         public void draw(BufferedImage mapImage, Graphics2D mapGraphics, double scale, ViewPort viewPort,
             Cancellable cancel, double dpi) throws ReadException {
     		int x = (int) viewPort.getOffset().getX();
     		int y = (int) viewPort.getOffset().getY();
             drawnGeometryLabels = new ArrayList<Geometry>(1000);
     		// offsets for page generation (PDF, PS, direct printing)
     		int print_offset_x = x;
     		int print_offset_y = y;
     		if (printMode) {
     			// for printing, we never offset the labels themselves
     			x = 0;
     			y = 0;
     			printMode = false;
+    		}
             int x = (int) viewPort.getOffset().getX();
             int y = (int) viewPort.getOffset().getY();
     		TreeMap<String[], GeometryItem> labelsToPlace = null;
             // offsets for page generation (PDF, PS, direct printing)
             int print_offset_x = x;
             int print_offset_y = y;
             if (printMode) {
                 // for printing, we never offset the labels themselves
                 x = 0;
                 y = 0;
                 printMode = false;
+            }
     		String[] usedFields = getUsedFields();
             TreeMap<String[], GeometryItem> labelsToPlace = null;
     		int notPlacedCount = 0;
     		int placedCount = 0;
             String[] usedFields = getUsedFields();
     		/*
     		 * Get the label placement solvers according the user's settings
     		 */
     		ILabelPlacement placement = PlacementManager.getPlacement(
     				getPlacementConstraints(), layer.getShapeType());
             int notPlacedCount = 0;
             int placedCount = 0;
     		BufferedImage targetBI;
     		Graphics2D targetGr;
             /*
              * Get the label placement solvers according the user's settings
              */
             ILabelPlacement placement = PlacementManager.getPlacement(getPlacementConstraints(), layer.getShapeType());
     		/*
     		 * get an ordered set of the LabelClasses up on the label priority
     		 */
     		ILabelClass[] lcs = method.getLabelClasses();
     		TreeSet<ILabelClass> ts = new TreeSet<ILabelClass>(
     				new LabelClassComparatorByPriority());
             BufferedImage targetBI;
             Graphics2D targetGr;
     		for (int i = 0; i < lcs.length; i++)
     			ts.add(lcs[i]);
             /*
              * get an ordered set of the LabelClasses up on the label priority
              */
             ILabelClass[] lcs = method.getLabelClasses();
             TreeSet<ILabelClass> ts = new TreeSet<ILabelClass>(new LabelClassComparatorByPriority());
     		if (ts.size() == 0)
     			return;
             for (int i = 0; i < lcs.length; i++)
                 ts.add(lcs[i]);
     		/*
     		 * now we have an ordered set, it is only need to give a pass for each
     		 * label class to render by priorities.
+    		 *
     		 * If no priorities were defined, the following loop only executes once
     		 */
     		for (ILabelClass lc : ts) {
             if (ts.size() == 0)
                 return;
     			if (!lc.isVisible(scale)) {
     				/*
     				 * Avoid non-visible labels
     				 */
     				continue;
+    			}
             /*
              * now we have an ordered set, it is only need to give a pass for each
              * label class to render by priorities.
+             *
              * If no priorities were defined, the following loop only executes once
              */
             for (ILabelClass lc : ts) {
     			FeatureSet fset = null;
     			DisposableIterator diter = null;
     			try {
                 if (!lc.isVisible(scale)) {
                     /*
                      * Avoid non-visible labels
                      */
                     continue;
+                }
     				try {
     					fset = method.getFeatureIteratorByLabelClass(layer, lc,
     							viewPort, usedFields);
     				} catch (DataException e) {
     					throw new ReadException(layer.getFeatureStore()
     							.getProviderName(), e);
+    				}
                 FeatureSet fset = null;
                 DisposableIterator diter = null;
                 try {
     				// duplicates treatment stuff
     				/* handle the duplicates mode */
     				int duplicateMode = getDuplicateLabelsMode();
     				if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {
     					// we need to register the labels already placed
                     try {
                         fset = method.getFeatureIteratorByLabelClass(layer, lc, viewPort, usedFields);
                     } catch (DataException e) {
                         throw new ReadException(layer.getFeatureStore().getProviderName(), e);
+                    }
     					labelsToPlace = new TreeMap<String[], GeometryItem>(
     							new RemoveDuplicatesComparator());
+    				}
                     // duplicates treatment stuff
                     /* handle the duplicates mode */
                     int duplicateMode = getDuplicateLabelsMode();
                     if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {
                         // we need to register the labels already placed
     				boolean bLabelsReallocatable = !isAllowingOverlap();
                         labelsToPlace = new TreeMap<String[], GeometryItem>(new RemoveDuplicatesComparator());
+                    }
     				BufferedImage overlapDetectImage = null;
     				Graphics2D overlapDetectGraphics = null;
     				if (bLabelsReallocatable) {
     					int width = viewPort.getImageWidth() + print_offset_x;
                     boolean bLabelsReallocatable = !isAllowingOverlap();
     					if (width < 0) {
     						width = 1;
+    					}
     					int height = viewPort.getImageHeight() + print_offset_y;
     					if (height < 0) {
     						height = 1;
+    					}
     					if (mapImage != null)
     						overlapDetectImage = new BufferedImage(
     								mapImage.getWidth() + print_offset_x,
     								mapImage.getHeight() + print_offset_y,
     								BufferedImage.TYPE_INT_ARGB);
     					else
     						overlapDetectImage = new BufferedImage(
     								viewPort.getImageWidth() + print_offset_x,
     								viewPort.getImageHeight() + print_offset_y,
     								BufferedImage.TYPE_INT_ARGB);
                     BufferedImage overlapDetectImage = null;
                     Graphics2D overlapDetectGraphics = null;
                     if (bLabelsReallocatable) {
                         int width = viewPort.getImageWidth() + print_offset_x;
     					overlapDetectGraphics = overlapDetectImage.createGraphics();
     					overlapDetectGraphics.setRenderingHints(mapGraphics
     							.getRenderingHints());
+    				}
     				if (bLabelsReallocatable) {
     					targetBI = overlapDetectImage;
     					targetGr = overlapDetectGraphics;
     					targetGr.translate(-x, -y);
     				} else {
     					targetBI = mapImage;
     					targetGr = mapGraphics;
+    				}
                         if (width < 0) {
                             width = 1;
+                        }
                         int height = viewPort.getImageHeight() + print_offset_y;
                         if (height < 0) {
                             height = 1;
+                        }
                         if (mapImage != null)
                             overlapDetectImage =
                                 new BufferedImage(mapImage.getWidth() + print_offset_x, mapImage.getHeight()
                                     + print_offset_y, BufferedImage.TYPE_INT_ARGB);
                         else
                             overlapDetectImage =
                                 new BufferedImage(viewPort.getImageWidth() + print_offset_x, viewPort.getImageHeight()
                                     + print_offset_y, BufferedImage.TYPE_INT_ARGB);
     				try {
     					diter = fset.fastIterator();
     				} catch (DataException e) {
     					throw new ReadException(layer.getFeatureStore()
     							.getProviderName(), e);
+    				}
     				Feature featu = null;
     				Geometry geome = null;
                         overlapDetectGraphics = overlapDetectImage.createGraphics();
                         overlapDetectGraphics.setRenderingHints(mapGraphics.getRenderingHints());
+                    }
                     if (bLabelsReallocatable) {
                         targetBI = overlapDetectImage;
                         targetGr = overlapDetectGraphics;
                         targetGr.translate(-x, -y);
                     } else {
                         targetBI = mapImage;
                         targetGr = mapGraphics;
+                    }
     				while (!cancel.isCanceled() && diter.hasNext()) {
                     try {
                         diter = fset.fastIterator();
                     } catch (DataException e) {
                         throw new ReadException(layer.getFeatureStore().getProviderName(), e);
+                    }
                     Feature featu = null;
                     Geometry geome = null;
     					featu = (Feature) diter.next();
     					geome = featu.getDefaultGeometry();
     					if (geome == null || geome.getType() == Geometry.TYPES.NULL) {
     						continue;
+    					}
                     while (!cancel.isCanceled() && diter.hasNext()) {
     					if (!setupLabel(featu, lc, cancel, usedFields, viewPort,
     							dpi, duplicateMode)) {
     						continue;
+    					}
                         featu = (Feature) diter.next();
                         geome = featu.getDefaultGeometry();
                         if (geome == null || geome.getType() == Geometry.TYPES.NULL) {
                             continue;
+                        }
     					String[] texts = lc.getTexts();
                         if (!setupLabel(featu, lc, cancel, usedFields, viewPort, dpi, duplicateMode)) {
                             continue;
+                        }
     					if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {
     						// check if this text (so label) is already present in
     						// the map
                         String[] texts = lc.getTexts();
     						GeometryItem item = labelsToPlace.get(texts);
     						if (item == null) {
     							item = new GeometryItem(geome, 0);
     							labelsToPlace.put(texts, item);
+    						}
     						if (item.geom != null) {
                         if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {
                             // check if this text (so label) is already present in
                             // the map
     							notPlacedCount++;
     							if (geome.getType() != Geometry.TYPES.POINT) {
                             GeometryItem item = labelsToPlace.get(texts);
                             if (item == null) {
                                 item = new GeometryItem(geome, 0);
                                 labelsToPlace.put(texts, item);
+                            }
                             if (item.geom != null) {
     								Envelope auxBox = geome.getEnvelope();
     								double perimeterAux = 2 * (auxBox.getLength(0) + auxBox
     										.getLength(1));
     								if (perimeterAux > item.savedPerimeter) {
     									item.geom = geome; // FConverter.jts_to_igeometry(jtsGeom);
     									item.savedPerimeter = perimeterAux;
+    								}
     							} else {
     								int weigh = item.weigh;
                                 notPlacedCount++;
                                 if (geome.getType() != Geometry.TYPES.POINT) {
     								try {
     									Point pointFromLabel = item.geom.centroid();
     									Point pointGeome = geome.centroid();
     									item.geom = GeometryLocator
     											.getGeometryManager()
     											.createPoint(
     													(pointFromLabel.getX()
     															* weigh + pointGeome.getX())
     															/ (weigh + 1),
     													(pointFromLabel.getY()
     															* weigh + pointGeome
     																.getY())
     															/ (weigh + 1),
     													Geometry.SUBTYPES.GEOM2D);
     								} catch (Exception ex) {
     									throw new ReadException(layer
     											.getFeatureStore()
     											.getProviderName(), ex);
+    								}
                                     Envelope auxBox = geome.getEnvelope();
                                     double perimeterAux = 2 * (auxBox.getLength(0) + auxBox.getLength(1));
                                     if (perimeterAux > item.savedPerimeter) {
                                         item.geom = geome; // FConverter.jts_to_igeometry(jtsGeom);
                                         item.savedPerimeter = perimeterAux;
+                                    }
                                 } else {
                                     int weigh = item.weigh;
+    							}
     						} else {
     							item.geom = geome;
+    						}
     						item.weigh++;
     					} else {
     						// Check if size is a pixel
     						if (isOnePoint(viewPort, geome)) {
     							continue;
+    						}
                                     try {
                                         Point pointFromLabel = item.geom.centroid();
                                         Point pointGeome = geome.centroid();
                                         item.geom =
                                             GeometryLocator.getGeometryManager().createPoint(
                                                 (pointFromLabel.getX() * weigh + pointGeome.getX()) / (weigh + 1),
                                                 (pointFromLabel.getY() * weigh + pointGeome.getY()) / (weigh + 1),
                                                 Geometry.SUBTYPES.GEOM2D);
                                     } catch (Exception ex) {
                                         throw new ReadException(layer.getFeatureStore().getProviderName(), ex);
+                                    }
     						List<Geometry> geome_parts = new ArrayList<Geometry>();
     						if (duplicateMode == IPlacementConstraints.ONE_LABEL_PER_FEATURE_PART) {
     							geome_parts = getGeometryParts(geome);
     						} else {
     							geome_parts.add(geome);
+    						}
+                                }
                             } else {
                                 item.geom = geome;
+                            }
                             item.weigh++;
                         } else {
                             // Check if size is a pixel
                             if (isOnePoint(viewPort, geome)) {
                                 continue;
+                            }
     						try {
     							int n = geome_parts.size();
     							for (int k = 0; k < n; k++) {
     								drawLabelInGeom(targetBI, targetGr, lc,
     										placement, viewPort,
     										geome_parts.get(k), cancel, dpi,
     										bLabelsReallocatable);
+    							}
     						} catch (GeometryException e) {
     							throw new ReadException(layer.getFeatureStore()
     									.getProviderName(), e);
+    						}
                             List<Geometry> geome_parts = new ArrayList<Geometry>();
                             if (duplicateMode == IPlacementConstraints.ONE_LABEL_PER_FEATURE_PART) {
                                 geome_parts = getGeometryParts(geome);
                             } else {
                                 geome_parts.add(geome);
+                            }
     						placedCount++;
+    					}
+    				}
                             try {
                                 int n = geome_parts.size();
                                 for (int k = 0; k < n; k++) {
                                     drawLabelInGeom(targetBI, targetGr, lc, placement, viewPort, geome_parts.get(k),
                                         cancel, dpi, bLabelsReallocatable);
+                                }
                             } catch (GeometryException e) {
                                 throw new ReadException(layer.getFeatureStore().getProviderName(), e);
+                            }
     				// ======= End iteration in feature set ====================
                             placedCount++;
+                        }
+                    }
     				if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {
     					Iterator<String[]> textsIt = labelsToPlace.keySet()
     							.iterator();
     					while (!cancel.isCanceled() && textsIt.hasNext()) {
     						notPlacedCount++;
     						String[] texts = textsIt.next();
                     // ======= End iteration in feature set ====================
     						GeometryItem item = labelsToPlace.get(texts);
     						if (item != null) {
     							lc.setTexts(texts);
     							// Check if size is a pixel
     							if (isOnePoint(viewPort, item.geom)) {
     								continue;
+    							}
                     if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {
                         Iterator<String[]> textsIt = labelsToPlace.keySet().iterator();
                         while (!cancel.isCanceled() && textsIt.hasNext()) {
                             notPlacedCount++;
                             String[] texts = textsIt.next();
     							try {
     								drawLabelInGeom(targetBI, targetGr, lc,
     										placement, viewPort, item.geom, cancel,
     										dpi, bLabelsReallocatable);
     							} catch (GeometryException e) {
     								throw new ReadException(layer.getFeatureStore()
     										.getProviderName(), e);
+    							}
+    						}
+    					}
+    				}
                             GeometryItem item = labelsToPlace.get(texts);
                             if (item != null) {
                                 lc.setTexts(texts);
                                 // Check if size is a pixel
                                 if (isOnePoint(viewPort, item.geom)) {
                                     continue;
+                                }
     				if (bLabelsReallocatable) {
     					targetGr.translate(x, y);
     					if (mapImage != null) {
     						mapGraphics.drawImage(overlapDetectImage, null, null);
     					} else {
     						mapGraphics.drawImage(overlapDetectImage, null, null);
+    					}
+    				}
                                 try {
                                     drawLabelInGeom(targetBI, targetGr, lc, placement, viewPort, item.geom, cancel, dpi,
                                         bLabelsReallocatable);
                                 } catch (GeometryException e) {
                                     throw new ReadException(layer.getFeatureStore().getProviderName(), e);
+                                }
+                            }
+                        }
+                    }
     			} finally {
     				if (diter != null) {
     					diter.dispose();
+    				}
     				if (fset != null){
     					fset.dispose();
+    				}
+    			}
     		} // big iteration
                     if (bLabelsReallocatable) {
                         targetGr.translate(x, y);
                         if (mapImage != null) {
                             mapGraphics.drawImage(overlapDetectImage, null, null);
                         } else {
                             mapGraphics.drawImage(overlapDetectImage, null, null);
+                        }
+                    }
+    	}
                 } finally {
                     if (diter != null) {
                         diter.dispose();
+                    }
                     if (fset != null) {
                         fset.dispose();
+                    }
+                }
             } // big iteration
+        }
     	private List<Geometry> getGeometryParts(Geometry ge) {
     		List<Geometry> resp = new ArrayList<Geometry>();
-...
     			Cancellable cancel, boolean bLabelsReallocatable)
     			throws GeometryException {
     	    GeometryManager gm = GeometryLocator.getGeometryManager();
     		int i;
     		for (i = 0; !cancel.isCanceled() && i < llm.size(); i++) {
     			LabelLocationMetrics labelMetrics = llm.get(i);
-...
     			if (pc instanceof MultiShapePlacementConstraints) {
     				MultiShapePlacementConstraints mpc = (MultiShapePlacementConstraints) pc;
     				GeometryManager gm = GeometryLocator.getGeometryManager();
     				GeometryType line_gt = null;
     				GeometryType polyg_gt = null;
     				GeometryType geom_gt = null;
     				line_gt = gm.getGeometryType(TYPES.CURVE, SUBTYPES.GEOM2D);
     				polyg_gt = gm.getGeometryType(TYPES.SURFACE, SUBTYPES.GEOM2D);
     				geom_gt = gm.getGeometryType(geom.getType(), SUBTYPES.GEOM2D);
     				if (geom_gt.getType() == TYPES.POINT
-...
     		return true;
+    	}
     	private boolean isOverlapping(BufferedImage bi, Geometry lblgeom) {
         private boolean isOverlapping(BufferedImage bi, Geometry lblgeom) {
     		if (lblgeom == null || lblgeom.getType() == TYPES.NULL) {
     			return false;
+    		}
     		Envelope rPixels = lblgeom.getEnvelope();
     		int minx = (int) rPixels.getMinimum(0);
     		int miny = (int) rPixels.getMinimum(1);
     		int maxx = (int) rPixels.getMaximum(0);
     		int maxy = (int) rPixels.getMaximum(1);
             for (int i = minx; i <= maxx; i++) {
                 for (int j = miny; j <= maxy; j++) {
                     GeometryManager geomManager = GeometryLocator.getGeometryManager();
                     try {
                         if (!lblgeom.contains(geomManager.createPoint(i, j, Geometry.SUBTYPES.GEOM2D))
                         // contains seems to don't detect points
                         // placed in the rectangle boundaries
                             && !lblgeom.intersects(geomManager.createEnvelope(i, j, i, j, Geometry.SUBTYPES.GEOM2D).getGeometry())) {
                             continue;
+                        }
                     } catch (CreateGeometryException | GeometryOperationNotSupportedException | GeometryOperationException
                         | CreateEnvelopeException e) {
                         logger.warn("Can't check overlapping with point ("+i+","+j+").");
+                    }
                     if (i < 0 || j < 0) {
                         continue;
+                    }
                     if (bi.getWidth() < i + 1 || bi.getHeight() < j + 1) {
                         continue;
+                    }
                     if (bi.getRGB(i, j) != 0) {
             for (Iterator iterator = drawnGeometryLabels.iterator(); iterator.hasNext();) {
                 Geometry drawnGeometry = (Geometry) iterator.next();
                 try {
                     if (drawnGeometry.intersects(lblgeom)) {
                         return true;
+                    }
                 } catch (GeometryOperationNotSupportedException | GeometryOperationException e) {
                     logger.warn("Can't check overlapping geometry");
+                }
+            }
     		return false;
+    	}
             drawnGeometryLabels.add(lblgeom);
             return false;
+        }
     	private boolean isOnePoint(ViewPort viewPort, Geometry geom) {
     		boolean onePoint = false;

     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.Polygon;
     import org.gvsig.fmap.mapcontext.ViewPort;
     import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelClass;
     import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelLocationMetrics;
-...
     import org.gvsig.tools.persistence.exception.PersistenceException;
     import org.gvsig.tools.persistence.spi.PersistentContextServices;
     import org.gvsig.tools.util.Callable;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
      * @author jaume dominguez faus - jaume.dominguez@iver.es
      */
     public class LabelClass implements ILabelClass {
     	private static final String FIELD_REFERENCE_SYSTEM = "referenceSystem";
     	private static final String FIELD_UNIT = "unit";
     	private static final String FIELD_SQL_QUERY = "sqlQuery";
-...
     	private String[] texts;
     	private int priority;
     	private double scale = 1;
     	private String sqlQuery;
     	private boolean usesSQL;
     	private int unit = CartographicSupportToolkit.DefaultMeasureUnit;
     	private int referenceSystem =
     			CartographicSupportToolkit.DefaultReferenceSystem;
     	/**
     	 * Returns true if the label will be showed in the map
+    	 *
-...
     		} else {
     			this.labelExpressions = lbl_exps;
+    		}
+    	}
     	/**
-...
     		if (llm==null)
     			return null;
     		Point2D anchor = llm.getAnchor();
     		org.gvsig.fmap.geom.primitive.Point p = geomManager.createPoint(anchor.getX(), anchor.getY(), SUBTYPES.GEOM2D);
     		double theta = llm.getRotation();
     		// 2. calculate the container shape
     		Geometry returnedValue;
     		Polygon returnedValue;
     		Rectangle bounds = getBounds();
     		AffineTransform at = AffineTransform.getTranslateInstance(p.getX(), p.getY());
     		AffineTransform at = AffineTransform.getTranslateInstance(anchor.getX(), anchor.getY());
     		at.concatenate(AffineTransform.getRotateInstance(theta));
     		returnedValue = geomManager.createSurface(new GeneralPathX(bounds
     				.getPathIterator(null)), SUBTYPES.GEOM2D);
     		returnedValue = geomManager.createPolygon(SUBTYPES.GEOM2D);
     		returnedValue.addVertex(bounds.getMinX(), bounds.getMinY());
     		returnedValue.addVertex(bounds.getMinX(), bounds.getMaxY());
     		returnedValue.addVertex(bounds.getMaxX(), bounds.getMaxY());
     		returnedValue.addVertex(bounds.getMaxX(), bounds.getMinY());
     		returnedValue.addVertex(bounds.getMinX(), bounds.getMinY());
     		returnedValue.transform(at);
     		return returnedValue;
-...
     	/*
     	 * (non-Javadoc)
+    	 *
+    	 *
     	 * @seeorg.gvsig.tools.persistence.Persistent#saveToState(org.gvsig.tools.
     	 * persistence.PersistentState)
     	 */
-...
     		state.set(FIELD_TEXT_SYMBOL, getTextSymbol());
     		state.set(FIELD_LABEL_EXPRESSIONS, getLabelExpressions());
     		state.set(FIELD_VISIBLE, isVisible());
     		ILabelStyle sty = getLabelStyle();
     		if (sty != null) {
     			state.set(FIELD_LABEL_STYLE, getLabelStyle());
+    		}
     		state.set(FIELD_TEXTS, getTexts());
     		state.set(FIELD_PRIORITY, getPriority());
     		state.set(FIELD_SCALE, scale);
     		state.set(FIELD_SQL_QUERY, getSQLQuery());
     		state.set(FIELD_IS_USESQL, isUseSqlQuery());
     		state.set(FIELD_UNIT, getUnit());
     		state.set(FIELD_REFERENCE_SYSTEM, getReferenceSystem());
+    	}
     	/*
     	 * (non-Javadoc)
+    	 *
+    	 *
     	 * @see
     	 * org.gvsig.tools.persistence.Persistent#loadFromState(org.gvsig.tools.
     	 * persistence.PersistentState)
-...
     		setTextSymbol((ITextSymbol) state.get(FIELD_TEXT_SYMBOL));
     		setLabelExpressions(state.getStringArray(FIELD_LABEL_EXPRESSIONS));
     		setVisible(state.getBoolean(FIELD_VISIBLE));
     		if (state.hasValue(FIELD_LABEL_STYLE)) {
     			setLabelStyle((ILabelStyle) state.get(FIELD_LABEL_STYLE));
     			setLabelStyle((ILabelStyle) state.get(FIELD_LABEL_STYLE));
+    		}
     		setTexts((String[]) state.getArray(FIELD_TEXTS, String.class));
     		setPriority(state.getInt(FIELD_PRIORITY));
     		scale = state.getDouble(FIELD_SCALE);
     		setUseSqlQuery(state.getBoolean(FIELD_IS_USESQL));
     		setSQLQuery(state.getString(FIELD_SQL_QUERY));
     		setUnit(state.getInt(FIELD_UNIT));
     		setReferenceSystem(state.getInt(FIELD_REFERENCE_SYSTEM));
+    	}
-...
     						LabelClass.class,
     						LABEL_CLASS_PERSISTENCE_DEFINITION_NAME,
     						LABEL_CLASS_PERSISTENCE_DEFINITION_NAME+" Persistence definition",
     						null,
     						null,
     						null
     				);
     				definition.addDynFieldString(FIELD_NAME).setMandatory(true);
     				definition.addDynFieldObject(FIELD_TEXT_SYMBOL).setMandatory(true).setClassOfValue(ITextSymbol.class);
     				definition.addDynFieldArray(FIELD_LABEL_EXPRESSIONS)
     				.setClassOfItems(String.class).setMandatory(true);
     				definition.addDynFieldBoolean(FIELD_VISIBLE).setMandatory(true);
     				definition.addDynFieldObject(FIELD_LABEL_STYLE).setMandatory(false)
     				.setClassOfValue(ILabelStyle.class);
     				definition.addDynFieldList(FIELD_TEXTS).setMandatory(true).setClassOfItems(String.class);
     				definition.addDynFieldInt(FIELD_PRIORITY).setMandatory(true);
     				definition.addDynFieldDouble(FIELD_SCALE).setMandatory(true);
-...
+    			}
     			return Boolean.TRUE;
+    		}
+    	}
     	public void setUseSqlQuery(boolean use_sql) {
-...
+        }
+    }

Also available in: Unified diff