| gvSIG desktop 1

package com.iver.cit.gvsig.project.documents.layout;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.Toolkit;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.awt.image.MemoryImageSource;

import java.util.HashMap;

import javax.swing.JComponent;

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

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

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

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

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

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

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

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddBoxListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddCircleListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddLegendListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddLineListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddNorthListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddOverViewListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddPictureListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddPointListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddPolygonListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddPolylineListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddRectangleListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddScaleListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddTextListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutAddViewListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutEditGraphicsListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutPanListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutSelectListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutViewPanListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutViewZoomInListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutViewZoomOutListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutZoomInListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.LayoutZoomOutListenerImpl;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutEditBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutMoveBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutPointBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutRectangleBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutSelectBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutViewMoveBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.behavior.LayoutZoomBehavior;

import com.iver.cit.gvsig.project.documents.layout.tools.listener.ILayoutGraphicListener;

/**

 * Control del Layout.

 *

 * @author Vicente Caballero Navarro

 */

public class LayoutControl extends JComponent {

        public static final int DESACTUALIZADO = 4;

    public static final int ACTUALIZADO = 5;

    private int status = DESACTUALIZADO;

    private Rectangle2D rectVisible;

    private BufferedImage img = null;

    private BufferedImage imgRuler = null;

    private boolean initial = true;

        private LayoutContext layoutContext;

        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 FLayoutDraw layoutDraw = null;

        private FLayoutFunctions layoutFunctions = null;

        private LayoutBehavior currentLayoutTool = null;

        private Image imageCursor=null;

         private HashMap namesLayoutTools = new HashMap();

         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 LayoutEvents layoutEvents;

            private Point position;

            private AffineTransform m_MatrizTransf;

            private GeometryAdapter geometryAdapter = new PolyLineAdapter();

                //private String prevTool;

                private String currentTool;

                 private boolean m_bCancelDrawing = false;

                 private Rectangle reSel = null;

                 private boolean isReSel = true;

                    private FLayoutZooms layoutZooms;

                        private Point pointToMove=new Point();

