Application: gvSIG desktop » gvSIG Document Layout

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2015 gvSIG Association.

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.print.PageFormat;

import java.awt.print.Paper;

import java.text.NumberFormat;

import java.util.ArrayList;

import javax.print.attribute.DocAttributeSet;

import javax.print.attribute.HashDocAttributeSet;

import javax.print.attribute.HashPrintRequestAttributeSet;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.Copies;

import javax.print.attribute.standard.Fidelity;

import javax.print.attribute.standard.Media;

import javax.print.attribute.standard.MediaPrintableArea;

import javax.print.attribute.standard.MediaSizeName;

import javax.print.attribute.standard.OrientationRequested;

import javax.print.attribute.standard.PrintQuality;

import javax.print.attribute.standard.Sides;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.app.extension.LayoutExtension;

import org.gvsig.app.gui.preferencespage.PreferenceKeys;

import org.gvsig.compat.CompatLocator;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.i18n.Messages;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.utils.XMLEntity;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.app.project.documents.layout.Size;

/**

 * Attributes of Layout.

 * 

 * @author Vicente Caballero Navarro

 * @author jldominguez

 */

public class Attributes implements Persistent, Cloneable {

    public static final String PERSISTENCE_DEFINITION_NAME = "Attributes";

    public static final String DPI_FIELD = "DPI";

    public static final String DPISCREEN_FIELD = "DPISCREEN";

    public static final String TYPEUNIT_FIELD = "typeUnit";

    public static final String NUMX_FIELD = "numX";

    public static final String NUMY_FIELD = "numY";

    public static final String UNITX_FIELD = "unitX";

    public static final String UNITY_FIELD = "unitY";

    public static final String HASMARGIN_FIELD = "hasMargin";

    public static final String RESOLUTIONSEL_FIELD = "resolutionSel";

    public static final String TYPESEL_FIELD = "typeSel";

    public static final String SELTYPEUNIT_FIELD = "selTypeUnit";

    public static final String SIZEPAPER_FIELD = "sizePaper";

    public static final String AREA_FIELD = "area";

    public static final String SIZEINUNITS_FIELD = "sizeInUnits";

    public static final String ISLANDSEL_FIELD = "isLandSel";

    public static final String DEGREES = "Grados";

    public static final int HIGH = 0;

    public static final int NORMAL = 1;

    public static final int DRAFT = 2;

    // Para impresi?n

    public final static double PULGADA = 2.54;

    public final static Size STANDARD_LETTER_PAPER_SIZE = new Size(8.5, 11.0);

    public final static Size STANDARD_FOLIO_PAPER_SIZE = new Size(8.5, 13.0);

    public final static Size STANDARD_LEGAL_PAPER_SIZE = new Size(8.5, 14.0);

    public final static Size STANDARD_TABLOID_PAPER_SIZE = new Size(11.0, 17.0);

    public final static Size METRIC_A0_PAPER_SIZE = new Size(118.9, 84.1);

    public final static Size METRIC_A1_PAPER_SIZE = new Size(84.1, 59.4);

    public final static Size METRIC_A2_PAPER_SIZE = new Size(59.4, 42.0);

    public final static Size METRIC_A3_PAPER_SIZE = new Size(42.0, 29.7);

    public final static Size METRIC_A4_PAPER_SIZE = new Size(29.7, 21.0);

    public final static Size METRIC_A5_PAPER_SIZE = new Size(21.0, 14.8);

    public final static Size ANSI_ENG_A_PAPER_SIZE = new Size(11.0, 8.5);

    public final static Size ANSI_ENG_B_PAPER_SIZE = new Size(17.0, 11.0);

    public final static Size ANSI_ENG_C_PAPER_SIZE = new Size(22.0, 17.0);

    public final static Size ANSI_ENG_D_PAPER_SIZE = new Size(34.0, 22.0);

    public final static Size ANSI_ENG_E_PAPER_SIZE = new Size(44.0, 34.0);

    public final static Size ANSI_ARCH_A_PAPER_SIZE = new Size(12.0, 9.0);

    public final static Size ANSI_ARCH_B_PAPER_SIZE = new Size(18.0, 12.0);

    public final static Size ANSI_ARCH_C_PAPER_SIZE = new Size(24.0, 18.0);

    public final static Size ANSI_ARCH_D_PAPER_SIZE = new Size(36.0, 24.0);

    public final static Size ANSI_ARCH_E_PAPER_SIZE = new Size(42.0, 30.0);

    /**

     * Stores the last custom paper size. It will be equal to

     * {@link #getPaperSize()} when {@link #getType()} is

     * {@link #CUSTOM}.

     * CUSTOM_PAPER_SIZE knows about portrait/landscape

     * (same as other PAPER constants)

     */

    private Size last_custom_paper_size = new Size(100.0, 100.0);

    public final static int PRINT = 0;

    public final static int CUSTOM = 6;

