* Copyright (C) 2012 United States Government as represented by the Administrator of the

* National Aeronautics and Space Administration.

* All Rights Reserved.

*/

* A utility class to interactively draw shapes and measure distance and area across the terrain. When armed, the class

* monitors mouse events to allow the definition of a measure shape that can be one of {@link #SHAPE_LINE}, {@link

* #SHAPE_PATH}, {@link #SHAPE_POLYGON}, {@link #SHAPE_CIRCLE}, {@link #SHAPE_ELLIPSE}, {@link #SHAPE_SQUARE} or {@link

* #SHAPE_QUAD}. <p/> <p>In order to allow user interaction with the measuring shape, a controller must be set by

* calling {@link #setController(MeasureToolController)} with a new instance of a <code>MeasureToolController</code>.</p>

* <p/> <p>The interaction sequence for drawing a shape and measuring is as follows: <ul> <li>Set the measure

* shape.</li> <li>Arm the <code>MeasureTool</code> object by calling its {@link #setArmed(boolean)} method with an

* argument of true.</li> <li>Click on the terrain to add points.</li> <li>Disarm the <code>MeasureTool</code> object by

* calling its {@link #setArmed(boolean)} method with an argument of false. </li> <li>Read the measured length or area

* by calling the <code>MeasureTool</code> {@link #getLength()} or {@link #getArea()} method. Note that the length and

* area can be queried at any time during or after the process.</li> </ul> </p> <p>While entering points or after the

* measure tool has been disarmed, dragging the control points allow to change the initial points positions and alter

* the measure shape.</p> <p/> <p> While the <code>MeasureTool</code> is armed, pressing and immediately releasing mouse

* button one while also pressing the control key (Ctl) removes the last point entered. </p> <p/> <p>Arming and

* disarming the <code>MeasureTool</code> does not change the contents or attributes of the measure tool's layer. Note

* that the measure tool will NOT disarm itself after the second point of a line or a regular shape has been entered -

* the MeasureToolController has that responsability.</p> <p/> <p><b>Setting the measure shape from the

* application</b></p> <p/> <p>The application can set the measure shape to an arbitrary list of positions using {@link

* #setPositions(java.util.ArrayList)}. If the provided list contains two positions, the measure shape will be set to

* {@link #SHAPE_LINE}. If more then two positions are provided, the measure shape will be set to {@link #SHAPE_PATH} if

* the last position differs from the first (open path), or {@link #SHAPE_POLYGON} if the path is closed.</p> <p/>

* <p>The application can also set the measure shape to a predefined regular shape by calling {@link

* #setMeasureShapeType(String, Position, double, double, Angle)}, providing a shape type (one of {@link #SHAPE_CIRCLE},

* {@link #SHAPE_ELLIPSE}, {@link #SHAPE_SQUARE} or {@link #SHAPE_QUAD}), a center position, a wdth, a height (in

* meters) and a heading angle.</p> <p/> <p>Finally, the application can use an existing <code>Polyline</code> or

* <code>SurfaceShape</code> by using {@link #setMeasureShape(Polyline)} or {@link #setMeasureShape(SurfaceShape)}. The

* surface shape can be one of <code>SurfacePolygon</code>, <code>SurfaceQuad</code>, <code>SurfaceSquare</code>,

* <code>SurfaceEllipse</code> or <code>SurfaceCircle</code>. <p/> <p><b>Measuring</b></p> <p/> <p>The application can

* read the measured length or area by calling the <code>MeasureTool</code> {@link #getLength()} or {@link #getArea()}

* method. These methods will return -1 when no value is available.</p> <p/> <p>Regular shapes are defined by a center

* position, a width a height and a heading angle. Those attributes can be accessed by calling the {@link

* #getCenterPosition()}, {@link #getWidth()}, {@link #getHeight()} and {@link #getOrientation()} methods.</p> <p/>

* <p>The measurements are dislayed in units specified in the measure tool's {@link UnitsFormat} object. Access to the

* units format is via the method {@link #getUnitsFormat()}. <p/> <p><b>Events</b></p> <p/> <p>The

* <code>MeasureTool</code> will send events on several occasions: when the position list has changed - {@link

* #EVENT_POSITION_ADD}, {@link #EVENT_POSITION_REMOVE} or {@link #EVENT_POSITION_REPLACE}, when metrics has changed

* {@link #EVENT_METRIC_CHANGED} or when the tool is armed or disarmed {@link #EVENT_ARMED}.</p> <p/> <p>Events will

* also be fired at the start and end of a rubber band operation during shape creation: {@link #EVENT_RUBBERBAND_START}

* and {@link #EVENT_RUBBERBAND_STOP}.</p> <p/> <p>See {@link gov.nasa.worldwindx.examples.MeasureToolPanel} for some

* events usage.</p> <p/> <p>Several instances of this class can be used simultaneously. However, each instance should

* be disposed of after usage by calling the {@link #dispose()} method.</p>

*

* @author Patrick Murris

* @version $Id: MeasureTool.java 1171 2013-02-11 21:45:02Z dcollins $

* @see MeasureToolController

*/

    public static final String SHAPE_LINE = "MeasureTool.ShapeLine";

    public static final String SHAPE_PATH = "MeasureTool.ShapePath";

    public static final String SHAPE_POLYGON = "MeasureTool.ShapePolygon";

    public static final String SHAPE_CIRCLE = "MeasureTool.ShapeCircle";

    public static final String SHAPE_ELLIPSE = "MeasureTool.ShapeEllipse";

    public static final String SHAPE_QUAD = "MeasureTool.ShapeQuad";

    public static final String SHAPE_SQUARE = "MeasureTool.ShapeSquare";

    public static final String EVENT_POSITION_ADD = "MeasureTool.AddPosition";

    public static final String EVENT_POSITION_REMOVE = "MeasureTool.RemovePosition";

    public static final String EVENT_POSITION_REPLACE = "MeasureTool.ReplacePosition";

    public static final String EVENT_METRIC_CHANGED = "MeasureTool.MetricChanged";

    public static final String EVENT_ARMED = "MeasureTool.Armed";

    public static final String EVENT_RUBBERBAND_START = "MeasureTool.RubberBandStart";

    public static final String EVENT_RUBBERBAND_STOP = "MeasureTool.RubberBandStop";

    public static final String ANGLE_LABEL = "MeasureTool.AngleLabel";

    public static final String AREA_LABEL = "MeasureTool.AreaLabel";

    public static final String LENGTH_LABEL = "MeasureTool.LengthLabel";

    public static final String PERIMETER_LABEL = "MeasureTool.PerimeterLabel";

    public static final String RADIUS_LABEL = "MeasureTool.RadiusLabel";

    public static final String HEIGHT_LABEL = "MeasureTool.HeightLabel";

    public static final String WIDTH_LABEL = "MeasureTool.WidthLabel";

    public static final String HEADING_LABEL = "MeasureTool.HeadingLabel";

    public static final String CENTER_LATITUDE_LABEL = "MeasureTool.CenterLatitudeLabel";

    public static final String CENTER_LONGITUDE_LABEL = "MeasureTool.CenterLongitudeLabel";

    public static final String LATITUDE_LABEL = "MeasureTool.LatitudeLabel";

    public static final String LONGITUDE_LABEL = "MeasureTool.LongitudeLabel";

    public static final String ACCUMULATED_LABEL = "MeasureTool.AccumulatedLabel";

    public static final String MAJOR_AXIS_LABEL = "MeasureTool.MajorAxisLabel";

    public static final String MINOR_AXIS_LABEL = "MeasureTool.MinorAxisLabel";

    public static final String CONTROL_TYPE_LOCATION_INDEX = "MeasureTool.ControlTypeLocationIndex";

    public static final String CONTROL_TYPE_REGULAR_SHAPE = "MeasureTool.ControlTypeRegularShape";

    public static final String CONTROL_TYPE_LEADER_ORIGIN = "MeasureTool.ControlTypeLeaderOrigin";

    private static final String CENTER = "Center";

    private static final String NORTH = "North";

    private static final String EAST = "East";

    private static final String SOUTH = "South";

    private static final String WEST = "West";

    private static final String NORTHEAST = "NE";

    private static final String SOUTHEAST = "SE";

    private static final String SOUTHWEST = "SW";

    private static final String NORTHWEST = "NW";

    private static final String NORTH_LEADER = "NorthLeader";

    protected static final double SHAPE_MIN_WIDTH_METERS = 0.1;

    protected static final double SHAPE_MIN_HEIGHT_METERS = 0.1;

    protected static final int MAX_SHAPE_MOVE_ITERATIONS = 10;

    protected static final double SHAPE_CONTROL_EPSILON_METERS = 0.01;

    protected final WorldWindow wwd;

    protected MeasureToolController controller;

    protected ArrayList<Position> positions = new ArrayList<Position>();

    protected ArrayList<Renderable> controlPoints = new ArrayList<Renderable>();

    protected RenderableLayer applicationLayer;

    protected CustomRenderableLayer layer;

    protected CustomRenderableLayer controlPointsLayer;

    protected CustomRenderableLayer shapeLayer;

    protected Polyline line;

    protected SurfaceShape surfaceShape;

    protected ScreenAnnotation annotation;

    protected Color lineColor = Color.YELLOW;

    protected Color fillColor = new Color(.6f, .6f, .4f, .5f);

    protected double lineWidth = 2;

    protected String pathType = AVKey.GREAT_CIRCLE;

    protected AnnotationAttributes controlPointsAttributes;

    protected AnnotationAttributes controlPointWithLeaderAttributes;

    protected ShapeAttributes leaderAttributes;

    protected AnnotationAttributes annotationAttributes;

    protected String measureShapeType = SHAPE_LINE;

    protected boolean followTerrain = false;

    protected boolean showControlPoints = true;

    protected boolean showAnnotation = true;

    protected UnitsFormat unitsFormat = new UnitsFormat();

    // Rectangle enclosed regular shapes attributes

    protected Rectangle2D.Double shapeRectangle = null;

    protected Position shapeCenterPosition = null;

    protected Angle shapeOrientation = null;

    protected int shapeIntervals = 64;

    protected static class CustomRenderableLayer extends RenderableLayer implements PreRenderable, Renderable

    {

        public void render(DrawContext dc)

        {

            if (dc.isPickingMode() && !this.isPickEnabled())

                return;

            if (!this.isEnabled())

                return;

            super.render(dc);

        }

    }

    /**

     * Construct a new measure tool drawing events from the specified <code>WorldWindow</code>.

     *

     * @param wwd the <code>WorldWindow</code> to draw events from.

     */

    public MeasureTool(final WorldWindow wwd)

    {

        this(wwd, null);

    }

    /**

     * Construct a new measure tool drawing events from the specified <code>WorldWindow</code> and using the given

     * <code>RenderableLayer</code>.

     *

     * @param wwd              the <code>WorldWindow</code> to draw events from.

     * @param applicationLayer the <code>RenderableLayer</code> to use. May be null. If specified, the caller is

     *                         responsible for adding the layer to the model and enabling it.

     */

    public MeasureTool(final WorldWindow wwd, RenderableLayer applicationLayer)

    {

        if (wwd == null)

        {

            String msg = Logging.getMessage("nullValue.WorldWindow");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        this.wwd = wwd;

        this.applicationLayer = applicationLayer; // can be null

        // Set up layers

        this.layer = createCustomRenderableLayer();

        this.shapeLayer = createCustomRenderableLayer();

        this.controlPointsLayer = createCustomRenderableLayer();

        this.shapeLayer.setPickEnabled(false);

        this.layer.setName("Measure Tool");

        this.layer.addRenderable(this.shapeLayer);          // add shape layer to render layer

        this.layer.addRenderable(this.controlPointsLayer);  // add control points layer to render layer

        this.controlPointsLayer.setEnabled(this.showControlPoints);

        if (this.applicationLayer != null)

            this.applicationLayer.addRenderable(this.layer);    // add render layer to the application provided layer

        else

            this.wwd.getModel().getLayers().add(this.layer);    // add render layer to the globe model

        // Init control points rendering attributes

        this.controlPointsAttributes = new AnnotationAttributes();

        // Define an 8x8 square centered on the screen point

        this.controlPointsAttributes.setFrameShape(AVKey.SHAPE_RECTANGLE);

        this.controlPointsAttributes.setLeader(AVKey.SHAPE_NONE);

        this.controlPointsAttributes.setAdjustWidthToText(AVKey.SIZE_FIXED);

        this.controlPointsAttributes.setSize(new Dimension(8, 8));

        this.controlPointsAttributes.setDrawOffset(new Point(0, -4));

        this.controlPointsAttributes.setInsets(new Insets(0, 0, 0, 0));

        this.controlPointsAttributes.setBorderWidth(0);

        this.controlPointsAttributes.setCornerRadius(0);

        this.controlPointsAttributes.setBackgroundColor(Color.BLUE);    // Normal color

        this.controlPointsAttributes.setTextColor(Color.GREEN);         // Highlighted color

        this.controlPointsAttributes.setHighlightScale(1.2);

        this.controlPointsAttributes.setDistanceMaxScale(1);            // No distance scaling

        this.controlPointsAttributes.setDistanceMinScale(1);

        this.controlPointsAttributes.setDistanceMinOpacity(1);

        // Init control point with leader rendering attributes.

        this.controlPointWithLeaderAttributes = new AnnotationAttributes();

        this.controlPointWithLeaderAttributes.setDefaults(this.controlPointsAttributes);

        this.controlPointWithLeaderAttributes.setFrameShape(AVKey.SHAPE_ELLIPSE);

        this.controlPointWithLeaderAttributes.setSize(new Dimension(10, 10));

        this.controlPointWithLeaderAttributes.setDrawOffset(new Point(0, -5));

        this.controlPointWithLeaderAttributes.setBackgroundColor(Color.LIGHT_GRAY);

        this.leaderAttributes = new BasicShapeAttributes();

        this.leaderAttributes.setOutlineMaterial(Material.WHITE);

        this.leaderAttributes.setOutlineOpacity(0.7);

        this.leaderAttributes.setOutlineWidth(3);

        // Annotation attributes

        this.setInitialLabels();

        this.annotationAttributes = new AnnotationAttributes();

        this.annotationAttributes.setFrameShape(AVKey.SHAPE_NONE);

        this.annotationAttributes.setInsets(new Insets(0, 0, 0, 0));

        this.annotationAttributes.setDrawOffset(new Point(0, 10));

        this.annotationAttributes.setTextAlign(AVKey.CENTER);

        this.annotationAttributes.setEffect(AVKey.TEXT_EFFECT_OUTLINE);

        this.annotationAttributes.setFont(Font.decode("Arial-Bold-14"));

        this.annotationAttributes.setTextColor(Color.WHITE);

        this.annotationAttributes.setBackgroundColor(Color.BLACK);

        this.annotationAttributes.setSize(new Dimension(220, 0));

        this.annotation = new ScreenAnnotation("", new Point(0, 0), this.annotationAttributes);

        this.annotation.getAttributes().setVisible(false);

        this.annotation.getAttributes().setDrawOffset(null); // use defaults

        this.shapeLayer.addRenderable(this.annotation);

    }

    protected void setInitialLabels()

    {

        this.setLabel(ACCUMULATED_LABEL, Logging.getMessage(ACCUMULATED_LABEL));

        this.setLabel(ANGLE_LABEL, Logging.getMessage(ANGLE_LABEL));

        this.setLabel(AREA_LABEL, Logging.getMessage(AREA_LABEL));

        this.setLabel(CENTER_LATITUDE_LABEL, Logging.getMessage(CENTER_LATITUDE_LABEL));

        this.setLabel(CENTER_LONGITUDE_LABEL, Logging.getMessage(CENTER_LONGITUDE_LABEL));

        this.setLabel(HEADING_LABEL, Logging.getMessage(HEADING_LABEL));

        this.setLabel(HEIGHT_LABEL, Logging.getMessage(HEIGHT_LABEL));

        this.setLabel(LATITUDE_LABEL, Logging.getMessage(LATITUDE_LABEL));

        this.setLabel(LONGITUDE_LABEL, Logging.getMessage(LONGITUDE_LABEL));

        this.setLabel(LENGTH_LABEL, Logging.getMessage(LENGTH_LABEL));

        this.setLabel(MAJOR_AXIS_LABEL, Logging.getMessage(MAJOR_AXIS_LABEL));

        this.setLabel(MINOR_AXIS_LABEL, Logging.getMessage(MINOR_AXIS_LABEL));

        this.setLabel(PERIMETER_LABEL, Logging.getMessage(PERIMETER_LABEL));

        this.setLabel(RADIUS_LABEL, Logging.getMessage(RADIUS_LABEL));

        this.setLabel(WIDTH_LABEL, Logging.getMessage(WIDTH_LABEL));

    }

    public WorldWindow getWwd()

    {

        return this.wwd;

    }

    /**

     * Return the {@link UnitsFormat} instance governing the measurement value display units and format.

     *

     * @return the tool's units format instance.

     */

    public UnitsFormat getUnitsFormat()

    {

        return this.unitsFormat;

    }

    /**

     * Set the measure tool's @{link UnitsFormat} instance that governs measurement value display units and format.

     *

     * @param unitsFormat the units format instance.

     *

     * @throws IllegalArgumentException if the units format instance is null.

     */

    public void setUnitsFormat(UnitsFormat unitsFormat)

    {

        if (unitsFormat == null)

        {

            String msg = Logging.getMessage("nullValue.Format");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        this.unitsFormat = unitsFormat;

    }

    /** @return Instance of the custom renderable layer to use of our internal layers */

    protected CustomRenderableLayer createCustomRenderableLayer()

    {

        return new CustomRenderableLayer();

    }

    /**

     * Set the controller object for this measure tool - can be null.

     *

     * @param controller the controller object for this measure tool.

     */

    public void setController(MeasureToolController controller)

    {

        if (this.controller != null)

        {

            this.wwd.getInputHandler().removeMouseListener(this.controller);

            this.wwd.getInputHandler().removeMouseMotionListener(this.controller);

            this.wwd.removePositionListener(this.controller);

            this.wwd.removeSelectListener(this.controller);

            this.wwd.removeRenderingListener(this.controller);

            this.controller = null;

        }

        if (controller != null)

        {

            this.controller = controller;

            this.controller.setMeasureTool(this);

            this.wwd.getInputHandler().addMouseListener(this.controller);

            this.wwd.getInputHandler().addMouseMotionListener(this.controller);

            this.wwd.addPositionListener(this.controller);

            this.wwd.addSelectListener(this.controller);

            this.wwd.addRenderingListener(this.controller);

        }

    }

    public void setLabel(String labelName, String label)

    {

        if (labelName != null && labelName.length() > 0)

            this.setValue(labelName, label);

    }

    public String getLabel(String labelName)

    {

        if (labelName == null)

        {

            String msg = Logging.getMessage("nullValue.LabelName");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        String label = this.getStringValue(labelName);

        return label != null ? label : this.unitsFormat.getStringValue(labelName);

    }

    /**

     * Get the <code>MeasureToolController</code> for this measure tool.

     *

     * @return the <code>MeasureToolController</code> for this measure tool.

     */

    public MeasureToolController getController()

    {

        return this.controller;

    }

    /**

     * Arms and disarms the measure tool controller. When armed, the controller monitors user input and builds the shape

     * in response to user actions. When disarmed, the controller ignores all user input.

     *

     * @param state true to arm the controller, false to disarm it.

     */

    public void setArmed(boolean state)

    {

        if (this.controller != null)

            this.controller.setArmed(state);

    }

    /**

     * Identifies whether the measure tool controller is armed.

     *

     * @return true if armed, false if not armed.

     */

    public boolean isArmed()

    {

        return this.controller != null && this.controller.isArmed();

    }

    /**

     * Returns the measure tool layer.

     *

     * @return the layer containing the measure shape and control points.

     */

    public RenderableLayer getLayer()

    {

        return this.layer;

    }

    /**

     * Returns the applilcation layer passed to the constructor.

     *

     * @return the layer containing the measure shape and control points.

     */

    public RenderableLayer getApplicationLayer()

    {

        return applicationLayer;

    }

    /**

     * Returns the polyline currently used to display lines and path.

     *

     * @return the polyline currently used to display lines and path.

     */

    public Polyline getLine()

    {

        return this.line;

    }

    /**

     * Returns the surface shape currently used to display polygons.

     *

     * @return the surface shape currently used to display polygons.

     */

    public SurfaceShape getSurfaceShape()

    {

        return this.surfaceShape;

    }

    /**

     * Get the list of positions that define the current measure shape.

     *

     * @return the list of positions that define the current measure shape.

     */

    public ArrayList<? extends Position> getPositions()

    {

        return this.positions;

    }

    /**

     * Set the measure shape to an arbitrary list of positions. If the provided list contains two positions, the measure

     * shape will be set to {@link #SHAPE_LINE}. If more then two positions are provided, the measure shape will be set

     * to {@link #SHAPE_PATH} if the last position differs from the first (open path), or {@link #SHAPE_POLYGON} if the

     * path is closed.

     *

     * @param newPositions the shape position list.

     */

    public void setPositions(ArrayList<? extends Position> newPositions)

    {

        if (newPositions == null)

        {

            String msg = Logging.getMessage("nullValue.PositionsListIsNull");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        if (newPositions.size() < 2)

            return;

        this.clear();

        // Setup the proper measure shape

        boolean closedShape = newPositions.get(0).equals(newPositions.get(newPositions.size() - 1));

        if (newPositions.size() > 2 && closedShape)

            setMeasureShapeType(SHAPE_POLYGON);

        else

            setMeasureShapeType(getPathType(newPositions));

        // Import positions and create control points

        for (int i = 0; i < newPositions.size(); i++)

        {

            Position pos = newPositions.get(i);

            this.positions.add(pos);

            if (i < newPositions.size() - 1 || !closedShape)

                addControlPoint(pos, CONTROL_TYPE_LOCATION_INDEX, this.positions.size() - 1);

        }

        // Update line heading if needed

        if (this.measureShapeType.equals(SHAPE_LINE))

            this.shapeOrientation = LatLon.greatCircleAzimuth(this.positions.get(0), this.positions.get(1));

        // Update screen shapes

        updateMeasureShape();

        this.firePropertyChange(EVENT_POSITION_REPLACE, null, null);

        this.wwd.redraw();

    }

    /**

     * Get the list of control points associated with the current measure shape.

     *

     * @return the list of control points associated with the current measure shape.

     */

    public ArrayList<Renderable> getControlPoints()

    {

        return this.controlPoints;

    }

    /**

     * Get the attributes associated with the control points.

     *

     * @return the attributes associated with the control points.

     */

    public AnnotationAttributes getControlPointsAttributes()

    {

        return this.controlPointsAttributes;

    }

    /**

     * Get the attributes associated with the tool tip annotation.

     *

     * @return the attributes associated with the tool tip annotation.

     */

    public AnnotationAttributes getAnnotationAttributes()

    {

        return this.annotationAttributes;

    }

    public void setLineColor(Color color)

    {

        if (color == null)

        {

            String msg = Logging.getMessage("nullValue.ColorIsNull");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        this.lineColor = color;

        if (this.line != null)

        {

            this.line.setColor(color);

        }

        if (this.surfaceShape != null)

        {

            ShapeAttributes attr = this.surfaceShape.getAttributes();

            if (attr == null)

                attr = new BasicShapeAttributes();

            attr.setOutlineMaterial(new Material(color));

            attr.setOutlineOpacity(color.getAlpha() / 255d);

            this.surfaceShape.setAttributes(attr);

        }

        this.wwd.redraw();

    }

    public Color getLineColor()

    {

        return this.lineColor;

    }

    public void setFillColor(Color color)

    {

        if (color == null)

        {

            String msg = Logging.getMessage("nullValue.ColorIsNull");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        this.fillColor = color;

        if (this.surfaceShape != null)

        {

            ShapeAttributes attr = this.surfaceShape.getAttributes();

            if (attr == null)

                attr = new BasicShapeAttributes();

            attr.setInteriorMaterial(new Material(color));

            attr.setInteriorOpacity(color.getAlpha() / 255d);

            this.surfaceShape.setAttributes(attr);

        }

        this.wwd.redraw();

    }

    public Color getFillColor()

    {

        return this.fillColor;

    }

    public void setLineWidth(double width)

    {

        this.lineWidth = width;

        if (this.line != null)

            this.line.setLineWidth(width);

        if (this.surfaceShape != null)

        {

            ShapeAttributes attr = this.surfaceShape.getAttributes();

            if (attr == null)

                attr = new BasicShapeAttributes();

            attr.setOutlineWidth(width);

            this.surfaceShape.setAttributes(attr);

        }

        this.wwd.redraw();

    }

    public double getLineWidth()

    {

        return this.lineWidth;

    }

    public String getPathType()

    {

        return this.pathType;

    }

    public void setPathType(String type)

    {

        this.pathType = type;

        if (this.line != null)

            this.line.setPathType(polylinePathTypeFromKey(type));

        if (this.surfaceShape != null)

            this.surfaceShape.setPathType(type);

        if (this.isRegularShape())

            this.updateShapeControlPoints();

        this.wwd.redraw();

    }

    @SuppressWarnings({"StringEquality"})

    protected static int polylinePathTypeFromKey(String type)

    {

        if (type != null && type == AVKey.GREAT_CIRCLE)

        {

            return Polyline.GREAT_CIRCLE;

        }

        else if (type != null && (type == AVKey.RHUMB_LINE || type == AVKey.LOXODROME))

        {

            return Polyline.RHUMB_LINE;

        }

        else

        {

            return Polyline.LINEAR;

        }

    }

    protected static String keyFromPolylinePathType(int type)

    {

        if (type == Polyline.GREAT_CIRCLE)

        {

            return AVKey.GREAT_CIRCLE;

        }

        else if (type == Polyline.RHUMB_LINE)

        {

            return AVKey.RHUMB_LINE;

        }

        else

        {

            return AVKey.LINEAR;

        }

    }

    public boolean isShowControlPoints()

    {

        return this.showControlPoints;

    }

    public void setShowControlPoints(boolean state)

    {

        this.showControlPoints = state;

        this.controlPointsLayer.setEnabled(state);

        this.wwd.redraw();

    }

    public boolean isShowAnnotation()

    {

        return this.showAnnotation;

    }

    public void setShowAnnotation(boolean state)

    {

        this.showAnnotation = state;

    }

    /** Removes all positions from the shape, clear attributes. */

    public void clear()

    {

        while (this.positions.size() > 0 || this.controlPoints.size() > 0)

        {

            this.removeControlPoint();

        }

        this.shapeCenterPosition = null;

        this.shapeOrientation = null;

        this.shapeRectangle = null;

    }

    public boolean isMeasureShape(Object o)

    {

        return o == this.shapeLayer;

    }

    /**

     * Get the measure shape type. can be one of {@link #SHAPE_LINE}, {@link #SHAPE_PATH}, {@link #SHAPE_POLYGON},

     * {@link #SHAPE_CIRCLE}, {@link #SHAPE_ELLIPSE}, {@link #SHAPE_SQUARE} or {@link #SHAPE_QUAD}.

     *

     * @return the measure shape type.

     */

    public String getMeasureShapeType()

    {

        return this.measureShapeType;

    }

    /**

     * Set the measure shape type. can be one of {@link #SHAPE_LINE}, {@link #SHAPE_PATH}, {@link #SHAPE_POLYGON},

     * {@link #SHAPE_CIRCLE}, {@link #SHAPE_ELLIPSE}, {@link #SHAPE_SQUARE} or {@link #SHAPE_QUAD}. This will reset the

     * measure tool and clear the current measure shape.

     *

     * @param shape the measure shape type.

     */

    public void setMeasureShapeType(String shape)

    {

        if (shape == null)

        {

            String msg = Logging.getMessage("nullValue.ShapeType");

            Logging.logger().severe(msg);

            throw new IllegalArgumentException(msg);

        }

        if (!this.measureShapeType.equals(shape))

        {

            setArmed(false);

            clear();

            this.measureShapeType = shape;

        }

    }

    /**

     * Set and initialize the measure shape to one of the regular shapes {@link #SHAPE_CIRCLE}, {@link #SHAPE_ELLIPSE},

     * {@link #SHAPE_SQUARE} or {@link #SHAPE_QUAD}.

     *

     * @param shapeType      the shape type.

     * @param centerPosition ther shape center position.

     * @param radius         the shape radius of half width/height.

     */

    public void setMeasureShapeType(String shapeType, Position centerPosition, double radius)

    {

        setMeasureShapeType(shapeType, centerPosition, radius * 2, radius * 2, Angle.ZERO);

    }

    /**

     * Set and initialize the measure shape to one of the regular shapes {@link #SHAPE_CIRCLE}, {@link #SHAPE_ELLIPSE},

     * {@link #SHAPE_SQUARE} or {@link #SHAPE_QUAD}.

     *

     * @param shapeType      the shape type.

     * @param centerPosition ther shape center position.

     * @param width          the shape width.

     * @param height         the shape height.

     * @param orientation    the shape orientation or azimuth angle - clockwise from north.

     */

    public void setMeasureShapeType(String shapeType, Position centerPosition, double width, double height,