| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.app.project.documents.layout.fframes;

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.font.FontRenderContext;

import java.awt.font.TextLayout;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.gvsig.andami.PluginServices;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.Draw;

import org.gvsig.fmap.geom.operation.DrawOperationContext;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Curve;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

import org.gvsig.tools.ToolsLocator;

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;

/**

 * FFrame para introducir una cuadr?cula sobre una vista en el Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFrameGrid extends AbstractFFrameViewDependence implements

    IFFrameViewDependence {

    private static final GeometryManager GEOMETRY_MANAGER = GeometryLocator.getGeometryManager();

    private static final int OFFSET_IN_PIXELS = 5;

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameGrid";

    private static final String SYMBOLLINE_FIELD = "symbolLine";

    private static final String SYMBOLPOINT_FIELD = "symbolPoint";

    private static final String FONT_FIELD = "font";

    private static final String INTERVALX_FIELD = "intervalX";

    private static final String INTERVALY_FIELD = "intervalY";

    private static final String ISLINE_FIELD = "isLine";

    private static final String FONTSYZE_FIELD = "fontsize";

    private static final String TEXTCOLOR_FIELD = "textColor";

    private static final ViewPort viewPortI = new ViewPort(null);

    private double intervalX = 10000;

    private double intervalY = 10000;

    private Color textColor = Color.black;

    private boolean isLine;

    private int sizeFont = 8;

    // private boolean print=false;

    private SymbolManager symbolManager = MapContextLocator.getSymbolManager();

    private ILineSymbol symbolLine = (ILineSymbol) symbolManager

        .createSymbol(ILineSymbol.SYMBOL_NAME);

    private IMarkerSymbol symbolPoint = (IMarkerSymbol) symbolManager

        .createSymbol(IMarkerSymbol.SYMBOL_NAME);

    private Font font = new Font("Arial", Font.PLAIN, sizeFont);

    private AffineTransform emptyTransform = new AffineTransform();

    public void draw(Graphics2D g, AffineTransform at, Rectangle2D rv,

        BufferedImage imgBase) {

        ViewPort vp = fframeViewDependence.getMapContext().getViewPort();        

        Rectangle2D.Double r = getBoundingBox(at);

        Rectangle2D rView = fframeViewDependence.getBoundingBox(at);

        g.rotate(Math.toRadians(getRotation()), r.x + (r.width / 2), r.y

            + (r.height / 2));

        Envelope envelope = vp.getAdjustedEnvelope();

        double minX = envelope.getMinimum(0);

        double minY = envelope.getMinimum(1);

        double restX = (minX / intervalX) % 1;

        double distX = restX * intervalX;

        double restY = (minY / intervalY) % 1;

        double distY = restY * intervalY;

        ISymbol symbolForMargins = null;

        if (isLine){

            symbolForMargins = symbolLine;

        }else{

            try {

                symbolForMargins = (ISymbol)symbolLine.clone();

                symbolForMargins.setColor(symbolPoint.getColor());

            } catch (CloneNotSupportedException e) {

                LOG.error("Symbol desn't support the clone method", e);

            }

        }

        //Draw the box

        drawBox(rView, g, symbolForMargins);

        //Draw the margins

        double myScale = at.getScaleX() * 0.0234; 

        int scaledFontSize = (int) (myScale * sizeFont);

        Font font =

            new Font(this.font.getFamily(), this.font.getStyle(),

                scaledFontSize);

        drawMargins(envelope, distX, distY, vp,  g, font, symbolForMargins);

        //Draw the lines or the points

        if (isLine) { 

            drawLines(envelope, distX, distY, vp, g);

        } else {

            drawPoints(envelope, distX, distY, vp, g);

        }

        g.rotate(Math.toRadians(-getRotation()), r.x + (r.width / 2), r.y

            + (r.height / 2));       

    } 

    private void drawMargins(Envelope envelope, double distX, double distY, ViewPort viewPort, Graphics2D g,  Font font, ISymbol symbolForMargins){

        double minX = envelope.getMinimum(0);

        double minY = envelope.getMinimum(1);

        double x = minX - distX;

        double y = minY - distY;

        double restX = (minX / intervalX) % 1;       

        double restY = (minY / intervalY) % 1;       

        double valueIntervalX =

            ((minX / intervalX) - restX) * intervalX - intervalX;

        double topX = minX;

        FontRenderContext frc = g.getFontRenderContext();

        //Draw vertical margins

        while (x < envelope.getMaximum(0)) {

            if (x > topX) {

                Point2D p2 = viewPort.fromMapPoint(x, minY);

                Point2D p1 = viewPort.fromMapPoint(x, envelope.getMaximum(1));

                drawLine(p1.getX(), p1.getY() - OFFSET_IN_PIXELS, p1.getX() , p1.getY(), g, symbolForMargins);

                drawLine(p2.getX(), p2.getY(), p2.getX() , p2.getY() + OFFSET_IN_PIXELS, g, symbolForMargins);

                TextLayout textaux =

                    new TextLayout(String.valueOf(valueIntervalX), font, frc);

                double w = textaux.getBounds().getWidth();

                double h = textaux.getBounds().getHeight();

                g.setColor(textColor);                                                    

                textaux.draw(g, (int) (p1.getX() - w / 2),

                    (int) (p1.getY() - h) - 5);

                textaux.draw(g, (int) (p2.getX() - w / 2),

                    (int) (p2.getY() + h * 2) + 5);

            }

            valueIntervalX = valueIntervalX + intervalX;

            x = x + intervalX;

        }

        double valueIntervalY =

            ((minY / intervalY) - restY) * intervalY - intervalY;

        y = y - intervalY;

        double topY = minY;

        while (y < envelope.getMaximum(1)) {

            if (y > topY) {

                Point2D p1 = viewPort.fromMapPoint(minX, y);

                Point2D p2 = viewPort.fromMapPoint(envelope.getMaximum(0), y);

                drawLine(p1.getX() - OFFSET_IN_PIXELS, p1.getY(), p1.getX() , p1.getY(), g, symbolForMargins);

                drawLine(p2.getX(), p2.getY(), p2.getX() + OFFSET_IN_PIXELS, p2.getY(), g, symbolForMargins);

                TextLayout textaux =

                    new TextLayout(String.valueOf(valueIntervalY), font, frc);

                double w = textaux.getBounds().getWidth();

                double h = textaux.getBounds().getHeight();

                g.setColor(textColor);

                textaux.draw(g, (int) (p1.getX() - w - 10),

                    (int) (p1.getY() + h / 2));

                textaux

                    .draw(g, (int) p2.getX() + 10, (int) (p2.getY() + h / 2));

            }

            valueIntervalY = valueIntervalY + intervalY;

            y = y + intervalY;

        }

    }

    private void drawBox(Rectangle2D mapRectangle, Graphics2D g, ISymbol symbol){        

        try {         

            Curve curve = (Curve) GEOMETRY_MANAGER.create(TYPES.CURVE, SUBTYPES.GEOM2D);

            curve.addMoveToVertex(GEOMETRY_MANAGER.createPoint(mapRectangle.getMinX(), mapRectangle.getMinY(), SUBTYPES.GEOM2D));

            curve.addVertex(GEOMETRY_MANAGER.createPoint(mapRectangle.getMinX(), mapRectangle.getMaxY()-1, SUBTYPES.GEOM2D));

            curve.addVertex(GEOMETRY_MANAGER.createPoint(mapRectangle.getMaxX()-1, mapRectangle.getMaxY()-1, SUBTYPES.GEOM2D));

            curve.addVertex(GEOMETRY_MANAGER.createPoint(mapRectangle.getMaxX()-1, mapRectangle.getMinY(), SUBTYPES.GEOM2D));

            curve.addVertex(GEOMETRY_MANAGER.createPoint(mapRectangle.getMinX(), mapRectangle.getMinY(), SUBTYPES.GEOM2D));

            symbol.draw(g, null, curve, null, null);

        } catch (CreateGeometryException e) {

            LOG.error("Error drawing the box", e);

        } 

    }

    private void drawPoints(Envelope envelope, double distX, double distY, ViewPort viewPort, Graphics2D g){

        double minX = envelope.getMinimum(0);

        double minY = envelope.getMinimum(1);

        double x = minX - distX;

        double y = minY - distY;

        while (x <= envelope.getMaximum(0)) {

            if (x > minX) {

                while (y <= envelope.getMaximum(1)) {

                    if (y >= minY) {

                        Point2D p = viewPort.fromMapPoint(x, y);

                        drawPoint(p, g);

                    }

                    y = y + intervalY;

                }

                y = minY - distY;

            }

            x = x + intervalX;

        }

    }

    private void drawPoint(Point2D point, Graphics2D g){

        try {

            Geometry geom =

                createPoint((int) point.getX(), (int) point.getY());

            symbolPoint.draw(g, emptyTransform, geom, null, null);           

        }  catch (LocatorException e) {

            LOG.error("Error drawing the grid", e);

        } catch (CreateGeometryException e) {

            LOG.error("Error drawing the grid", e);

        }

    }

    private void drawLines(Envelope envelope, double distX, double distY, ViewPort viewPort, Graphics2D g){

        double minX = envelope.getMinimum(0);

        double minY = envelope.getMinimum(1);

        double x = minX - distX;

        double y = minY - distY;

        //Draw the vertical lines

        while (x < envelope.getMaximum(0)) {

            Point2D antPoint = viewPort.fromMapPoint(x, minY);

            //This if removes the first vertical line

            if (x > minX) {

                Point2D p = viewPort.fromMapPoint(x, envelope.getMaximum(1));

                drawLine(antPoint, p, g, symbolLine);                    

                antPoint = (Point2D) p.clone();               

            }

            x = x + intervalX;

        }

        //Draw the horizontal lines

        while (y <= envelope.getMaximum(1)) {

            Point2D antPoint = viewPort.fromMapPoint(minX, y);

            //This if removes the first horizontal line

            if (y > minY) {                

                Point2D p = viewPort.fromMapPoint(envelope.getMaximum(0), y);

                drawLine(antPoint, p, g, symbolLine);              

                antPoint = (Point2D) p.clone();               

            }

            y = y + intervalY;

        }

    }

    private void drawLine(double startX, double startY, double endX, double endY, Graphics2D g, ISymbol symbolLine){

        try {

            Geometry geom =

                createLine((int) startX, (int)startY, (int) endX, (int) endY);

            symbolLine.draw(g, null, geom, null, null);          

        } catch (LocatorException e) {

            LOG.error("Error drawing the grid", e);

        } catch (CreateGeometryException e) {

            LOG.error("Error drawing the grid", e);

        }

    }

    private void drawLine(Point2D startPoint, Point2D endPoint, Graphics2D g,  ISymbol symbolLine){

        drawLine(startPoint.getX(), startPoint.getY(), endPoint.getX(), endPoint.getY(), g, symbolLine);

    }

    private Geometry createLine(int i, int j, int k, int l)

        throws LocatorException, CreateGeometryException {

        Curve curve = (Curve)GEOMETRY_MANAGER.create(Geometry.TYPES.CURVE, SUBTYPES.GEOM2D);

        curve.addMoveToVertex(GEOMETRY_MANAGER.createPoint(i, j, SUBTYPES.GEOM2D));

        curve.addVertex(GEOMETRY_MANAGER.createPoint(k, l, SUBTYPES.GEOM2D));

        return curve; 

    }

    private Geometry createPoint(int i, int j) throws LocatorException,

        CreateGeometryException {

        return GeometryLocator.getGeometryManager().createPoint(i, j,

            SUBTYPES.GEOM2D);

    }

    public String getNameFFrame() {

        return PluginServices.getText(this, "cuadricula") + num;

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    public void setFFrameDependence(IFFrame f) {

        super.setFFrameDependence(f);

        fframeViewDependence.refresh();       

    }

    public void setIntervalX(double d) {

        intervalX = d;

    }

    public void setIntervalY(double d) {

        intervalY = d;

    }

    public double getIntervalX() {

        return intervalX;

    }

    public double getIntervalY() {

        return intervalY;

    }

    public void setTextColor(Color textcolor) {

        textColor = textcolor;

    }

    public void setIsLine(boolean b) {

        isLine = b;

    }

    public boolean isLine() {

        return isLine;

    }

    public Color getFontColor() {

        return textColor;

    }

    public int getSizeFont() {

        return sizeFont;

    }

    public void setSizeFont(int sizeFont) {

        this.sizeFont = sizeFont;

    }

    public Rectangle2D.Double getBoundingBox(AffineTransform at) {

        if ((fframeViewDependence == null) ||  (fframeViewDependence.getMapContext() == null)){

            return super.getBoundingBox(at);

        }

        Rectangle2D.Double r = fframeViewDependence.getBoundingBox(at);

        Envelope extent =

            fframeViewDependence.getMapContext().getViewPort()

                .getAdjustedEnvelope();

        double extentX = extent.getMaximum(0);

        double extentY = extent.getMaximum(1);

        int lengthX = String.valueOf((long) extentX).length();

        double myScale = at.getScaleX() * 0.0234; 

        int scaledFontSize = (int) (myScale * sizeFont);

        int pixelsX = (int) (lengthX * scaledFontSize * 0.7);

        int lengthY = String.valueOf((long) extentY).length();

        int pixelsY = (lengthY * scaledFontSize);       

        return new Rectangle2D.Double(r.getMinX() - pixelsX, r.getMinY() - pixelsY,

                r.getWidth() + pixelsX * 2, r.getHeight() + pixelsY * 2);        

    }

    public Rectangle2D getMovieRect(int difx, int dify) {

        return this.getBoundingBox(null);

    }

    public void refreshDependence(IFFrame fant, IFFrame fnew) {

        if (fframeViewDependence.equals(fant)) {

            fframeViewDependence = (FFrameView) fnew;

            fframeViewDependence.refresh();           

        }

    }

    public void drawHandlers(Graphics2D g) {

        g.setColor(Color.gray);

        super.drawHandlers(g);

        g.setColor(Color.black);

    }

    public Rectangle2D getLastMoveRect() {

        return getBoundBox();

    }

    public ISymbol getSymbolLine() {

        return symbolLine;

    }

    public void setSymbolLine(ISymbol symbolLine) {

        this.symbolLine = (ILineSymbol) symbolLine;

    }

    public ISymbol getSymbolPoint() {

        return symbolPoint;

    }

    public void setSymbolPoint(ISymbol symbolPoint) {

        this.symbolPoint = (IMarkerSymbol) symbolPoint;

    }

    public Font getFont() {

        return font;

    }

    public void setFont(Font m_font) {

        this.font = m_font;

    }

    public int getFontSize() {

        return sizeFont;

    }

    public void print(Graphics2D g, AffineTransform at, Geometry shape,

        PrintAttributes properties) {

        fframeViewDependence.refresh();

        DrawOperationContext doc = new DrawOperationContext();

        doc.setGraphics(g);

        doc.setViewPort(viewPortI);

        doc.setSymbol(symbolLine);

        ViewPort vp = fframeViewDependence.getMapContext().getViewPort();

        FontRenderContext frc = g.getFontRenderContext();

        int pq = properties.getPrintQuality();

        double factor = 1;

        if (pq == PrintAttributes.PRINT_QUALITY_NORMAL) {

            factor = (double) 300 / 72;

        } else

            if (pq == PrintAttributes.PRINT_QUALITY_HIGH) {

                factor = (double) 600 / 72;

            } else

                if (pq == PrintAttributes.PRINT_QUALITY_DRAFT) {

                    // unitFactor *= 72; (which is the same than doing nothing)

                }

        sizeFont *= factor;

        double myScale = at.getScaleX() * 0.0234; // FLayoutUtilities.fromSheetDistance(folio.getAncho(),at)/rv.getWidth();

        int scaledFontSize = (int) (myScale * sizeFont);

        Font font =

            new Font(this.font.getFamily(), this.font.getStyle(),

                scaledFontSize);

        Rectangle2D.Double r = getBoundingBox(at);

        Rectangle2D rView = fframeViewDependence.getBoundingBox(at);

        g.rotate(Math.toRadians(getRotation()), r.x + (r.width / 2), r.y

            + (r.height / 2));

        Envelope extent = vp.getAdjustedEnvelope();

        double extentX = extent.getMinimum(0);

        double extentY = extent.getMinimum(1);

        double restX = (extentX / intervalX) % 1;

        double distX = restX * intervalX;

        double restY = (extentY / intervalY) % 1;

        double distY = restY * intervalY;

        double x = extentX - distX;

        double y = extentY - distY;

        g.setColor(Color.black);

        // Dibuja los m?rgenes

        double valueIntervalX =

            ((extentX / intervalX) - restX) * intervalX - intervalX;

        x = x - intervalX;

        double topX = extentX;

        while (x < extent.getMaximum(0)) {

            if (x > topX) {

                Point2D p2 = vp.fromMapPoint(x, extentY);

                Point2D p1 = vp.fromMapPoint(x, extent.getMaximum(1));

                if (isLine()) {

                    g.setColor(symbolLine.getColor());

                    g.setStroke(new BasicStroke((int) (symbolLine

                        .getLineWidth() * factor)));

                } else {

                    g.setColor(symbolPoint.getColor());

                    g.setStroke(new BasicStroke(1));

                }

                // g.setColor(lineColor);

                g.drawLine((int) p1.getX(), (int) p1.getY() - 5,

                    (int) p1.getX(), (int) p1.getY());

                g.drawLine((int) p2.getX(), (int) p2.getY(), (int) p2.getX(),

                    (int) p2.getY() + 5);

                TextLayout textaux =

                    new TextLayout(String.valueOf(valueIntervalX), font, frc);

                double w = textaux.getBounds().getWidth();

                double h = textaux.getBounds().getHeight();

                g.setColor(textColor);

                textaux.draw(g, (int) (p1.getX() - w / 2),

                    (int) (p1.getY() - h) - 5);

                textaux.draw(g, (int) (p2.getX() - w / 2),

                    (int) (p2.getY() + h * 2) + 5);

            }

            valueIntervalX = valueIntervalX + intervalX;

            x = x + intervalX;

        }

        double valueIntervalY =

            ((extentY / intervalY) - restY) * intervalY - intervalY;

        y = y - intervalY;

        double topY = extentY;

        while (y < extent.getMaximum(1)) {

            if (y > topY) {

                Point2D p1 = vp.fromMapPoint(extentX, y);

                Point2D p2 = vp.fromMapPoint(extent.getMaximum(0), y);

                if (isLine()) {

                    g.setColor(symbolLine.getColor());

                    g.setStroke(new BasicStroke((int) (symbolLine

                        .getLineWidth() * factor)));

                } else {

                    g.setColor(symbolPoint.getColor());

                    g.setStroke(new BasicStroke(1));

                }

                g.drawLine((int) p1.getX() - 5, (int) p1.getY(),

                    (int) p1.getX(), (int) p1.getY());

                g.drawLine((int) p2.getX(), (int) p2.getY(),

                    (int) p2.getX() + 5, (int) p2.getY());

                TextLayout textaux =

                    new TextLayout(String.valueOf(valueIntervalY), font, frc);

                double w = textaux.getBounds().getWidth();

                double h = textaux.getBounds().getHeight();

                g.setColor(textColor);

                textaux.draw(g, (int) (p1.getX() - w - 10),

                    (int) (p1.getY() + h / 2));

                textaux

                    .draw(g, (int) p2.getX() + 10, (int) (p2.getY() + h / 2));

            }

            valueIntervalY = valueIntervalY + intervalY;

            y = y + intervalY;

        }

        if (isLine()) {

            g.setColor(symbolLine.getColor());

            g.setStroke(new BasicStroke(

                (int) (symbolLine.getLineWidth() * factor)));

        } else {

            g.setColor(symbolPoint.getColor());

            g.setStroke(new BasicStroke(1));

        }

        g.draw(rView);

        x = extentX - distX;

        y = extentY - distY;

        if (isLine) { // Dibuja las l?neas.

            while (x < extent.getMaximum(0)) {

                Point2D antPoint = vp.fromMapPoint(x, extentY);

                if (x > extentX) {

                    while (y <= extent.getMaximum(1)) {

                        if (y >= extentY) {

                            Point2D p = vp.fromMapPoint(x, y);

                            try {

                                Geometry geom =

                                    createLine((int) antPoint.getX(),

                                        (int) antPoint.getY(), (int) p.getX(),

                                        (int) p.getY());

                                geom.invokeOperation(Draw.CODE, doc);

                            } catch (GeometryOperationNotSupportedException e) {

                                e.printStackTrace();

                            } catch (GeometryOperationException e) {

                                e.printStackTrace();

                            } catch (LocatorException e) {

                                e.printStackTrace();

                            } catch (CreateGeometryException e) {

                                e.printStackTrace();

                            }

                            antPoint = (Point2D) p.clone();

                        }

                        y = y + intervalY;

                    }

                    Point2D p = vp.fromMapPoint(x, extent.getMaximum(1));

                    try {

                        Geometry geom =

                            createLine((int) antPoint.getX(),

                                (int) antPoint.getY(), (int) p.getX(),

                                (int) p.getY());

                        geom.invokeOperation(Draw.CODE, doc);

                    } catch (GeometryOperationNotSupportedException e) {

                        e.printStackTrace();

                    } catch (GeometryOperationException e) {

                        e.printStackTrace();

                    } catch (LocatorException e) {

                        e.printStackTrace();

                    } catch (CreateGeometryException e) {

                        e.printStackTrace();

                    }

                    antPoint = (Point2D) p.clone();

                    y = extentY - distY;

                }

                x = x + intervalX;

            }

            while (y <= extent.getMaximum(1)) {

                Point2D antPoint = vp.fromMapPoint(extentX, y);

                if (y > extentY) {

                    while (x <= extent.getMaximum(0)) {

                        if (x >= extentX) {

                            Point2D p = vp.fromMapPoint(x, y);

                            try {

                                Geometry geom =

                                    createLine((int) antPoint.getX(),

                                        (int) antPoint.getY(), (int) p.getX(),

                                        (int) p.getY());

                                geom.invokeOperation(Draw.CODE, doc);

                            } catch (GeometryOperationNotSupportedException e) {

                                e.printStackTrace();

                            } catch (GeometryOperationException e) {

                                e.printStackTrace();

                            } catch (LocatorException e) {

                                e.printStackTrace();

                            } catch (CreateGeometryException e) {

                                e.printStackTrace();

                            }

                            antPoint = p;

                        }

                        x = x + intervalX;

                    }

                    Point2D p = vp.fromMapPoint(extent.getMaximum(0), y);

                    g.drawLine((int) antPoint.getX(), (int) antPoint.getY(),

                        (int) p.getX(), (int) p.getY());

                    antPoint = (Point2D) p.clone();

                    x = extentX - distX;

                }

                y = y + intervalY;

            }

        } else { // Dibuja los puntos

            while (x <= extent.getMaximum(0)) {

                if (x > extentX) {

                    while (y <= extent.getMaximum(1)) {

                        if (y >= extentY) {

                            Point2D p = vp.fromMapPoint(x, y);

                            try {

                                Geometry geom =

                                    createPoint((int) p.getX(), (int) p.getY());

                                geom.invokeOperation(Draw.CODE, doc);

                            } catch (GeometryOperationNotSupportedException e) {

                                e.printStackTrace();

                            } catch (GeometryOperationException e) {

                                e.printStackTrace();

                            } catch (LocatorException e) {

                                e.printStackTrace();

                            } catch (CreateGeometryException e) {

                                e.printStackTrace();

                            }

                        }

                        y = y + intervalY;

                    }

                    y = extentY - distY;

                }

                x = x + intervalX;

            }

        }

        g.rotate(Math.toRadians(-getRotation()), r.x + (r.width / 2), r.y

            + (r.height / 2));

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null) {

            DynStruct definition =

                manager.addDefinition(FFrameGrid.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameGrid persistence definition", null, null);

            definition

                .extend(manager

                    .getDefinition(AbstractFFrameViewDependence.PERSISTENCE_DEFINITION_NAME));

            definition.addDynFieldObject(SYMBOLLINE_FIELD)

                .setClassOfValue(ILineSymbol.class).setMandatory(true);

            definition.addDynFieldObject(SYMBOLPOINT_FIELD)

                .setClassOfValue(IMarkerSymbol.class).setMandatory(true);

            definition.addDynFieldObject(FONT_FIELD)

                .setClassOfValue(Font.class).setMandatory(true);

            definition.addDynFieldDouble(INTERVALX_FIELD).setMandatory(true);

            definition.addDynFieldDouble(INTERVALY_FIELD).setMandatory(true);

            definition.addDynFieldBoolean(ISLINE_FIELD).setMandatory(true);

            definition.addDynFieldInt(FONTSYZE_FIELD).setMandatory(true);

            definition.addDynFieldObject(TEXTCOLOR_FIELD)

                .setClassOfValue(Color.class).setMandatory(true);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        symbolLine = (ILineSymbol) state.get(SYMBOLLINE_FIELD);

        symbolPoint = (IMarkerSymbol) state.get(SYMBOLPOINT_FIELD);

        font = (Font) state.get(FONT_FIELD);

        intervalX = state.getDouble(INTERVALX_FIELD);

        intervalY = state.getDouble(INTERVALY_FIELD);

        isLine = state.getBoolean(ISLINE_FIELD);

        sizeFont = state.getInt(FONTSYZE_FIELD);

        textColor = (Color) state.get(TEXTCOLOR_FIELD);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(SYMBOLLINE_FIELD, symbolLine);

        state.set(SYMBOLPOINT_FIELD, symbolPoint);

        state.set(FONT_FIELD, font);

        state.set(INTERVALX_FIELD, intervalX);

        state.set(INTERVALY_FIELD, intervalY);

        state.set(ISLINE_FIELD, isLine);

        state.set(FONTSYZE_FIELD, sizeFont);

        state.set(TEXTCOLOR_FIELD, textColor);

    }

}