| gvSIG desktop 1

/*

 * Created on 20-feb-2004

 *

 */

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.gui.layout;

import java.awt.Color;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.Toolkit;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.awt.print.PageFormat;

import java.awt.print.Printable;

import java.awt.print.PrinterException;

import java.awt.print.PrinterJob;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.io.File;

import java.util.ArrayList;

import java.util.Hashtable;

import javax.print.Doc;

import javax.print.DocFlavor;

import javax.print.DocPrintJob;

import javax.print.PrintException;

import javax.print.PrintService;

import javax.print.PrintServiceLookup;

import javax.print.ServiceUI;

import javax.print.SimpleDoc;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.event.PrintJobAdapter;

import javax.print.event.PrintJobEvent;

import javax.print.event.PrintJobListener;

import javax.swing.ImageIcon;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.filechooser.FileFilter;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.ui.mdiManager.IWindowListener;

import com.iver.andami.ui.mdiManager.SingletonWindow;

import com.iver.andami.ui.mdiManager.WindowInfo;

import com.iver.cit.gvsig.AddLayer;

import com.iver.cit.gvsig.fmap.ColorEvent;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.ExtentEvent;

import com.iver.cit.gvsig.fmap.ProjectionEvent;

import com.iver.cit.gvsig.fmap.ViewPortListener;

import com.iver.cit.gvsig.fmap.core.adapter.CircleAdapter;

import com.iver.cit.gvsig.fmap.core.adapter.GeometryAdapter;

import com.iver.cit.gvsig.fmap.core.adapter.PointAdapter;

import com.iver.cit.gvsig.fmap.core.adapter.PolyLineAdapter;

import com.iver.cit.gvsig.fmap.core.adapter.PolygonAdapter;

import com.iver.cit.gvsig.fmap.core.adapter.RectangleAdapter;

import com.iver.cit.gvsig.fmap.edition.commands.CommandListener;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.cit.gvsig.gui.layout.fframes.FFrame;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameGraphics;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameGroup;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameLegend;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameNorth;

import com.iver.cit.gvsig.gui.layout.fframes.FFramePicture;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameScaleBar;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameTable;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameText;

import com.iver.cit.gvsig.gui.layout.fframes.FFrameView;

import com.iver.cit.gvsig.project.Project;

import com.iver.cit.gvsig.project.documents.exceptions.OpenException;

import com.iver.cit.gvsig.project.documents.exceptions.SaveException;

import com.iver.cit.gvsig.project.documents.layout.EventsHandler;

import com.iver.cit.gvsig.project.documents.layout.FLayoutDraw;

import com.iver.cit.gvsig.project.documents.layout.FLayoutFunctions;

import com.iver.cit.gvsig.project.documents.layout.FLayoutUtilities;

import com.iver.cit.gvsig.project.documents.layout.ProjectMap;

import com.iver.cit.gvsig.project.documents.layout.commands.DefaultEditableFeatureSource;

import com.iver.cit.gvsig.project.documents.layout.commands.EditableFeatureSource;

import com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame;

import com.iver.cit.gvsig.project.documents.layout.fframes.IFFrameEditableVertex;

import com.iver.cit.gvsig.project.documents.layout.fframes.IFFrameLayoutDependence;

import com.iver.cit.gvsig.project.documents.layout.fframes.IFFrameUseFMap;

import com.iver.cit.gvsig.project.documents.layout.fframes.IFFrameViewDependence;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameBoxDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameGraphicsDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameGroupDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameLegendDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameNorthDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFramePictureDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameScaleBarDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameTextDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.FFrameViewDialog;

import com.iver.cit.gvsig.project.documents.layout.fframes.gui.dialogs.IFFrameDialog;

import com.iver.cit.gvsig.project.documents.layout.gui.MapProperties;

import com.iver.cit.gvsig.project.documents.layout.gui.dialogs.FConfigLayoutDialog;

import com.iver.utiles.GenericFileFilter;

import com.iver.utiles.XMLEntity;

/**

 * Mapa.

 *

 * @author Vicente Caballero Navarro

 */