    public final static int A0 = 5;

    public final static int A1 = 4;

    public final static int A2 = 3;

    public final static int A3 = 2;

    public final static int A4 = 1;

    public static int DPI = 300;

    public static int DPISCREEN = 72;

    private static Point2D defaultGridGap;

    private PrintRequestAttributeSet attributes =

        new HashPrintRequestAttributeSet();

    /**

     * Media size name, used when type is {@link #PRINT}.

     * @see #setType(int)

     */

    private MediaSizeName m_type = MediaSizeName.ISO_A4;

    private OrientationRequested m_Orientation;

    /**

     * Change factor from configured map unit (m_selTypeUnit) to centimeters

     */

    private double m_TypeUnit = getConversionFactorToCm(2); // [2] = Centimeters

    private String m_NameUnit;

    /**

     * Horizontal space between grid lines, measured in centimeters

     */

    private Double m_gridGapCmX = null;

    /**

     * Vertical space between grid lines, measured  in centimeters

     */

    private Double m_gridGapCmY = null;

    /**

     * Horizontal space between grid lines, measured in centimeters

     */

    private double m_gridGapPxX = 0;

    /**

     * Vertical space between grid lines, measured  in pixels

     */

    private double m_gridGapPxY = 0;

    private boolean hasmargin;

    private int m_resolutionSel = NORMAL;

    private int m_typeSel = PRINT;

    /**

     * The selected unit (km, cm, etc) for this layout. It defaults to centimeters

     * 

     * @see {@link MapContext#getDistanceNames()}

     * @see {@link MapContext#getDistanceTrans2Meter()}

     */

    private int m_selTypeUnit = 2;

    /**

     * Paper size in centimeters.

     * This field changes when it's landscape

     * (it "knows" about portrait/landscape)

     */

    private Size m_sizePaper = new Size(

        METRIC_A4_PAPER_SIZE.getHeight(),

        METRIC_A4_PAPER_SIZE.getWidth());

    /**

     * Print area (top, bottom, left, right).

     * This array changes when it's landscape

     * (it "knows" about portrait/landscape)

     */

    private double[] area_tblr = {

        0,

        0,

        0,

        0 };

    /**

     * Page size in user selected units

     * This field changes when it's landscape

     * (it "knows" about portrait/landscape)

     */

    private Size m_sizeinUnits = m_sizePaper;

    /**

     * Create a new object of Attributes.

     * 

     */

    public Attributes() {

        m_NameUnit = Messages.getText("Centimetros");

        m_Orientation = OrientationRequested.LANDSCAPE;

        m_type = MediaSizeName.ISO_A4;

        resetSizeinUnits();

        hasmargin = false;

        attributes.add(new Copies(1));

        attributes.add(MediaSizeName.ISO_A4);

        attributes.add(Sides.ONE_SIDED);

        attributes.add(Fidelity.FIDELITY_FALSE);

        attributes.add(PrintQuality.NORMAL);

        setType(m_typeSel);

        attributes.add(new MediaPrintableArea(0, 0,

                (float) ((getPaperSize().getWidth() * DPISCREEN) / PULGADA),

                (float) ((getPaperSize().getHeight() * DPISCREEN) / PULGADA),

                MediaPrintableArea.MM)); // FIXME: centimeters or milimeters

    }

    /**

     * @return

     */

    public boolean isLandscape() {

        return m_Orientation.getValue() ==

            OrientationRequested.LANDSCAPE.getValue();

    }

    /**

     * @return

     */

    public boolean isPortrait() {

        return m_Orientation.getValue() ==

            OrientationRequested.PORTRAIT.getValue();

    }

    /**

     * Inserts the Layout's properties to print.

     * 

     * @param typeSel

     *            Type of sheet.

     * @param units

     *            Units.

     * @param isLand

     *            True if the sheet is horizontal.

     * @param margin

     *            True if the sheet has margin.

     * @param resolution

     *            Type of quality of resolution.

     * @param area

     *            Printing area (top, bottom, left, right). 

     */

    public void setSelectedOptions(int typeSel, int units, boolean isLand,

        boolean margin, int resolution, double[] _area_tplr) {

        setType(typeSel);

        setUnit(units);

        setIsLandScape(isLand);

        hasmargin = margin;

        setResolution(resolution);

        area_tblr = _area_tplr;

    }

    /**

     * Paper size, measured in centimeters.

     * This field knows about orientation.

     * 

     * Note that this size is always measured in centimeters, regardless

     * the selected unit for the page. However, the user should be always

     * presented measures in the selected unit.

     * 

     * @see #getUnit()

     * @see #setUnit(int)

     * 

     * @return

     */

    public Size getPaperSize() {

        return m_sizePaper;

    }

    /**

     * Sets the paper size, measured in centimeters

     * @param paperSize

     */

