/trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/layers/GraphicLayer.java - Diff - | gvSIG desktop 1 - gvSIG

Revision 20098 trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/layers/GraphicLayer.java

     import com.vividsolutions.jts.index.ItemVisitor;
     import com.vividsolutions.jts.index.SpatialIndex;
     import com.vividsolutions.jts.index.quadtree.Quadtree;
     /**
      * <p>The class <code>GraphicLayer</code> represents a layer with graphical items, that are geometries with
      * <p><code>GraphicLayer</code> represents a layer with graphical items, that are geometries with
      *  a symbol and handlers associated.</p>
+     *
      * <p>The internal graphical items are independent to each other and can be selected separately. There is a bit set to
      * define which item are selected. And they which are selected, will be drawn with handlers, that according to the particular
      * implementation of each one, can allow to move, center, ... the graphic item.</p>
+     *
+     *
      * <p>The internal graphical items are independent to each other and can be selected separately. There is a <i>bit set</i> to
      * define which item are selected. They, will be drawn with handlers, that according to the particular
      * implementation of each one, can allow user to move, center, deform, ... each graphical item.</p>
+     *
      * @see FLyrDefault
      */
     public class GraphicLayer extends FLyrDefault {
     	/**
     	 * Internal list with all graphic items of this layer.
+    	 *
+    	 *
     	 * @see #addGraphic(FGraphic)
     	 * @see #clearAllGraphics()
     	 * @see #getGraphic(int)
-...
     	/**
     	 * Internal list with all symbols of this layer.
+    	 *
+    	 *
     	 * @see #addSymbol(ISymbol)
     	 * @see #clearSymbolsGraphics()
     	 */
         private ArrayList symbols = new ArrayList();
         /**
     	/**
     	 * Describes a rectangle defined by a location (x, y) and dimension, that represents this layer position
     	 *  and dimension.
+    	 *
+    	 *
     	 * @see #getFullExtent()
     	 * @see #reCalculateFullExtent()
     	 */
-...
     	 * An optimal index according a quadtree for fast access to spatial data.
     	 */
         private SpatialIndex spatialIndex = new Quadtree();
         /**
     	/**
     	 * A set of boolean items that specifies which graphic items of this layer are selected.
+    	 *
+    	 *
     	 * @see #getSelection()
     	 * @see #setSelection(FBitSet)
     	 */
         private FBitSet selection = new FBitSet();
         /**
     	 * Creates a default <i>FMap</i> layer.
+    	 *
     	/**
     	 * <p>Creates a new <code>GraphicLayer</code> instance.</p>
+    	 *
     	 * @see FLyrDefault#FLyrDefault()
     	 */
         public GraphicLayer() {
-...
             return fullExtent;
+        }
         /*
          * @see com.iver.cit.gvsig.fmap.layers.FLayer#draw(java.awt.image.BufferedImage, java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.utiles.swing.threads.Cancellable, double)
          */
-...
         /**
          * <p>Processes all graphic items of this layer according to the <i>visitor pattern</i>. This
          *  operation can be cancelled at any time.</p>
+         *
          *  operation can be canceled at any time.</p>
+         *
          * @param visitor object that allows visit each graphic item
          * @param cancel an object thread that implements the {@link Cancellable Cancellable} interface, and allows
          *  cancel the visit
          * @param cancel shared object that determines if this layer can continue being drawn
          */
         public void process(ItemVisitor visitor, Cancellable cancel)
+        {
-...
+        }
         /*
          * @see com.iver.cit.gvsig.fmap.layers.FLayer#print(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.utiles.swing.threads.Cancellable, double, javax.print.attribute.PrintRequestAttributeSet)
          */
-...
                 drawGraphics(null, g, viewPort, cancel);
+                }
+        }
         /**
          * <p>Draws each graphic item of this layer that it's associated symbol is also in this layer, and its
          *  geometry intersects with the extent currently covered by the view (of the {@link ViewPort ViewPort}). If
          *  the graphic item is selected, will also draw its selection handlers.</p>
+         *
          *  the graphic item is selected, will also draw its selection handlers.</p>
+         *
          * @param image buffer used sometimes instead <code>g</code> to accelerate the draw. For example, if two points are as closed that can't be distinguished, draws only one.
     	 * @param g for rendering 2-dimensional shapes, text and images on the Java(tm) platform
     	 * @param viewPort the information for drawing the layers
     	 * @param cancel an object thread that implements the {@link Cancellable Cancellable} interface, and will allow to cancel the draw
+    	 *
+    	 *
          * @see #draw(BufferedImage, Graphics2D, ViewPort, Cancellable, double)
          * @see #print(Graphics2D, ViewPort, Cancellable, double, PrintRequestAttributeSet)
          */