public class Layout extends JPanel implements SingletonWindow, ViewPortListener,

                IWindowListener, CommandListener {

        //private static Logger logger = Logger.getLogger(Layout.class.getName());

        public static final int ZOOM_MAS = 1;

        public static final int ZOOM_MENOS = 2;

        public static final int PAN = 3;

        public static final int DESACTUALIZADO = 4;

        public static final int ACTUALIZADO = 5;

        public static final int SELECT = 6;

        public static final int RECTANGLE = 10;

        public static final int RECTANGLEVIEW = 11;

        public static final int RECTANGLEPICTURE = 12;

        public static final int RECTANGLESCALEBAR = 13;

        public static final int RECTANGLELEGEND = 14;

        public static final int RECTANGLETEXT = 15;

        public static final int RECTANGLEGROUP = 16;

        public static final int RECTANGLESYMBOL = 17;

        public static final int RECTANGLENORTH = 18;

        public static final int RECTANGLEBOX = 19;

        public static final int GRAPHICS = 20;

        public static final int POINT = 21;

        public static final int LINE = 22;

        public static final int POLYLINE = 23;

        public static final int RECTANGLESIMPLE = 24;

        public static final int CIRCLE = 25;

        public static final int POLYGON = 26;

        public static final int VIEW_ZOOMIN = 30;

        public static final int VIEW_ZOOMOUT = 31;

        public static final int VIEW_FULL = 32;

        public static final int VIEW_PAN = 33;

        public static final int SET_TAG = 34;

        public static final int EDIT = 40;

        public static final Image iLayoutpan = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/LayoutHand.gif")).getImage();

        public static final Image ipan = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/Hand.gif")).getImage();

        public static final Image iLayoutzoomin = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/LayoutZoomInCursor.gif"))

                        .getImage();

        public static final Image izoomin = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/ZoomInCursor.gif"))

                        .getImage();

        public static final Image iLayoutzoomout = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/LayoutZoomOutCursor.gif"))

                        .getImage();

        public static final Image izoomout = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/ZoomOutCursor.gif"))

                        .getImage();

        public static final Image iinfo = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/InfoCursor.gif")).getImage();

        public static final Image icrux = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/CruxCursor.png")).getImage();

        public static final Image itag = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/tagCursor.gif")).getImage();

        public static final Image iPoint = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/PointCursor.png")).getImage();

        public static final Image iRect = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/RectCursor.png")).getImage();

        public static final Image iLine = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/LineCursor.png")).getImage();

        public static final Image iRectangle = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/RectangleCursor.png"))

                        .getImage();

        public static final Image iCircle = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/CircleCursor.png"))

                        .getImage();

        public static final Image iPoligon = new ImageIcon(AddLayer.class

                        .getClassLoader().getResource("images/PoligonCursor.png"))

                        .getImage();

        public static Hashtable nums = new Hashtable();

        private static Boolean defaultShowGrid = null;

        private static Boolean defaultAdjustToGrid = null;

        private static Boolean defaultShowRulers = null;

        private Point origin = new Point(50, 50);

        private Point rectOrigin = new Point(origin);

        private Rectangle2D.Double rect = new Rectangle2D.Double(rectOrigin.x,

                        rectOrigin.y, 400, 300);

        private Point m_FirstPoint = new Point(0, 0);

        private Point m_PointAnt = new Point(0, 0);

        private Point m_LastPoint = new Point(0, 0);

        private EventsHandler events;

        private int tool = ZOOM_MAS;

        private int status = DESACTUALIZADO;

        private BufferedImage img = null;

        private BufferedImage imgRuler = null;

        private AffineTransform m_MatrizTransf;

        private Rectangle2D rectVisible;

        private IFFrameDialog fframedialog = null;

        private IFFrame[] fframes;

        private MapProperties m_propertiesLayout = null;

        private Attributes m_attributes = null;

        private PrintService[] m_cachePrintServices = null;

        private PrintService m_cachePrintService = null;

        private boolean m_bCancelDrawing = false;

        private Boolean adjustToGrid = null;

        private boolean initial = true;

        private ProjectMap map = null;

        private Rectangle reSel = null;

        private boolean isReSel = true;

        private Boolean m_showRuler;

        private FLayoutDraw layoutDraw = null;

        private Boolean isGridVisible = null;

        private Doc doc = null;

        private PrintRequestAttributeSet att = null;

        private GeometryAdapter geometryAdapter = new PolyLineAdapter();

        private DefaultEditableFeatureSource efs;

        private boolean isEditable = true;

        private WindowInfo m_viewInfo = null;

        private int numBefore = 0;

        private int numBehind = 0;

        /**

         * Lo usamos cuando estamos haciendo una ficha y asignando tags Se pone en

         * modo debug cuando hacemos un VIEW_TAGS

         */

        private boolean bModeDebug = false;

        private boolean editGroup;

        /**

         * Creates a new Layout object.

         */

        public Layout() {

                efs = new DefaultEditableFeatureSource();

                updateFFrames();

                this.setLayout(null);

                events = new EventsHandler(this);

                layoutDraw = new FLayoutDraw(this);

                addComponentListener(events);

                addMouseMotionListener(events);

                addMouseListener(events);

                m_MatrizTransf = new AffineTransform();

                m_MatrizTransf.setToIdentity();

                this.initComponents();

        }

        /**

         * Rellena el ProjectMap del Layout.

         *

         * @param m

         *            ProjectMap.

         */

        public void setProjectMap(ProjectMap m) {

                map = m;

                this.setName(m.getName());

                map.addPropertyChangeListener(new PropertyChangeListener() {

                        public void propertyChange(PropertyChangeEvent evt) {

                                if (evt.getPropertyName().equals("name")) {

                                        PluginServices.getMDIManager().getWindowInfo(Layout.this)

                                                        .setTitle(

                                                                        PluginServices.getText(this, "Mapa")

                                                                                        + " : "

                                                                                        + (String) evt.getNewValue());

                                }

                        }

                });

        }

        /**

         * Devuelve el rect?ngulo de selecci?n por rect?ngulo.

         *

         * @return Rect?ngulo de selecci?n.

         */

        public Rectangle getReSel() {

                return reSel;

        }

        /**

         * Devuelve true si se debe dibujar el rect?ngulo de selecci?n y realizar la

         * sellecci?n.

         *

         * @return true si se realiza la selecci?n por rect?ngulo.

         */

        public boolean isReSel() {

                return isReSel;

        }

        /**

         * Rellena con true si se debe de dibujar y seleccionar por rect?ngulo de

         * selecci?n.

         *

         * @param b

         *            boolean.

         */

        public void setIsReSel(boolean b) {

                isReSel = b;

        }

        /**

         * Devuelve true si el dibujado ha sido cancelado.

         *

         * @return true si el dibujado ha sido cancelado.

         */

        public synchronized boolean isDrawingCancelled() {

                return m_bCancelDrawing;

        }

        /**

         * Pone el dibuja a cancelado o no seg?n se quiera.

         *

         * @param b

         *            true si se quiere cancelar el dibujado.

         */

        public synchronized void setCancelDrawing(boolean b) {

                m_bCancelDrawing = b;

                for (int i = 0; i < getFFrames().length; i++) {

                        IFFrame fframe = getFFrame(i);

                        if (fframe instanceof IFFrameUseFMap

                                        && (((IFFrameUseFMap) fframe).getMapContext() != null)) {

                                // //TODO((FFrameView)

                                // getFFrames().get(i)).getFMap().setCancelDrawing(b);

                        }

                }

        }

        /**

         * Obtiene el ArrayList con todos los FFrames que se han a?adido al Layout.

         *

         * @return Array con todos los fframes que contiene el Layout.

         */

        public IFFrame[] getFFrames() {

                return fframes;

        }

        public IFFrame getFFrame(int i) {

                return fframes[i];

        }

        public void updateFFrames() {

                ArrayList frames = new ArrayList();

                IFFrame[] auxfframes = efs.getFFrames();

                for (int j = numBehind; j <= numBefore; j++) {

                        for (int i = 0; i < auxfframes.length; i++) {

                                if (auxfframes[i].getLevel() == j) {

                                        frames.add(auxfframes[i]);

                                        continue;

                                }

                        }

                }

                fframes = (IFFrame[]) frames.toArray(new IFFrame[0]);

        }

        /**

         * Obtiene el rect que se ajusta al tama?o de la ventana, para ver el folio

         * entero.

         */

        public void fullRect() {

                rect.setRect(origin.x, origin.y, getWidth() - (origin.x * 2),

                                getHeight() - (origin.x * 2));

                if (m_attributes.isLandSpace()) {

                        rect = m_attributes.getRectangleLandscape(rect, getWidth(),

                                        getHeight());

                } else {

                        rect = m_attributes.getRectanglePortrait(rect, getWidth(),

                                        getHeight());

                }

                refresh();

        }

        /**

         * M?todo para imprimir el Layout sin modificar la matriz de transformaci?n.

         *

         * @param g2

         */

        public void drawLayoutPrint(Graphics2D g2) {

                setCancelDrawing(false);

                setCursor(Cursor.getDefaultCursor());

                double scale = 0;

                scale = rect.height / m_attributes.m_sizePaper.getAlto() * 1;

                AffineTransform escalado = new AffineTransform();

                AffineTransform translacion = new AffineTransform();

                translacion.setToTranslation(rect.getMinX(), rect.getMinY());

                escalado.setToScale(scale, scale);

                m_MatrizTransf.setToIdentity();

                m_MatrizTransf.concatenate(translacion);

                m_MatrizTransf.concatenate(escalado);

                m_attributes.setDistanceUnitX(rect);

                m_attributes.setDistanceUnitY(rect);

                IFFrame[] fframes=getFFrames();

                for (int i = 0; i < fframes.length; i++) {

                        try {

                                fframes[i].print(g2, getAT());

                        } catch (DriverException e) {

                                NotificationManager.addError(e.getMessage(), e);

                        }

                }

                // TODO Esto es para ver el rect?ngulo que representa el folio en la

                // impresi?n.

                // g2.drawRect(0, 0, (int) rect.getWidth(), (int) rect.getHeight());

                // setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

        }

        /**

         * Clip sobre el rect?ngulo visible.

         *

         * @param g2d

         *            Graphics sobre el que hacer el clip.

         */

        private void clipVisibleRect(Graphics2D g2d) {

                rectVisible = this.getVisibleRect();

                g2d.clipRect((int) rectVisible.getMinX(), (int) rectVisible.getMinY(),

                                (int) rectVisible.getWidth(), (int) rectVisible.getHeight());

        }

        /**

         * Inicializa los componentes.

         */

        private void initComponents() {

                m_attributes = new Attributes();

                m_attributes.setDistanceUnitX(rect);

                m_attributes.setDistanceUnitY(rect);

                //actionDelFFrame();

                setDoubleBuffered(true);

        }

        /**

         * paintComponent del Layout.

         *

         * @param g

         *            Graphics del Layout.

         */

        protected void paintComponent(Graphics g) {

                super.paintComponent(g);

                clipVisibleRect((Graphics2D) g);

                Rectangle rClip = g.getClipBounds();

                if (rClip == null) {

                        System.err.println("clip = null");

                }

                switch (status) {

                case ZOOM_MAS:

                        //logger.debug("zoom mas");

                        layoutDraw.drawRectangle((Graphics2D) g);

                        g.drawImage(img, 0, 0, this);

                        g.setClip(rClip);

                        g.drawImage(imgRuler, 0, 0, this);

                        g.setColor(Color.black);

                        g.setXORMode(Color.white);

                        Rectangle r = new Rectangle();

                        r.setFrameFromDiagonal(m_FirstPoint, m_LastPoint);

                        g.drawRect(r.x, r.y, r.width, r.height);

                        break;

                case RECTANGLE:

                        //logger.debug("rectangle");

                        layoutDraw.drawRectangle((Graphics2D) g);

                        g.drawImage(img, 0, 0, this);

                        g.setClip(rClip);

                        g.drawImage(imgRuler, 0, 0, this);

                        g.setColor(Color.black);

                        g.setXORMode(Color.white);

                        Rectangle re = new Rectangle();

                        re.setFrameFromDiagonal(m_FirstPoint, m_LastPoint);

                        if (isAdjustingToGrid()) {

                                FLayoutUtilities.setRectGrid(re, m_attributes

                                                .getUnitInPixelsX(), m_attributes.getUnitInPixelsY(),

                                                m_MatrizTransf);

                        }

                        g.drawRect(re.x, re.y, re.width, re.height);

                        break;

                case PAN:

                        //logger.debug("pan");

                        rect.x = rectOrigin.x + (m_LastPoint.x - m_PointAnt.x);

                        rect.y = rectOrigin.y + (m_LastPoint.y - m_PointAnt.y);

                        layoutDraw.drawRectangle((Graphics2D) g);

                        if (img != null) {

                                g.drawImage(img, (getLastPoint().x - getPointAnt().x),

                                                (getLastPoint().y - getPointAnt().y), this);

                        }

                        g.setClip(rClip);

                        layoutDraw.drawGrid((Graphics2D) g);

                        layoutDraw.drawRuler((Graphics2D) g, Color.black);

                        break;

                case VIEW_PAN:

                        //logger.debug("View pan");

                        layoutDraw.drawRectangle((Graphics2D) g);

                        for (int i = 0; i < getFFrames().length; i++) {

                                if (getFFrame(i) instanceof IFFrameUseFMap) {

                                        IFFrameUseFMap fframe = (IFFrameUseFMap) getFFrame(i);

                                        if (((IFFrame) fframe).getSelected() != IFFrame.NOSELECT) {

                                                Rectangle2D.Double rec = ((IFFrame) fframe)

                                                                .getBoundingBox(getAT());

                                                if (img != null) {

                                                        rec = (Rectangle2D.Double) rec

                                                                        .createIntersection(getVisibleRect());

                                                }

                                                if (fframe.getBufferedImage() != null) {

                                                        layoutDraw

                                                                        .drawHandlers((Graphics2D) g, Color.black);

                                                        g.clipRect((int) rec.x, (int) rec.y,

                                                                        (int) rec.width, (int) rec.height);

                                                        layoutDraw.drawRectangle((Graphics2D) g);

                                                        layoutDraw.drawRuler((Graphics2D) g, Color.black);

                                                        Rectangle2D.Double r1 = ((IFFrame) fframe)

                                                                        .getBoundingBox(getAT());

                                                        g.drawImage(fframe.getBufferedImage(), (int) r1

                                                                        .getX()

                                                                        + m_LastPoint.x - m_PointAnt.x, (int) r1

                                                                        .getY()

                                                                        + m_LastPoint.y - m_PointAnt.y, this);

                                                        fframe.refresh();

                                                }

                                        }

                                }

                        }

                        g.setClip(rClip);

                        g.drawImage(imgRuler, 0, 0, this);

                        break;

                case SELECT:

                        //logger.debug("select");

                        layoutDraw.drawRectangle((Graphics2D) g);

                        g.drawImage(img, 0, 0, this);

                        if (isReSel) {

                                reSel = new Rectangle();

                                reSel.setFrameFromDiagonal(m_FirstPoint, m_LastPoint);

                                g.drawRect(reSel.x, reSel.y, reSel.width, reSel.height);

                        }

                        IFFrame[] frames = getFFrameSelected();

                        for (int i = 0; i < frames.length; i++) {

                                g.setColor(Color.black);

                                frames[i].drawHandlers((Graphics2D) g);

                                int difx = (m_LastPoint.x - m_FirstPoint.x);

                                int dify = (m_LastPoint.y - m_FirstPoint.y);

                                if ((Math.abs(difx) > 3) || (Math.abs(dify) > 3)) {

                                        Rectangle2D rectangle = frames[i].getMovieRect(difx, dify);

                                        if (rectangle == null)

                                                return;

                                        ((Graphics2D) g).rotate(Math.toRadians(frames[i]

                                                        .getRotation()), rectangle.getX()

                                                        + (rectangle.getWidth() / 2), rectangle.getY()

                                                        + (rectangle.getHeight() / 2));

                                        if (rectangle != null) {

                                                if (isAdjustingToGrid()) {

                                                        FLayoutUtilities.setRectGrid(rectangle,

                                                                        m_attributes.getUnitInPixelsX(),

                                                                        m_attributes.getUnitInPixelsY(),

                                                                        m_MatrizTransf);

                                                }

                                                g.drawRect((int) rectangle.getMinX(), (int) rectangle

                                                                .getMinY(), (int) rectangle.getWidth(),

                                                                (int) rectangle.getHeight());

                                        }

                                        ((Graphics2D) g).rotate(Math.toRadians(-frames[i]

                                                        .getRotation()), rectangle.getX()

                                                        + (rectangle.getWidth() / 2), rectangle.getY()

                                                        + (rectangle.getHeight() / 2));

                                }

                        }

                        g.setClip(rClip);

                        g.drawImage(imgRuler, 0, 0, this);

                        break;

                case GRAPHICS:

                        //logger.debug("graphics");

                        layoutDraw.drawRectangle((Graphics2D) g);

                        g.drawImage(img, 0, 0, this);

                        g.setClip(rClip);

                        layoutDraw.drawHandlers((Graphics2D) g, Color.black);

                        if (getTool() == EDIT) {

                                IFFrame[] fframeSelect = getFFrameSelected();

                                for (int i = 0; i < fframeSelect.length; i++) {

                                        if (fframeSelect[i] instanceof IFFrameEditableVertex) {

                                                ((IFFrameEditableVertex) fframeSelect[i]).paint(

                                                                (Graphics2D) g, getAT());

                                        }

                                }

                        } else {

                                geometryAdapter.paint((Graphics2D) g, getAT(), true);

                        }

                        g.drawImage(imgRuler, 0, 0, this);

                        break;

                case DESACTUALIZADO:

                        //logger.debug("desactualizado");

                        img = new BufferedImage(getWidth(), getHeight(),

                                        BufferedImage.TYPE_INT_ARGB);

                        imgRuler = new BufferedImage(getWidth(), getHeight(),

                                        BufferedImage.TYPE_INT_ARGB);

                        Graphics gimag = img.getGraphics();

                        Graphics gimgRuler = imgRuler.getGraphics();

                        clipVisibleRect((Graphics2D) gimag);

                        if (initial) {

                                fullRect();

                                initial = false;

                        }

                        try {

                                layoutDraw.drawLayout((Graphics2D) gimag, img);

                        } catch (DriverException e) {

                                e.printStackTrace();

                        }

                        g.setClip(rClip);

                        layoutDraw.drawRectangle((Graphics2D) g);

                        g.drawImage(img, 0, 0, this);

                        g.setClip(rClip);

                        layoutDraw.drawHandlers((Graphics2D) g, Color.black);

                        layoutDraw.drawGrid((Graphics2D) gimgRuler);

                        layoutDraw.drawRuler((Graphics2D) gimgRuler, Color.black);

                        g.drawImage(imgRuler, 0, 0, this);

                        break;

                case ACTUALIZADO:

                        layoutDraw.drawRectangle((Graphics2D) g);

                        g.drawImage(img, 0, 0, this);

                        g.setClip(rClip);

                        layoutDraw.drawHandlers((Graphics2D) g, Color.black);

                        g.drawImage(imgRuler, 0, 0, this);

                }

        }

        /**

         * A?ade un fframe al Arraylist m_fframes.

         *

         * @param frame

         *            fframe a a?adir.

         * @param clearSelection

         *            para que se quede seleccionado ?nicamente el que a?adimos y

         *            false si lo que se pretende es que no se deseleccionen lo que

         *            ya est?n seleccionados.

         * @param select

         *            Booleano que indica si se tiene que quedar seleccionado el

         *            FFrame que se a?ade o no.

         */

        public void addFFrame(IFFrame frame, boolean clearSelection, boolean select) {

                IFFrame[] fframes = getFFrames();

                if (clearSelection) {

                        for (int i = fframes.length - 1; i >= 0; i--) {

                                IFFrame fframe1 = fframes[i];

                                fframe1.setSelected(false);

                        }

                }

                if (nums.containsKey(frame.getClass())) {

                        nums.put(frame.getClass(), new Integer(Integer.parseInt(nums.get(

                                        frame.getClass()).toString()) + 1));

                } else {

                        nums.put(frame.getClass(), new Integer(0));

                }

                frame.setNum(Integer.parseInt(nums.get(frame.getClass()).toString()));

                efs.addFFrame(frame);

                frame.setSelected(select);

                frame.setLevel(getNumBefore());

                updateFFrames();

        }

        /**

         * Abre el di?logo de propiedades del folio, pasando como par?metro el

         * PrinterJob.

         *

         * @param job

         */

        public void showPagePropertiesWindow(PrinterJob job) {

                PageFormat pf1;

                pf1 = m_attributes.getPageFormat();

                pf1 = job.pageDialog(pf1);

                m_attributes.setPageFormat(pf1);

                refresh();

        }

        /**

         * Refresca el Layout.

         */

        public void refresh() {

                setStatus(DESACTUALIZADO);

                repaint();

        }

        public void fullRefresh() {

                IFFrame[] fframes = getFFrames();

                for (int i = 0; i < fframes.length; i++) {

                        if (fframes[i] instanceof IFFrameUseFMap) {

                                IFFrameUseFMap fframe = (IFFrameUseFMap) fframes[i];

                                fframe.refresh();

                        }

                }

                refresh();

        }

        /**

         * Obtiene el rect?ngulo que representa el folio con las caracter?sticas que

         * contiene attributes y diferenciando si es para visualizar en pantalla o

         * para imprimir.

         *

         * @param isPrint

         *            si es para imprimir.

         */

        public void obtainRect(boolean isPrint) {

                m_attributes.obtainRect(isPrint, rect, getWidth(), getHeight());

        }

        /**

         * Muestra el di?logo de configuraci?n del Layout.

         */

        public void showFConfig() {

                FConfigLayoutDialog m_configLayout = new FConfigLayoutDialog(this);

                PluginServices.getMDIManager().addWindow(m_configLayout);

        }

        /**

         * Mestra el di?logo de propiedades del Layout.

         */

        public void showFProperties() {

                if (map == null) {

                        map = new ProjectMap();

                        map.setModel(this);

                        map.setName(getName());

                }

                m_propertiesLayout = new MapProperties(map);

                PluginServices.getMDIManager().addWindow(m_propertiesLayout);

        }

        /**

         * Muestra el di?logo de imprimir pasandole el printerJob como par?metro.

         *

         * @param job

         */

        public void showPrintDialog(PrinterJob job) {

                if (job != null) {

                        job.printDialog();

                        try {

                                job.setPrintable((Printable) PluginServices

                                                .getExtension(com.iver.cit.gvsig.Print.class));

                                job.print();

                        } catch (PrinterException e) {

                                e.printStackTrace();

                        }

                } else {

                        // Actualizar attributes

                        att = m_attributes.toPrintAttributes();

                        // ------------------ The Printing things --------------------- //

                        DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;

                        // returns the set of printers that support printing a specific

                        // document type (such as GIF)

                        // with a specific set of attributes (such as two sided).

                        // PrintRequestAttributeSet pras = new

                        // HashPrintRequestAttributeSet();

                        // interestingly, the printer dialog's default behavior has changed

                        // with the new API: by default the dialog is not shown.

                        // So we must use the ServiceUI class to create a print dialog

                        // returns the default print service.

                        if (m_cachePrintServices == null) {

                                m_cachePrintServices = PrintServiceLookup.lookupPrintServices(

                                                flavor, null);

                        }

                        PrintService defaultService = null;

                        if (m_cachePrintService == null) {

                                defaultService = PrintServiceLookup.lookupDefaultPrintService();

                        }

                        if ((defaultService == null) && (m_cachePrintService == null)) {

                                JOptionPane.showMessageDialog((Component) PluginServices

                                                .getMainFrame(),PluginServices.getText(this,"ninguna_impresora_configurada"));

                                return;

                        }

                        if (m_cachePrintService == null) {

                                m_cachePrintService = ServiceUI.printDialog(null, 200, 200,

                                                m_cachePrintServices, defaultService, flavor, att);

                                // m_cachePrintRequestAtributeSet = new

                                // HashPrintRequestAttributeSet();

                                // m_cachePrintRequestAtributeSet.addAll(pras);

                        } else {

                                m_cachePrintService = ServiceUI.printDialog(null, 200, 200,

                                                m_cachePrintServices, m_cachePrintService, flavor, att);

                        }

                        if (m_cachePrintService != null) {

                                DocPrintJob jobNuevo = m_cachePrintService.createPrintJob();

                                PrintJobListener pjlistener = new PrintJobAdapter() {

                                        public void printDataTransferCompleted(PrintJobEvent e) {

                                                System.out.println("Fin de impresi?n");

                                                fullRect();

                                        }

                                };

                                jobNuevo.addPrintJobListener(pjlistener);

                                // DocAttributeSet das = new HashDocAttributeSet();

                                doc = new SimpleDoc(PluginServices

                                                .getExtension(com.iver.cit.gvsig.Print.class), flavor,

                                                null);

                                try {

                                        jobNuevo.print(doc, att);

                                        // m_attributes.

                                } catch (PrintException pe) {

                                        pe.printStackTrace();

                                }

                        }

                }

                /*

                 * try { print = job.printDialog(att); } catch (Exception e) {

                 * logger.error("Abriendo el Di?logo de imprimir");

                 * //System.out.println("Excepci?n "+e); } if (print) {

                 * job.setPrintable((Printable)

                 * App.instance.getPc().getExtension(com.iver.cit.gvsig.Print.class));

                 * try { job.print(att); } catch (Exception ex) { ex.printStackTrace(); } }

                 */

        }

        /**

         * Sustituye el puntero del rat?n por la imagen que se le pasa como

         * par?metro.

         *

         * @param image

         */

        public void setMapCursor(Image image) {

                Cursor cur = Toolkit.getDefaultToolkit().createCustomCursor(image,

                                new Point(16, 16), "");

                setCursor(cur);

        }

        /**

         * Cambia el puntero del raton al cusor que se le introduce como par?metro.

         *

         * @param cursor

         *            cursor a mostrar en el puntero del rat?n.

         */

        public void setMapCursor(Cursor cursor) {

                setCursor(cursor);

        }

        /**

         * Pone como seleccionada a la herramienta a partir de su n?mero.

         *

         * @param i

         */

        public void setTool(int i) {

                tool = i;

                if (getTool() == PAN) {

                        setMapCursor(ipan);

                } else if (getTool() == ZOOM_MAS) {

                        setMapCursor(izoomin);

                } else if (getTool() == ZOOM_MENOS) {

                        setMapCursor(izoomout);

                } else if (getTool() == RECTANGLEVIEW) {

                        setMapCursor(icrux);

                } else if (getTool() == RECTANGLEPICTURE) {

                        setMapCursor(icrux);

                } else if (getTool() == RECTANGLESCALEBAR) {

                        setMapCursor(icrux);

                } else if (getTool() == RECTANGLELEGEND) {

                        setMapCursor(icrux);

                } else if (getTool() == RECTANGLETEXT) {

                        setMapCursor(icrux);

                } else if (getTool() == RECTANGLENORTH) {

                        setMapCursor(icrux);

                } else if (getTool() == RECTANGLEBOX) {

                        setMapCursor(icrux);

                } else if (getTool() == SELECT) {

                        setCursor(Cursor.getDefaultCursor());

                } else if (getTool() == SET_TAG) {

                        setMapCursor(itag);

                } else if (getTool() == POINT) {

                        setMapCursor(iPoint);

                } else if (getTool() == LINE) {

                        setMapCursor(iRect);

                } else if (getTool() == RECTANGLESIMPLE) {

                        setMapCursor(iRectangle);

                } else if (getTool() == POLYLINE) {

                        setMapCursor(iLine);

                } else if (getTool() == POLYGON) {

                        setMapCursor(iPoligon);

                } else if (getTool() == CIRCLE) {

                        setMapCursor(iCircle);

                }

                if (getTool() == EDIT) {

                        setMapCursor(icrux);

                        startEdit();

                } else {

                        stopEdit();

                }

                initGeometryAdapter();

        }

        /**

         * Se crean aqu? los dialogos cada vez que se necesitan.

         *

         * @param fframe

         *            Rectangle que representa el lugar que ocupara el elemento

         *            a?adido.

         *

         * @return true si se debe de a?adir el fframe.

         */

        public boolean openFFrameDialog(IFFrame fframe) {

                switch (tool) {

                case RECTANGLEVIEW:

                        fframedialog = new FFrameViewDialog(this, (FFrameView) fframe);

                        break;

                case RECTANGLEPICTURE:

                        fframedialog = new FFramePictureDialog(this, (FFramePicture) fframe);

                        break;

                case RECTANGLESCALEBAR:

                        fframedialog = new FFrameScaleBarDialog(this,

                                        (FFrameScaleBar) fframe);

                        break;

                case RECTANGLELEGEND:

                        fframedialog = new FFrameLegendDialog(this, (FFrameLegend) fframe);

                        break;

                case RECTANGLETEXT:

                        fframedialog = new FFrameTextDialog(this, (FFrameText) fframe);

                        break;

                case GRAPHICS:

                        fframedialog = new FFrameGraphicsDialog(this,

                                        (FFrameGraphics) fframe);

                        break;

                case RECTANGLEGROUP:

                        fframedialog = new FFrameGroupDialog(this, (FFrameGroup) fframe);

                        break;

                case RECTANGLENORTH:

                        fframedialog = new FFrameNorthDialog(this, (FFrameNorth) fframe);

                        break;

                case RECTANGLEBOX:

                        fframedialog = new FFrameBoxDialog(this, (FFrameTable) fframe);

                        break;

                default:

                        return true;

                }

                if (fframedialog != null) {

                        fframedialog.setRectangle(fframe.getBoundingBox(m_MatrizTransf));

                        PluginServices.getMDIManager().addWindow(fframedialog);

                }

                return fframedialog.getIsAcepted();

        }

        /**

         * Devuelve el Rectangle2D que representa en pixels al folio.

         *

         * @return Rectangle2D.Double

         */

        public Rectangle2D.Double getRect() {

                return rect;

        }

        public void setRect(Rectangle2D r) {

                rect.setRect(r);

        }

        /**

         * Obtiene un entero que representa la herramienta seleccionada.

         *

         * @return entero.

         */

        public int getTool() {

                return tool;

        }

        /**

         * Devuelve la Matriz transformada que se esta plicando al Layout.

         *

         * @return AffineTransform

         */

        public AffineTransform getAT() {

                return m_MatrizTransf;

        }

        /**

         * Devuelve los atributos del Mapa.

         *

         * @return Attributes.

         */

        public Attributes getAtributes() {

                return m_attributes;

        }

        /**

         * Pone el estado que se quiera.

         *

         * @param s

         *            estado.

         */

        public void setStatus(int s) {

                status = s;

        }

        /**

         * Devuelve el punto que representa la esquina noroeste del mapa.

         *

         * @return un punto.

         */

        public Point getRectOrigin() {

                return rectOrigin;

        }

        /**

         * Devuelve el punto del primer click de rat?n.

         *

         * @return un punto.

         */

        public Point getFirstPoint() {

                return m_FirstPoint;

        }

        /**

         * Devuelve el punto de click de rat?n anterior.

         *

         * @return un punto.

         */

        public Point getPointAnt() {

                return m_PointAnt;

        }

        /**

         * Devuelve el punto donde se solt? el bot?n del rat?n.

         *

         * @return un punto.

         */

        public Point getLastPoint() {

                return m_LastPoint;

        }

        /**

         * Rellena el primer punto de click de rat?n.

         *

         * @param p

         *            punto.

         */

        public void setFirstPoint(Point p) {

                m_FirstPoint = p;

        }

        /**

         * Rellena el punto de click de rat?n anterior.

         *

         * @param p

         *            punto.

         */

        public void setPointAnt(Point p) {

                m_PointAnt = p;

        }

        /**

         * Rellena el punto donde se solto el bot?n del rat?n.

         *

         * @param p

         *            punto.

         */

        public void setLastPoint(Point p) {

                m_LastPoint = p;

        }

        /**

         * This method is used to get <strong>an initial</strong> ViewInfo object

         * for this Map. It is not intended to retrieve the ViewInfo object in a

         * later time. <strong>Use PluginServices.getMDIManager().getViewInfo(view)

         * to retrieve the ViewInfo object at any time after the creation of the

         * object.

         *

         * @see com.iver.mdiApp.ui.MDIManager.IWindow#getWindowInfo()

         */

        public WindowInfo getWindowInfo() {

                if (m_viewInfo == null) {

                        m_viewInfo = new WindowInfo(WindowInfo.ICONIFIABLE | WindowInfo.RESIZABLE

                                        | WindowInfo.MAXIMIZABLE);

                        m_viewInfo.setWidth(500);

                        m_viewInfo.setHeight(400);

                        m_viewInfo.setTitle(PluginServices.getText(this, "Mapa") + " : "

                                        + map.getName());

                }

                return m_viewInfo;

        }

        /**

         * Inserta si se muestra o no la regla del Layout.

         *

         * @param b

         *            True si se muestra la regla.

         */

        public void setRuler(boolean b) {

                m_showRuler = new Boolean(b);