    public void setPaperSize(Size paperSize) {

            this.m_sizePaper = getCorrectedSize(paperSize);

            if (getType()==CUSTOM) {

                    this.last_custom_paper_size = paperSize;

            }

            resetSizeinUnits();

    }

    /**

     * Gets the last selected custom paper size. It will be equal to

     * {@link #getPaperSize()} when {@link #getType()} is

     * {@link #CUSTOM}.

     * @return

     */

    public Size getCustomPaperSize() {

            return this.last_custom_paper_size;

    }

    /**

     * Returns a PageFormat with the properties of printing.

     * 

     * @return PageFormat

     */

    public PageFormat getPageFormat() {

        PageFormat pf1 = new PageFormat();

        Paper paper = pf1.getPaper();

        paper.setSize(

            (m_sizePaper.getWidth() * DPISCREEN) / PULGADA,

            (m_sizePaper.getHeight() * DPISCREEN) / PULGADA);

        if (isLandscape()) {

            pf1.setOrientation(0);

            /*

             * 'area_tblr' and 'm_sizeinUnits' depend on

             * whether it is portrait or landscape, but

             * 'Paper' and 'm_sizePaper' must not know if it's

             * portrait/landscape, so we change order of

             * parameters. 'PageFormat' will do the changes again

             * because it is aware of portrait/landscape

             */

            paper.setImageableArea(

                getInPixels(area_tblr[1]),

                getInPixels(area_tblr[2]),

                getInPixels(m_sizeinUnits.getHeight() - area_tblr[0] - area_tblr[1]),

                getInPixels(m_sizeinUnits.getWidth()  - area_tblr[2] - area_tblr[3]));

        } else {

            // portrait

            pf1.setOrientation(1);

            paper.setImageableArea(

                getInPixels(area_tblr[2]),

                getInPixels(area_tblr[0]),

                getInPixels(m_sizeinUnits.getWidth() - area_tblr[2] - area_tblr[3]),

                getInPixels(m_sizeinUnits.getHeight()  - area_tblr[0] - area_tblr[1]));

        }

        pf1.setPaper(paper);

        return pf1;

    }

    /**

     * Changes centimeters to pixels.

     * 

     * @param d

     *            Centimeters.

     * 

     * @return Pixels.

     */

    private double getInPixels(double d) {

        return d * (DPISCREEN / PULGADA);

    }

    /**

     * Changes pixels to centimeters.

     * 

     * @param d

     *            Pixel.

     * 

     * @return Centimeters.

     */

    private double getInCM(double d) {

        return d / (DPISCREEN / PULGADA);

    }

    /**

     * Returns the printing area.

     * The value returned changes if orientation changes

     * (it "knows" about portrait/landscape)

     * 

     * @return Rectangle Area.

     */

    public Rectangle2D getArea() {

        Rectangle2D.Double rect = new Rectangle2D.Double();

        rect.setRect(

                area_tblr[2],

                area_tblr[0],

                m_sizePaper.getWidth() - area_tblr[2] - area_tblr[3],

                m_sizePaper.getHeight()  - area_tblr[0] - area_tblr[1]);

        return rect;

    }

    public double[] getAreaInsets() {

        return area_tblr;

    }

    /**

     * Inserts the attributes with a PageFormat.

     * 

     * @param pf

     *            PageFormat.

     */

    public void setPageFormat(PageFormat pf) {

        /*

         * Paper does not know about orientation

         */

        Size portrait_size = new Size(

            pf.getPaper().getHeight(),

            pf.getPaper().getWidth());

        setType(getTypePaper(portrait_size, true));

        if (pf.getOrientation() == 0) {

            setIsLandScape(true);

        } else {

            setIsLandScape(false);

        }

        attributes.add(m_Orientation);

        // tipo formato

        if (isLandscape()) {

            // landscape

            area_tblr[1] = getInCM(pf.getImageableX());

            area_tblr[2] = getInCM(pf.getImageableY());

            area_tblr[0] = 

                portrait_size.getWidth() - getInCM(pf.getImageableHeight())

                - area_tblr[1];

            area_tblr[3] =

                portrait_size.getHeight() - getInCM(pf.getImageableWidth())

                - area_tblr[2];

        } else {

            // portrait

            area_tblr[2] = getInCM(pf.getImageableX());

            area_tblr[0] = getInCM(pf.getImageableY());

            area_tblr[1] =

                portrait_size.getHeight() - getInCM(pf.getImageableHeight())

                - area_tblr[0];

            area_tblr[3] =

                portrait_size.getWidth() - getInCM(pf.getImageableWidth())

                - area_tblr[2];

        }

        /*

         * 'area_tblr' and 'pf' "know"

         * about orientation

         * 

         */

        attributes.add(new MediaPrintableArea(

            (float) (area_tblr[2] * 10),

            (float) (area_tblr[0] * 10),

            (float) (getInCM(pf.getImageableWidth()) * 10),

            (float) (getInCM(pf.getImageableHeight()) * 10),

            MediaPrintableArea.MM));

    }

