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

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.event.MouseEvent;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.gvsig.app.project.documents.Document;

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

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

import org.gvsig.fmap.mapcontext.rendering.symbols.IPrintable;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.lang.Cloneable;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.Persistent;

/**

 * Interface representing a frame that can be added to a LayoutDocument.

 * IFFrames are assumed to be rectangular objects that are able to draw themselves

 * on a Graphics2D object. They handle selection status and can also be

 * rotated. Specific implementations of this interface should be able to persist

 * their status.

 * 

 * @author Vicente Caballero Navarro

 * @author Cesar Martinez Izquierdo

 */

public interface IFFrame extends IPrintable, Persistent, Cloneable, Observable, Disposable {

        //FIXME: ensure the following comments are correct!

        /** FFrame has been selected by clicking on its North boundary */

        public static final int N = 1;

        /** FFrame has been selected by clicking on its North-East corner */

    public static final int NE = 2;

    /** FFrame has been selected by clicking on its East boundary */

    public static final int E = 3;

    /** FFrame has been selected by clicking on its South-East corner */

    public static final int SE = 4;

    /** FFrame has been selected by clicking on its South boundary */

    public static final int S = 5;

    /** FFrame has been selected by clicking on its South-West corner */

    public static final int SO = 6;

    /** FFrame has been selected by clicking on its West boundary */

    public static final int O = 7;

    /** FFrame has been selected by clicking on its North-West corner */

    public static final int NO = 8;

    /** FFrame has been selected by clicking within the frame rectangle */

    public static final int RECT = 9;

    /** FFrame is not selected */

    public static final int NOSELECT = 0;

    /**

     * Returns the bounding box (in pixels) of this FFrame, based on the provided

     * AffineTransform. If the AffineTransform is null, it returns the last

     * calculated bounding box.

     * 

     * @param at Affine transform to apply to the sheet coordinates to get the

     *                  bounding box in pixels.

     * @return Rectangle representing the bounding box (in pixels) of this

     * FFrame

     */

    public Rectangle2D.Double getBoundingBox(AffineTransform at);

    /**

     * Returns the bounding box in centimeters of this FFrame, using paper

     * coordinates

     * 

     * @return The bounding box of this FFrame, measured in centimeters.

     */

    public Rectangle2D.Double getBoundBox();

    /**

     * Sets the bounding box in centimeters of this FFrame, using  paper

     * coordinates.

     * 

     * @param r

     *            Rectangle in centimeters

     */

    public void setBoundBox(Rectangle2D rect);

    /**

     * Este m?todo se implementa en cada una de las fframe, ya que cada una se

     * dibuja de una forma diferente sobre el graphics. M?todo que dibuja

     * sobre el graphics que se le pasa como par?metro, seg?n la transformada

     * afin que se debe de aplicar y el rect?ngulo que se debe de dibujar.

     * 

     * @param g

     *            Graphics

     * @param at

     *            Transformada afin.

     * @param r

     *            rect?ngulo sobre el que hacer un clip.

     * @param imgBase

     *            Imagen para acelerar el dibujado.

     * @throws ReadDriverException

     *             TODO

     */

    public void draw(Graphics2D g, AffineTransform at, Rectangle2D r,

        BufferedImage imgBase);

    /**

     * Devuelve el nombre que representa al fframe.

     * 

     * @return String nombre del FFrame.

     */

    public String getName();

    /**

     * Devuelve true, si el punto que se pasa como par?metro esta contenido

     * dentro del boundingbox del fframe.

     * 

     * @param p

     *            punto a comprobar.

     * 

     * @return true si el punto esta dentro del boundingbox.

     */

    public boolean contains(Point2D p);

    /**

     * Dibuja los handlers sobre el boundingBox en el graphics que se pasa como

     * par?metro.

     * 

     * @param g

     *            Graphics sobre el que dibujar.

     */

    public void drawHandlers(Graphics2D g);

    /**

     * Sets the type of selection performed on the frame, based on the position

     * of the provided Point compared with the boundaries of the FFrame.

     * This method is usually called when the user clicks on the FFrame

     * 

     * @param p

     *            Point which should be evaluated to establish if the FFrame must

     *            be selected or not

     * @param e   Mouse event that triggered this method call

     * @see {@link #isSelected()}, {@link #getSelected()}

     */

    public void setSelected(Point2D b, MouseEvent e);

    /**

     * Sets the selected status of the frame.

     * 

     * @param selected

     *            <code>true</code> to select the frame, <code>false</code> to

     *            unselect it

     * @see {@link #isSelected()}, {@link #getSelected()}

     */

    public void setSelected(boolean b);

