| gvSIG desktop 1

package com.iver.cit.gvsig.fmap.core.symbols;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.util.logging.Logger;

import javax.print.attribute.PrintRequestAttributeSet;

import sun.rmi.runtime.Log;

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

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

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

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

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

import com.iver.cit.gvsig.fmap.core.styles.ILineStyle;

import com.iver.cit.gvsig.fmap.core.styles.IMask;

import com.iver.utiles.XMLEntity;

public class MultiShapeSymbol implements ILineSymbol, IMarkerSymbol, IFillSymbol {

        private IMarkerSymbol marker = SymbologyFactory.createDefaultMarkerSymbol();

        private ILineSymbol line = SymbologyFactory.createDefaultLineSymbol();

        private IFillSymbol fill = SymbologyFactory.createDefaultFillSymbol();

        private IMask mask;

        private String desc;

        private int referenceSystem;

        public Color getLineColor() {

                return line.getColor();

        }

        public void setLineColor(Color color) {

                line.setLineColor(color);

        }

        public ILineStyle getLineStyle() {

                return line.getLineStyle();

        }

        public void setLineStyle(ILineStyle lineStyle) {

                line.setLineStyle(lineStyle);

        }

        public void setLineWidth(double width) {

                line.setLineWidth(width);

        }

        public double getLineWidth() {

                return line.getLineWidth();

        }

        public int getAlpha() {

                return line.getAlpha();

        }

        public void setAlpha(int outlineAlpha) {

                line.setAlpha(outlineAlpha);

        }

        public ISymbol getSymbolForSelection() {

                // TODO Implement it

                throw new Error("Not yet implemented!");

        }

        public void draw(Graphics2D g, AffineTransform affineTransform, FShape shp) {

                switch (shp.getShapeType()) {

                case FShape.POINT: //Tipo punto

        case FShape.POINT + FShape.Z:

                        marker.draw(g, affineTransform, shp);

                        break;

                case FShape.LINE:

        case FShape.LINE + FShape.Z:

                case FShape.ARC:

                case FShape.ARC + FShape.Z:

                        line.draw(g, affineTransform, shp);

                        break;

                case FShape.POLYGON:

        case FShape.POLYGON + FShape.Z:

                case FShape.ELLIPSE:

                case FShape.ELLIPSE + FShape.Z:

        case FShape.CIRCLE:

                case FShape.CIRCLE + FShape.Z:

                        fill.draw(g, affineTransform, shp);

                        break;

                }

        }

        public int getPixExtentPlus(Graphics2D g, AffineTransform affineTransform,

                        Shape shp) {

                // TODO Implement it

                throw new Error("Not yet implemented!");

        }

        public int getOnePointRgb() {

                // will return a mixture of all symbol's getOnePointRgb() value

                int rMarker = marker.getColor().getRed();

                int rLine = line.getColor().getRed();

                int rFill = fill.getOutline().getColor().getRed();

                int red = (rMarker + rLine + rFill) / 3;

                int gMarker = marker.getColor().getGreen();

                int gLine = line.getColor().getGreen();

                int gFill = fill.getOutline().getColor().getGreen();

                int green = (gMarker + gLine + gFill) / 3;

                int bMarker = marker.getColor().getBlue();

                int bLine = line.getColor().getBlue();

                int bFill = fill.getOutline().getColor().getBlue();

                int blue = (bMarker + bLine + bFill) / 3;

                int aMarker = marker.getColor().getAlpha();

                int aLine = line.getColor().getAlpha();

                int aFill = fill.getOutline().getColor().getAlpha();

                int alpha = (aMarker + aLine + aFill) / 3;

                return (alpha) << 24 + (red << 16) + (green << 8) + blue;

        }

        public XMLEntity getXMLEntity() {

                XMLEntity xml = new XMLEntity();

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

                xml.putProperty("desc", getDescription());

                xml.putProperty("unit", getUnit());

                xml.addChild(marker.getXMLEntity());

                xml.addChild(line.getXMLEntity());

                xml.addChild(fill.getXMLEntity());

                return xml;

        }

        public void setXMLEntity(XMLEntity xml) {

                setDescription(xml.getStringProperty("desc"));

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

                marker = (IMarkerSymbol) SymbologyFactory.createSymbolFromXML(xml.getChild(0), null);

                line = (ILineSymbol) SymbologyFactory.createSymbolFromXML(xml.getChild(0), null);

                fill = (IFillSymbol) SymbologyFactory.createSymbolFromXML(xml.getChild(0), null);

        }

        public String getDescription() {

                return desc;

        }