    /**

     * Returns a PrintRequestAttributeSet with all properties to the

     * PrintDialog.

     * 

     * @return PrintRequestAttributesSet.

     */

    public PrintRequestAttributeSet toPrintRequestAttributeSet() {

        HashPrintRequestAttributeSet resul = new HashPrintRequestAttributeSet();

        setType(m_typeSel);

        resul.add(m_type);

        // units, no hace falta a?adirlo a attributes

        resul.add(m_Orientation);

        // setArea(area_tblr);

        Rectangle2D rect = this.getArea();

        resul.add(new MediaPrintableArea(

            (float) (rect.getX() *10),

            (float) (rect.getY() *10),

            (float) (rect.getWidth() *10),

            (float) (rect.getHeight() *10),

            MediaPrintableArea.MM));

        resul.add(toPrintQuality(m_resolutionSel));

        return resul;

    }

    public DocAttributeSet toDocAttributes() {

        HashDocAttributeSet resul = new HashDocAttributeSet();

        setType(m_typeSel);

        resul.add(m_type);

        // units, no hace falta a?adirlo a attributes

        resul.add(m_Orientation);

        // setArea(area_tblr);

        Rectangle2D rect = this.getArea();

        resul.add(new MediaPrintableArea(

            (float) (rect.getX() *10),

            (float) (rect.getY() *10),

            (float) (rect.getWidth() *10),

            (float) (rect.getHeight() *10),

            MediaPrintableArea.MM));

        resul.add(toPrintQuality(m_resolutionSel));

        return resul;

    }

    public PrintAttributes toPrintAttributes() {

        PrintAttributes resul =

            CompatLocator.getGraphicsUtils().createPrintAttributes();

        if (m_resolutionSel == DRAFT) {

            resul.setPrintQuality(PrintAttributes.PRINT_QUALITY_DRAFT);

        } else

            if (m_resolutionSel == NORMAL) {

                resul.setPrintQuality(PrintAttributes.PRINT_QUALITY_NORMAL);

            } else

                if (m_resolutionSel == HIGH) {

                    resul.setPrintQuality(PrintAttributes.PRINT_QUALITY_HIGH);

                } else {

                    throw new UnsupportedOperationException(

                        "Unsupported Print Quality: " + m_resolutionSel);

                }

        setType(m_typeSel);

        return resul;

    }

    /**

     * Returns a PrintRequestAttributeSet with all properties to the

     * PrintDialog.

     * 

     * @return PrintRequestAttributesSet.

     */

    public PrintRequestAttributeSet toPrintAttributeSet() {

        HashPrintRequestAttributeSet resul = new HashPrintRequestAttributeSet();

        setType(m_typeSel);

        resul.add(m_type);

        resul.add(m_Orientation);

        Rectangle2D rect = this.getArea();

        resul.add(new MediaPrintableArea(

            (float) (rect.getX() * DPISCREEN / PULGADA),

            (float) (rect.getY() * DPISCREEN / PULGADA),

            (float) (rect.getWidth() * DPISCREEN / PULGADA),

            (float) (rect.getHeight() * DPISCREEN / PULGADA),

            MediaPrintableArea.MM));

        resul.add(toPrintQuality(m_resolutionSel));

        return resul;

    }

    /**

     * Returns true if the margin should be used.

     * 

     * @return True if margin should be used.

     */

    public boolean isMargin() {

        return hasmargin;

    }

    /**

     * Returns the resolution of properties to print.

     * 

     * @return Resolution.

     */

    public int getResolution() {

        return m_resolutionSel;

    }

    /**

     * Inserts the resolution to apply at printing.

     * 

     * @param i

     *            Type of resolution.

     * 

     *            The type of resolution can be:

     * 

     *            DRAFT: 27 dpi.

     *            NORMAL: 300 dpi.

     *            HIGH: 600 dpi.

     */

    public void setResolution(int i) {

        m_resolutionSel = i;

        switch (i) {

        case (HIGH):

            DPI = 600;

            break;

        case (NORMAL):

            DPI = 300;

            break;

        case (DRAFT):

            DPI = 72;

            break;

        }

        attributes.add(toPrintQuality(i));

    }

    /**

     * Converts print quality from Attributes format

     * ({@link #HIGH}, {@link #NORMAL}, {@link #DRAFT})

     * to {@link PrintQuality} format.

     * 

     * @param quality

     * @return

     */

    public static PrintQuality toPrintQuality(int quality) {

        switch (quality) {

        case (HIGH):

                return PrintQuality.HIGH;

        case (NORMAL):

            return PrintQuality.NORMAL;

        case (DRAFT):

                return PrintQuality.DRAFT;

        default:

                return PrintQuality.NORMAL;

        }

    }