        public LayoutControl(Layout layout) {

                layoutContext=layout.getLayoutContext();

                layoutDraw = new FLayoutDraw(layout);

                layoutEvents = new LayoutEvents(layout);

                 layoutZooms=new FLayoutZooms(layout);

                 layoutFunctions=new FLayoutFunctions(layout);

                addComponentListener(layoutEvents);

            addMouseMotionListener(layoutEvents);

            addMouseListener(layoutEvents);

            m_MatrizTransf = new AffineTransform();

        m_MatrizTransf.setToIdentity();

        layoutContext.updateFFrames();

            LayoutPanListenerImpl lpl = new LayoutPanListenerImpl(layout);

        addLayoutTool("layoutpan", new LayoutMoveBehavior(lpl));

        LayoutZoomInListenerImpl lzil = new LayoutZoomInListenerImpl(layout);

        addLayoutTool("layoutzoomin", new LayoutZoomBehavior(lzil));

        LayoutZoomOutListenerImpl lzol = new LayoutZoomOutListenerImpl(layout);

        addLayoutTool("layoutzoomout", new LayoutZoomBehavior(lzol));

        LayoutAddViewListenerImpl lavl = new LayoutAddViewListenerImpl(layout);

        addLayoutTool("layoutaddview", new LayoutRectangleBehavior(lavl));

        LayoutAddOverViewListenerImpl laovl = new LayoutAddOverViewListenerImpl(layout);

        addLayoutTool("layoutaddoverview", new LayoutRectangleBehavior(laovl));

        LayoutAddPictureListenerImpl lapl = new LayoutAddPictureListenerImpl(layout);

        addLayoutTool("layoutaddpicture", new LayoutRectangleBehavior(lapl));

        LayoutAddNorthListenerImpl lanorthl = new LayoutAddNorthListenerImpl(layout);

        addLayoutTool("layoutaddnorth", new LayoutRectangleBehavior(lanorthl));

        LayoutAddScaleListenerImpl lasl = new LayoutAddScaleListenerImpl(layout);

        addLayoutTool("layoutaddscale", new LayoutRectangleBehavior(lasl));

        LayoutAddLegendListenerImpl lall = new LayoutAddLegendListenerImpl(layout);

        addLayoutTool("layoutaddlegend", new LayoutRectangleBehavior(lall));

        LayoutAddTextListenerImpl latl = new LayoutAddTextListenerImpl(layout);

        addLayoutTool("layoutaddtext", new LayoutRectangleBehavior(latl));

        LayoutAddBoxListenerImpl labl = new LayoutAddBoxListenerImpl(layout);

        addLayoutTool("layoutaddbox", new LayoutRectangleBehavior(labl));

        LayoutAddPointListenerImpl lapointl = new LayoutAddPointListenerImpl(layout);

        addLayoutTool("layoutaddpoint", new LayoutPointBehavior(lapointl));

        LayoutAddLineListenerImpl lalinel = new LayoutAddLineListenerImpl(layout);

        addLayoutTool("layoutaddline", new LayoutPointBehavior(lalinel));

        LayoutAddPolygonListenerImpl lapolygonl = new LayoutAddPolygonListenerImpl(layout);

        addLayoutTool("layoutaddpolygon", new LayoutPointBehavior(lapolygonl));

        LayoutAddPolylineListenerImpl lapolylinel = new LayoutAddPolylineListenerImpl(layout);

        addLayoutTool("layoutaddpolyline", new LayoutPointBehavior(lapolylinel));

        LayoutAddCircleListenerImpl lacirclel = new LayoutAddCircleListenerImpl(layout);

        addLayoutTool("layoutaddcircle", new LayoutPointBehavior(lacirclel));

        LayoutAddRectangleListenerImpl larectanglel = new LayoutAddRectangleListenerImpl(layout);

        addLayoutTool("layoutaddrectangle", new LayoutPointBehavior(larectanglel));

        LayoutViewPanListenerImpl lvpl = new LayoutViewPanListenerImpl(layout);

        addLayoutTool("layoutviewpan", new LayoutViewMoveBehavior(lvpl));

        LayoutViewZoomInListenerImpl lvzil = new LayoutViewZoomInListenerImpl(layout);

        addLayoutTool("layoutviewzoomin", new LayoutViewMoveBehavior(lvzil));

        LayoutViewZoomOutListenerImpl lvzol = new LayoutViewZoomOutListenerImpl(layout);

        addLayoutTool("layoutviewzoomout", new LayoutViewMoveBehavior(lvzol));

        LayoutSelectListenerImpl lselectl = new LayoutSelectListenerImpl(layout);

        addLayoutTool("layoutselect", new LayoutSelectBehavior(lselectl));

        LayoutEditGraphicsListenerImpl leditl = new LayoutEditGraphicsListenerImpl(layout);

        addLayoutTool("layoutedit", new LayoutEditBehavior(leditl));

        setTool("layoutzoomin");

        }

        /**

         * Returns the name of the current selected tool on this Layout

         *

         * @return A tool name.

         */

        public String getCurrentTool() {

                return currentTool;

        }

    public void addLayoutTool(String name, LayoutBehavior tool) {

                namesLayoutTools.put(name, tool);

                tool.setLayoutControl(this);

        }

    public void setLayoutContext(LayoutContext lc) {

            layoutContext=lc;

    }

    /**

     * paintComponent del Layout.

     *

     * @param g

     *            Graphics del Layout.

     */

    protected void paintComponent(Graphics g) {

        clipVisibleRect((Graphics2D) g);

        Rectangle rClip = g.getClipBounds();

        if (rClip == null) {

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

        }

        switch (status) {

            case DESACTUALIZADO:

            //logger.debug("desactualizado");

                    if (getWidth()==0)

                            return;

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

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

            setStatus(ACTUALIZADO);

            repaint();

            break;

        case ACTUALIZADO:

            layoutDraw.drawRectangle((Graphics2D) g);

            if (currentLayoutTool != null)

                currentLayoutTool.paintComponent(g);

            else {

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

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

            }

            g.setClip(rClip);

            drawCursor(g);

        }

    }

        public void setStatus(int s) {

                status=s;

        }

