Application: gvSIG desktop

/*

 * Created on 20-feb-2004

 *

 * To change the template for this generated file go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

package com.iver.cit.gvsig.gui.layout.fframes;

import com.iver.cit.gvsig.fmap.FConstant;

import com.iver.cit.gvsig.fmap.FMap;

import com.iver.cit.gvsig.gui.layout.Attributes;

import com.iver.cit.gvsig.gui.layout.FLayoutUtilities;

import com.iver.cit.gvsig.gui.layout.Layout;

import com.iver.cit.gvsig.project.Project;

import com.iver.cit.gvsig.project.castor.View;

import com.iver.utiles.XMLEntity;

import org.apache.log4j.Logger;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

/**

 * FFrame para introducir una barra de escala en el Layout.

 *

 * @author Vicente Caballero Navarro

 */

public class FFrameScaleBar extends FFrame {

    private static Logger logger = Logger.getLogger(FFrameView.class.getName());

    private static final int NUMERO = 0;

    private static final int BARRA1 = 1;

    private static final int BARRA2 = 2;

    private static final int BARRA3 = 3;

    private static final int BARRA4 = 4;

    private static final int DIFL = 25;

    private static final int DIFR = 4;

    private static final int DIFUP = 4;

    private boolean m_bIntervalSet = true;

    private int m_style = NUMERO;

    private int m_units = 1; //Metros

    private int m_mapUnits = 1; //unidad de medida de la vista(Metros)

    private long m_interval = 1;

    private int m_numinterval = 3;

    private int m_numleft = 2;

    private double m_height = 0;

    //private FMap m_fmap = null;

    private FFrameView fframeview = null;

    private double m_typeUnit = Attributes.CHANGE[1]; //METROS;

    private String m_nameUnit = null;

    private double m_numUnit = 0;

    private double m_dif = 1;

    private int m_hasleft = 0;

    private Font m_f = new Font("Monospaced", Font.PLAIN, 9);

        private int num=0;

    private View view = null;

    /**

     * Creates a new FFrameScaleBar object.

     */

    public FFrameScaleBar() {

    }

    public void setFFrameView(FFrameView f) {

        fframeview = f;

        view = f.getView();

        setMapUnits(f.getMapUnits());

        //setFMap(f.getFMap());

        setHeight(f.getBoundBox().height);

        /*if (f.getTypeScale()!=0){

           isFixed=true;

           }else{

                   isFixed=false;

           }

         */

    }

    /**

     * Devuelve el FFrameView que se representa con la escala.

     *

     * @return FFrameView a representar.

     */

    public FFrameView getFFrameView() {

        return fframeview;

    }

    /**

     * Pone el FMap de la vista que representa a la escala.

     *

     * @return DOCUMENT ME!

     */

    /*  public void setFMap(FMap map) {

       m_fmap = map;

       }

     */

    /**

     * Devuelve el FMap de la vista que se representa en la escala.

     *

     * @return FMap.

     */

    public FMap getFMap() {

        return fframeview.getFMap();

    }

    /**

     * Rellenar el estilo de barra de escala que se elige.

     *

     * @param s entero que representa el tipo de barra seleccionada.

     */

    public void setStyle(int s) {

        m_style = s;

    }

    /**

     * Devuelve el tipo de escala a dibujar.

     *

     * @return entero.

     */

    public int getStyle() {

        return m_style;

    }

    /**

     * Rellenar el tama?o de un intervalo.

     *

     * @param s tama?o de un intervalo.

     */

    public void setInterval(long s) {

        m_interval = s;

        if (m_numleft != 0) {

            m_hasleft = 1;

        }

        Rectangle2D.Double rect = getBoundBox();

        double difUp = (rect.height / DIFUP);

        double difL = (rect.width / DIFL);

        double difR = (rect.width / DIFR);

        double n = (rect.width - difL - difR);

        m_numUnit = (m_interval * m_typeUnit) / getScaleView();

        m_numinterval = (int) (n / m_numUnit) - m_hasleft;

        m_dif = 1;

    }