    /**

     * Returns attributes of PrintDialog.

     * 

     * @return Attributes of printing.

     */

    public PrintRequestAttributeSet getAttributes() {

        return attributes;

    }

    /**

     * Returns True if the position of sheet is horizontal.

     * 

     * @return True if position is horizontal.

     */

    /**

     * Returns the format of sheet.

     * 

     * @return Format of sheet.

     */

    public int getType() {

        return m_typeSel;

    }

    /**

     * Inserts the number of units to define the coords X grid.

     * 

     * @param d

     *            number of units to define the grid.

     */

    public void setHGridGrapCm(double d) {

        m_gridGapCmX = new Double(d);

    }

    /**

     * Gets the grid gap for the x axis, in centimeters. The grip gap is the

     * distance from one point to the next point in the snapping grid.

     * 

     * @return Default grid gap for the x axis, measured in centimeters

     */

    public double getHGridGapCm() {

        if (m_gridGapCmX == null) {

            m_gridGapCmX = new Double(getDefaultGridGap().getX());

        }

        return m_gridGapCmX.doubleValue();

    }

    /**

     * Gets the grid gap for the y axis, in centimeters. The grip gap is the

     * distance from one point to the next point in the snapping grid.

     * 

     * @return Default grid gap for the y axis, measured in centimeters

     */

    public double getVGridGapCm() {

        if (m_gridGapCmY == null) {

            m_gridGapCmY = new Double(getDefaultGridGap().getY());

        }

        return m_gridGapCmY.doubleValue();

    }

    /**

     * Inserts the number of units to define the coords X grid.

     * 

     * @param d

     *            number of units to define the grid.

     */

    public void setVGridGrapCm(double d) {

        m_gridGapCmY = new Double(d);

    }

    /**

     * Inserts true if the sheet is horizontal or false if is vertical.

     * 

     * @param b

     *            True if sheet is horizontal.

     */

    public void setIsLandScape(boolean b) {

        if (b) {

            m_Orientation = OrientationRequested.LANDSCAPE;

        } else {

            m_Orientation = OrientationRequested.PORTRAIT;

        }

        setType(m_typeSel);

    }

    /**

     * Sets the type of sheet to show. See

     * {@link #PRINT}, {@link #CUSTOM}, {@link #A4}, {@link #A3}, {@link #A2},

     * {@link #A1}, {@link #A0}.

     * 

     * @param t

     *            Type of sheet.

     */

    public void setType(int t) {

        m_typeSel = t;

        switch (t) {

        case (PRINT):

            m_type = ((MediaSizeName) attributes.get(Media.class));

                // FIXME: Shouldn't we adapt the actual size to the printer???? 

                setPaperSize(METRIC_A4_PAPER_SIZE);

            break;

        case (A4):

            m_type = MediaSizeName.ISO_A4;

                setPaperSize(METRIC_A4_PAPER_SIZE);

            break;

        case (A3):

            m_type = MediaSizeName.ISO_A3;

                setPaperSize(METRIC_A3_PAPER_SIZE);

            break;

        case (A2):

            m_type = MediaSizeName.ISO_A2;

                setPaperSize(METRIC_A2_PAPER_SIZE);

            break;

        case (A1):

            m_type = MediaSizeName.ISO_A1;

                setPaperSize(METRIC_A1_PAPER_SIZE);

            break;

        case (A0):

            m_type = MediaSizeName.ISO_A0;

                setPaperSize(METRIC_A0_PAPER_SIZE);

            break;

        case (CUSTOM):

            m_type = MediaSizeName.PERSONAL_ENVELOPE;

                setPaperSize(last_custom_paper_size);

            break;

        }

        attributes.add(m_type);

    }

    /**

     * Sets the paper size, measured on the selected units

     * @see #getUnit()

     */

    public void setPaperSizeInUnits(Size sizeInUnits) {

            setPaperSize(new Size(sizeInUnits.getHeight() * m_TypeUnit,

                            sizeInUnits.getWidth() * m_TypeUnit));

    }

    /**

     * Returns the size of sheet.

     * 

     * @param isLand

     *            True if is horizontal and false if is vertical.

     * @param type

     *            Type of sheet.

     * 

     * @return Size of sheet with these properties.

     */

