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

import javax.swing.JPanel;

import javax.swing.KeyStroke;

import javax.swing.filechooser.FileFilter;

import org.apache.log4j.Logger;

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.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.commands.DefaultEditableFeatureSource;

import com.iver.cit.gvsig.gui.layout.commands.EditableFeatureSource;

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

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

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

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

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

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

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

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

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

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

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.gui.project.OpenException;

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

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

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

import com.iver.utiles.GenericFileFilter;

import com.iver.utiles.XMLEntity;

/**

 * Mapa.

 *

 * @author Vicente Caballero Navarro

 */

public class Layout extends JPanel implements SingletonView, ViewPortListener,

    ViewListener,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 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 ArrayList m_fframes = new ArrayList();

    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 isCuadricula = false;

    private boolean initial = true;

    private ProjectMap map = null;

    private Rectangle reSel = null;

    private boolean isReSel = true;

    private boolean m_showRuler = true;

    private FLayoutDraw layoutDraw = null;

    private boolean isDrawCuadricula = true;

    private Doc doc = null;

    private PrintRequestAttributeSet att = null;

    private GeometryAdapter geometryAdapter=new PolyLineAdapter();

    private DefaultEditableFeatureSource efs;

    private boolean isEditable=true;

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

        addKeyListener(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().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().length; i++) {

            IFFrame fframe = (IFFrame) getFFrame(i);

            if (fframe instanceof IFFrameUseFMap &&

                    (((IFFrameUseFMap) 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 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()==-1){

            //        frames.add(auxfframes[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());

        }

        /*IFFrame[] fframes=getFFrames();

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

                fframes[i].initialize();

        }*/

        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().length; i++) {

            try {

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

    }

    /**

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

                   delFFrameSelected();

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

                //layoutDraw.drawGrid((Graphics2D) g);

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

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

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

                }

                g.setClip(rClip);

                layoutDraw.drawGrid((Graphics2D) g);

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

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

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

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

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

                //layoutDraw.drawGrid((Graphics2D) g);

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

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

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

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

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

                       // System.out.println(m_FirstPoint);

                       // System.out.println(m_LastPoint);

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

                                    -frames[i].getRotation()),

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

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

                        }

                    //}

                }

                g.setClip(rClip);

                //layoutDraw.drawGrid((Graphics2D) g);

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

                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.drawGrid((Graphics2D) g);

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

                //layoutDraw.drawRuler((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:

                    logger.debug("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);

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

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

            //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(),

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

               }

           } */

    }

    /**

     * 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().addView(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.View#getViewInfo()

     */

    public ViewInfo getViewInfo() {

            if (m_viewInfo == null) {

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

                ViewInfo.MAXIMIZABLE);

                    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