Application: gvSIG desktop » gvSIG Document Layout

/* 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.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 java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

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.primitive.Curve;

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

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

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.math.intervals.IntervalUtils;

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 String USE_NUM_DIVISIONS_FIELD = "useNumDivisions";

    private static final String NUM_DIV_HORIZ_FIELD = "numDivHoriz";

    private static final String NUM_DIV_VERT_FIELD = "numDivVret";

    private static final String LABEL_FORMAT_FIELD = "labelFormat";

    private static final String HORIZ_LABEL_ROTATION_FIELD = "horizLabelRotation";

    private static final String VERT_LABEL_ROTATION_FIELD = "vertLabelRotation";

    /**

     * Use a fixed distance (intervalX and intervalY)

     * to calculate the position of grid lines

     */

    public static final int FIXED_DISTANCE_MODE = 0;

    /**

     * Use a specific number of horizontal divisions in order

     * to calculate the position of grid lines

     */

    public static final int NUM_DIVISIONS_HORIZ_MODE = 1;

    /**

     * Use a specific number of vertical divisions in order to calculate

     * the position of grid lines

     */

    public static final int NUM_DIVISIONS_VERT_MODE = 2;

    private double defaultInterval = 100000;

    private Double intervalX = null;

    private Double intervalY = null;

    private Color textColor = Color.black;

    private boolean isLine;

    private int sizeFont = 8;

        private int useNumDivisions = FIXED_DISTANCE_MODE;

        private int numDivHoriz = 4;

        private int numDivVert = 4;

        private DecimalFormat labelFormat = new DecimalFormat("#0.00", DecimalFormatSymbols.getInstance());

        private double horizLabelRotation = 0.0;

        private double vertLabelRotation = 0.0;

    // 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);

        if (r==null || rView==null) {

                //extent may be null, for instance if no layer has been loaded on the view

                return;

        }

        Envelope envelope = vp.getAdjustedEnvelope();

        updateIntervals(envelope);

        double intervalX = getIntervalX();

        double intervalY = getIntervalY();

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

        double minX = envelope.getMinimum(0);

        double minY = envelope.getMinimum(1);

        // init point, in map coordinates

        double initPointGridWCX = Math.floor(minX / intervalX)*intervalX;

        double initPointGridWCY = Math.floor(minY / intervalY)*intervalY;

        // shift from the beginning of the map till the first point of the grid

        double shiftXMap = initPointGridWCX-minX;

        double shiftYMap = initPointGridWCY-minY;

        // init point, in screen coordinates (pixels)

        double initPointGridPxX = rView.getMinX() + (rView.getWidth() * shiftXMap) /  envelope.getLength(0);

        double initPointGridPxY = rView.getMinY() + (rView.getHeight() * shiftYMap) /  envelope.getLength(1);

        double intervalPxWidth = (rView.getWidth() * intervalX) /  envelope.getLength(0);

        double intervalPxHeight = (rView.getHeight() * intervalY) /  envelope.getLength(1);

        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(rView,

                        initPointGridWCX,

                        initPointGridWCY,

                        intervalX,

                        intervalY,

                        initPointGridPxX,

                        initPointGridPxY,

                        intervalPxWidth,

                        intervalPxHeight,

                        g,

                        font,

                        symbolForMargins);

        //Draw the lines or the points

        if (isLine) {

            drawLines(rView,

                            initPointGridPxX,

                            initPointGridPxY,

                            intervalPxWidth,

                            intervalPxHeight,

                            vp, g);

        } else {

            drawPoints(rView,

                            initPointGridPxX,

                            initPointGridPxY,

                            intervalPxWidth,

                            intervalPxHeight,

                            vp, g);

        }

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

            + (r.height / 2));

    }

    private void drawPoints(Rectangle2D rView,

                    double initPointGridPxX,

                    double initPointGridPxY,

                    double intervalPxX,

                    double intervalPxY,

                    ViewPort viewPort,

                    Graphics2D g) {

        double minX = rView.getMinX();

        double maxX = rView.getMaxX();

        double minY = rView.getMinY();

        double maxY = rView.getMaxY();

        double x = initPointGridPxX;

        double y = initPointGridPxY;

        while (x <= maxX) {

            if (x > minX) {

                while (y <= maxY) {

                    if (y > minY) {

                        Point2D p = new Point2D.Double(x, y);

                        drawPoint(p, g);

                    }

                    y = y + intervalPxY;

                }

                y = initPointGridPxY;

            }

            x = x + intervalPxX;

        }

    }

    private void drawLines(Rectangle2D rView,

                    double initPointGridPxX,

                    double initPointGridPxY,

                    double intervalPxX,

                    double intervalPxY,

                    ViewPort viewPort,

                    Graphics2D g) {

        double minX = rView.getMinX();

        double maxX = rView.getMaxX();

        double minY = rView.getMinY();

        double maxY = rView.getMaxY();

        double x = initPointGridPxX;

        double y = initPointGridPxY;

        //Draw the vertical lines

        while (x < maxX) {

                if (x>minX) {

                        Point2D antPoint = new Point2D.Double(x, minY - 5);

                        Point2D p = new Point2D.Double(x, maxY + 5);

                        drawLine(antPoint, p, g, symbolLine);

                        antPoint = (Point2D) p.clone();

                }

            x = x + intervalPxX;

        }

        //Draw the horizontal lines

        while (y <= maxY) {

                if (y > minY) {

                        Point2D antPoint = new Point2D.Double(minX, y);

                        Point2D p = new Point2D.Double(rView.getMaxX(), y);

                        drawLine(antPoint, p, g, symbolLine);

                        antPoint = (Point2D) p.clone();

                }

            y = y + intervalPxY;

        }

    }

    private void drawMargins(Rectangle2D rView,

                    double initPointGridMapX,

                    double initPointGridMapY,

                    double intervalMapX,

                    double intervalMapY,

                    double initPointGridPxX,

                    double initPointGridPxY,

                    double intervalPxX,

                    double intervalPxY,

                    Graphics2D g,

                    Font font,

                    ISymbol

                    symbolForMargins) {

            FontRenderContext frc = g.getFontRenderContext();

        double minX = rView.getMinX();

        double maxX = rView.getMaxX();

        double minY = rView.getMinY();

        double maxY = rView.getMaxY();

        double xPx = initPointGridPxX;

        double xMap = initPointGridMapX;

        // Draw vertical ticks and labels

        while (xPx < maxX) {

            if (xPx > minX) {

                Point2D p2 = new Point2D.Double(xPx, minY);

                Point2D p1 = new Point2D.Double(xPx, maxY);

                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(this.labelFormat.format(xMap), font, frc);

                g.setColor(textColor);

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

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

                double labelY = (p1.getY() + h) + 8;

                g.rotate(Math.toRadians(getVertLabelRotation()), p1.getX(), (labelY - (h / 2.0)));

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

                    (int) labelY);

                g.rotate(Math.toRadians(-getVertLabelRotation()),  p1.getX(), (labelY - (h / 2.0)));

                labelY = (p2.getY() - h);

                g.rotate(Math.toRadians(getVertLabelRotation()), p1.getX(), (labelY - (h / 2.0)));

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

                    (int) labelY);

                g.rotate(Math.toRadians(-getVertLabelRotation()),  p1.getX(), (labelY - (h / 2.0)));

            }

            xMap = xMap + intervalMapX;

            xPx = xPx + intervalPxX;

        }

        double yPx = initPointGridPxY;

        double yMap = initPointGridMapY;

        // horizontal ticks and labels

        while (yPx < maxY) {

            if (yPx > minY) {

                Point2D p1 = new Point2D.Double(minX, yPx);

                Point2D p2 = new Point2D.Double(rView.getMaxX(), yPx);

                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(this.labelFormat.format(yMap), font, frc);

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

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

                g.setColor(textColor);

                double rotationX = p1.getX()-10-w/2.0;

                g.rotate(Math.toRadians(getHorizLabelRotation()), rotationX, p1.getY());

                textaux.draw(g,

                        (int) (p1.getX() - w - 10),

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

                g.rotate(Math.toRadians(-getHorizLabelRotation()), rotationX, p1.getY());

                rotationX = p2.getX()+10+w/2.0;

                g.rotate(Math.toRadians(getHorizLabelRotation()), rotationX, p2.getY());

                textaux.draw(g,

                        (int) p2.getX() + 10,

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

                g.rotate(Math.toRadians(-getHorizLabelRotation()), rotationX, p2.getY());

            }

            yMap = yMap + intervalMapY;

            yPx = yPx + intervalPxY;

        }

    }

    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 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 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() {

            if (intervalX!=null) {

                    return intervalX;

            }

            intervalX = intervalY = getReasonableInterval();

            return intervalX;

    }

    private double getReasonableInterval() {

            if (fframeViewDependence!=null

                            && fframeViewDependence.getMapContext()!=null

                            && fframeViewDependence.getMapContext().getViewPort().getAdjustedEnvelope()!=null) {

                    Envelope env = fframeViewDependence.getMapContext().getViewPort().getAdjustedEnvelope();

                    return IntervalUtils.roundIntervalDivision(env.getLength(0), 5);

            }

            return defaultInterval;

    }

    public double getIntervalY() {

            if (intervalX!=null) {

                    return intervalX;

            }

            intervalX = intervalY = new Double(getReasonableInterval());

            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();

        if (extent==null) {

                //extent may be null, for instance if no layer has been loaded on the view

                return null;

        }

        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 font.getSize();

    }

    /**

     * Defines whether a number of divisions is used to calculate the

     * location of grid lines,

     * or a distance (intervalX and intervalY) is used to

     * calculate them.

     *

     * @param useNumDivisions One of {@link #FIXED_DISTANCE_MODE},

     * {@link #NUM_DIVISIONS_HORIZ_MODE} or {@link #NUM_DIVISIONS_HORIZ_MODE}.

     * @return

     */

    public void setUseNumDivisions(int mode) {

            this.useNumDivisions  = mode;

    }

    protected void updateIntervals() {

            if (fframeViewDependence.getMapContext()!=null

                            && fframeViewDependence.getMapContext().getViewPort()!=null) {

                    Envelope env = fframeViewDependence.getMapContext().getViewPort().getAdjustedEnvelope();

                    updateIntervals(env);

            }

    }

    protected void updateIntervals(Envelope env) {

            if (useNumDivisions==NUM_DIVISIONS_HORIZ_MODE) {

                    double division = IntervalUtils.roundIntervalDivision(env.getLength(0), numDivHoriz);

                    intervalX = division;

                    intervalY = division;

            }

            else if (useNumDivisions==NUM_DIVISIONS_VERT_MODE) {

                    double division = IntervalUtils.roundIntervalDivision(env.getLength(1), numDivVert);

                    intervalX = division;

                    intervalY = division;

            }

    }

    /**

     * Returns true if a number of divisions is used to calculate the

     * location of grid lines,

     * or false if a distance (intervalX and intervalY) is used to

     * calculate them.

     *

     * @return  One of {@link #FIXED_DISTANCE_MODE},

     * {@link #NUM_DIVISIONS_HORIZ_MODE} or {@link #NUM_DIVISIONS_HORIZ_MODE}.

     */

    public int getUseNumDivisions() {

            return this.useNumDivisions;

    }

    public void setNumDivisionsHoriz(int nx) {

            this.numDivHoriz = nx;

    }

    public void setNumDivisionsVert(int ny) {

            this.numDivVert = ny;

    }

    public int getNumDivisionHoriz() {

            return this.numDivHoriz;

    }

    public int getNumDivisionsVert() {

            return this.numDivVert;

    }

    public void setLabelFormat(DecimalFormat f) {

            this.labelFormat  = f;

    }

    public DecimalFormat  getLabelFormat() {

            return this.labelFormat;

    }

    /**

     * Sets the rotation of the labels corresponding to horizontal lines

     *

     * @param labelRotation Label rotation, measured in arc degrees

     */

    public void setHorizLabelRotation(double labelRotation) {

            this.horizLabelRotation  = labelRotation;

    }

    /**

     * Sets the rotation of the labels corresponding to vertical lines

     *

     * @param labelRotation Label rotation, measured in arc degrees

     */

    public void setVertLabelRotation(double labelRotation) {

            this.vertLabelRotation  = labelRotation;

    }

    /**

     * Gets the rotation of the labels corresponding to horizontal lines

     *

     * @param labelRotation Label rotation, measured in arc degrees

     */

    public double getHorizLabelRotation() {

            return this.horizLabelRotation;

    }

    /**

     * Gets the rotation of the labels corresponding to vertical lines

     *

     * @param labelRotation Label rotation, measured in arc degrees

     */

    public double getVertLabelRotation() {

            return this.vertLabelRotation;

    }

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

        PrintAttributes properties) {

        draw(g, at, null, null);

    }

    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);

            definition.addDynFieldInt(USE_NUM_DIVISIONS_FIELD).setMandatory(false);

            definition.addDynFieldInt(NUM_DIV_HORIZ_FIELD).setMandatory(false);

            definition.addDynFieldInt(NUM_DIV_VERT_FIELD).setMandatory(false);

            definition.addDynFieldObject(LABEL_FORMAT_FIELD)

            .setClassOfValue(DecimalFormat.class).setMandatory(false);

            definition.addDynFieldDouble(VERT_LABEL_ROTATION_FIELD).setMandatory(false);

            definition.addDynFieldDouble(HORIZ_LABEL_ROTATION_FIELD).setMandatory(false);

        }

    }

    @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);

        if (state.hasValue(USE_NUM_DIVISIONS_FIELD)) {

                useNumDivisions = state.getInt(USE_NUM_DIVISIONS_FIELD);

        }

        if (state.hasValue(NUM_DIV_HORIZ_FIELD)) {

                numDivHoriz = state.getInt(NUM_DIV_HORIZ_FIELD);

        }

        if (state.hasValue(NUM_DIV_VERT_FIELD)) {

                numDivVert = state.getInt(NUM_DIV_VERT_FIELD);

        }

        if (state.hasValue(LABEL_FORMAT_FIELD)) {

                labelFormat = (DecimalFormat) state.get(LABEL_FORMAT_FIELD);

        }

        if (state.hasValue(VERT_LABEL_ROTATION_FIELD)) {

                vertLabelRotation = state.getDouble(VERT_LABEL_ROTATION_FIELD);

        }

        if (state.hasValue(HORIZ_LABEL_ROTATION_FIELD)) {

                horizLabelRotation = state.getDouble(HORIZ_LABEL_ROTATION_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);

        state.set(USE_NUM_DIVISIONS_FIELD, useNumDivisions);

        state.set(NUM_DIV_HORIZ_FIELD, numDivHoriz);

        state.set(NUM_DIV_VERT_FIELD, numDivVert);

        state.set(LABEL_FORMAT_FIELD, labelFormat);

        state.set(VERT_LABEL_ROTATION_FIELD, vertLabelRotation);

        state.set(HORIZ_LABEL_ROTATION_FIELD, horizLabelRotation);

    }

}