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.layout.mapbox.tools;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.event.MouseEvent;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.app.project.documents.layout.DefaultLayoutNotification;

import org.gvsig.app.project.documents.layout.FLayoutUtilities;

import org.gvsig.app.project.documents.layout.LayoutContext;

import org.gvsig.app.project.documents.layout.LayoutNotification;

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

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

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

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

import org.gvsig.fmap.mapcontrol.tools.BehaviorException;

import org.gvsig.layout.mapbox.fframe.FFrameMapBox;

import static org.gvsig.layout.mapbox.fframe.FFrameMapBox.PIXELS_TOLERANCE;

import org.gvsig.layout.mapbox.model.Cell;

import static org.gvsig.layout.mapbox.model.MapBoxModel.POSITION_AT_BOTOM_OF_CELL;

import static org.gvsig.layout.mapbox.model.MapBoxModel.POSITION_AT_TOP_OF_CELL;

import static org.gvsig.layout.mapbox.model.MapBoxModel.POSITION_ON_LEFT_EDGE_OF_CELL;

import static org.gvsig.layout.mapbox.model.MapBoxModel.POSITION_ON_RIGHT_EDGE_OF_CELL;

import static org.gvsig.layout.mapbox.model.MapBoxModel.POSITION_OUT_OF_MAPBOX;

import org.gvsig.tools.lang.CloneableUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Behaviour que espera un listener de tipo LayoutMoveListener.

 * 

 * @author gvSIG team

 */

public class LayoutEditMapBoxBehavior extends LayoutBehavior {

    private static Logger LOGGER = LoggerFactory.getLogger(LayoutEditMapBoxBehavior.class);

    private final LayoutEditMapBoxListenerImpl listener;

    private boolean dragging = false;

    private Point2D.Double pointPressed;

    private Pair<Integer, Cell> relativePosition;

//    private FFrameMapBox currFrame;

    private FFrameMapBox dragFrame;

    /**

     * Crea un nuevo MoveBehavior.

     * 

     * @param pli

     *            listener.

     */

    public LayoutEditMapBoxBehavior(LayoutEditMapBoxListenerImpl lpl) {

        listener = lpl;

    }

    /**

     * @see org.gvsig.fmap.mapcontrol.tools.Behavior.Behavior#paintComponent(java.awt.Graphics)

     */

    @Override

    public void paintComponent(Graphics g) {

        getLayoutControl().getLayoutDraw().drawRectangle((Graphics2D) g);

        g.drawImage(getLayoutControl().getImage(), 0, 0, getLayoutControl()

            .getComponent());

        getLayoutControl().getLayoutDraw().drawHandlers((Graphics2D) g,

            Color.black);

        if(dragFrame != null){

                dragFrame.draw((Graphics2D) g, getLayoutControl().getAT());

        }

        g.drawImage(getLayoutControl().getImgRuler(), 0, 0, getLayoutControl()

            .getComponent());

    }

    /**

     * @throws BehaviorException

     * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)

     */

    @Override

    public void mousePressed(MouseEvent e) throws BehaviorException {

        super.mousePressed(e);

        this.dragFrame = null;

        this.dragging = false;

        IFFrame[] fframes = getLayoutControl().getLayoutContext().getSelectedFFrames();

        if(fframes.length != 1 || !(fframes[0] instanceof FFrameMapBox)){

            return;

        }

        AffineTransform at = getLayoutControl().getAT();

        for (IFFrame frame : fframes) {

            if (frame instanceof FFrameMapBox) {

                this.pointPressed = 

                    FLayoutUtilities.toSheetPoint(

                        e.getPoint(),

                        at

                );

                this.relativePosition = ((FFrameMapBox)frame).getModel().getRelativePosition(

                    ((FFrameMapBox)frame).fromSheetPointToMapBoxPoint(this.pointPressed),

                    FLayoutUtilities.toSheetDistance(PIXELS_TOLERANCE, at)

                );

                if(this.relativePosition.getLeft() == POSITION_OUT_OF_MAPBOX 

//                    || this.cursorPosition.getLeft() == POSITION_IN_CELL

                    ){

                    continue;

                }

//                this.currFrame = (FFrameMapBox)frame;

                break;

            }

        }

    }

    /**

     * Reimplementaci?n del m?todo mouseReleased de Behavior.

     * 

     * @param e

     *            MouseEvent

     * 

     * @throws BehaviorException

     *             Excepci?n lanzada cuando el Behavior.

     */

    @Override

