Application: gvSIG desktop » gvSIG Document Layout

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

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

import org.gvsig.tools.observer.Observable;

/**

 * Control of Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class DefaultLayoutControl extends JComponent implements LayoutControl {

    private static final int DESACTUALIZADO = 4;

    private static final int ACTUALIZADO = 5;

    private static final long serialVersionUID = -8290006366669291510L;

    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 LayoutPanel layoutPanel;

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

    }

    public void initialize(LayoutPanel layoutPanel){

            this.layoutPanel = layoutPanel;

        layoutDraw = new FLayoutDraw(layoutPanel);

        layoutEvents = new LayoutEvents(layoutPanel);

        layoutZooms = new FLayoutZooms(layoutPanel);

        layoutFunctions = new FLayoutFunctions(layoutPanel);

        addComponentListener(layoutEvents);

        addMouseMotionListener(layoutEvents);

        addMouseListener(layoutEvents);

        LayoutPanListenerImpl lpl = new LayoutPanListenerImpl(layoutPanel);

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

        LayoutZoomInListenerImpl lzil = new LayoutZoomInListenerImpl(layoutPanel);

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

        LayoutZoomOutListenerImpl lzol = new LayoutZoomOutListenerImpl(layoutPanel);

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

        LayoutAddViewListenerImpl lavl = new LayoutAddViewListenerImpl(layoutPanel);

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

        LayoutAddOverViewListenerImpl laovl =

            new LayoutAddOverViewListenerImpl(layoutPanel);

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

        LayoutAddPictureListenerImpl lapl =

            new LayoutAddPictureListenerImpl(layoutPanel);

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

        LayoutAddNorthListenerImpl lanorthl =

            new LayoutAddNorthListenerImpl(layoutPanel);

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

        LayoutAddScaleListenerImpl lasl =

            new LayoutAddScaleListenerImpl(layoutPanel);

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

        LayoutAddLegendListenerImpl lall =

            new LayoutAddLegendListenerImpl(layoutPanel);

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

        LayoutAddTextListenerImpl latl = new LayoutAddTextListenerImpl(layoutPanel);

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

        LayoutAddBoxListenerImpl labl = new LayoutAddBoxListenerImpl(layoutPanel);

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

        LayoutAddPointListenerImpl lapointl =

            new LayoutAddPointListenerImpl(layoutPanel);

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

        LayoutAddLineListenerImpl lalinel =

            new LayoutAddLineListenerImpl(layoutPanel);

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

        LayoutAddPolygonListenerImpl lapolygonl =

            new LayoutAddPolygonListenerImpl(layoutPanel);

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

        LayoutAddPolylineListenerImpl lapolylinel =

            new LayoutAddPolylineListenerImpl(layoutPanel);

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

        LayoutAddCircleListenerImpl lacirclel =

            new LayoutAddCircleListenerImpl(layoutPanel);

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

        LayoutAddRectangleListenerImpl larectanglel =

            new LayoutAddRectangleListenerImpl(layoutPanel);

        addLayoutTool("layoutaddrectangle", new LayoutPointBehavior(

            larectanglel));

        LayoutViewPanListenerImpl lvpl = new LayoutViewPanListenerImpl(layoutPanel);

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

        LayoutViewZoomInListenerImpl lvzil =

            new LayoutViewZoomInListenerImpl(layoutPanel);

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

        LayoutViewZoomOutListenerImpl lvzol =

            new LayoutViewZoomOutListenerImpl(layoutPanel);

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

        LayoutSelectListenerImpl lselectl =

            new LayoutSelectListenerImpl(layoutPanel);

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

        LayoutEditGraphicsListenerImpl leditl =

            new LayoutEditGraphicsListenerImpl(layoutPanel);

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

    }

    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.addObserver(this);

        fullRect();

    }

    /**

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

            // moved to initialize()

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

        }

    }

    private 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().isLandscape()) {

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

        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;

    }

    public void update(Observable observable, Object notification) {

       if ((notification != null) && (notification instanceof LayoutNotification)){

           LayoutNotification layoutNotification = (LayoutNotification)notification;

           if (LayoutNotification.LAYOUT_VALIDATED.equals(layoutNotification.getType())){

               status = ACTUALIZADO;

           }else if (LayoutNotification.LAYOUT_INVALIDATED.equals(layoutNotification.getType())){

               status = DESACTUALIZADO;

           }else if (LayoutNotification.LAYOUT_REFRESH.equals(layoutNotification.getType())){

               refresh();

           }

       }

    }

}