    public Size getPaperSizeinUnits(boolean isLand, int type) {

        Size size = null;

        switch (type) {

        case (PRINT):

            if (isLand) {

                size =

                    new Size(METRIC_A4_PAPER_SIZE.getWidth(),

                        METRIC_A4_PAPER_SIZE.getHeight());

            } else {

                size = METRIC_A4_PAPER_SIZE;

            }

            break;

        case (A4):

            if (isLand) {

                size =

                    new Size(METRIC_A4_PAPER_SIZE.getWidth(),

                        METRIC_A4_PAPER_SIZE.getHeight());

            } else {

                size = METRIC_A4_PAPER_SIZE;

            }

            break;

        case (A3):

            if (isLand) {

                size =

                    new Size(METRIC_A3_PAPER_SIZE.getWidth(),

                        METRIC_A3_PAPER_SIZE.getHeight());

            } else {

                size = METRIC_A3_PAPER_SIZE;

            }

            break;

        case (A2):

            if (isLand) {

                size =

                    new Size(METRIC_A2_PAPER_SIZE.getWidth(),

                        METRIC_A2_PAPER_SIZE.getHeight());

            } else {

                size = METRIC_A2_PAPER_SIZE;

            }

            break;

        case (A1):

            if (isLand) {

                size =

                    new Size(METRIC_A1_PAPER_SIZE.getWidth(),

                        METRIC_A1_PAPER_SIZE.getHeight());

            } else {

                size = METRIC_A1_PAPER_SIZE;

            }

            break;

        case (A0):

            if (isLand) {

                size =

                    new Size(METRIC_A0_PAPER_SIZE.getWidth(),

                        METRIC_A0_PAPER_SIZE.getHeight());

            } else {

                size = METRIC_A0_PAPER_SIZE;

            }

            break;

        case (CUSTOM):

            if (isLandscape()) {

                size =

                    new Size(

                        last_custom_paper_size.getWidth() * m_TypeUnit,

                        last_custom_paper_size.getHeight() * m_TypeUnit);

            } else {

                size =

                    new Size(

                        last_custom_paper_size.getHeight() * m_TypeUnit,

                        last_custom_paper_size.getWidth() * m_TypeUnit);

            }

            break;

        }

        Size resp = new Size(

            size.getHeight() / m_TypeUnit, 

            size.getWidth() / m_TypeUnit);

        return resp;

    }

    /**

     * Returns the type of unit in use (cm, mm, km, etc), codified as

     * a position in the array returned by {@link MapContext#getDistanceNames()}

     *

     * @see #setUnit(int)

     * @see MapContext#getDistanceNames() 

     * @see MapContext#getDistanceTrans2Meter()

     * @see MapContext#getDistanceAbbr()

     * @see MapContext#getDistancePosition(String)

     * @see MapContext#getDistancePosition(String)

     * 

     * @return Type of units.

     */

    public int getUnit() {

        return m_selTypeUnit;

    }

    /**

     * @deprecated Use {@link #getUnit()} instead

     */

    @Deprecated

    public int getSelTypeUnit() {

            return getUnit();

    }

    /**

     * Returns the name of the selected units.

     * @see #getUnit()

     * 

     * @return String Name of units.

     */

    public String getNameUnit() {

        return m_NameUnit;

    }

    /**

     * Sets the type of unit that is used in the Layout, defined as an

     * integer indicating a position in the array

     * {@link MapContext#getDistanceNames()}. By default is

     * centimeters.

     * 

     * @param sel

     *            Type of unit.

     * @see #getUnit()

     */

    public void setUnit(int sel) {

        Logger logger = LoggerFactory

                .getLogger(LayoutExtension.class);

        logger.debug("setUnit: "+sel);

        m_selTypeUnit = sel;

        m_TypeUnit = getConversionFactorToCm(sel);

        resetSizeinUnits();

        m_NameUnit =

            PluginServices.getText(this, MapContext.getDistanceNames()[sel]);

    }

    /**

     * Actualize to date m_sizeinUnits with the height and width of the sheet

     * in the units of media selected.

     * 

     * @param b

     *            True if is horizontal.

     */

    private void resetSizeinUnits() {

            Size correctedSize = getCorrectedSize(m_sizePaper);

            m_sizeinUnits =

                new Size(correctedSize.getHeight() / m_TypeUnit,

                                correctedSize.getWidth() / m_TypeUnit);

    }

    /**

     * Returns a double in the unit of measure selected from the double in

     * centimeters.

     * 

     * @param d

     *            Distance in centimeters.

     * 

     * @return Distance in the unit measure selected.

     */

    public double toUnits(double d) {

        NumberFormat nf = NumberFormat.getInstance();

        nf.setMaximumFractionDigits(2);

        String s = String.valueOf(nf.format(d));

        s = s.replace(',', '.');

        return (Double.valueOf(s).doubleValue() / m_TypeUnit);

    }

    /**

     * Returns a double in centimeters from the the unit of measure selected.

     * 

     * @param d

     *            Distance in the unit measure selected.

     * 

     * @return Distance in centimeters.

     */

    public double fromUnits(double d) {

        return (d * m_TypeUnit);

    }

    /**

     * Returns one centimeter in pixels on screen in this moment.

     * 

     * @param rect

     *            Rectangle of sheet.

     * 

     * @return Pixels from centimeter.

     */

    public double getPixXCm(Rectangle2D rect) {

        double value = m_sizePaper.getWidth();

        double cm = getConversionFactorToCm(2);

        double unidades = 0;

        unidades = ((rect.getMaxX() - rect.getMinX()) / ((value / cm)));

        return unidades;

    }

