| gvSIG desktop 1

package com.iver.cit.gvsig.fmap.rendering.styling;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.print.attribute.PrintRequestAttributeSet;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.values.NullValue;

import com.hardcode.gdbms.engine.values.NumericValue;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException;

import com.iver.cit.gvsig.exceptions.visitors.VisitorException;

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

import com.iver.cit.gvsig.fmap.core.FPoint2D;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.symbols.SimpleTextSymbol;

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

import com.iver.cit.gvsig.fmap.core.v02.FLabel;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.ReadableVectorial;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.Cancellable;

/**

 * LabelingStrategy used when the user wants to use label sizes, rotations, etc. from

 * the values included in fields of the datasource's table

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 *

 */

public class AttrInTableLabeling implements ILabelingStrategy {

        public static final double MIN_TEXT_SIZE = 3;

        private ILabelingMethod method = new DefaultLabelingMethod();

        private IZoomConstraints zoom;

        private int idTextField;

        private int idHeightField;

        private int idRotationField;

        private FLyrVect layer;

        private double unitFactor = 1D;

        private double fixedSize;

        private boolean useFixedSize;

        public ILabelingMethod getLabelingMethod() {

                return this.method;

        }

        public void setLabelingMethod(ILabelingMethod method) {

                this.method = method;

        }

        public IPlacementConstraints getPlacementConstraints() {

                return null; // (automatically handled by the driver)

        }

        public void setPlacementConstraints(IPlacementConstraints constraints) {

                // nothing

        }

        public IZoomConstraints getZoomConstraints() {

                return zoom;

        }

        public void setZoomConstraints(IZoomConstraints constraints) {

                this.zoom = constraints;

        }

