/trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/rendering/styling/LinePlacementConstraints.java - | gvSIG desktop 1 - gvSIG

root / trunk / libraries / libFMap / src / com / iver / cit / gvsig / fmap / rendering / styling / LinePlacementConstraints.java @ 11192

History | View | Annotate | Download (4.99 KB)

       /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+       *
        * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.
+       *
        * This program is free software; you can redistribute it and/or
        * modify it under the terms of the GNU General Public License
        * as published by the Free Software Foundation; either version 2
        * of the License, or (at your option) any later version.
+       *
        * This program is distributed in the hope that it will be useful,
        * but WITHOUT ANY WARRANTY; without even the implied warranty of
        * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        * GNU General Public License for more details.
+       *
        * You should have received a copy of the GNU General Public License
        * along with this program; if not, write to the Free Software
        * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+       *
        * For more information, contact:
+       *
        *  Generalitat Valenciana
        *   Conselleria d'Infraestructures i Transport
        *   Av. Blasco Ib??ez, 50
        *   46010 VALENCIA
        *   SPAIN
+       *
        *      +34 963862235
        *   gvsig@gva.es
        *      www.gvsig.gva.es
+       *
        *    or
+       *
        *   IVER T.I. S.A
        *   Salamanca 50
        *   46005 Valencia
        *   Spain
+       *
        *   +34 963163400
        *   dac@iver.es
        */
       /* CVS MESSAGES:
+      *
       * $Id: LinePlacementConstraints.java 11192 2007-04-13 11:59:30Z jaume $
       * $Log$
       * Revision 1.7  2007-04-13 11:59:30  jaume
       * *** empty log message ***
+      *
       * Revision 1.6  2007/04/12 16:01:11  jaume
       * *** empty log message ***
+      *
       * Revision 1.5  2007/04/12 14:28:43  jaume
       * basic labeling support for lines
+      *
       * Revision 1.4  2007/04/11 16:01:08  jaume
       * maybe a label placer refactor
+      *
       * Revision 1.3  2007/04/02 16:34:56  jaume
       * Styled labeling (start commiting)
+      *
       * Revision 1.2  2007/03/09 08:33:43  jaume
       * *** empty log message ***
+      *
       * Revision 1.1.2.1  2007/02/09 07:47:05  jaume
       * Isymbol moved
+      *
+      *
       */
       package com.iver.cit.gvsig.fmap.rendering.styling;
       import java.awt.Graphics2D;
       import java.awt.Rectangle;
       import java.awt.geom.AffineTransform;
       import org.apache.batik.ext.awt.geom.PathLength;
       import org.cresques.px.gml.MultiPolygon;
       import com.iver.cit.gvsig.fmap.core.FPoint2D;
       import com.iver.cit.gvsig.fmap.core.FShape;
       import com.iver.cit.gvsig.fmap.core.IGeometry;
       import com.iver.utiles.XMLEntity;
       /**
+       *
        * @author jaume dominguez faus - jaume.dominguez@iver.es
+       *
        */
       public class LinePlacementConstraints extends AbstractPlacementConstraints {
               private static final double HALF_PI = Math.PI * 0.5;
               public FShape[] getLocationsFor(IGeometry geom, FShape labelShape, MultiPolygon exclusionZone) {
                       return new FShape[] { (FShape) geom.getInternalShape() };
+              }
               public void placeLabel(Graphics2D g, IGeometry geom, LabelClass lc, MultiPolygon exclusionZone, AffineTransform at) {
                       Rectangle labelBounds = lc.getShape(g, at, geom).getBounds();
                       FPoint2D startingPoint = null;
                       double theta = 0;
                       if (isFollowingLine()) {
                               throw new Error("following line option not yet implemented");
                               // 1. create text path
                               // 2. convert text symbol to SmartTextSymbol if need
                       } else {
                               PathLength pathLen = new PathLength(geom.getInternalShape());
                               float distance;
                               if (isAtTheBeginingOfLine()) {
                                       distance = 0;
                               } else if (isAtTheEndOfLine()) {
                                       distance = pathLen.lengthOfPath();
                               } else {
                                       // will use in the middle of the line
                                       distance = pathLen.lengthOfPath() * 0.5F;
+                              }
                               startingPoint = new FPoint2D(pathLen.pointAtLength(distance));
                               if (isParallel()) {
                                       // get the line theta and apply it
                                       theta = -pathLen.angleAtLength(distance);
                               } else if (isPerpendicular()) {
                                       // get the line theta with 90 degrees
                                       theta = -pathLen.angleAtLength(distance) + HALF_PI;
+                              }
+                      }
                       /*
                        * Now we have the starting point for the text and the angle of
                        * the line in such point , we will apply the offset to place the
                        * text either over, under or above the line
                        */
                       if (exclusionZone == null) {
                               // no check for overlapping is needed
                               if (isBellowTheLine()) {
                                       // Offset to be on bellow of the line.
                               } else if (isAboveTheLine()) {
                                       // Offset to be above the line (inverse offset to under the line)
                               } else {
                                       // No offset.
+                              }
                               /*
                                * Now, we'll need to see who is defining the orientation
                                * either the line or the page.
                                */
                               if (isPageOriented()) {
                               } else {
                                       // The line defines the orientation.
+                              }
                       } else {
                               // the case of the process for look for a non-overlapping place
                               // will be better handled by a SmartLinePlacement
                               throw new Error("overlapping detection option not yet implemented");
+                      }
                       startingPoint.transform(at);
                       labelBounds.setLocation(0-(int) (labelBounds.width*.5), 0 - (int) (labelBounds.height*.5));
                       g.translate((int) startingPoint.getX(), (int) startingPoint.getY());
                       if (theta != 0) {
                               g.rotate(theta);
+                      }
                       lc.drawInsideRectangle(g, labelBounds);
                       if (theta != 0) {
                               g.rotate(-theta);
+                      }
                       g.translate(-(int) startingPoint.getX(), -(int) startingPoint.getY());
+              }
               public String getClassName() {
                       return getClass().getName();
+              }
               public XMLEntity getXMLEntity() {
                       XMLEntity xml = super.getXMLEntity();
                       xml.putProperty("className", getClassName());
                       return xml;
+              }
+      }