| gvSIG desktop 1

package org.gvsig.fmap.mapcontext.rendering.legend.styling;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.Vector;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.PrintQuality;

import org.gvsig.fmap.core.geometries.IGeometry;

import org.gvsig.fmap.core.geometries.utils.FConstant;

import org.gvsig.fmap.core.geometries.utils.FLabel;

import org.gvsig.fmap.core.shapes.FPoint2D;

import org.gvsig.fmap.core.shapes.FShape;

import org.gvsig.fmap.datasources.SelectableDataSource;

import org.gvsig.fmap.drivers.exceptions.ExpansionFileReadException;

import org.gvsig.fmap.drivers.exceptions.VisitorException;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.FBitSet;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.ReadableVectorial;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

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

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

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

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.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 AttrInTableLabelingStrategy implements ILabelingStrategy, CartographicSupport {

        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 int unit = -1; //(pixel)

        private boolean useFixedSize;

        private int referenceSystem;

        private boolean isPrinting;

        private double  printDPI;

        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, double dpi)

        throws ReadDriverException {

                double scale = viewPort.getScale();

                double fontScaleFactor = FConstant.FONT_HEIGHT_SCALE_FACTOR;

                LabelClass lClass = method.getDefaultLabelClass();

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

                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 && !cancel.isCanceled(); 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();

                                        }

                                        size = CartographicSupportToolkit.

                                                                getCartographicLength(this,

                                                                                                          size,

                                                                                                          viewPort,

                                                                                                          MapContext.getScreenDPI());

//                                                                                                          dpi);

//                                                                toScreenUnitYAxis(this,

//                                                                                                  size,

//                                                                                                  viewPort

//                                                                                                 );

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

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

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

                                                p.transform(viewPort.getAffineTransform());

                                                sym.draw(g, null, p, cancel);

                                        }

                                }

                        } 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 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("Unit", unit);

                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"))

                        setUnit(xml.getIntProperty("Unit"));

        }

        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) {

                if (rotationFieldName != null) {

                        try {

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

                                        .getFieldIndexByName(rotationFieldName);

                        } catch (ReadDriverException e) {

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

                        }

                } else idRotationField = -1;

        }

        /**

         * 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) {

                if (heightFieldName != null) {

                        try {

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

                                .getFieldIndexByName(heightFieldName);

                        } catch (ReadDriverException e) {

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

                        }

                } else idHeightField = -1;

        }

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

                isPrinting = true;

                PrintQuality resolution=(PrintQuality)properties.get(PrintQuality.class);

                if (resolution.equals(PrintQuality.NORMAL)){

                        printDPI=300;

                } else if (resolution.equals(PrintQuality.HIGH)) {

                        printDPI=600;

                } else if (resolution.equals(PrintQuality.DRAFT)) {

                        printDPI=72;

                }

                draw(null, g, viewPort, cancel, printDPI);

                isPrinting = false;

        }

        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;

        }

        public void setUnit(int unitIndex) {

                unit = unitIndex;

        }

        public int getUnit() {

                return unit;

        }

        public String[] getUsedFields() {

                Vector v = new Vector();

                try {

                        if (getHeightField()!=null) v.add(getHeightField());

                        if (getRotationField()!=null) v.add(getRotationField());

                        if (getTextField()!=null) v.add(getTextField());

                        if (getHeightField()!=null) v.add(getHeightField());

                } catch (ReadDriverException e) {

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

                }

                return (String[]) v.toArray(new String[v.size()]);

        }

        public int getReferenceSystem() {

                return referenceSystem;

        }

        public void setReferenceSystem(int referenceSystem) {

                this.referenceSystem = referenceSystem;

        }

        public double toCartographicSize(ViewPort viewPort, double dpi, FShape shp) {

                // not required here

                throw new Error("Undefined in this context");

        }

        public void setCartographicSize(double cartographicSize, FShape shp) {

                // not required here

                throw new Error("Undefined in this context");

        }

        public double getCartographicSize(ViewPort viewPort, double dpi, FShape shp) {

                // not required here

                throw new Error("Undefined in this context");

        }

        public void setLayer(FLayer layer) {

                this.layer = (FLyrVect) layer;

        }

        public boolean shouldDrawLabels(double scale) {

                return layer.isWithinScale(scale);

        }

}