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

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.app.project.documents.layout.commands.FrameCommandsRecord;

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

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

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

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

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

/**

 * Funciones utilizadas desde el Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class FLayoutFunctions implements Observable {

    protected static final Logger LOG = LoggerFactory

        .getLogger(FLayoutFunctions.class);

    private static final GeometryManager geomManager = GeometryLocator

        .getGeometryManager();

    private static final Logger logger = LoggerFactory

        .getLogger(FLayoutFunctions.class);

    private LayoutPanel layout = null;

    private ObservableHelper observers;

    /**

     * Crea un nuevo FLayoutFunctions.

     * 

     * @param l

     *            Referencia al Layout.

     */

    public FLayoutFunctions(LayoutPanel layoutPanel) {

        layout = layoutPanel;

        observers = new ObservableHelper();

        observers.addObserver(layoutPanel.getLayoutControl());

    }

    /**

     * Gestiona la herramienta de selecci?n sobre el Mapa.

     */

    public void setSelect() {

        IFFrame fframe = null;

        boolean isUpdate = false;

        layout.getLayoutContext().updateFFrames();

        IFFrame[] fframes = layout.getLayoutContext().getFFrames();

        FrameCommandsRecord efs =

            layout.getLayoutContext().getFrameCommandsRecord();

        efs.startComplex("move");

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

            fframe = fframes[i];

            int difx =

                (layout.getLayoutControl().getLastPoint().x - layout

                    .getLayoutControl().getFirstPoint().x);

            int dify =

                (layout.getLayoutControl().getLastPoint().y - layout

                    .getLayoutControl().getFirstPoint().y);

            if (((Math.abs(difx) > 3) || (Math.abs(dify) > 3))

                && (fframe.getSelected() != IFFrame.NOSELECT)) {

                Rectangle2D rectangle = fframe.getLastMoveRect();

                if (rectangle == null) {

                    efs.endComplex();

                    return;

                }

                if (fframe instanceof FFrameGroup) {

                    ((FFrameGroup) fframe).setAt(layout.getLayoutControl()

                        .getAT());

                }

                IFFrame fframeAux;

                try {

                    fframeAux = (IFFrame) fframe.clone();

                    fframeAux.setBoundBox(FLayoutUtilities.toSheetRect(

                        rectangle, layout.getLayoutControl().getAT()));

                    efs.update(fframe, fframeAux);

                    fframeAux.getBoundingBox(layout.getLayoutControl().getAT());

                    isUpdate = true;

                } catch (CloneNotSupportedException e) {

                    LOG.error("It is not possible clonate the object", e);

                }

            }

            Rectangle rect = null;

            if (layout.getLayoutControl().getReSel() == null) {

                rect = new Rectangle();

                rect.setFrameFromDiagonal(layout.getLayoutControl()

                    .getFirstPoint(), layout.getLayoutControl().getLastPoint());

            } else {

                rect = layout.getLayoutControl().getReSel();

            }

            if (layout.getLayoutControl().isReSel()

                && (rect.contains(fframe.getBoundingBox(layout

                    .getLayoutControl().getAT())))) {

                fframe.setSelected(true);

            }

            if (isUpdate) {

                observers.notifyObservers(this, 

                    new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));

            } else {

                observers.notifyObservers(this, 

                    new DefaultLayoutNotification(LayoutNotification.LAYOUT_VALIDATED));

            }

        }

        efs.endComplex();

        layout.getLayoutContext().updateFFrames();

    }

    /**

     * Pan sobre la vista del FFrameView.

     * 

     * @param p1

     *            Punto inicial del desplazamiento.

     * @param p2

     *            Punto final del desplazamiento.

     */

    public void setViewPan(Point p1, Point p2) {

        IFFrame[] fframes = layout.getLayoutContext().getFFrames();

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

            if (fframes[i] instanceof IFFrameUseFMap) {

                IFFrameUseFMap fframe = (IFFrameUseFMap) fframes[i];

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

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

                        Rectangle2D.Double r = new Rectangle2D.Double();

                        Rectangle2D extent =

                            fframe.getMapContext().getViewPort().getExtent();

                        if (extent != null) {

                            Point2D mp1 = toMapPoint(p1, fframe.getATMap());

                            Point2D mp2 = toMapPoint(p2, fframe.getATMap());

                            double x =

                                extent.getX() - (mp2.getX() - mp1.getX());

                            double y =

                                extent.getY() - (mp2.getY() - mp1.getY());

                            double width = extent.getWidth();

                            double height = extent.getHeight();

                            try {

                                fframe

                                    .getMapContext()

                                    .getViewPort()

                                    .setEnvelope(

                                        geomManager.createEnvelope(x, y, x

                                            + width, y + height,

                                            SUBTYPES.GEOM2D));

                            } catch (CreateEnvelopeException e) {

                                logger.error("Error creating the envelope", e);

                            }

                            fframe.refresh();

                            fframe.refreshOriginalExtent();

                        }

                    }

                }

            }

        }

    }

    /**

     * Devuelve un punto real a partir de un punto en pixels sobre la vista.

     * 

     * @param pScreen

     *            Punto en pixels.

     * @param at1

     *            Matriz de transformaci?n.

     * 

     * @return Punto real.

     */

    public static Point2D.Double toMapPoint(Point2D pScreen, AffineTransform at1) {

        Point2D.Double pWorld = new Point2D.Double();

        AffineTransform at;

        try {

            at = at1.createInverse();

            at.transform(pScreen, pWorld);

        } catch (NoninvertibleTransformException e) {

            // throw new RuntimeException(e);

        }

        return pWorld;

    }

    public void addObserver(Observer o) {

        observers.addObserver(o);        

    }

    public void deleteObserver(Observer o) {

      observers.deleteObserver(o);        

    }

    public void deleteObservers() {

       observers.deleteObservers();        

    }

}