        public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort, Cancellable cancel)

        throws ReadDriverException {

                double scale = viewPort.getScale();

                double fontScaleFactor = FConstant.FONT_HEIGHT_SCALE_FACTOR;

                if (unitFactor >= 0) {

                        // distance units

                        fontScaleFactor *= Math.abs(

                                        viewPort.getAffineTransform().getScaleY()*unitFactor

                        );

                }

                LabelClass lClass = method.getDefaultLabelClass();

                SimpleTextSymbol sym = (SimpleTextSymbol) lClass.getLabelSymbol();

                if (zoom==null ||

                        ( zoom.isUserDefined() && (scale >= zoom.getMaxScale())

                        && (scale <= zoom.getMinScale()) ) ) {

                        try {

                                // limit the labeling to the visible extent

                                FBitSet bs = layer.queryByRect(viewPort.getAdjustedExtent());

                                ReadableVectorial source = layer.getSource();

                                SelectableDataSource recordSet = source.getRecordset();

                                for(int i=bs.nextSetBit(0); i>=0; i=bs.nextSetBit(i+1)) {

                                        Value[] vv = recordSet.getRow(i);

                                        double size;

                                        if (useFixedSize){

                                                // uses fixed size

                                                size = fixedSize * fontScaleFactor;

                                        } else if (idHeightField != -1) {

                                                // text size is defined in the table

                                                try {

                                                        size = ((NumericValue) vv[idHeightField]).doubleValue() * fontScaleFactor;

                                                } catch (ClassCastException ccEx) {

                                                        if (!NullValue.class.equals(vv[idHeightField].getClass())) {

                                                                throw new ReadDriverException("Unknown", ccEx);

                                                        }

                                                        // a null value

                                                        Logger.getAnonymousLogger().

                                                                warning("Null text height value for text '"+vv[idTextField].toString()+"'");

                                                        continue;

                                                }

                                        } else {

                                                // otherwise will use the size in the symbol

                                                size = sym.getFont().getSize();

                                        }

                                        if (size <= MIN_TEXT_SIZE) {

                                                // label is too small to be readable, will be skipped

                                                // this speeds up the rendering in wider zooms

                                                continue;

                                        }

                                        sym.setFontSize(size);

                                        double rotation = 0D;

                                        if (idRotationField!= -1) {

                                                // text rotation is defined in the table

                                                rotation = -Math.toRadians(((NumericValue) vv[idRotationField]).doubleValue());

                                        }

                                        IGeometry geom = source.getShape(i);

                                        sym.setText(vv[idTextField].toString());

                                        sym.setRotation(rotation);

                                        FLabel[] aux = geom.createLabels(0, true);

                                        g.setColor(Color.GREEN);

                                        for (int j = 0; j < aux.length; j++) {

                                                FPoint2D p = new FPoint2D(aux[j].getOrig());

                                                FPoint2D p2 = (FPoint2D)p.cloneFShape();

                                                p2.transform(viewPort.getAffineTransform());

                                                FShape s = sym.getTextWrappingShape(g, p2);

                                                sym.draw(g, viewPort.getAffineTransform(), p);

                                                g.draw(s);

                                        }

                                }

                        } catch (VisitorException e) {

                                Logger.getAnonymousLogger().log(Level.SEVERE, "Could not get the layer extent.\n" +

                                                e.getMessage());

                        } catch (ExpansionFileReadException e) {

                                Logger.getAnonymousLogger().log(Level.SEVERE, "Could not draw annotation in the layer" +

                                                "\""+layer.getName()+"\".\nIs the layer being edited?.\n"+e.getMessage());

                        } catch (ReadDriverException e) {

                                Logger.getAnonymousLogger().log(Level.SEVERE, "Could not draw annotation in the layer.\n" +

                                                e.getMessage());

                        }

                }

        }

        public void setLayer(FLyrVect lyrVect) {

                this.layer = lyrVect;

        }

        public String getClassName() {

                return getClass().getName();

        }

        public XMLEntity getXMLEntity() {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("className", getClassName());

                try {

                        xml.putProperty("HeightField", getHeightField());

                } catch (ReadDriverException e) {

                        Logger.getAnonymousLogger().log(Level.SEVERE, "Acessing TextHeight field.\n"+e.getMessage());

                }

                try {

                        xml.putProperty("TextField", getTextField());

                } catch (ReadDriverException e) {

                        Logger.getAnonymousLogger().log(Level.SEVERE, "Acessing TextField field.\n"+e.getMessage());

                }

                try {

                        xml.putProperty("RotationField", getRotationField());

                } catch (ReadDriverException e) {

                        Logger.getAnonymousLogger().log(Level.SEVERE, "Acessing RotationField field.\n"+e.getMessage());

                }

                xml.putProperty("UnitFactor", unitFactor);

                return xml;

        }

        public String getRotationField() throws ReadDriverException {

                if (idRotationField == -1) return null;

                return ((SelectableDataSource) layer.getRecordset())

                                .getFieldName(idRotationField);

        }

        public int getRotationFieldId() {

                return idRotationField;

        }

        public void setRotationFieldId(int fieldId) {

                this.idRotationField = fieldId;

        }

        public String getTextField() throws ReadDriverException {

                if (idTextField == -1) return null;

                return ((SelectableDataSource) layer.getRecordset())

                                .getFieldName(idTextField);

        }

        public int getTextFieldId() {

                return idTextField;

        }

        public void setTextFieldId(int fieldId) {

                this.idTextField = fieldId;

        }

        public String getHeightField() throws ReadDriverException {

                if (idHeightField == -1) return null;

                return ((SelectableDataSource) layer.getRecordset())

                                .getFieldName(idHeightField);

        }

        public int getHeightFieldId() {

                return idHeightField;

        }

        public void setHeightFieldId(int fieldId) {

                this.idHeightField = fieldId;

        }

        public void setXMLEntity(XMLEntity xml) {

                if (xml.contains("TextField" ))

                        setTextField(xml.getStringProperty("TextField"));

                if (xml.contains("HeightField"))

                        setHeightField("HeightField");

                if (xml.contains("RotationField"))

                        setRotationField("RotationField");

                if (xml.contains("UnitFactor"))

                        setUnitFactor(xml.getDoubleProperty("UnitFactor"));

        }

        public void setTextField(String textFieldName) {

                try {

                        idTextField = ((SelectableDataSource) layer.getRecordset())

                                                                .getFieldIndexByName(textFieldName);

                } catch (ReadDriverException e) {

                        Logger.getAnonymousLogger().log(Level.SEVERE, e.getMessage());

                }

        }

        public void setRotationField(String rotationFieldName) {

                try {

                        idRotationField = ((SelectableDataSource) layer.getRecordset())

                                                                .getFieldIndexByName(rotationFieldName);

                } catch (ReadDriverException e) {

                        Logger.getAnonymousLogger().log(Level.SEVERE, e.getMessage());

                }

        }

        /**

         * Sets the field that contains the size of the text. The size is computed

         * in meters. To use any other unit, call setUnit(int) with the scale factor from meters

         * (for centimeters, call <b>setUnitFactor(0.01))</b>.

         * @param heightFieldName

         */

        public void setHeightField(String heightFieldName) {

                try {

                        idHeightField = ((SelectableDataSource) layer.getRecordset())

                                                                .getFieldIndexByName(heightFieldName);

                } catch (ReadDriverException e) {

                        Logger.getAnonymousLogger().log(Level.SEVERE, e.getMessage());

                }

        }

        public void setUnitFactor(double unitFactor) {

                this.unitFactor = unitFactor;

        }

        public double getUnitFactor() {

                return unitFactor;

        }

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel, PrintRequestAttributeSet properties) throws ReadDriverException {

                draw(null, g, viewPort, cancel);

        }

        public void setUsesFixedSize(boolean b) {

                useFixedSize = b;

        }

        public boolean usesFixedSize() {

                return useFixedSize;

        }

        public double getFixedSize() {

                return fixedSize;

        }

        public void setFixedSize(double fixedSize) {

                this.fixedSize = fixedSize;

        }

}