    /**

     * Calculates the grid gap for the x axis, in pixels,

     * based on the paper width (in cm) and the width

     * of the rectangle of sheet in screen, measured in

     * pixels.

     *  

     * The grip gap is the distance from one

     * point to the next point in the snapping grid.

     * 

     * @param rect

     *            Rectangle of sheet, measured in pixels

     */

    public void calculateGridGapX(Rectangle2D rect) {

        double width = m_sizePaper.getWidth();

        double numberOfGaps = width / getHGridGapCm();

        double unidades =

            (rect.getMaxX() - rect.getMinX()) / numberOfGaps;

        m_gridGapPxX = unidades;

    }

    /**

     * Calculates the grid gap for the y axis, in pixels,

     * based on the paper height (in cm) and the height

     * of the rectangle of sheet in screen, measured in

     * pixels.

     *  

     * The grip gap is the distance from one

     * point to the next point in the snapping grid.

     * 

     * @param rect

     *            Rectangle of sheet, measured in pixels

     */

    public void calculateGridGapY(Rectangle2D rect) {

        double height = m_sizePaper.getHeight();

        double numberOfGaps = height / getVGridGapCm();

        double unidades =

            (rect.getMaxY() - rect.getMinY()) / numberOfGaps;

        m_gridGapPxY = unidades;

    }

    private double getPaperSizeRatio() {

        double resp = 1;

        if (isLandscape()) {

            resp = m_sizePaper.getWidth() / m_sizePaper.getHeight();

        } else {

            resp = m_sizePaper.getHeight() / m_sizePaper.getWidth();

        }

        return resp;

    }

    /**

     * Obtains the rectangle that represents the sheet with the characteristics

     * that contains attributes

     * 

     * @param rect

     *            rectangle.

     * 

     */

    public void obtainRect(boolean isPrint, Rectangle2D rect, int w, int h) {

        double value1 = 0;

        double value2 = 0;

        if (!isPrint) {

            if (isLandscape()) {

                rect = getRectangleLandscape(rect, w, h);

            } else {

                rect = getRectanglePortrait(rect, w, h);

            }

        } else {

            value1 = m_sizePaper.getWidth();

            value2 = m_sizePaper.getHeight();

            rect.setRect(0, 0, ((value1 / PULGADA) * DPI),

                ((value2 / PULGADA) * DPI));

        }

        calculateGridGapX(rect);

        calculateGridGapY(rect);

    }

    /**

     * It obtains the rect that is adjusted to the size of the window,

     * to see the full extent of horizontal layout.

     * 

     * @param rect

     *            Rectangle sheet.

     * @param w

     *            Width of Layout.

     * @param h

     *            Height of Layout.

     * 

     * @return Rectangle modified.

     */

    public Rectangle2D.Double getRectangleLandscape(Rectangle2D rect, int w,

        int h) {

        Rectangle2D.Double rectaux = new Rectangle2D.Double();

        int x0 = (int) rect.getMinX();

        int y0 = (int) rect.getMinY();

        // Don't use the whole component space to draw the sheet,

        // add some margin to make the sheet evident.

        // 2 * x0: margin left and margin right

        // 2 * y0: margin top and margin bottom

        int newHeight = (h - (2 * y0));

        int newWidth = (int) (newHeight * getPaperSizeRatio());

        if (((int) (((h) - (2 * y0)) * getPaperSizeRatio())) > ((w) - (2 * x0))) {

                newWidth = ((w) - (2 * x0));

                newHeight = (int) (newWidth / getPaperSizeRatio());

        }

        rectaux.setRect(x0, y0, newWidth, newHeight);

        return rectaux;

    }

    /**

     * Returns the size of sheet in the units of measure selected.

     * 

     * @return Size of sheet.

     */

    public Size getPaperSizeInUnits() {

        return m_sizeinUnits;

    }

    /**

     * @deprecated Use {@link #getPaperSizeInUnits()} instead

     * 

     */

    @Deprecated

    public Size getSizeInUnits() {

            return getPaperSizeInUnits();

    }

    /**

     * It obtains the rect that is adjusted to the size of the window,

     * to see the full extent of vertical layout.

     * 

     * @param rect

     *            Rectangle sheet.

     * @param w

     *            Width of Layout.

     * @param h

     *            Height of Layout.

     * 

     * @return Rectangle modified.

     */

