| gvSIG desktop 1

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

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.util.Iterator;

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.data.ReadException;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureCollection;

import org.gvsig.data.vectorial.FeatureType;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Point2D;

import org.gvsig.fmap.geometry.operation.CreateLabels;

import org.gvsig.fmap.geometry.operation.CreateLabelsOperationContext;

import org.gvsig.fmap.geometry.utils.FConstant;

import org.gvsig.fmap.geometry.utils.FLabel;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.NullValue;

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.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 ReadException {

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

                                FeatureCollection collection=(FeatureCollection)layer.getFeatureStore().getDataCollection(new String[0],null,null);

//                                ReadableVectorial source = layer.getSource();

//                                SelectableDataSource recordSet = source.getRecordset();

                                Iterator iterator=collection.iterator();

                                CreateLabelsOperationContext cloc=new CreateLabelsOperationContext();

                                cloc.setDublicates(true);

                                cloc.setPosition(0);

                                while(iterator.hasNext()){

                                        if (cancel.isCanceled()){

                                                return;

                                        }

                                        Feature feature=(Feature)iterator.next();

//                                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 = ((Number) feature.get(idHeightField)).doubleValue() * fontScaleFactor;

                                                } catch (ClassCastException ccEx) {

                                                        if (!NullValue.class.equals(feature.get(idHeightField).getClass())) {

                                                                throw new ReadException("Unknown", ccEx);

                                                        }

                                                        // a null value

                                                        Logger.getAnonymousLogger().

                                                                warning("Null text height value for text '"+feature.get(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(((Number) feature.get(idRotationField)).doubleValue());

                                        }

                                        Geometry geom = (Geometry)feature.getDefaultGeometry();

                                        sym.setText(feature.get(idTextField).toString());

                                        sym.setRotation(rotation);

                                        FLabel[] aux =(FLabel[])geom.invokeOperation(CreateLabels.CODE,cloc);

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

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

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

                                                p.transform(viewPort.getAffineTransform());

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

                                        }

                                }

                        } catch (ReadException e) {

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

                                                e.getMessage());

                        } catch (GeometryOperationNotSupportedException e) {

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

                                                e.getMessage());

                        } catch (GeometryOperationException 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 (ReadException e) {

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

                }

                try {

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

                } catch (ReadException e) {

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

                }

                try {

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

                } catch (ReadException e) {

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

                }

                xml.putProperty("Unit", unit);

                return xml;

        }

        public String getRotationField() throws ReadException {

                if (idRotationField == -1) return null;

                return ((FeatureType)layer.getFeatureStore().getFeatureTypes().get(0)).getByOrder(idRotationField).getName();

        }

        public int getRotationFieldId() {

                return idRotationField;

        }

        public void setRotationFieldId(int fieldId) {

                this.idRotationField = fieldId;

        }

        public String getTextField() throws ReadException {

                if (idTextField == -1) return null;

                return ((FeatureType)layer.getFeatureStore().getFeatureTypes().get(0)).getByOrder(idTextField).getName();

        }

        public int getTextFieldId() {

                return idTextField;

        }

        public void setTextFieldId(int fieldId) {

                this.idTextField = fieldId;

        }

        public String getHeightField() throws ReadException {

                if (idHeightField == -1) return null;

                return ((FeatureType)layer.getFeatureStore().getFeatureTypes().get(0)).getByOrder(idHeightField).getName();

        }

        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 = ((FeatureType)layer.getFeatureStore().getFeatureTypes().get(0)).getFieldIndex(textFieldName);

                } catch (ReadException e) {

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

                }

        }

        public void setRotationField(String rotationFieldName) {

                if (rotationFieldName != null) {

                        try {

                                idRotationField = ((FeatureType)layer.getFeatureStore().getFeatureTypes().get(0)).getFieldIndex(rotationFieldName);

                        } catch (ReadException 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 = ((FeatureType)layer.getFeatureStore().getFeatureTypes().get(0)).getFieldIndex(heightFieldName);

                        } catch (ReadException e) {

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

                        }

                } else idHeightField = -1;

        }

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

                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 (ReadException 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, Geometry geom) {

                // not required here

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

        }

        public void setCartographicSize(double cartographicSize, Geometry geom) {

                // not required here

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

        }

        public double getCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

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

        }

}