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.geom.Rectangle2D.Double;

import java.awt.image.BufferedImage;

import java.awt.image.MemoryImageSource;

import java.util.HashMap;

import javax.swing.JComponent;

import org.gvsig.andami.PluginsLocator;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

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

    private Point origin = new Point(50, 50);

    private Point rectOrigin = new Point(origin);

    /**

     * Size and position of the layout sheet within visible area of

     * the layout component, measured in screen coordinates (pixels).

     */

    private Rectangle2D.Double rect = new Rectangle2D.Double(rectOrigin.x,

        rectOrigin.y, 400, 300);

    /**

     * Visible area of the layout document, measured on paper coordinates.

     */

    private Rectangle2D.Double viewPort = new Rectangle2D.Double();

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

            setFocusable(true);

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

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

        Rectangle2D r = new Rectangle2D.Double(origin.x, origin.y, getWidth(),

            getHeight());

        if (layoutContext.getAttributes().isLandscape()) {

            r =

                layoutContext.getAttributes().getRectangleLandscape(r,

                    getWidth(), getHeight());

        } else {

            r =

                layoutContext.getAttributes().getRectanglePortrait(r,

                    getWidth(), getHeight());

        }

        setRect(r);

        refresh();

    }

    public Rectangle2D.Double getRect() {

            return (Rectangle2D.Double) rect.clone();

    }

    public void setRect(Rectangle2D r) {

        rect.setRect(r);

        Rectangle2D bounds = getBounds();

        if (rect.getWidth()>0 && bounds.getWidth()>0) { // only when the component has been laid out and rect properly initialized

                // ensure the AT is properly initialized

                layoutDraw.initializeAffineTransform();

                AffineTransform at = layoutContext.getAT();

                if (at!=null) {

                        Rectangle2D.Double newVp = new Rectangle2D.Double(0d, 0d, bounds.getWidth(), bounds.getHeight());

                        viewPort.setRect(FLayoutUtilities.toSheetRect(newVp, at));

                }

        }

    }

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

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

        PluginsLocator.getMainFrame().setSelectedTool("selection-select-by-rectangle-layout");

        setTool("layoutselect");

        }

    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().getHGridGapCm(), layoutContext

                    .getAttributes().getVGridGapCm(), 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() {

            AffineTransform at = calculateTransformFromViewport();

            if (at!=null) {

                // update rect according to the viewport rectangle

                    Size s = getLayoutContext().getAttributes().getPaperSize();

                    Rectangle2D paperRect = new Rectangle2D.Double(0, 0, s.getWidth(), s.getHeight());

                    Rectangle2D newRect = FLayoutUtilities.fromSheetRect(paperRect, at);

                    setRect(newRect);

            }

            // repaint

        setStatus(DESACTUALIZADO);

        invalidate();

        repaint();

    }

    /**

     * Calculates the affine transform using the viewport and the control size,

     * instead of calculating it from {@link #rect}. as usual. This is required when

     * the component size changes, as {@link #rect}. has to be recalculated using

     * the viewport, and thus we can't calculate the affine transform using

     * {@link #rect}.

     * 

     * @return An matrix to transform from paper coordinates to screen coordinates

     */

    protected AffineTransform calculateTransformFromViewport() {

            Rectangle2D bounds = getBounds();

            if (bounds.getWidth()>0 && viewPort.getHeight()>0) {

                    AffineTransform at = new AffineTransform();

                    // paper (paper units) to screen (pixels) scale

                double scale, scale1, scale2;

                scale1 = bounds.getHeight() / viewPort.getHeight() * 1;

                scale2 = bounds.getWidth() / viewPort.getWidth() * 1;

                scale = (scale1+scale2)/2d; // average scale

                    AffineTransform scaleAt = new AffineTransform();

                    AffineTransform translationAt = new AffineTransform();

                    translationAt.setToTranslation(-viewPort.getMinX(), -viewPort.getMinY());

                    scaleAt.setToScale(scale, scale);

                    at.concatenate(scaleAt);

                    at.concatenate(translationAt);

                    return at;

            }

            return null;

    }

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

           }

       }

    }

}