    public Rectangle2D.Double getRectanglePortrait(Rectangle2D rect, int w,

        int h) {

        Rectangle2D.Double rectaux = new Rectangle2D.Double();

        int x0 = (int) rect.getMinX();

        int y0 = (int) rect.getMinY();

        // Don't use the whole component space to draw the sheet,

        // add some margin to make the sheet evident.

        // 2 * x0: margin left and margin right

        // 2 * y0: margin top and margin bottom

        int newWidth = (w - (2 * x0));

        int newHeight = (int) (newWidth * getPaperSizeRatio());

        if (((int) (((w) - (2 * x0)) * getPaperSizeRatio())) > ((h) - (2 * y0))) {

                newHeight = (h - (2 * y0));

                newWidth = (int) (newHeight / getPaperSizeRatio());

        }

        rectaux.setRect(x0, y0, newWidth, newHeight);

        return rectaux;

    }

    /**

     * Adapts the provided size to the configured orientation

     * @param size

     * @return

     */

    private Size getCorrectedSize(Size size) {

            Size result;

            if ( (isLandscape() && (size.getWidth()<size.getHeight()))

                            || (isPortrait() && (size.getHeight()<size.getWidth()))) {

                    // swap sizes to ensure they match the configured orientation

                    result = new Size(size.getWidth(), size.getHeight());                            

            }

            else {

                    result = size;                

            }

            return result;

    }

    /**

     * Adapts the provided size to the configured orientation

     * @param size

     * @return

     */

    private Size getCorrectedSize(double height, double width) {

            Size result;

            if ( (isLandscape() && (width<height))

                            || (isPortrait() && (height<width))) {

                    // swap sizes to ensure they match the configured orientation

                    result = new Size(width, height);                            

            }

            else {

                    result = new Size(height, width);                

            }

            return result;

    }

    /**

     * It obtains the type of format from the size.

     * 

     * @param size

     *            Size of sheet.

     * 

     * @return Type of sheet.

     */

    private int getTypePaper(Size size, boolean is_portrait) {

        double tol = 1d;

        double width, height;

        // the METRIC constants are defined as portrait sizes

        // so we must compare with the right paper size

        if (size.getHeight()<size.getWidth()) {

                height = size.getWidth();

                width = size.getHeight();

        }

        else {

                width = size.getWidth();

                height = size.getHeight();

        }

        double conversionFactor = PULGADA / DPISCREEN;

        if (((width * conversionFactor)  <

                        (tol + METRIC_A4_PAPER_SIZE.getWidth()))

                        && ((height * conversionFactor) <

                                        (tol + METRIC_A4_PAPER_SIZE.getHeight()))) {

                return A4;

        }

        else if (((width * conversionFactor) <

                        (tol + METRIC_A3_PAPER_SIZE.getWidth()))

                        && ((height * conversionFactor) <

                                        (tol + METRIC_A3_PAPER_SIZE.getHeight()))) {

                return A3;

        }

        else if (((width * conversionFactor) <

                        (tol + METRIC_A2_PAPER_SIZE.getWidth()))

                        && ((height * conversionFactor) <

                                        (tol + METRIC_A2_PAPER_SIZE.getHeight()))) {

                return A2;

        }

        else if (((width * conversionFactor) < 

                        (tol + METRIC_A1_PAPER_SIZE.getWidth()))

                        && ((height * conversionFactor) < 

                                        (tol + METRIC_A1_PAPER_SIZE.getHeight()))) {

                return A1;

        } else if (((width * conversionFactor) <

                                        (tol + METRIC_A0_PAPER_SIZE.getWidth()))

                                && ((height * conversionFactor) < 

                                                (tol + METRIC_A0_PAPER_SIZE.getHeight()))) {

                        return A0;

                }

        return A4;

    }

    /**

     * Sets the default grid gap. The grip gap is the distance from one

     * point to the next point in the snapping grid.

     * 

     * @param hGap

     *            Horizontal distance.

     * @param vGap

     *            Vertical distance.

     * @param hUnitAbbr The abbreviation of the measure in which hGap has

     * been provided, codified as one of the abbreviations specified in

     * {@link MapContext#getDistanceAbbr()}

     * 

     * @param vUnitAbbr The abbreviation of the measure in which vGap has

     * been provided, codified as one of the abbreviations specified in

     * {@link MapContext#getDistanceAbbr()}

     */

    public static void setDefaultGridGap(double hGap, double vGap, String hUnitAbbr, String vUnitAbbr) {

            int hUnit = getDistanceAbbrPosition(hUnitAbbr);

        int vUnit = getDistanceAbbrPosition(vUnitAbbr);

        double hGapCm = hGap*getConversionFactorToCm(hUnit);

        double vGapCm = vGap*getConversionFactorToCm(vUnit);

        defaultGridGap = new Point2D.Double(hGapCm, vGapCm);

    }

    /**

     * Gets the default grid gap, in centimeters. The grip gap is the distance

     * from one point to the next point in the snapping grid.

     * 

     * @return Default grid gap, measured in centimeters

     */

    public static Point2D getDefaultGridGap() {

        if (defaultGridGap == null) {

                PluginServices pluginServices = PluginsLocator.getManager().getPlugin(LayoutExtension.class);

            XMLEntity xml = null;

            if (pluginServices != null) {