| 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 com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.iver.utiles.GenericFileFilter;

import com.iver.utiles.XMLEntity;

import org.apache.log4j.Logger;

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.event.ActionEvent;

import java.awt.event.KeyEvent;

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

import javax.swing.Action;

import javax.swing.ImageIcon;

import javax.swing.JFileChooser;

import javax.swing.JPanel;

import javax.swing.KeyStroke;

import javax.swing.filechooser.FileFilter;

/**

 * Mapa.

 *

 * @author Vicente Caballero Navarro

 */

public class Layout extends JPanel implements SingletonView, ViewPortListener,

        ViewListener {

        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 RECTANGLEVIEW = 5;

        public static final int RECTANGLEPICTURE = 6;

        public static final int RECTANGLESCALEBAR = 7;

        public static final int RECTANGLELEGEND = 8;

        public static final int RECTANGLETEXT = 9;

        public static final int RECTANGLE = 10;

        public static final int ACTUALIZADO = 11;

        public static final int SELECT = 12;

        public static final int POINT = 13;

        public static final int LINE = 14;

        public static final int POLYLINE = 15;

        public static final int RECTANGLESIMPLE = 16;

        public static final int CIRCLE = 17;

        public static final int POLYGON = 18;

        public static final int GRAPHICS = 19;

        public static final int RECTANGLESYMBOL = 20;

        public static final int RECTANGLEGROUP = 21;

        public static final int VIEW_ZOOMIN = 22;

        public static final int VIEW_ZOOMOUT = 23;

        public static final int VIEW_FULL = 24;

        public static final int VIEW_PAN = 25;

        public static final int SET_TAG = 26;

        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 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 AffineTransform m_MatrizTransf;

        private Rectangle2D rectVisible;

        private IFFrameDialog fframedialog = null;

        private ArrayList m_fframes = new ArrayList();

        private FConfigLayoutDialog m_configLayout = null;

        private MapProperties m_propertiesLayout = null;

        private Attributes m_attributes = null;

        private PrintService[] m_cachePrintServices = null;

        private PrintRequestAttributeSet m_cachePrintRequestAtributeSet = null;

        private PrintService m_cachePrintService = null;

        private boolean m_bCancelDrawing = false;

        private boolean isCuadricula = false;

        private boolean initial = true;

        private ProjectMap map = null;

        private Rectangle reSel = null;

        private boolean isReSel = true;

        // private String m_name = null;

        private boolean m_showRuler = true;

        private FLayoutDraw layoutDraw = null;

        private boolean isDrawCuadricula = true;

        private Doc doc = null;

        private PrintRequestAttributeSet att = null;

        /**

         * Creates a new Layout object.

         */

        public Layout() {

                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;

                map.addPropertyChangeListener(new PropertyChangeListener() {

                                public void propertyChange(PropertyChangeEvent evt) {

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

                                                PluginServices.getMDIManager().getViewInfo(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().size(); i++) {

                        IFFrame fframe = (IFFrame) getFFrames().get(i);

                        if (fframe instanceof FFrameView &&

                                        (((FFrameView) fframe).getFMap() != 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 ArrayList getFFrames() {

                return m_fframes;

        }

        /**

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

                }

                status = DESACTUALIZADO;

                repaint();

        }

        /**

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

                ///if (rect.width > rect.height) {

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

                ///} else {

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

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

                        try {

                                ((IFFrame) getFFrames().get(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();

        }

        /**

         * Crea un ActionEvent para controlar las teclas que se pulsen cuando este

         * el Layout Focusable a true.

         */

        private void actionDelFFrame() {

                Action doNothing = new AbstractAction() {

                                public void actionPerformed(ActionEvent e) {

                                        for (int i = getFFrames().size() - 1; i >= 0; i--) {

                                                IFFrame fframe = (IFFrame) getFFrames().get(i);

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

                                                        getFFrames().remove(i);

                                                }

                                        }

                                        refresh();

                                }

                        };

                this.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0),

                        "doNothing");

                this.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0),

                        "doNothing");

                this.getActionMap().put("doNothing", doNothing);

        }

        /**

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

                                layoutDraw.drawGrid((Graphics2D) g);

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

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

                                layoutDraw.drawGrid((Graphics2D) g);

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

                                g.setColor(Color.black);

                                g.setXORMode(Color.white);

                                Rectangle re = new Rectangle();

                                re.setFrameFromDiagonal(m_FirstPoint, m_LastPoint);

                                if (isCuadricula()) {

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

                                //g.setXORMode(Color.black);

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

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

                                //g.clearRect(0, 0, getWidth(), getHeight());

                                layoutDraw.drawRectangle((Graphics2D) g);

                                if (img != null) {

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

                                                (m_LastPoint.y - m_PointAnt.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().size(); i++) {

                                        if (getFFrames().get(i) instanceof FFrameView) {

                                                FFrameView fframe = (FFrameView) getFFrames().get(i);

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

                                                        Rectangle2D.Double rec = fframe.getBoundingBox(getAT());

                                                        if (img != null) {

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

                                                                rec = (Rectangle2D.Double) rec.createIntersection(getVisibleRect());

                                                                //((Graphics2D)g).clearRect((int)rec.x,(int)rec.y,(int)rec.width,(int)rec.height);

                                                        }

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

                                                                layoutDraw.drawHandlers((Graphics2D) g,

                                                                        Color.black);

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

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

                                                                //g.setColor(Color.gray);

                                                                //g.fillRect(0,0,getWidth(),getHeight());

                                                                layoutDraw.drawRectangle((Graphics2D) g);

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

                                                                g.drawImage(fframe.getBufferedImage(),

                                                                        m_LastPoint.x - m_PointAnt.x,

                                                                        m_LastPoint.y - m_PointAnt.y, this);

                                                                /*System.out.println(

                                                                   "m_LastPoint.x - m_PointAnt.x" +

                                                                   (m_LastPoint.x - m_PointAnt.x));

                                                                   System.out.println(

                                                                           "m_LastPoint.y - m_PointAnt.y" +

                                                                           (m_LastPoint.y - m_PointAnt.y));

                                                                 */

                                                        }

                                                }

                                        }

                                }

                                g.setClip(rClip);

                                layoutDraw.drawGrid((Graphics2D) g);

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

                                //g.setXORMode(Color.black);

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

                                }

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

                                        IFFrame fframe = (IFFrame) getFFrames().get(i);

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

                                                g.setColor(Color.black);

                                                fframe.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 = fframe.getMovieRect(difx,

                                                                        dify);

                                                        ((Graphics2D) g).rotate(Math.toRadians(

                                                                        fframe.getRotation()),

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

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

                                                        if (rectangle != null) {

                                                                if (isCuadricula) {

                                                                        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(

                                                                        -fframe.getRotation()),

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

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

                                                }

                                        }

                                }

                                g.setClip(rClip);

                                layoutDraw.drawGrid((Graphics2D) g);

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

                                PluginServices.getMainFrame().enableControls();

                                break;

                        case GRAPHICS:

                                layoutDraw.drawRectangle((Graphics2D) g);

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

                                g.setClip(rClip);

                                layoutDraw.drawGrid((Graphics2D) g);

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

                                break;

                        case DESACTUALIZADO:

                                logger.debug("desactualizado");

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

                                                BufferedImage.TYPE_INT_ARGB);

                                Graphics gimag = img.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.drawGrid((Graphics2D) g);

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

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

                                break;

                        case ACTUALIZADO:

                                layoutDraw.drawRectangle((Graphics2D) g);

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

                                g.setClip(rClip);

                                layoutDraw.drawGrid((Graphics2D) g);

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

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

                }

        }

        /**

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

         */

        public void addFFrame(IFFrame frame, boolean clearSelection) {

                if (clearSelection) {

                        for (int i = getFFrames().size() - 1; i >= 0; i--) {

                                IFFrame fframe1 = (IFFrame) getFFrames().get(i);

                                fframe1.setSelected(false);

                        }

                }

                if (frame instanceof FFrameView &&

                                (((FFrameView) frame).getFMap() != null)) {

                        ((FFrameView) frame).getFMap().getViewPort().addViewPortListener(this);

                }

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

                getFFrames().add(frame);

                frame.setSelected(true);

        }

        /**

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

         * PrinterJob.

         *

         * @param job

         */

        public void showPagePropertiesWindow(PrinterJob job) {

                PageFormat pf1; //=new PageFormat();

                pf1 = m_attributes.getPageFormat();

                pf1 = job.pageDialog(pf1);

                m_attributes.setPageFormat(pf1);

                refresh();

        }

        /**

         * Refresca el Layout.

         */

        public void refresh() {

                //rect = m_attributes.obtainRect(false, rect, getWidth(), getHeight());

                status = DESACTUALIZADO;

                repaint();

        }

        /**

         * 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().addView(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().addView(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 {

                        boolean print = false;

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

                                                }

                                        };

                                jobNuevo.addPrintJobListener(pjlistener);

                                // DocAttributeSet das = new HashDocAttributeSet();

                                doc = new SimpleDoc((Printable) 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();

                       }

                   } */

                fullRect();

        }

        /**

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

                }

        }

        /**

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

                        default:

                                return true;

                }

                if (fframedialog != null) {

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

                        PluginServices.getMDIManager().addView(fframedialog);

                }

                return fframedialog.getIsAcepted();

        }

        /**

         * Devuelve el Rectangle2D que representa en pixels al folio.

         *

         * @return Rectangle2D.Double

         */

        public Rectangle2D.Double getRect() {

                return rect;

        }

        /**

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

        }

        /**

         * @see com.iver.mdiApp.ui.MDIManager.View#getViewInfo()

         */

        public ViewInfo getViewInfo() {

                ViewInfo m_viewinfo = new ViewInfo(ViewInfo.ICONIFIABLE |

                                ViewInfo.MAXIMIZABLE | ViewInfo.RESIZABLE);

                m_viewinfo.setWidth(500);

                m_viewinfo.setHeight(400);

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

                        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 = b;

        }

        /**

         * Devuelve si se muestra la regla del Layout.

         *

         * @return True si se muestra la regla.

         */

        public boolean getRuler() {

                return m_showRuler;

        }

        /**

         * Devuelve si se esta aplicando en los fframes que se a?den al Layout la

         * cuadr?cula, o no.

         *

         * @return true si se esta aplicando la cuadr?cula.

         */

        public boolean isCuadricula() {

                return isCuadricula;

        }

        /**

         * Se actualiza el estado de la cuadr?cula, si se aplica o no.

         *

         * @param b true si se aplica la cuadr?cula.

         */

        public void setIsCuadricula(boolean b) {

                isCuadricula = b;

        }

        /**

         * Realiza una exteni?n completa de las capas que contiene la vista del

         * FFrameView.

         *

         * @throws DriverException

         */

        public void viewFull() throws DriverException {

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

                        if (getFFrames().get(i) instanceof FFrameView) {

                                FFrameView fframe = (FFrameView) getFFrames().get(i);

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

                                        fframe.getFMap().getViewPort().setExtent(fframe.getFMap()

                                                                                                                                   .getFullExtent());

                                }

                        }

                }

                setStatus(DESACTUALIZADO);

                repaint();

        }

        /**

         * Devuelve un Objeto XMLEntity con la informaci?n los atributos necesarios

         * para poder despu?s volver a crear el objeto original.

         *

         * @return XMLEntity.

         *

         * @throws XMLException

         */

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("className", this.getClass().getName());

                xml.setName("layout");

                xml.putProperty("isCuadricula", isCuadricula());

                xml.putProperty("m_name", this.getName());

                xml.addChild(getAtributes().getXMLEntity());

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

                        xml.addChild(((IFFrame) getFFrames().get(i)).getXMLEntity());

                }

                return xml;

        }

        /**

         * Crea un Objeto de esta clase a partir de la informaci?n del XMLEntity.

         *

         * @param xml XMLEntity

         * @param p Proyecto.

         *

         * @return Objeto de esta clase.

         */

        public static Layout createLayout(XMLEntity xml, Project p) {

                Layout layout = new Layout();

                layout.isCuadricula = xml.getBooleanProperty("isCuadricula");

                layout.setName(xml.getStringProperty("m_name"));

                layout.m_attributes = Attributes.createAtributes(xml.getChild(0));

                for (int i = 1; i < xml.getNumChild(); i++) {

                        if (xml.getChild(i).getStringProperty("className").equals("com.iver.cit.gvsig.gui.layout.fframe.FFrameView")) {

                                layout.addFFrame(FFrame.createFFrame(xml.getChild(i), layout, p),

                                        true);

                        }

                }

                for (int i = 1; i < xml.getNumChild(); i++) {

                        if (!xml.getChild(i).getStringProperty("className").equals("com.iver.cit.gvsig.gui.layout.fframe.FFrameView")) {

                                layout.addFFrame(FFrame.createFFrame(xml.getChild(i), layout, p),

                                        true);

                        }

                }

                return layout;

        }

        /**

         * Crea un Objeto de esta clase a partir de la informaci?n del XMLEntity.

         *

         * @param xml XMLEntity

         * @param p Proyecto.

         *

         * @return Objeto de esta clase.

         */

        public static Layout createLayout03(XMLEntity xml, Project p) {

                Layout layout = new Layout();

                layout.isCuadricula = xml.getBooleanProperty("isCuadricula");

                layout.setName(xml.getStringProperty("m_name"));

                layout.m_attributes = Attributes.createAtributes03(xml.getChild(0));

                for (int i = 1; i < xml.getNumChild(); i++) {

                        if (xml.getChild(i).getStringProperty("className").equals("com.iver.cit.gvsig.gui.layout.fframe.FFrameView")) {

                                layout.addFFrame(FFrame.createFFrame03(xml.getChild(i), layout,

                                                p), true);

                        }

                }

                for (int i = 1; i < xml.getNumChild(); i++) {

                        if (!xml.getChild(i).getStringProperty("className").equals("com.iver.cit.gvsig.gui.layout.fframe.FFrameView")) {

                                layout.addFFrame(FFrame.createFFrame03(xml.getChild(i), layout,

                                                p), true);

                        }

                }

                return layout;

        }

        /**

         * @see com.iver.mdiApp.ui.MDIManager.View#viewActivated()

         */

        public void viewActivated() {

                PluginServices.getMainFrame().getStatusBar().setMessage("1",

                        getAtributes().getNameUnit());

                ///System.out.println("---------- 1 "+ getAtributes().getNameUnit());

        }

        /**

         * @see com.iver.cit.gvsig.fmap.IMapExtentListener#extentChanged(java.awt.geom.Rectangle2D)

         */

        public void extentChanged(Rectangle2D newExtent) {