-...
+                }
+            }
+        }
         /**
          * <p>Adds a new symbol to the graphic layer, and if success, returns the last index of the internal
          * <p>Adds a new symbol to the graphic layer, and, if success, returns the last index of the internal
          *  list of symbols.</p>
+         *
+         *
          * @param newSymbol the new symbol
          * @return last index of the internal list of symbols if success, -1 otherwise
+         *
+         *
          * @see #clearSymbolsGraphics()
          */
         public int addSymbol(ISymbol newSymbol)
-...
             return -1;
+        }
         /**
          * <p>Adds a new graphic item to the graphic layer, and if success, sets as new extent the graphic's
          * <p>Adds a new graphic item to the graphic layer, and, if success, sets as new extent the graphic's
          *  one if this layer hadn't, otherwise sets as new extent the union of both.</p>
+         *
+         *
          * @param g the new graphic item
+         *
+         *
          * @see #insertGraphic(int, FGraphic)
          * @see #inserGraphics(int, Collection)
          */
-...
     //        return -1;
+        }
         /**
          * <p>Adds a new graphic item to the graphic layer at the position specified of the internal list, and if success,
          * <p>Adds a new graphic item to the graphic layer at the position specified of the internal list, and, if success,
          *  sets as new extent the graphic's one if this layer hadn't, otherwise sets as new extent the union of both.</p>
+         *
          * @param position the index of the element to insert
+         *
          * @param position the index of the element to insert
          * @param g the new graphic item
+         *
+         *
          * @see #inserGraphics(int, Collection)
          * @see #addGraphic(FGraphic)
          */
-...
                 fullExtent.add(g.getGeom().getBounds2D());
+            }
+        }
         /**
          * Removes all graphic items from this layer. The internal list of graphic items will be empty
          *  after this call returns, and layer won't have extent.
+         *
+         *
          * @see #removeGraphic(FGraphic)
          * @see #removeGraphic(int)
          */
-...
             graphics.clear();
             fullExtent = null;
+        }
         /**
          * Removes all symbols from this layer. The internal list of symbols will be empty
          *  after this call returns.
+         *
+         *
          * @see #addSymbol(ISymbol)
          */
         public void clearSymbolsGraphics()
+        {
             symbols.clear();
+        }
         /**
          * <p>Gets a set of boolean values that specifies which graphic items of this layer are selected.</p>
+         *
          * @return a set of boolean values. Each value is equal to <code>true</code> if is selected the graphic item
+         *
          * @return a set of boolean values. Each value is equal to <code>true</code> if is selected the graphic item
          *  that has the same position in the internal list of graphic items of this layer, and to <code>false</code> if isn't selected
+         *
+         *
          * @see #setSelection(FBitSet)
          */
     	public FBitSet getSelection() {
-...
     	/**
          * <p>Sets a set of boolean values that specifies which graphic items of this layer are selected.</p>
+         *
          * @param selection a set of boolean values. Each value is equal to <code>true</code> if is selected the graphic item
+         *
          * @param selection a set of boolean values. Each value is equal to <code>true</code> if is selected the graphic item
          *  that has the same position in the internal list of graphic items of this layer, and to <code>false</code> if isn't selected
+         *
+         *
          * @see #getSelection()
     	 */
     	public void setSelection(FBitSet selection) {
     		this.selection = selection;
+    	}
     	/**
     	 * Returns a bit set that reports which graphic items that are geometries, intersect with
     	 * Returns a bit set that reports which graphic items <i>(geometries)</i>, intersect with
     	 *  the rectangle <code>r</code>.
+    	 *
     	 * @param r the <code>Rectangle2D</code> to be intersected with all geometries of this layer
+    	 *
     	 * @param r the <code>Rectangle2D</code> to be intersected with some geometries of this layer
     	 * @return a <code>FBitSet</code> which <code>true</code> bits represent the geometries of this layer
     	 *  that intersect with the rectangle
+    	 *
+    	 *
     	 * @see IGeometry#intersects(Rectangle2D)
     	 */
     	public FBitSet queryByRect(Rectangle2D r) {
-...
+            }
             return newSel;
+    	}
     	/**
     	 * Removes a graphic item and recalculates the extent of this layer.
+    	 *
+    	 *
     	 * @param graphic the graphic item to be removed
+    	 *
+    	 *
     	 * @see #removeGraphic(int)
     	 * @see #clearAllGraphics()
     	 */