        /**

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

    }

    public BufferedImage getImgRuler() {

                return imgRuler;

        }

    /**

     * 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 (layoutContext.getAtributes().isLandSpace()) {

            rect = layoutContext.getAtributes().getRectangleLandscape(rect, getWidth(),

                    getHeight());

        } else {

            rect = layoutContext.getAtributes().getRectanglePortrait(rect, getWidth(),

                    getHeight());

        }

        refresh();

    }

    /**

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

    }

    public BufferedImage getImage() {

                return img;

        }

    private void drawCursor(Graphics g) {

            if (imageCursor!=null && position!=null) {

                    Point pAdjusted=position;

//                     if (layoutContext.isAdjustingToGrid()&&

//                                    getCurrentLayoutTool().isAdjustable()){

//                            pAdjusted=FLayoutUtilities.getPointGrid(position,layoutContext.getAtributes().getUnitInPixelsX(),

//                                            layoutContext.getAtributes().getUnitInPixelsY(),

//                                    m_MatrizTransf);

//                    }

            g.drawImage(imageCursor,(int)pAdjusted.getX()-16,(int)pAdjusted.getY()-16,this);

        }

    }

    /**

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

     * par?metro.

     *

     * @param image

     */

    public void setMapCursor(Image image) {

        imageCursor=image;

    }

    /**

         * DOCUMENT ME!

         *

         * @param toolName DOCUMENT ME!

         */

        public void setTool(String toolName) {

                //prevTool=getCurrentTool();

                LayoutBehavior layoutTool = (LayoutBehavior) namesLayoutTools.get(toolName);

                currentLayoutTool = layoutTool;

                currentLayoutTool.setLayoutControl(this);

                currentTool = toolName;

                this.setMapCursor(layoutTool.getImageCursor());

                if (getCurrentLayoutTool().getListener() instanceof ILayoutGraphicListener) {

                        geometryAdapter=((ILayoutGraphicListener)getCurrentLayoutTool().getListener()).createGeometryAdapter();

                }

                if (getCurrentTool().equals("layoutedit")) {

                        startEdit();

                } else{

                        stopEdit();

                }

    }