    public void mouseReleased(MouseEvent e) throws BehaviorException {

        super.mouseReleased(e);

        LayoutContext layoutContext = getLayoutControl().getLayoutContext();

        IFFrame[] fframes = layoutContext.getSelectedFFrames();

        if (fframes.length != 1 || !(fframes[0] instanceof FFrameMapBox)) {

            return;

        }

        FFrameMapBox currFrame = (FFrameMapBox) fframes[0];

        Point2D.Double point

            = FLayoutUtilities.toSheetPoint(

                e.getPoint(),

                getLayoutControl().getAT()

            );

        try {

            FFrameMapBox newFrame = (FFrameMapBox) CloneableUtils.cloneQuietly(currFrame);

            if (this.dragging) {

                this.listener.drag(newFrame, relativePosition.getLeft(), relativePosition.getRight(), point);

                currFrame.getLayoutContext().getFrameCommandsRecord().update(currFrame, newFrame);

                getLayoutControl().getLayoutContext().updateFFrames();

            } else {

                Point2D.Double mapPoint = newFrame.fromSheetPointToMapBoxPoint(point);

                Cell cell = newFrame.getModel().getCell(mapPoint.getX(), mapPoint.getY());

                if (cell == null) {

                    return;

                }

                this.listener.selectCell(newFrame, cell);

            }

            layoutContext.getFrameCommandsRecord().update(currFrame, newFrame);

            layoutContext.updateFFrames();

        } catch (Exception ex) {

            LOGGER.warn("Failed releasing mouse over FFrameMapBox", ex);

            //FIXME: Do nothing?

        } finally {

            dragging = false;

            dragFrame = null;

        }

        getLayoutControl().refresh();

    }

    /**

     * Reimplementaci?n del m?todo mouseDragged de Behavior.

     * 

     * @param e

     *            MouseEvent

     * @throws BehaviorException

     */

    @Override

    public void mouseDragged(MouseEvent e) throws BehaviorException {

        super.mouseDragged(e);

        IFFrame[] fframes = getLayoutControl().getLayoutContext().getSelectedFFrames();

        if(fframes.length != 1 || !(fframes[0] instanceof FFrameMapBox)){

            return;

        }

        FFrameMapBox currFrame = (FFrameMapBox) fframes[0];

        Pair<Integer, Cell>  rP;

        this.dragFrame = (FFrameMapBox) CloneableUtils.cloneQuietly(currFrame);

        AffineTransform at = getLayoutControl().getAT();

        Point2D.Double point = FLayoutUtilities.toSheetPoint(

            e.getPoint(),

            at

        );

        rP = dragFrame.getModel().getRelativePosition(

            dragFrame.fromSheetPointToMapBoxPoint(this.pointPressed),

            FLayoutUtilities.toSheetDistance(PIXELS_TOLERANCE, at)

        );

        this.dragging = true;

        Point2D.Double dragPoint

            = FLayoutUtilities.toSheetPoint(

                e.getPoint(),

                getLayoutControl().getAT()

            );

        this.listener.drag(dragFrame, rP.getLeft(), rP.getRight(), dragPoint);

        getLayoutControl().refresh();

    }

    @Override

    public void mouseMoved(MouseEvent e) throws BehaviorException {

        super.mouseMoved(e);

        IFFrame[] fframes = getLayoutControl().getLayoutContext().getSelectedFFrames();

        if(fframes.length != 1 || !(fframes[0] instanceof FFrameMapBox)){

            return;

        }

        FFrameMapBox currFrame = (FFrameMapBox) fframes[0];

//        if(currFrame == null){

//            return;

//        }

        if(this.dragging) {

            return;

        }

        AffineTransform at = getLayoutControl().getAT();

//        if (this.currFrame.contains(e.getPoint())) {

            Point2D.Double point = FLayoutUtilities.toSheetPoint(

                e.getPoint(),

                at

            );

            Point2D.Double mapBoxPoint = currFrame.fromSheetPointToMapBoxPoint(point);

            Pair<Integer, Cell> cursorPosition = currFrame.getModel().getRelativePosition(mapBoxPoint,

                FLayoutUtilities.toSheetDistance(PIXELS_TOLERANCE, at)

            );

            switch (cursorPosition.getLeft()) {

                case POSITION_ON_LEFT_EDGE_OF_CELL:

                case POSITION_ON_RIGHT_EDGE_OF_CELL:

                    getLayoutControl().setMapCursor(FFrame.iEResize);

                    break;

                case POSITION_AT_TOP_OF_CELL:

                case POSITION_AT_BOTOM_OF_CELL:

                    getLayoutControl().setMapCursor(FFrame.iNResize);

                    break;

                default:

                    getLayoutControl().setMapCursor(this.listener.getImageCursor());

            }

//        } else {

//            getLayoutControl().setMapCursor(this.listener.getImageCursor());

//        }

    }

    /**

     * @see org.gvsig.fmap.mapcontrol.tools.Behavior.Behavior#getListener()

     */

    @Override

    public LayoutToolListener getListener() {

        return listener;

    }

    @Override

    public boolean isAdjustable() {

        return true;

    }

}