Application: gvSIG desktop

package org.gvsig.app.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 org.gvsig.app.project.documents.layout.fframes.IFFrame;

import org.gvsig.app.project.documents.layout.fframes.IFFrameEditableVertex;

import org.gvsig.app.project.documents.layout.fframes.IFFrameUseFMap;

import org.gvsig.app.project.documents.layout.geometryadapters.GeometryAdapter;

import org.gvsig.app.project.documents.layout.geometryadapters.PolyLineAdapter;

import org.gvsig.app.project.documents.layout.gui.FPopupMenu;

import org.gvsig.app.project.documents.layout.gui.LayoutPanel;

import org.gvsig.app.project.documents.layout.tools.LayoutAddBoxListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddCircleListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddLegendListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddLineListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddNorthListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddOverViewListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPictureListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPointListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPolygonListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPolylineListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddRectangleListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddScaleListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddTextListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddViewListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutEditGraphicsListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutPanListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutSelectListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutViewPanListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutViewZoomInListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutViewZoomOutListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutZoomInListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutZoomOutListenerImpl;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutEditBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutMoveBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutPointBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutRectangleBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutSelectBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutViewMoveBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutViewZoomBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutZoomBehavior;

import org.gvsig.app.project.documents.layout.tools.listener.ILayoutGraphicListener;

import org.gvsig.fmap.dal.exception.ReadException;

/**

 * Control of Layout.

 *

 * @author Vicente Caballero Navarro

 */

public class DefaultLayoutControl extends JComponent implements LayoutControl {

        public static final String PERSISTENCE_DEFINITION_NAME = "LayoutControl";

        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 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 static Cursor transparentCursor = Toolkit.getDefaultToolkit()

            .createCustomCursor(Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(

            16, 16, new int[16 * 16], 0, 16)),

            new Point(0, 0), "invisiblecursor");

    /**

     * Create a new object of LayoutControl.

     * @param layout

     */

    public DefaultLayoutControl(LayoutPanel layout) {       

        layoutDraw = new FLayoutDraw(layout);

        layoutEvents = new LayoutEvents(layout);

        layoutZooms = new FLayoutZooms(layout);

        layoutFunctions = new FLayoutFunctions(layout);

        addComponentListener(layoutEvents);

        addMouseMotionListener(layoutEvents);

        addMouseListener(layoutEvents);

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

        LayoutViewZoomOutListenerImpl lvzol = new LayoutViewZoomOutListenerImpl(layout);

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

        LayoutSelectListenerImpl lselectl = new LayoutSelectListenerImpl(layout);

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

        LayoutEditGraphicsListenerImpl leditl = new LayoutEditGraphicsListenerImpl(layout);

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

        FPopupMenu.registerExtensionPoint();

    }

    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;

        layoutContext.addLayoutDrawListener(this);

    }

    /**

     * paintComponent of Layout.

     *

     * @param g Graphics of 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:

            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 (ReadException 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 on visible rectangle.

     *

     * @param g2d Graphics.

     */

    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;

    }

    public void fullRect() {

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

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

        if (layoutContext.getAttributes().isLandSpace()) {

            rect = layoutContext.getAttributes().getRectangleLandscape(rect,

                    getWidth(), getHeight());

        } else {

            rect = layoutContext.getAttributes().getRectanglePortrait(rect,

                    getWidth(), getHeight());

        }

        refresh();

    }

    public Rectangle2D.Double getRect() {

        return rect;

    }

    public void setRect(Rectangle2D r) {

        rect.setRect(r);

    }

    public BufferedImage getImage() {

        return img;

    }

    /**

     * Draw the cursor on the Graphics.

     *

     * @param g Graphics.

     */

    private void drawCursor(Graphics g) {

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

            Point pAdjusted = position;

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

                (int) pAdjusted.getY() - 16, this);

        }

    }

    public void setMapCursor(Image image) {

        imageCursor = image;

    }

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

        }

    }

    public Point getRectOrigin() {

        return rectOrigin;

    }

    public FLayoutDraw getLayoutDraw() {

        return layoutDraw;

    }

    public LayoutBehavior getCurrentLayoutTool() {

        return currentLayoutTool;

    }

    public Point getFirstPoint() {

        return m_FirstPoint;

    }

    public Point getPointAnt() {

        return m_PointAnt;

    }

    public Point getLastPoint() {

        return m_LastPoint;

    }

    public void setFirstPoint() {

        m_FirstPoint = position;

    }

    public void setPointAnt() {

        m_PointAnt = position;

    }

    public void setLastPoint() {

        m_LastPoint = position;

    }

    public void setPosition(Point point2) {

        if (layoutContext.isAdjustingToGrid() &&

                getCurrentLayoutTool().isAdjustable()) {

            position = FLayoutUtilities.getPointGrid(point2,

                    layoutContext.getAttributes().getNumUnitsX(),

                    layoutContext.getAttributes().getNumUnitsY(),

                    layoutContext.getAT());

        } else {

            position = point2;

        }

    }

    public Point getPosition() {

        return position;

    }

    public AffineTransform getAT() {

        return layoutContext.getAT();

    }

    public GeometryAdapter getGeometryAdapter() {

        return geometryAdapter;

    }

    public void delLastPoint() {

        getGeometryAdapter().delLastPoint();

    }

    public int addGeometryAdapterPoint() {

        return getGeometryAdapter().addPoint(FLayoutUtilities.toSheetPoint(

                getPosition(), getAT()));

    }

    public void setGeometryAdapterPoinPosition() {

        getGeometryAdapter().pointPosition(FLayoutUtilities.toSheetPoint(

                getPosition(), getAT()));

    }

    public void clearMouseImage() {

        setCursor(transparentCursor);

    }

    public void refresh() {

        setStatus(LayoutControl.DESACTUALIZADO);

        repaint();

    }

    public synchronized boolean isDrawingCancelled() {

        return m_bCancelDrawing;

    }

     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 Rectangle getReSel() {

        return reSel;

    }

    public boolean isReSel() {

        return isReSel;

    }

    public void setIsReSel(boolean b) {

        isReSel = b;

    }

    public void viewFull() throws ReadException {

        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 FLayoutFunctions getLayoutFunctions() {

        return layoutFunctions;

    }

    public LayoutContext getLayoutContext() {

        return layoutContext;

    }

    public void setGeometryAdapter(GeometryAdapter adapter) {

        geometryAdapter = adapter;

    }

        public JComponent getComponent() {

                return this;

        }

}