        public boolean isShapeVisible() {

                return marker.isShapeVisible() || line.isShapeVisible() || fill.isShapeVisible();

        }

        public void setDescription(String desc) {

                this.desc = desc ;

        }

        public int getSymbolType() {

                return FShape.MULTI;

        }

        public boolean isSuitableFor(IGeometry geom) {

                // suitable for everything (why else does it exist?)

                return true;

        }

        public void drawInsideRectangle(Graphics2D g,

                        AffineTransform scaleInstance, Rectangle r) {

                Rectangle rect = new Rectangle(r.x, r.y+1, r.width, r.height-2);

                double myWidth =  (rect.getWidth()/3);

                rect.setBounds(0, rect.y, (int) myWidth, rect.height);

//                g.setColor(Color.RED);

//                g.drawRect(rect.x, rect.y, rect.width, rect.height);

                marker.drawInsideRectangle(g, scaleInstance, rect);

                rect.setBounds((int) (myWidth), rect.y, (int) myWidth, rect.height  );

//                g.setColor(Color.GREEN);

//                g.drawRect(rect.x, rect.y, rect.width, rect.height);

                line.drawInsideRectangle(g, scaleInstance, rect);

                rect.setBounds((int) (myWidth + myWidth)-1,  rect.y, (int) myWidth, rect.height  );

//                g.setColor(Color.BLUE);

//                g.drawRect(rect.x, rect.y, rect.width, rect.height);

                fill.drawInsideRectangle(g, scaleInstance, rect);

        }

        public String getClassName() {

                return getClass().getName();

        }

        public void print(Graphics2D g, AffineTransform at, FShape shape, PrintRequestAttributeSet properties)

                        throws ReadDriverException {

                switch (shape.getShapeType()) {

                case FShape.POINT: //Tipo punto

        case FShape.POINT + FShape.Z:

                        marker.print(g, at, shape, properties);

                        break;

                case FShape.LINE:

        case FShape.LINE + FShape.Z:

                case FShape.ARC:

                case FShape.ARC + FShape.Z:

                        line.print(g, at, shape, properties);

                        break;

                case FShape.POLYGON:

        case FShape.POLYGON + FShape.Z:

                case FShape.ELLIPSE:

                case FShape.ELLIPSE + FShape.Z:

        case FShape.CIRCLE:

                case FShape.CIRCLE + FShape.Z:

                        fill.print(g, at, shape, properties);

                        break;

                }

        }

        public double getRotation() {

                return marker.getRotation();

        }

        public void setRotation(double rotation) {

                marker.setRotation(rotation);

        }

        public Point2D getOffset() {

                return marker.getOffset();

        }

        public void setOffset(Point2D offset) {

                marker.setOffset(offset);

        }

        public double getSize() {

                return marker.getSize();

        }

        public void setSize(double size) {

                marker.setSize(size);

        }

        public Color getColor() {

                return marker.getColor();

        }

        public void setColor(Color color) {

                marker.setColor(color);

        }

        public void setFillColor(Color color) {

                fill.setFillColor(color);

        }

        public void setOutline(ILineSymbol outline) {

                fill.setOutline(outline);

        }

        public Color getFillColor() {

                return fill.getFillColor();

        }

        public ILineSymbol getOutline() {

                return fill.getOutline();

        }

        public int getFillAlpha() {

                return fill.getFillAlpha();

        }

        public IMask getMask() {

                return mask;

        }

        public void setUnit(int unitIndex) {

                marker.setUnit(unitIndex);

                line.setUnit(unitIndex);

        }

        public int getUnit() {

                return marker.getUnit();

        }

        public void setMask(IMask mask) {

                // TODO Implement it

                throw new Error("Not yet implemented!");

        }

        public int getReferenceSystem() {

                return this.referenceSystem;

        }

        public void setReferenceSystem(int system) {

                this.referenceSystem = system;

        }

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

                switch (shp.getShapeType()) {

                case FShape.POINT: //Tipo punto

        case FShape.POINT + FShape.Z:

                        return marker.getCartographicSize(viewPort, dpi, shp);

                case FShape.LINE:

        case FShape.LINE + FShape.Z:

                case FShape.ARC:

                case FShape.ARC + FShape.Z:

                        return line.getCartographicSize(viewPort, dpi, shp);

                case FShape.POLYGON:

        case FShape.POLYGON + FShape.Z:

                case FShape.ELLIPSE:

                case FShape.ELLIPSE + FShape.Z:

        case FShape.CIRCLE:

                case FShape.CIRCLE + FShape.Z:

                        Logger.getAnonymousLogger().warning("Cartographic size does not have any sense for fill symbols");

                }

                return -1;

        }

}