         public void startEdit() {

                IFFrame[] fframes=layoutContext.getFFrames();

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

                    IFFrame frame = fframes[i];

                    if (frame instanceof IFFrameEditableVertex) {

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

                            ((IFFrameEditableVertex) frame).startEditing();

                        } else {

                            ((IFFrameEditableVertex) frame).stopEditing();

                        }

                    }

                }

                refresh();

            }

            public void stopEdit() {

                boolean refresh = false;

                IFFrame[] fframes=layoutContext.getFFrames();

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

                    IFFrame frame = fframes[i];

                    if (frame instanceof IFFrameEditableVertex) {

                        if (((IFFrameEditableVertex) frame).isEditing()) {

                            ((IFFrameEditableVertex) fframes[i]).stopEditing();

                            refresh = true;

                        }

                    }

                }

                if (refresh)

                    refresh();

            }

         /**

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

     *

     * @return un punto.

     */

    public Point getRectOrigin() {

        return rectOrigin;

    }

    public FLayoutDraw getLayoutDraw() {

                return layoutDraw;

        }

        public LayoutBehavior getCurrentLayoutTool() {

                return currentLayoutTool;

        }

         /**

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

//        if (layoutContext.isAdjustingToGrid() && getCurrentLayoutTool().isAdjustable()) {

//            m_FirstPoint = FLayoutUtilities.getPointGrid(position,layoutContext.getAtributes().getUnitInPixelsX(),layoutContext.getAtributes().getUnitInPixelsY(),m_MatrizTransf);

//        }else {

            m_FirstPoint=position;

//        }

    }

    /**

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

     *

     * @param p

     *            punto.

     */

    public void setPointAnt() {

//        if (layoutContext.isAdjustingToGrid()&& getCurrentLayoutTool().isAdjustable()) {

//            m_PointAnt = FLayoutUtilities.getPointGrid(position,layoutContext.getAtributes().getUnitInPixelsX(),layoutContext.getAtributes().getUnitInPixelsY(),m_MatrizTransf);

//        }else {

            m_PointAnt=position;

//        }

    }

    /**

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

     *

     * @param p

     *            punto.

     */

    public void setLastPoint() {

//        if (layoutContext.isAdjustingToGrid()&& getCurrentLayoutTool().isAdjustable()) {

//            m_LastPoint = FLayoutUtilities.getPointGrid(position,layoutContext.getAtributes().getUnitInPixelsX(),layoutContext.getAtributes().getUnitInPixelsY(),m_MatrizTransf);

//        }else {

            m_LastPoint=position;

//        }

    }

    public void setPosition(Point point2) {

            if (layoutContext.isAdjustingToGrid()&& getCurrentLayoutTool().isAdjustable()) {

            position = FLayoutUtilities.getPointGrid(point2,layoutContext.getAtributes().getUnitInPixelsX(),layoutContext.getAtributes().getUnitInPixelsY(),m_MatrizTransf);

        }else {

            position=point2;

        }

    }

        public Point getPosition() {

                return position;

        }

        /**

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

     *

     * @return AffineTransform

     */

    public AffineTransform getAT() {

        return m_MatrizTransf;

    }

    public GeometryAdapter getGeometryAdapter() {

        return geometryAdapter;

    }

    public void delLastPoint() {

        getGeometryAdapter().delLastPoint();

    }

    public int addGeometryAdapterPoint() {

//            if (layoutContext.isAdjustingToGrid() && getCurrentLayoutTool().isAdjustable()) {

//        return getGeometryAdapter().addPoint(FLayoutUtilities.toSheetPoint(FLayoutUtilities.getPointGrid(getPosition(),layoutContext.getAtributes().getUnitInPixelsX(),layoutContext.getAtributes().getUnitInPixelsY(),getAT())

//                , getAT()));

//            }

            return getGeometryAdapter().addPoint(FLayoutUtilities.toSheetPoint(getPosition(),getAT()));

    }

    public void setGeometryAdapterPoinPosition() {

//            if (layoutContext.isAdjustingToGrid() && getCurrentLayoutTool().isAdjustable()) {

//                        getGeometryAdapter().pointPosition(

//                                        FLayoutUtilities.toSheetPoint(FLayoutUtilities

//                                                        .getPointGrid(getPosition(), layoutContext.getAtributes()

//                                                                        .getUnitInPixelsX(), layoutContext.getAtributes()

//                                                                        .getUnitInPixelsX(), getAT()), getAT()));

//                } else {

                        getGeometryAdapter().pointPosition(FLayoutUtilities.toSheetPoint(getPosition(),getAT()));

//                }

    }

        public void clearMouseImage() {

                int[] pixels = new int[16 * 16];

                Image image = Toolkit.getDefaultToolkit().createImage(

                                new MemoryImageSource(16, 16, pixels, 0, 16));

                Cursor transparentCursor = Toolkit.getDefaultToolkit()

                                .createCustomCursor(image, new Point(0, 0), "invisiblecursor");

                setCursor(transparentCursor);

        }

        public void refresh() {

                setStatus(LayoutControl.DESACTUALIZADO);

                repaint();

        }

         /**

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

            IFFrame fframe = layoutContext.getFFrame(i);

            if (fframe instanceof IFFrameUseFMap

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

                // //TODO((FFrameView)

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

            }

        }

    }

    public void fullRefresh() {

        IFFrame[] fframes = layoutContext.getFFrames();

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

            if (fframes[i] instanceof IFFrameUseFMap) {

                IFFrameUseFMap fframe = (IFFrameUseFMap) fframes[i];

                fframe.refresh();

            }

        }

        refresh();

    }

    /**

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

    }

    /**

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

     * FFrameView.

     *

     * @throws DriverException

     */

    public void viewFull() throws DriverException {

        IFFrame[] fframes = layoutContext.getFFrameSelected();

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

            if (fframes[i] instanceof IFFrameUseFMap) {

                IFFrameUseFMap fframe = (IFFrameUseFMap) fframes[i];

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

                    fframe.fullExtent();

                }

                fframe.refresh();

            }

        }

        refresh();

    }

    public FLayoutZooms getLayoutZooms() {

                return layoutZooms;

        }

        public Point getPointToMove() {

                return pointToMove;

        }

        public void setPointToMove(Point pointToMove) {

                this.pointToMove = pointToMove;

        }

        public FLayoutFunctions getLayoutFunctions() {

                return layoutFunctions;

        }

        public LayoutContext getLayoutContext() {

                return layoutContext;

        }

        public void setGeometryAdapter(GeometryAdapter adapter) {

                geometryAdapter=adapter;

        }

}