    /**

     * Returns an integer representing the type of selection applied to the

     * FFrame. Valid values are:

     * {@link IFFrame#NOSELECT},

     * {@link IFFrame#NO}, {@link IFFrame#N}, {@link IFFrame#NE},

     * {@link IFFrame#O}, {@link IFFrame#RECT}, {@link IFFrame#E},

     * {@link IFFrame#SO}, {@link IFFrame#S}, {@link IFFrame#SE}.

     * 

     * @see {@link #isSelected()}, {@link #setSelected(boolean)}

     * @return The type of selection that has been applied

     */

    public int getSelected();

    /**

     * Gets the selection status of the frame

     * 

     * @return <code>true</code> if the frame is selected,

     *    <code>false</code> otherwise

     * @see {@link #getSelected()}, {@link #setSelected(boolean)}

     */

    public boolean isSelected();

    /**

     * Checks whether the provided point is contained within the FFrame

     * rectangle.

     * 

     * @param p

     *            Point to compare

     * 

     * @return An integer representing the topologic relation of the point and

     * the frame rectangle. It can be one of:

     * {@link IFFrame#NOSELECT},

     * {@link IFFrame#NO}, {@link IFFrame#N}, {@link IFFrame#NE},

     * {@link IFFrame#O}, {@link IFFrame#RECT}, {@link IFFrame#E},

     * {@link IFFrame#SO}, {@link IFFrame#S}, {@link IFFrame#SE}.

     */

    public int getContains(Point2D p);

    /**

     * Devuelve el Cursor adecuado seg?n como est? contenido el punto, si es

     * para desplazamiento, o cambio de tama?o.

     * 

     * @param p

     *            punto a comprobar.

     * 

     * @return Cursor adecuado a la posici?n.

     */

    public Image getMapCursor(Point2D p);

    /**

     * Devuelve el rect?ngulo a partir del desplazamiento en el eje x y el

     * desplazamiento en el eje y.

     * 

     * @param difx

     *            desplazamiento sobre el eje x.

     * @param dify

     *            desplazamiento sobre el eje y.

     * 

     * @return rect?ngulo modificado en funci?n del desplazamiento realizado.

     */

    public Rectangle2D getMovieRect(int difx, int dify);

    /**

     * Dibuja un rect?ngulo de color gris, con el nombre en el centro y

     * escalado en forma de borrador.

     * 

     * @param g

     *            Graphics sobre el que se dibuja.

     */

    public void drawDraft(Graphics2D g);

    /**

     * Actualiza el BoundBox del FFrame a partir de su rect?ngulo en pixels y

     * la matriz de transformaci?n.

     * 

     * @param r

     *            Rect?ngulo.

     * @param at

     *            Matriz de transformaci?n.

     */

    public void updateRect(Rectangle2D r, AffineTransform at);

    /**

     * Devuelve true si el rect?ngulo primero es null o si es distinto de null

     * e intersecta.

     * 

     * @param rv

     *            Rect?ngulo

     * @param r

     *            Rect?ngulo

     * 

     * @return True si intersecta o es null.

     */

    public boolean intersects(Rectangle2D rv, Rectangle2D r);

    /**

     * Introduce el n?mero de FFrame en el que de que se trata.

     * 

     * @param i

     *            n?mero de FFrame

     */

    public void setNum(int i);

    /**

     * Devuelve el nombre que representa al tipo de FFrame.

     * 

     * @return nombre del elemento.

     */

    public String getNameFFrame();

    /**

     * Rellena el tag.

     * 

     * @param s

     *            valor del tag.

     */

    public void setTag(String s);

    /**

     * Devuelve el valor del tag.

     * 

     * @return String del valor del tag.

     */

    public String getTag();

    /**

     * Dibuja el s?mbolo que indica que el FFrame contiene un tag.

     * 

     * @param g

     *            Graphics sobre el que dibujar.

     */

    public void drawSymbolTag(Graphics2D g);

    /**

     * Sets the rotation of the frame, measured in arc degrees

     * 

     * @param rotation

     *            Rotation to apply to the frame

     */

    public void setRotation(double rotation);

    /**

     * Gets the rotation of the frame, measured in arc degrees

     * 

     * @return Rotation of the frame

     */

    public double getRotation();

    /**

     * Devuelve el nivel al que se encuentra el FFrame en el Layout.

     * 

     * @return nivel.

     */

    public int getLevel();

    /**

     * Inserta el nivel de dibujado del FFrame respecto del resto de fframes

     * del Layout.

     * 

     * @param l

     *            nivel.

     */

    public void setLevel(int l);

    public Rectangle2D getLastMoveRect();

    public void setFrameFactory(FrameFactory frameFactory);

    public FrameFactory getFrameFactory();

        public Document getDocument();

        public void setDocument(Document document);

        public LayoutContext getLayoutContext();

        public void setLayoutContext(LayoutContext layoutContext);

        /**

         * This method is called when the FFrame has been

         * removed from the Layout

         */

        public void frameRemoved();

        /**

         * This method is called when the FFrame has been

         * added to the Layout

         */

        public void frameAdded();

}