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 java.awt.print.PageFormat;

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.fmap.geom.primitive.Envelope;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

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

                        Envelope envel =

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

                            fframe.getMapContext().getViewPort().getEnvelope();

                        if (envel != null) {

                            double visible_factor = screenPixelToViewPortPixelRatio(

                                layout,

                                ((IFFrame) fframe).getBoundBox().getHeight(),

                                fframe.getMapContext().getViewPort().getImageHeight());

                            Point p1scaled = new Point(

                                (int) (visible_factor * p1.getX()),

                                (int) (visible_factor * p1.getY()));

                            Point p2scaled = new Point(

                                (int) (visible_factor * p2.getX()),

                                (int) (visible_factor * p2.getY()));

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

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

                            double x =

                                envel.getMinimum(0) - (mp2.getX() - mp1.getX());

                            double y =

                                envel.getMinimum(1) - (mp2.getY() - mp1.getY());

                            double width = envel.getLength(0);

                            double height = envel.getLength(1);

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

                            if (fframe.getExtentSynced()) {

                                fframe.refreshOriginalExtent();

                            }

                        }

                    }

                }

            }

        }

    }

    public void setScale(long scale) {

            IFFrameUseFMap[] selectedFrames = layout.getLayoutContext().getSelectedFFrames(IFFrameUseFMap.class);

            if (selectedFrames.length==1) {

                    IFFrameUseFMap fframe = (IFFrameUseFMap) selectedFrames[0];

                    fframe.setScale(scale);

                    // FIXME CMI: needed?? fframe.refresh();

            }

    }

    public void addLayer() {

    }

    /**

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

    }

    /**

     * Gets the proportion between the number of pixels used

     * on the screen (physical pixels) and the "logical" pixels

     * used in the viewport of a frame (imageHeight, etc).

     * 

     * For example if viewport image height is 500

     * and the frame actually needs 100 pixels in height

     * (due to zooming) then this method returns 5.

     *  

     * @param lyt_panel

     * @param frame_height_cm frame height in cm

     * @param frame_vp_img_height frame viewport image height (pixels)

     * @return

     */

    public static double screenPixelToViewPortPixelRatio(

        LayoutPanel lyt_panel, double frame_height_cm, int frame_vp_img_height) {

        double sheet_height_screen_pix = lyt_panel.getLayoutControl().getRect().getHeight();

        int ori = lyt_panel.getLayoutContext().getAttributes().getPageFormat().getOrientation();

        double paper_h_i72 = 0;

        /*

         * Javadoc says getPageFormat().getWidth()(getHeight()

         * take into account orientation

         * but apparently it's not like that

         */

        if (ori == PageFormat.LANDSCAPE || ori == PageFormat.REVERSE_LANDSCAPE) {

            paper_h_i72 = lyt_panel.getLayoutContext().getAttributes().getPageFormat().getWidth();

        } else {

            paper_h_i72 = lyt_panel.getLayoutContext().getAttributes().getPageFormat().getHeight();

        }

        /*

         * page format uses old unit (inch/72)

         */

        double paper_h_cm = (2.54 / 72.0) * paper_h_i72;

        double frame_part = frame_height_cm / paper_h_cm;

        double pixels_fview_screen_h = sheet_height_screen_pix * frame_part;   

        double pixels_fview_vp_h = 1.0 * frame_vp_img_height;

        return pixels_fview_vp_h / pixels_fview_screen_h;

    }

    public static String getLastMessage(Throwable ex) {

        if (ex == null) {

            return "[null]";

        }

        Throwable p = ex;

        while (p.getCause() != null && p.getCause() != p) {

            p = p.getCause();

        }

        return p.getMessage();

    }

}