-...
     		reCalculateFullExtent();
+    	}
     	/**
     	 * Returns the item at the specified position in the internal list of graphics.
+    	 *
+    	 *
     	 * @param idGraphic index of item to return
     	 * @return the item at the specified position in the internal list of graphics
+    	 *
+    	 *
     	 * @see #getGraphicByObjectTag(Object)
     	 * @see #getNumGraphics()
     	 */
     	public FGraphic getGraphic(int idGraphic) {
     		return (FGraphic) graphics.get(idGraphic);
+    	}
     	/**
     	 * Returns the graphic item of this layer, that has the specified object tag.
+    	 *
     	 * @param objectTag the object tag of the item to return
+    	 *
     	 * @param objectTag the tag of the item to return
     	 * @return the item that has the specified object tag, or <code>null</code> if there was no item that had it
+    	 *
+    	 *
     	 * @see #getGraphic(int)
     	 * @see #getNumGraphics()
     	 */
-...
     	 * Returns the number of graphic items in this layer.
+    	 *
     	 * @return the number of graphic items in this list
+    	 *
+    	 *
     	 * @see #addGraphic(FGraphic)
     	 * @see #inserGraphics(int, Collection)
     	 * @see #insertGraphic(int, FGraphic)
-...
     	public int getNumGraphics() {
     		return graphics.size();
+    	}
     	/**
     	 * Recalculates the full extent of this layer as the union of the bounds 2D
     	 *  of all internal graphic items.
-...
+    			}
+    		}
+    	}
     	/**
     	 * <p>Inserts all of the elements in the specified {@link Collection Collection} into the internal list of graphic items,
     	 *  starting at the specified position. Shifts the element currently at that position (if any) and any
     	 *  subsequent elements to the right (increases their indices). The new elements will appear in the list
     	 *  starting at the specified position. Shifts the element currently at that position (if there was any) and any
     	 *  subsequent elements to the right (increasing their indices). The new elements will appear in the list
     	 *  in the order that they are returned by the specified collection's iterator.</p>
+    	 *
     	 * @param index index at which to insert first element from the specified collection
+    	 *
     	 * @param index index where starting to insert the elements from the specified collection
     	 * @param c elements to be inserted into this list
+    	 *
+    	 *
     	 * @see #insertGraphic(int, FGraphic)
     	 * @see #addGraphic(FGraphic)
     	 */
-...
     	/**
     	 * <p>Fast remove: removes only a graphic item of this layer.</p>
     	 * <p>Remember to call {@linkplain #reCalculateFullExtent()} when you finish removing graphics.</p>
+    	 *
+    	 *
     	 * @param graphicIndex the graphic item to be removed
+    	 *
+    	 *
     	 * @see #removeGraphic(FGraphic)
     	 * @see #clearAllGraphics()
     	 */
     	public void removeGraphic(int graphicIndex) {
     		graphics.remove(graphicIndex);
+    	}
     	/**
     	  * Return index of symbol, if it exists.
     	  * @param sym
     	  * @return -1 if it is not inside the symbols list.
     	  * <p>Searches for the first symbol <code>sym</code>, testing for equality using the equals method.</p>
+    	  *
     	  * @param sym a symbol
     	  * @return the index of the first occurrence of <code>sym</code>; returns -1 if the object is not found.
     	  */
     	public int getSymbol(ISymbol sym) {
     		if (symbols.contains(sym)) {

Also available in: Unified diff