Application: gvSIG desktop

import org.gvsig.labeling.dynamiclabeling.DynamicLabelingStrategy;

import org.gvsig.symbology.fmap.mapcontext.rendering.dynamiclegend.DefaultDynamicLabelingStrategy;

import org.gvsig.labeling.dynamiclabeling.DynamicLabelingStrategy;

        public static DynamicLabelingStrategy createDynamicLabelingStrategy() {

            return new DefaultDynamicLabelingStrategy();

        }

import org.gvsig.labeling.dynamiclabeling.DynamicLabelingStrategy;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSelection;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.AttrInTableLabelingStrategy;

import static org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.AttrInTableLabelingStrategy.MIN_TEXT_SIZE;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.CartographicSupportToolkit;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.impl.SimpleTextSymbol;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    private Feature feature;

    public  String LROTATION = "LROTATION";

    public  String LTEXT = "LTEXT";

    public  String LHEIGHT = "LHEIGHT";

    public  String LCOLOR = "LCOLOR";

    public  String LFONT = "LFONT";

    public  String LFONTSTYLE = "LFONTS";

    private MutableSymbolTable symbolTable = null;

    private FLyrVect layer;

    private List<Geometry> drawnGeometryLabels;

    private boolean printMode = false;

    private IZoomConstraints zoom = null;

    private static final Logger logger = LoggerFactory.getLogger(AttrInTableLabelingStrategy.class);

    private int referenceSystem;

    private String textField;

    public SymbolTable getFeatureSymbolTable() {

        if (symbolTable == null) {

            MutableSymbolTable s = ExpressionEvaluatorLocator.getManager().createSymbolTable();

            FeatureSymbolTable fst = DALLocator.getDataManager().createFeatureSymbolTable();

            s.addSymbolTable(fst);

            fst.setFeature(feature);

            symbolTable = s;

        }

        return symbolTable;

    private Expression getExpressionFromString(String value) {

        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

        expression.setPhrase(value);

        return expression;

    }

    private Object getValueFromExpression(Expression exp) {

        if (exp == null) {

            return null;

        }

        Object value = exp.execute(getFeatureSymbolTable());

        return value;

    }

    public Object getComputedValue(String field) {

        Object value;

        value = feature.get(field);

        return value;

    }

    public Expression getRotation() {

        String value = feature.get(LROTATION).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public int getComputedRotation() {

        Integer value = (Integer) getValueFromExpression(getRotation());

        return value;

    public Expression getText() {

        if (feature == null) {

            return null;

        }

        String value = feature.get(LTEXT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public String getComputedText() {

        String value = (String) getValueFromExpression(getText());

        return value;

    public Expression getHeight() {

        String value = feature.get(LHEIGHT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public int getComputedHeight() {

        int value = (int) getValueFromExpression(getHeight());

        return value;

    }

    @Override

    public Expression getColor() {

        String value = feature.get(LCOLOR).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    @Override

    public Color getComputedColor() {

        int rgbcolor = (int) getColor().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public Expression getFixedSize() {

        String value = feature.get(LHEIGHT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    @Override

    public double getComputedFixedSize() {

        double value = (double) getValueFromExpression(getFixedSize());

        return value;

    }

    @Override

    public int getComputedUnit() {

        int value = (int) getValueFromExpression(getUnitExp());

        return value;

    }

    @Override

        this.LTEXT=textFieldName;

         this.LROTATION=rotationFieldName;

        this.LHEIGHT=heightFieldName;

         this.LCOLOR=colorFieldName;

        return false;

        return true;

    public Expression getFixedColor() {

        String value = feature.get(LCOLOR).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public Color getComputedFixedColor() {

        int rgbcolor = (int) getFixedColor().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public Expression getColorFont() {

        String value = feature.get(LCOLOR).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public Color getComputedColorFont() {

        int rgbcolor = (int) getColorFont().execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    @Override

    public Expression getFont() {

        String value = feature.get(LFONT).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    public Font getComputedFont() {

        String value = (String) getFont().execute(getFeatureSymbolTable());

        Font font = new Font(value, getComputedFontStyle(), getComputedHeight());

        return font;

    }

    @Override

    @Override

    public Expression getFontStyle() {

        String value = feature.get(LFONTSTYLE).toString();

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    @Override

    public int getComputedFontStyle() {

        int value = (int) getFontStyle().execute(getFeatureSymbolTable());

        return value;

    }

    @Override

    public void setFontStyle(int selFont) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public void setFeature(Feature f) {

        feature = f;

    }

    @Override

    public ILabelingMethod getLabelingMethod() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setLabelingMethod(ILabelingMethod method) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public IPlacementConstraints getPlacementConstraints() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setPlacementConstraints(IPlacementConstraints constraints) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public IZoomConstraints getZoomConstraints() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setZoomConstraints(IZoomConstraints constraints) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public Expression getUnitExp() {

        String value = "-1";

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    public Expression getReferenceSystemExp() {

        String value = "0";

        Expression exp = getExpressionFromString(value);

        return exp;

    }

    private org.gvsig.fmap.geom.primitive.Point createLabelPoint(org.gvsig.fmap.geom.Geometry geom)

            throws CreateGeometryException {

        try {

            return geom.centroid();

        } catch (GeometryOperationNotSupportedException e) {

            return null;

        } catch (GeometryOperationException e) {

            return null;

        }

    }

    @Override

    public void draw(BufferedImage mapImage, Graphics2D mapGraphics, double scale, ViewPort viewPort, Cancellable cancel, double dpi) throws ReadException {

//        double scale = getScale(viewPort, props);

        PrintAttributes props = null;

        if (layer == null) {

            return;

        }

        if (zoom == null

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

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

            FeatureSet set = null;

            DisposableIterator iterator = null;

            try {

//                AttrInTableLabelingStrategy.FilteredLogger logger = new AttrInTableLabelingStrategy.FilteredLogger(AttrInTableLabelingStrategy.logger, 10);

                // limit the labeling to the visible extent

                List<String> fields = new ArrayList<String>();

                FeatureStore featureStore = layer.getFeatureStore();

                ICoordTrans ct = layer.getCoordTrans();

                String geomName = featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName();

                fields.add(LCOLOR);

                fields.add(LFONT);

                fields.add(LFONTSTYLE);

                fields.add(LHEIGHT);

                fields.add(LROTATION);

                fields.add(LTEXT);

                fields.add(geomName);

                FeatureQuery featureQuery = layer.createFeatureQuery();

                if (viewPort.getAdjustedEnvelope().contains(

                        layer.getFullEnvelope())) {

                    /*

                     * viewport contains layer completely

                     */

                    set = featureStore.getFeatureSet(featureQuery);

                } else {

                    /*

                     * view port does not contain layer completely

                     */

                    Evaluator iee = null;

                    IProjection data_proj = null;

                    Envelope env_in_store_crs = null;

                    if (ct == null) {

                        env_in_store_crs = viewPort.getAdjustedEnvelope();

                        data_proj = viewPort.getProjection();

                    } else {

                        env_in_store_crs = viewPort.getAdjustedEnvelope().convert(

                                ct.getInverted());

                        data_proj = ct.getPOrig();

                    }

                    iee = SpatialEvaluatorsFactory.getInstance().intersects(

                            env_in_store_crs,

                            data_proj,

                            featureStore

                    );

                    featureQuery.setAttributeNames((String[]) fields.toArray(new String[fields.size()]));

                    featureQuery.setFilter(iee);

                    set = featureStore.getFeatureSet(featureQuery);

                }

                /*

                 * 'set' now has the features that have to be labeled

                 */

                FeatureSelection selection = this.layer.getFeatureStore().getFeatureSelection();

                iterator = set.fastIterator();

                while (iterator.hasNext()) {

                    if (cancel.isCanceled()) {

                        return;

                    }

                    try {

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

                        Geometry geom = feat.getDefaultGeometry();

                        if (geom == null) {

                            continue;

                        }

                        double size = 0;

                        Color color = null;

                        this.setFeature(feat);

                        if ("".equals(getComputedText())) {

                            continue;

                        } else if (getComputedText() == null) {

                            continue;

                        }

                        SimpleTextSymbol sym = new SimpleTextSymbol();

                        sym.setFont(getComputedFont());

                        sym.setUnit(getComputedUnit());

                        sym.setReferenceSystem(getComputedReferenceSystemExp());

                        if (this.usesFixedSize()) { //(useFixedSize) {

                            // uses fixed size

                            size = getComputedFixedSize();// * fontScaleFactor;

                        } else if (true) { //(getComputedHeight() ) {

                            // text size is defined in the table

                            size = getComputedHeight();

                        } else {

                            // otherwise will use the size in the symbol

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

                        }

                        double the_dpi = viewPort.getDPI();

                        if (props != null) {

                            int len = PrintAttributes.PRINT_QUALITY_DPI.length;

                            int priq = props.getPrintQuality();

                            if (priq < 0 || priq >= len) {

                                throw new ReadException(featureStore.getName(),

                                        new Exception("Bad print quality value: " + priq));

                            } else {

                                the_dpi = PrintAttributes.PRINT_QUALITY_DPI[priq];

                            }

                        }

                        size = CartographicSupportToolkit.getCartographicLength(this,

                                size,

                                viewPort,

                                the_dpi);

                        if (size <= MIN_TEXT_SIZE) {

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

                            // this speeds up the rendering in wider zooms

                            continue;

                        }

                        /*

                         * ym.setFontSize(int) assumes dpi = 72

                         */

                        double font_size = size * 72 / the_dpi;

                        sym.setFontSize(font_size);

//                        if (false) { //useFixedColor) {

//                            color = getComputedFixedColor();

//                        } else if (true) { //colorFieldName != null) {

//                            // text size is defined in the table

                        if (selection.isSelected(feat)) {

                            color = MapContext.getSelectionColor();

                        } else {

                            color = getComputedColorFont();

                        }

                        sym.setTextColor(color);

                        if (ct != null) {

                            /*

                             * Reproject from store CRS to view CRS

                             */

                            geom = geom.cloneGeometry();

                            geom.reProject(ct);

                        }

                        Point p = null;

                        // text rotation is defined in the table

                        double rotation = -Math.toRadians(((Number) getComputedRotation()).doubleValue());

                        p = createLabelPoint(geom);

                        sym.setText(getComputedText());

                        sym.setRotation(rotation);

                        if (p != null) {

                            if (props == null) {

                                sym.draw(mapGraphics, viewPort.getAffineTransform(), p, feat, cancel);

                            } else {

                                sym.print(mapGraphics, viewPort.getAffineTransform(), p, props);

                            }

                        }

                    } catch (Exception ex) {

                        logger.warn("", ex);

                    }

                }

            } catch (BaseException e) {

                throw new ReadException(

                        "Could not draw annotation in the layer.", e);

            } finally {

                if (iterator != null) {

                    iterator.dispose();

                }

                if (set != null) {

                    set.dispose();

                }

            }

        }

    }

    @Override

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

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public String[] getUsedFields() {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setLayer(FLayer flayer) {

        layer = (FLyrVect) flayer;

    }

    @Override

    public boolean shouldDrawLabels(double scale) {

        return true;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setUnit(int unitIndex) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public int getUnit() {

        return getComputedUnitExp();

    }

    public int getComputedUnitExp() {

        int value = (int) getValueFromExpression(getUnitExp());

        return value;

    }

    public int getComputedReferenceSystemExp() {

        int value = (int) getValueFromExpression(getReferenceSystemExp());

        return value;

    }

    @Override

    public int getReferenceSystem() {

        return 0;

    }

    @Override

    public void setReferenceSystem(int referenceSystem) {

        this.referenceSystem = referenceSystem;

    }

    @Override

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

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setCartographicSize(double cartographicSize, Geometry geom) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

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

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public void setFontField(String fontField) {

        this.LFONT = fontField;

    }

    @Override

    public void setFontStyleField(String field) {

        this.LFONTSTYLE=field;

    }

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.fmap.geom.GeometryLocator;

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

    public static final String FIELD_OUTLINECOLOR = "COUTLINE";

    public static final String FIELD_FILLCOLOR = "CFILL";

    public static final String FIELD_SIZE = "CSIZE";

    public static final String FIELD_ROTATION = "CROTATION";

    private Expression getExpressionFromString(String value) {

        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

        expression.setPhrase(value);

        return expression;

    }

        String fillcolor = feat.get(FIELD_FILLCOLOR).toString();

        Expression expFill = getExpressionFromString(fillcolor);

        symbol.setFillColor(expFill);

        String outlinecolor = feat.get(FIELD_OUTLINECOLOR).toString();

        Expression expOutlinecolor = getExpressionFromString(outlinecolor);

        symbol.setOutlineColor(expOutlinecolor);

        String size = feat.get(FIELD_SIZE).toString();

        Expression expSize = getExpressionFromString(size);

        symbol.setSize(expSize);

        String rotation = feat.get(FIELD_ROTATION).toString();

        Expression expRotation = getExpressionFromString(rotation);

        symbol.setRotation(expRotation);

        //OFFSET TODO

        Point pointOffset = null;

        String value = "";

        try {

            pointOffset = GeometryLocator.getGeometryManager().createPoint(0, 0, Geometry.SUBTYPES.GEOM2D);

            value = pointOffset.convertToWKT();

        } catch (Exception ex) {

            java.util.logging.Logger.getLogger(DefaultDynamicSymbol.class.getName()).log(Level.SEVERE, null, ex);

        }

        Expression offset = getExpressionFromString(value);

        symbol.setOffset(offset);

        List<String> requiredAttributes = new ArrayList<>();

        requiredAttributes.add(FIELD_OUTLINECOLOR);

        requiredAttributes.add(FIELD_FILLCOLOR);

        requiredAttributes.add(FIELD_ROTATION);

        requiredAttributes.add(FIELD_SIZE);

        symbol.setRequiredFeatureAttributesNames(requiredAttributes);

        LOG.warn("TODO: DefaultDynamicVectorLegend.useDefaultSymbol");

        LOG.warn("TODO: DefaultDynamicVectorLegend.useDefaultSymbol");

    private Feature feature = null;

    public static Expression eOutlineColor = null;

    public static Expression eFillColor = null;

    public static Expression eSize = null;

    public static Expression eRotation = null;

    public FeatureSymbolTable featureSymbolTable = null;

    public SymbolTable symbolTable = null;

    private Expression eOffset;

    private List<String> listRequiredAttributeNames;

        symbolTable = ExpressionEvaluatorLocator.getManager().createSymbolTable();

        featureSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

        symbolTable.addSymbolTable(featureSymbolTable);

        featureSymbolTable.setFeature(feat);

        int typeGeom = feature.getDefaultGeometry().getGeometryType().getType();

        switch (typeGeom) {

            case Geometry.TYPES.POINT:

            case Geometry.TYPES.MULTIPOINT:

                setPointSymbolValues();

                pointSymbol.setColor(MapContext.getSelectionColor());

                pointSymbol.setOutlineColor(MapContext.getSelectionColor());

                return pointSymbol;

            case Geometry.TYPES.LINE:

            case Geometry.TYPES.MULTILINE:

                setLineSymbolValues();

                lineSymbol.setColor(MapContext.getSelectionColor());

                return lineSymbol;

            case Geometry.TYPES.POLYGON:

            case Geometry.TYPES.ELLIPSE:

            case Geometry.TYPES.CIRCLE:

            case Geometry.TYPES.MULTIPOLYGON:

                setPolygonSymbolValues();

                polygonSymbol.setFillColor(MapContext.getSelectionColor());

                return polygonSymbol;

            default:

                break;

        return null;

        switch (typeGeom) {

            case Geometry.TYPES.POINT:

            case Geometry.TYPES.MULTIPOINT:

                drawPoint(g, affineTransform, geom, f, cancel);

                break;

            case Geometry.TYPES.LINE:

            case Geometry.TYPES.MULTILINE:

                drawLine(g, affineTransform, geom, f, cancel);

                break;

            case Geometry.TYPES.POLYGON:

            case Geometry.TYPES.ELLIPSE:

            case Geometry.TYPES.CIRCLE:

            case Geometry.TYPES.MULTIPOLYGON:

                drawPolygon(g, affineTransform, geom, f, cancel);

                break;

            default:

                // Optimiza el pintado de geometrias grandes.

                try {

                    Geometry env = geom.getEnvelope().getGeometry();

                    env.transform(affineTransform);

                    Envelope env2 = env.getEnvelope();

                    if (env2.getLength(0) < 1.5 && env2.getLength(1) < 1.5) {

                        geom = env2.getUpperCorner();

                    }

                } catch (Exception ex) {

                    LOG.warn("Error optimizing the drawing of the geometry. Continues with normal drawing.", ex);

                    // Do nothing, continue with the draw of the original geometry

                g.setColor(c);

                g.fill(geom.getShape(affineTransform));

                g.draw(geom.getShape(affineTransform));

                break;

        setPolygonSymbolValues();

        polygonSymbol.draw(g, affineTransform, geom, f, cancel);

    }

    protected void setPolygonSymbolValues() {

    protected void setPointSymbolValues() {

    }

    protected void drawPoint(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature f, Cancellable cancel) {

        setPointSymbolValues();

        return eFillColor;

        return eOutlineColor;

        eOutlineColor = exp;

        return eFillColor;

        eFillColor = exp;

        return eSize;

        eSize = exp;

        return eOffset;

    public void setOffset(Expression offset) {

        eOffset = offset;

    }

        return eRotation;

        eRotation = exp;

//    public Object getComputedValue(String field) {

//        Object value;

//        value = feature.get(field);

//

//        return value;

//    }

        eOutlineColor = color;

        return this.listRequiredAttributeNames;

    public void setRequiredFeatureAttributesNames(List<String> listRequiredAttributeNames) {

        this.listRequiredAttributeNames = listRequiredAttributeNames;

    }

    public Expression getOutlineColor();

    public void setOutlineColor(Expression exp);

    public Expression getFillColor();

    public void setFillColor(Expression exp);

    public Expression getRotation();

    public void setRotation(Expression exp);

    public Expression getSize();

    public void setSize(Expression exp);

    public Expression getOffset();

    public void setOffset(Expression offset);

    public void setRequiredFeatureAttributesNames(List<String> listRequiredAttributeNames);

package org.gvsig.labeling.dynamiclabeling;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelingStrategy;

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

public abstract class DynamicLabelingStrategy implements ILabelingStrategy, CartographicSupport {

    public abstract void setFeature(Feature f);

    public abstract Expression getRotation();

    public abstract int getComputedRotation();

    public abstract Expression getUnitExp();

    public abstract int getComputedUnit();

    public abstract Expression getText();

    public abstract String getComputedText();

    public abstract Expression getHeight();

    public abstract int getComputedHeight();

    public abstract Expression getColor();

    public abstract Color getComputedColor();

    public abstract Expression getFixedSize();

    public abstract double getComputedFixedSize();

    public abstract Expression getFontStyle();

    public abstract int getComputedFontStyle();

    public abstract void setFontStyle(int style);

    public abstract void setFontStyleField(String field);

    public abstract Expression getFixedColor();

    public abstract Color getComputedFixedColor();

    public abstract Expression getColorFont();

    public abstract Color getComputedColorFont();

    public abstract Expression getFont();

    public abstract Font getComputedFont();

    public abstract void setFontField(String fontField);