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.Dimension;

import java.awt.Font;

import java.awt.Graphics2D;

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.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.gui.awt.text.RotatedTextUtils;

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

    private static final String LABEL_ANCHOR = "LabelAnchor";

    /**

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

        /**

         * {@link RotatedTextUtils.ANCHOR_CENTER} or {@link RotatedTextUtils.ANCHOR_CORNER}

         */

        private int labelAnchor = RotatedTextUtils.ANCHOR_CORNER;

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

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

        BufferedImage imgBase) {

            try {

                    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;

                    }

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

                    vp.setOffset(new Point2D.Double(rView.getMinX(), rView.getMinY()));

                    vp.setImageSize(new Dimension((int)Math.round(rView.getWidth()), (int)Math.round(rView.getHeight())));

                    vp.refreshExtent();

                    Envelope envelope = vp.getAdjustedEnvelope();

                    AffineTransform mapTransform = vp.getAffineTransform();

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

                    double maxX = envelope.getMaximum(0);

                    double maxY = envelope.getMaximum(1);

                    // init point, in map coordinates

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

                    double initPointGridWCY = Math.ceil(minY / intervalY)*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; // FIXME: 0.0234?? Should this depend on output resolution?

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

                    Font font = new Font(

                                    this.font.getFamily(), 

                                    this.font.getStyle(),

                                    scaledFontSize);

                    drawLabels(rView,

                                    initPointGridWCX,

                                    initPointGridWCY,

                                    maxX,

                                    maxY,

                                    intervalX,

                                    intervalY,

                                    mapTransform,

                                    g, 

                                    font, 

                                    symbolForMargins);

                    //Draw the lines or the points

                    if (isLine) { 

                            drawLines(rView,

                                        initPointGridWCX,

                                        initPointGridWCY,

                                        maxX,

                                        maxY,

                                        intervalX,

                                        intervalY,

                                        mapTransform,

                                        g);

                    } else {

                            drawPoints(initPointGridWCX,

                                initPointGridWCY,

                                maxX,

                                maxY,

                                intervalX,

                                intervalY,

                                mapTransform,

                                g);

                    }

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

                                    + (r.height / 2));

            } catch (CloneNotSupportedException e1) {}

    } 

    /**

     * Draw the grid as point symbols

     * 

     * @param minGridX The starting grid point on the x axis, in map coordinates

     * @param minGridY The starting grid point on the y axis, in map coordinates

     * @param maxGridX The maximum map point on the x axis, in map coordinates.

     * It may be bigger than the maximum grid point

     * @param maxGridY The maximum map point on the y axis, in map coordinates.

     * It may be bigger than the maximum grid point

     * @param intervalGridX The grid interval on the x axis, in map coordinates

     * @param intervalGridY The grid interval on the y axis, in map coordinates

     * @param mapTransform Transforms map coordinates to screen coordinates

     * @param g The graphics object to draw on

     */

    private void drawPoints(

                    double minGridX,

                    double minGridY,

                    double maxGridX,

                    double maxGridY,

                    double intervalGridX,

                    double intervalGridY,

                        AffineTransform mapTransform, 

                    Graphics2D g) {

        Point2D currentPoint = new Point2D.Double(minGridX, minGridY);

        Point2D screenPoint = new Point2D.Double();

        while (currentPoint.getX() < maxGridX) {

                while (currentPoint.getY() < maxGridY) {

                        mapTransform.transform(currentPoint, screenPoint);

                drawPoint(g, screenPoint);

                    currentPoint.setLocation(currentPoint.getX(), currentPoint.getY()+intervalGridY);

                }

                currentPoint.setLocation(currentPoint.getX()+intervalGridX, minGridY);

        }

    }

    /**

     * Draw the grid as line symbols

     * 

     * @param rView The rectangle of the view, on screen coordinates

     * @param minGridX The starting grid point on the x axis, in map coordinates

     * @param minGridY The starting grid point on the y axis, in map coordinates

     * @param maxGridX The maximum map point on the x axis, in map coordinates.

     * It may be bigger than the maximum grid point

     * @param maxGridY The maximum map point on the y axis, in map coordinates.

     * It may be bigger than the maximum grid point

     * @param intervalGridX The grid interval on the x axis, in map coordinates

     * @param intervalGridY The grid interval on the y axis, in map coordinates

     * @param mapTransform Transforms map coordinates to screen coordinates

     * @param g The graphics object to draw on

     */

    private void drawLines(Rectangle2D rView,

                    double minMapX,

                    double minMapY,

                    double maxMapX,

                    double maxMapY,

                    double intervalMapX,

                    double intervalMapY,

                        AffineTransform mapTransform, 

                    Graphics2D g) {

        double minX = rView.getMinX();

        double maxX = rView.getMaxX();

        double minY = rView.getMinY();

        double maxY = rView.getMaxY();

        double xMap = minMapX;

        double yMap = minMapY;

        // transform to screen coordinates

        Point2D currentPoint = new Point2D.Double(minMapX, minMapY);

            // transform from map coordinates to screen (pixels) coordinates

        mapTransform.transform(currentPoint, currentPoint);

        //Draw the vertical lines

        while (xMap < maxMapX) {

                drawLine(currentPoint.getX(), minY, currentPoint.getX(), maxY, g, symbolLine);

                xMap = xMap + intervalMapX;

                currentPoint.setLocation(xMap, minMapY);

                // from map coordinates to screen (pixels)

                mapTransform.transform(currentPoint, currentPoint);

        }

        //Draw the horizontal lines

        while (yMap < maxMapY) {

                drawLine(minX, currentPoint.getY(), maxX , currentPoint.getY(), g, symbolLine);

                yMap = yMap + intervalMapY;

                currentPoint.setLocation(minMapX, yMap);

                // from map coordinates to screen (pixels)

                mapTransform.transform(currentPoint, currentPoint);

        }

    }

    /**

     * Draws the labels and the tick marks of labels

     * 

     * @param rView The rectangle of the view, on screen coordinates

     * @param minGridX The starting grid point on the x axis, in map coordinates

     * @param minGridY The starting grid point on the y axis, in map coordinates

     * @param maxGridX The maximum map point on the x axis, in map coordinates.

     * It may be bigger than the maximum grid point

     * @param maxGridY The maximum map point on the y axis, in map coordinates.

     * It may be bigger than the maximum grid point

     * @param intervalGridX The grid interval on the x axis, in map coordinates

     * @param intervalGridY The grid interval on the y axis, in map coordinates

     * @param mapTransform Transforms map coordinates to screen coordinates

     * @param g The graphics object to draw on

     * @param font

     * @param symbolForMargins

     */

    private void drawLabels(Rectangle2D rView,

                    double minGridX,

                    double minGridY,

                    double maxGridX,

                    double maxGridY,

                    double intervalGridX,

                    double intervalGridY,

                    AffineTransform mapTransform,

                    Graphics2D g,  

                    Font font,

                    ISymbol 

                    symbolForMargins) {

            AffineTransform defaultAt = g.getTransform();

            double minX = rView.getMinX();

            double maxX = rView.getMaxX();

            double minY = rView.getMinY();

            double maxY = rView.getMaxY();

            double xMap = minGridX;

            double yMap = minGridY;

            // transform to screen coordinates

            Point2D initGridPx = new Point2D.Double(minGridX, minGridY);

            mapTransform.transform(initGridPx, initGridPx);

            double xPx = initGridPx.getX();

            double angle = RotatedTextUtils.normalizeAngle(Math.toRadians(getVertLabelRotation()));

            int anchor = getLabelAnchor();

            // Draw vertical ticks and labels

            while (xMap < maxGridX) {   

                    // bottom tick

                    drawLine(xPx, maxY + OFFSET_IN_PIXELS, xPx , maxY, g, symbolForMargins);

                    // top tick

                    drawLine(xPx, minY, xPx, minY - OFFSET_IN_PIXELS, g, symbolForMargins);

                    g.rotate(angle);

                    g.setColor(textColor);

                    // bottom label

                    Point2D p1 = new Point2D.Double(xPx, maxY+OFFSET_IN_PIXELS); // bottom

                    TextLayout textaux = new TextLayout(this.labelFormat.format(xMap), font, g.getFontRenderContext());

                    Point2D rotatedP1 = RotatedTextUtils.getPosition(p1, textaux, angle, RotatedTextUtils.PLACEMENT_BOTTOM, anchor);

                    textaux.draw(g, (int) (rotatedP1.getX()), (int) rotatedP1.getY());

                    // top label

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

                    Point2D rotatedP2 = RotatedTextUtils.getPosition(p2, textaux, angle, RotatedTextUtils.PLACEMENT_TOP, anchor);

                    textaux.draw(g, (int) (rotatedP2.getX()),(int) rotatedP2.getY());

                    g.setTransform(defaultAt);

                    xMap = xMap + intervalGridX;

                    initGridPx.setLocation(xMap, minGridY);

                    mapTransform.transform(initGridPx, initGridPx);

                    xPx = initGridPx.getX();

            }

            double yPx = initGridPx.getY();

            angle = RotatedTextUtils.normalizeAngle(Math.toRadians(getHorizLabelRotation()));

            // horizontal ticks and labels

            while (yMap < maxGridY) {

                    // left tick

                    drawLine(minX - OFFSET_IN_PIXELS, yPx, minX , yPx, g, symbolForMargins);

                    // right tick

                    drawLine(maxX, yPx, maxX + OFFSET_IN_PIXELS, yPx, g, symbolForMargins);

                    g.rotate(angle);

                    g.setColor(textColor);

                    TextLayout textaux = new TextLayout(this.labelFormat.format(yMap), font, g.getFontRenderContext());

                    // left label

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

                    Point2D rotatedP1 = RotatedTextUtils.getPosition(p1, textaux, angle, RotatedTextUtils.PLACEMENT_LEFT, anchor);

                    textaux.draw(g, (int) (rotatedP1.getX()), (int) rotatedP1.getY());

                    // right label

                    Point2D p2 = new Point2D.Double(maxX+OFFSET_IN_PIXELS, yPx);

                    Point2D rotatedP2 = RotatedTextUtils.getPosition(p2, textaux, angle, RotatedTextUtils.PLACEMENT_RIGHT, anchor);

                    textaux.draw(g, (int) (rotatedP2.getX()),(int) rotatedP2.getY());

                    g.setTransform(defaultAt);

                    yMap = yMap + intervalGridY;

                    initGridPx.setLocation(minGridX, yMap);

                    mapTransform.transform(initGridPx, initGridPx);

                    yPx = initGridPx.getY();

            }

    }

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

        try {

                // FIXME: We are adding 1 extra pixel for correct adjustment when exporting to PDF.

                // However, this creates 1 blank pixel on the right side when drawing on screen.

                // Probably this is caused by some rounding.

                // Separating the implementation of print and draw methods should help, too.

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

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

            curve.addVertex(GEOMETRY_MANAGER.createPoint(mapRectangle.getMinX()-1, 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()-1, SUBTYPES.GEOM2D));

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

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

        } catch (CreateGeometryException e) {

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

        } 

    }

    /**

     * Draws a point using the configured symbol

     * 

     * @param g The graphics object to draw on

     * @param point Point to draw, in map coordinates

     * @param mapTransform Transforms from map coordinates to screen coordinates

     */

    private void drawPoint(Graphics2D g, Point2D point){

        try {

            Geometry geom =

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

            symbolPoint.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(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 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_VERT_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 getNumDivisionsHoriz() {

            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;

    }

    /**

     * Defines the alignment of the grid label compared with the

     * associated grid tick

     * 

     * @param anchor {@link RotatedTextUtils.ANCHOR_CORNER} or

     *   {@link RotatedTextUtils.ANCHOR_CENTER}

     */

    public int getLabelAnchor() {

            return this.labelAnchor;

    }

    /**

     * Gets the alignment of the grid labels. ANCHOR_CORNER aligns

     * the corner of the label with the grid tick, while ANCHOR_CENTER

     * aligns the label center with the grid tick.

     * 

     * @param anchor {@link RotatedTextUtils.ANCHOR_CORNER} or

     *   {@link RotatedTextUtils.ANCHOR_CENTER}

     */

    public void setLabelAnchor(int anchor) {

            // ensure a coherent value

            if (anchor==RotatedTextUtils.ANCHOR_CENTER) {

                    this.labelAnchor = anchor;

            }

            else {

                    this.labelAnchor = RotatedTextUtils.ANCHOR_CORNER;

            }

    }

    /**

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

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

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

            definition.addDynFieldInt(LABEL_ANCHOR).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 = (Double) state.get(INTERVALX_FIELD);

        intervalY = (Double) state.get(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);

        }

        if (state.hasValue(LABEL_ANCHOR)) {

                labelAnchor = state.getInt(LABEL_ANCHOR);

        }

    }

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

        state.set(LABEL_ANCHOR, labelAnchor);

    }

}