    /**

     * Devuelve el valor del intervalo.

     *

     * @return long.

     */

    public long obtainInterval() {

        Rectangle2D.Double rect = getBoundBox();

        if (m_numleft != 0) {

            m_hasleft = 1;

        }

        double difUp = (rect.height / DIFUP);

        double difL = (rect.width / DIFL);

        double difR = (rect.width / DIFR);

        double n = (rect.width - difL - difR);

        m_numUnit = n / (m_numinterval + m_hasleft);

        double scaleXunit = (m_numUnit * getScaleView()) / m_typeUnit;

        m_dif = getExact(scaleXunit);

        m_numUnit = m_numUnit * m_dif;

        m_interval = (long) (scaleXunit * m_dif);

        return m_interval;

    }

    /**

     * Rellenar el n?mero de intervalos.

     *

     * @param s n?mero de intervalos.

     */

    public void setNumInterval(int s) {

        m_numinterval = s;

        if (m_numleft != 0) {

            m_hasleft = 1;

        }

        Rectangle2D.Double rect = getBoundBox();

        double difUp = (rect.height / DIFUP);

        double difL = (rect.width / DIFL);

        double difR = (rect.width / DIFR);

        double n = (rect.width - difL - difR);

        m_numUnit = n / (m_numinterval + m_hasleft);

        double scaleXunit = (m_numUnit * getScaleView()) / m_typeUnit;

        m_dif = getExact(scaleXunit);

        m_numUnit = m_numUnit * m_dif;

        m_interval = (long) (scaleXunit * m_dif);

    }

    /**

     * Devuelve el n?mero de intervalos por encima del cero.

     *

     * @return entero.

     */

    public int getNumInterval() {

        return m_numinterval;

    }

    /**

     * Rellenar el n?mero de intervalos a la izquierda del cero.

     *

     * @param s n?mero de intervalos a la izquierda.

     */

    public void setNumLeft(int s) {

        m_numleft = s;

    }

    /**

     * Devuelve el n?mero de intervalos  en los que se quiere particionar el

     * intervalo  que se queda por debajo del cero.

     *

     * @return entero.

     */

    public int getNumLeft() {

        return m_numleft;

    }

    /**

     * Seleccionar ,a true, si se quiere o, a false, si no mantener los

     * intervalos.

     *

     * @param b boolean a true si se quiere mantener los intervalos.

     */

    public void setIntervalSet(boolean b) {

        m_bIntervalSet = b;

    }

    /**

     * Seleccionar la unidad de medida a representar en la barra de escala.

     *

     * @param s entero que representa la unidad de medida que se selecciona.

     */

    public void setUnits(int s) {

        m_units = s;

        m_typeUnit = Attributes.CHANGE[s];

        m_nameUnit = FConstant.NAMES[s];

    }

    /**

     * Devuelve un entero que representa el tipo de unidades que representamos.

     *

     * @return entero.

     */

    public int getUnits() {

        return m_units;

    }

    /**

     * Devuelve el long que representa el intervalo.

     *

     * @return Intervalo.

     */

    public long getInterval() {

        return m_interval;

    }

    /**

     * Rellenar el rect?ngulo de la vista sobre la que se obtiene la escala.

     *

     * @param d Rect?ngulo.

     */

    public void setHeight(double d) {

        m_height = d;

    }

    /**

     * Rellena la unidad de medida en la que est? la vista.

     *

     * @param i entero que representa la unidad de medida de la vista.

     */

    public void setMapUnits(int i) {

        m_mapUnits = i;

    }

    /*public void setIsFixed(boolean b){

       isFixed=b;

       }*/

    /*public void setScaleView(long l){

       m_scaleView=l;

       }

     */

    /**

     * Devuelve la escala de la vista seleccionada.

     *

     * @return la escala de la vista.

     */

    private long getScaleView() {

        return fframeview.getScale();

        /*        if (isFixed){

           return m_scaleView;

           }

           return FLayoutUtilities.getScaleView(m_fmap, m_height);

         */

    }

    /**

     * 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 rv rect?ngulo sobre el que hacer un clip.

     * @param imgBase DOCUMENT ME!

     */

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

        BufferedImage imgBase) {

        Rectangle2D.Double r = getBoundingBox(at);

        if (intersects(rv, r)) {

            if (fframeview==null || fframeview.getFMap() == null) {

                drawEmpty(g);

            } else {

                switch (m_style) {

                    case (NUMERO):

                        double scalex = r.getWidth() / (8);

                        g.setColor(Color.black);

                        if (m_f!=null){

                                m_f = new Font(m_f.getFontName(), m_f.getStyle(),

                                (int) (scalex));

                        g.setFont(m_f);

                        }

                        g.drawString(" 1:" + getScaleView(), (int) r.x,

                            (int) (r.y + (r.height / 2)));

                        //System.out.println("Escala real  " + getScaleView());

                        break;

                    case (BARRA1):

                    case (BARRA2):

                    case (BARRA3):

                    case (BARRA4):

                        drawBar(m_style, g, at);

                        break;

                }

            }

        }

    }

    /**

     * Rellena con el rect?ngulo que se pasa como par?metro el boundBox(en

     * cent?metros) del fframe del cual con una transformaci?n se podr?

     * calcular el BoundingBox (en pixels).

     *

     * @param r Rect?ngulo en cent?metros.

     */

    public void setBoundBox(Rectangle2D.Double r) {

        if ((m_numUnit < 1) || (fframeview.getFMap() == null)) {

            super.setBoundBox(r);

            return;

        }

        double difL = (r.width / DIFL);

        double difR = (r.width / DIFR);

        if (m_bIntervalSet) {

            m_numinterval = (int) (((r.width - (difL + difR)) * m_dif) / m_numUnit) -

                m_hasleft;

        }

        if (m_numinterval < 1) {

            m_numinterval = 1;

            r.width = ((m_numinterval + m_hasleft) * m_numUnit) + difL + difR;

        }

        getBoundBox().setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());

    }

    /**

     * Dibuja sobre el Graphics la escala gr?fica.

     *

     * @param type Tipo de barra.

     * @param g Graphics sobre el que dibujar.

     * @param at Matriz de transformaci?n.

     */

    private void drawBar(int type, Graphics2D g, AffineTransform at) {

        Rectangle2D.Double rect = getBoundBox();

        Rectangle2D.Double r = getBoundingBox(at);

        double numleft = m_numleft;

        double difUp = (rect.height / DIFUP);

        double difL = (rect.width / DIFL);

        double difR = (rect.width / DIFR);

        double n = (rect.width - difL - difR);

        //double scalex = r.getWidth() / (8);

        if (!m_bIntervalSet) {

            m_numUnit = n / (m_numinterval + m_hasleft);

            double scaleXunit = (m_numUnit * getScaleView()) / m_typeUnit;

            m_dif = getExact(scaleXunit);

            m_numUnit = m_numUnit * m_dif;

            m_interval = (long) (scaleXunit * m_dif);

        }

        if (m_bIntervalSet) {

            m_numUnit = (m_interval * m_typeUnit) / (m_dif * getScaleView());

            m_numinterval = (int) (((rect.width - (difL + difR)) * m_dif) / m_numUnit) -

                m_hasleft;

        }

        if (m_numinterval < 1) {

            m_numinterval = 1;

            rect.width = ((m_numinterval + m_hasleft) * m_numUnit) + difL +

                difR;

        }

        double h = 0;

        if (type == BARRA1) {

            h = (rect.height - (difUp * 2));

        } else if ((type == BARRA2) || (type == BARRA3)) {

            h = (rect.height - (difUp * 2)) / 2;

        }

        //Dibujar el rect?ngulo que bordea todo.

        Rectangle2D.Double rectotal = (FLayoutUtilities.fromSheetRect(new Rectangle2D.Double((rect.x +

                    difL), (rect.y + difUp),

                    m_numUnit * (m_hasleft + m_numinterval), h), at));

        g.setColor(Color.white);

        g.fillRect((int) rectotal.x, (int) rectotal.y, (int) (rectotal.width),

            (int) rectotal.height);

        g.setColor(Color.black);

        m_f = new Font(m_f.getFontName(), m_f.getStyle(),

                (int) ((r.getWidth() / 8) / (m_numinterval + m_hasleft)));

        g.setFont(m_f);

        //Derecha del cero

        for (int i = 0; i < m_numinterval; i++) {

            Rectangle2D.Double recder = FLayoutUtilities.fromSheetRect(new Rectangle2D.Double((rect.x +

                        (difL) + ((m_numUnit * i) + (m_hasleft * m_numUnit))),

                        (rect.y + (difUp)), (m_numUnit),

                        (rect.height - (difUp * 2)) / 2), at);

            Rectangle2D.Double recderB = FLayoutUtilities.fromSheetRect(new Rectangle2D.Double((rect.x +

                        (difL) + ((m_numUnit * i) + (m_hasleft * m_numUnit))),

                        (rect.y + difUp) + ((rect.height - (difUp * 2)) / 2),

                        (m_numUnit), ((rect.height - (difUp * 2)) / 2)), at);

            //                        Correcci?n cuando la altura en pixels del rectangulo es impar.

            rectotal.y = recder.y;

            recderB.height = rectotal.height - recder.height + 0.5;

            if (i == (m_numinterval - 1)) {

                if (recder.getMaxX() != rectotal.getMaxX()) {

                    recder.width = (recder.width + recder.getMaxX()) -

                        rectotal.getMaxX();

                }

                if (recderB.getMaxX() != rectotal.getMaxX()) {

                    recderB.width = (recderB.width + recderB.getMaxX()) -

                        rectotal.getMaxX();

                }

            }

            if (recderB.getMaxY() != rectotal.getMaxY()) {

                recderB.height = (recderB.height + recderB.getMaxY()) -

                    rectotal.getMaxY();

            }

            if ((m_numleft % 2) == 0) {

                if ((i % 2) == 0) {

                    if ((type == BARRA1) || (type == BARRA2)) {

                        fillRect(g, recder);

                    } else if (type == BARRA3) {

                        g.drawRect((int) recder.x, (int) recder.y,

                            (int) recder.width, (int) recder.height);

                    }

                } else if (type == BARRA1) {

                    fillRect(g, recderB);

                }

            } else {

                if ((i % 2) != 0) {

                    if ((type == BARRA1) || (type == BARRA2)) {

                        fillRect(g, recder);

                    } else if (type == BARRA3) {

                        g.drawRect((int) recderB.x, (int) recderB.y,

                            (int) recderB.width, (int) recderB.height);

                    }

                } else if (type == BARRA1) {

                    fillRect(g, recderB);

                }

            }

            long inter = (long) (m_interval * i);

            Long l = new Long(inter);

            int pos = ((int) (r.getWidth() / (m_numinterval + m_hasleft)) * l.toString()

                                                                             .length()) / 24;

            Point2D.Double p = new Point2D.Double(recder.x - pos, recder.y);

            drawInterval(g, inter, p);

        }

        //?ltimo n?mero a dibujar.

        long inter = (long) (m_interval * m_numinterval);

        Long l = new Long(inter);

        int pos = ((int) (r.getWidth() / (m_numinterval + m_hasleft)) * l.toString()

                                                                         .length()) / 24;

        Point2D.Double p = new Point2D.Double(rectotal.getMaxX() - pos,

                rectotal.y);

        drawInterval(g, inter, p);

        //Izquierda del cero

        for (int i = 0; i < m_numleft; i++) {

            Rectangle2D.Double reciz = FLayoutUtilities.fromSheetRect(new Rectangle2D.Double((rect.x +

                        difL + ((m_numUnit / m_numleft) * i)),

                        (rect.y + difUp), (m_numUnit / numleft),

                        (rect.height - (difUp * 2)) / 2), at);

            Rectangle2D.Double recizB = FLayoutUtilities.fromSheetRect(new Rectangle2D.Double((rect.x +

                        difL + ((m_numUnit / m_numleft) * i)),

                        (rect.y + difUp) + ((rect.height - (difUp * 2)) / 2),

                        (m_numUnit / numleft), ((rect.height - (difUp * 2)) / 2)),

                    at);

            //Correcci?n cuando la altura en pixels del rectangulo es impar.

            reciz.y = rectotal.y;

            recizB.height = rectotal.height - reciz.height + 0.5;

            if ((i % 2) == 0) {

                if ((type == BARRA1) || (type == BARRA2)) {

                    fillRect(g, reciz);

                } else if (type == BARRA3) {

                    g.drawRect((int) reciz.x, (int) reciz.y, (int) reciz.width,

                        (int) reciz.height);

                }

            } else if (type == BARRA1) {

                fillRect(g, recizB);

            }

        }

        if (m_numleft > 0) {

            inter = (long) (m_interval);

            l = new Long(inter);

            pos = ((int) (r.getWidth() / (m_numinterval + m_hasleft)) * l.toString()

                                                                         .length()) / 24;

            Point2D.Double p1 = new Point2D.Double(rectotal.x - pos, rectotal.y);

            drawInterval(g, inter, p1);

        }

        //Se dibuja el rect?ngulo que bordea toda la escala gr?fica.

        g.drawRect((int) rectotal.x, (int) rectotal.y, (int) (rectotal.width),

            (int) rectotal.height);

        //Nombre de las unidades utilizadas.

        p = new Point2D.Double(rect.getMaxX() - difR + 0.1,

                (rect.getMaxY() - difUp));

        p = FLayoutUtilities.fromSheetPoint(p, at);

        g.drawString(m_nameUnit, (int) p.x, (int) p.y);

    }

    /**

     * Rellena la fuente utilizada para dibujar los intervalos y la unidad de

     * medida utilizada.

     *

     * @param f fuente a utilizar.

     */

    public void setFont(Font f) {

        m_f = f;

    }

    /**

     * Devuelve la fuente con la que se est? dibujando sobre el graphics.

     *

     * @return fuente utilizada.

     */

    public Font getFont() {

        return new Font(m_f.getFontName(), m_f.getStyle(), 9);

    }

    /**

     * Devuelve si el intervalo es variable o si por el contrario es fijo.

     *

     * @return true si el intervalo es fijo.

     */

    public boolean isbIntervalSet() {

        return m_bIntervalSet;

    }

    /**

     * Especificar si el intervalo se debe mantener o es variable.

     *

     * @param b si se quiere mantener el intervalo especificado.

     */

    public void setbIntervalSet(boolean b) {

        m_bIntervalSet = b;

    }

    /**

     * Devuelve el porcentaje por el cual hay que multiplicar  el intervalo

     * para conseguir un intervalo redondeado,  de momento con dos cifras

     * significativas(NUM=1).

     *

     * @param total intervalo.

     *

     * @return Porcentaje

     */

    private double getExact(double total) {

        int NUM = 1;

        double t = 0;

        double dif = 1;

        Double d = new Double(total);

        Long l = new Long(d.longValue());

        int num = l.toString().length();

        t = ((long) (total / Math.pow(10, num - NUM)) * Math.pow(10, num - NUM));

        dif = t / total;

        return dif;

    }

    /**

     * Rellena un rect?ngulo.

     *

     * @param g Graphics sobre el que dibujar.

     * @param r Rect?ngulo a rellenar.

     */

    private void fillRect(Graphics2D g, Rectangle2D.Double r) {

        g.fillRect((int) r.x, (int) r.y, (int) r.width, (int) r.height);

    }

    /**

     * Escribe sobre el Graphics y en la posici?n indicada el tama?o del

     * intervalo.

     *

     * @param g Graphics sobre el que dibujar.

     * @param inter Valor del intervalo.

     * @param p Punto donde dibujarlo.

     */

    private void drawInterval(Graphics2D g, long inter, Point2D.Double p) {

        Long l = new Long(inter);

        g.drawString(l.toString(), (int) p.x, (int) p.y);

    }

    /**

     * @see com.iver.cit.gvsig.gui.layout.fframes.IFFrame#getXMLEntity()

     */

    public XMLEntity getXMLEntity() {

        XMLEntity xml = super.getXMLEntity();

        xml.putProperty("type", Layout.RECTANGLESCALEBAR);

        xml.putProperty("m_bIntervalSet", m_bIntervalSet);

        xml.putProperty("m_dif", m_dif);

        xml.putProperty("m_hasleft", m_hasleft);

        xml.putProperty("m_nameUnit", m_nameUnit);

        xml.putProperty("m_numUnit", m_numUnit);

        xml.putProperty("m_height", m_height);

        xml.putProperty("m_style", m_style);

        xml.putProperty("m_units", m_units);

        xml.putProperty("m_interval", m_interval);

        xml.putProperty("m_numinterval", m_numinterval);

        xml.putProperty("m_numleft", m_numleft);

        xml.putProperty("m_mapUnits", m_mapUnits);

        xml.putProperty("fontName", m_f.getFontName());

        xml.putProperty("fontStyle", m_f.getStyle());

        /*

           ProjectExtension pe = (ProjectExtension) App.instance.getPc()

                                                                .getExtension(ProjectExtension.class);

           ArrayList views = pe.getProject().getViews();

           boolean hasIndex = false;

           for (int i = 0; i < views.size(); i++) {

               if (m_fmap == ((ProjectView) views.get(i)).getMapContext()) {

                   xml.putProperty("indice", i);

                   hasIndex = true;

               }

           }

           if (!hasIndex) {

               xml.putProperty("indice", -1);

           }

         */

        xml.addChild(fframeview.getXMLEntity());

        return xml;

    }

    /**

     * Crea un Objeto de esta clase a partir de la informaci?n del XMLEntity.

     *

     * @param xml XMLEntity

     * @param p DOCUMENT ME!

     *

     * @return Objeto de esta clase.

     */

    public static FFrameScaleBar createFFrameScaleBar(XMLEntity xml, Project p) {

        FFrameScaleBar fframe = new FFrameScaleBar();

        if (xml.getIntProperty("m_Selected") != 0) {

            fframe.setSelected(true);

        } else {

            fframe.setSelected(false);

        }

        fframe.m_bIntervalSet = xml.getBooleanProperty("m_bIntervalSet");

        fframe.m_dif = xml.getDoubleProperty("m_dif");

        fframe.m_hasleft = xml.getIntProperty("m_hasleft");

        fframe.m_nameUnit = xml.getStringProperty("m_nameUnit");

        fframe.m_numUnit = xml.getDoubleProperty("m_numUnit");

        fframe.m_height = xml.getDoubleProperty("m_height");

        fframe.m_style = xml.getIntProperty("m_style");

        fframe.m_interval = xml.getLongProperty("m_interval");

        fframe.m_numinterval = xml.getIntProperty("m_numinterval");

        fframe.m_numleft = xml.getIntProperty("m_numleft");

        fframe.m_mapUnits = xml.getIntProperty("m_mapUnits");

        fframe.m_f = new Font(xml.getStringProperty("fontName"),

                xml.getIntProperty("fontStyle"), 9);

        /*

           int indice = xml.getIntProperty("indice");

           if (indice != -1) {

               ProjectView view = (ProjectView) p.getViews().get(indice);

               fframe.m_fmap = view.getMapContext();

           }

         */

        fframe.setFFrameView((FFrameView) FFrameView.createFFrame(xml.getChild(

                    0), p));

        return fframe;

    }

        /**

         * @see com.iver.cit.gvsig.gui.layout.fframes.IFFrame#updateNum()

         */

        public void updateNum() {

                num=Layout.numScaleBar++;

        }

public int getNum(){

           return num;

   }

}