mx.graphics.SolidColorStroke源代码解析

1.简介
       继承关系：SolidColorStroke ->EventDispatcher ->Object
       SolidColorStroke 类定义线条的属性。您可以在 MXML 中定义 SolidColorStroke 对象，但是必须将该 SolidColorStroke 附加到其他对象上，才能在应用程序中显示出来。以下示例首先定义了两个 SolidColorStroke 对象，然后将其应用于 LineChart 控件的 horizontalAxisRenderer 中：

...
  <mx:SolidColorStroke id="ticks" color="0xFF0000" weight="1"/>
  <mx:SolidColorStroke id="mticks" color="0x0000FF" weight="1"/>

  <mx:LineChart id="mychart" dataProvider="{ndxa}">
      <mx:horizontalAxisRenderer>
          <mx:AxisRenderer placement="bottom" canDropLabels="true">
              <mx:tickStroke>{ticks}</mx:tickStroke>
              <mx:minorTickStroke>{mticks}</mx:minorTickStroke>
          </mx:AxisRenderer>
      </mx:horizontalAxisRenderer>
  </LineChart>

完全属性定义：

2.常见属性和方法
2.1 alpha : Number
线条的透明度。可能的值为 0.0（不可见）到 1.0（不透明）。
默认值为 1.0.。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

2.2 caps : String
指定线条末端处端点类型。有效值为：CapsStyle.ROUND、CapsStyle.SQUARE 和 CapsStyle.NONE。
默认值为 CapsStyle.ROUND。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

2.3 color : uint
线条颜色。默认值为 0x000000 (black).。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

2.4 joints : String
指定用于拐角的连接外观的类型。有效值为：JointStyle.ROUND、JointStyle.MITER 和 JointStyle.BEVEL。
默认值为 JointStyle.ROUND。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

2.5 miterLimit : Number
指示将在哪个限制位置开始进行斜角。有效值范围是 0 到 255。
默认值为 3。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

2.6 pixelHinting : Boolean
指定是否提示笔触采用完整像素。此值同时影响曲线锚点的位置以及线条笔触大小本身。
默认值为 false。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

2.7 scaleMode : String
LineScaleMode 类中的一个值，指定要使用的缩放模式。有效值为：
    LineScaleMode.NORMAL—始终在缩放对象时缩放线条的粗细（默认值）。
    LineScaleMode.NONE—从不缩放线条粗细。
    LineScaleMode.VERTICAL—如果仅垂直缩放对象，则不缩放线条粗细。
    LineScaleMode.HORIZONTAL—如果仅水平缩放对象，则不缩放线条粗细。
默认值为 LineScaleMode.NORMAL。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

2.8 weight : Number
线条粗细（以像素为单位）。对于很多图表，默认值都为 1 个像素。
此属性可用作数据绑定的源。修改此属性后，将分派 propertyChange 事件。

3源代码

package mx.graphics
{

import flash.display.CapsStyle;
import flash.display.Graphics;
import flash.display.GraphicsSolidFill;
import flash.display.GraphicsStroke;
import flash.display.JointStyle;
import flash.events.EventDispatcher;
import flash.geom.Point;
import flash.geom.Rectangle;

import mx.events.PropertyChangeEvent;

public class SolidColorStroke extends EventDispatcher implements IStroke
{
    include "../core/Version.as";
    /**
     * 构造函数
     */
    public function SolidColorStroke(color:uint = 0x000000,
                                     weight:Number = 1,
                                     alpha:Number = 1.0,
                                     pixelHinting:Boolean = false,
                                     scaleMode:String = "normal",
                                     caps:String = "round",
                                     joints:String = "round",
                                     miterLimit:Number = 3)   {
        super();

        this.color = color;
        this._weight = weight;
        this.alpha = alpha;
        this.pixelHinting = pixelHinting;
        this.scaleMode = scaleMode;
        this.caps = caps;
        this.joints = joints;
        this.miterLimit = miterLimit;
    }

    // 属性 alpha
    private var _alpha:Number = 0.0;

    [Bindable("propertyChange")]
    [Inspectable(category="General")]
    public function get alpha():Number
    {
        return _alpha;
    }
    public function set alpha(value:Number):void
    {
        var oldValue:Number = _alpha;
        if (value != oldValue)
        {
            _alpha = value;
            dispatchStrokeChangedEvent("alpha", oldValue, value);
        }
    }

    // 属性 caps
    private var _caps:String = CapsStyle.ROUND;
    [Bindable("propertyChange")]
    [Inspectable(category="General", enumeration="round,square,none", defaultValue="round")]
    public function get caps():String
    {
        return _caps;
    }

    public function set caps(value:String):void
    {
        var oldValue:String = _caps;
        if (value != oldValue)
        {
            _caps = value;
            dispatchStrokeChangedEvent("caps", oldValue, value);
        }
    }

    //  属性color
    private var _color:uint = 0x000000;
    [Bindable("propertyChange")]
    [Inspectable(category="General", format="Color")]
    public function get color():uint
    {
        return _color;
    }

    public function set color(value:uint):void
    {
        var oldValue:uint = _color;
        if (value != oldValue)
        {
            _color = value;
            dispatchStrokeChangedEvent("color", oldValue, value);
        }
    }

    // 属性 joints
    private var _joints:String = JointStyle.ROUND;
    [Bindable("propertyChange")]
    [Inspectable(category="General", enumeration="round,bevel,miter", defaultValue="round")]
    public function get joints():String
    {
        return _joints;
    }

    public function set joints(value:String):void
    {
        var oldValue:String = _joints;
        if (value != oldValue)
        {
            _joints = value;
            dispatchStrokeChangedEvent("joints", oldValue, value);
        }
    }

    // 属性miterLimit
    private var _miterLimit:Number = 3;
    [Bindable("propertyChange")]
    [Inspectable(category="General", minValue="1.0", maxValue="255.0")]
    public function get miterLimit():Number
    {
        return _miterLimit;
    }

    public function set miterLimit(value:Number):void
    {
        var oldValue:Number = _miterLimit;
        if (value != oldValue)
        {
            _miterLimit = value;
            dispatchStrokeChangedEvent("miterLimit", oldValue, value);
        }
    }

    // 属性pixelHinting
    private var _pixelHinting:Boolean = false;
    [Bindable("propertyChange")]
    [Inspectable(category="General")]
    public function get pixelHinting():Boolean
    {
        return _pixelHinting;
    }

    public function set pixelHinting(value:Boolean):void
    {
        var oldValue:Boolean = _pixelHinting;
        if (value != oldValue)
        {
            _pixelHinting = value;
            dispatchStrokeChangedEvent("pixelHinting", oldValue, value);
        }
    }

    // 属性 scaleMode
    private var _scaleMode:String = "normal";
    [Bindable("propertyChange")]
    [Inspectable(category="General", enumeration="normal,vertical,horizontal,none", defaultValue="normal")]
    public function get scaleMode():String
    {
        return _scaleMode;
    }

    public function set scaleMode(value:String):void
    {
        var oldValue:String = _scaleMode;
        if (value != oldValue)
        {
            _scaleMode = value;
            dispatchStrokeChangedEvent("scaleMode", oldValue, value);
        }
    }

    //  属性weight
    public function get weight():Number
    {
        return _weight;
    }

    public function set weight(value:Number):void
    {
        var oldValue:Number = _weight;
        if (value != oldValue)
        {
            _weight = value;
            dispatchStrokeChangedEvent("weight", oldValue, value);
        }
    }

    /**
     *  @inheritDoc
     *
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function apply(graphics:Graphics, targetBounds:Rectangle, targetOrigin:Point):void
    {
        graphics.lineStyle(weight, color, alpha, pixelHinting,
                    scaleMode, caps, joints, miterLimit);
    }

    /**
     *继承接口IStroke
     */
    public function createGraphicsStroke(targetBounds:Rectangle, targetOrigin:Point):GraphicsStroke
    {
        // 构造对象 GraphicsStroke 并设置其所有属性
        var graphicsStroke:GraphicsStroke = new GraphicsStroke();
        graphicsStroke.thickness = weight;
        graphicsStroke.miterLimit = miterLimit;
        graphicsStroke.pixelHinting = pixelHinting;
        graphicsStroke.scaleMode = scaleMode;

        // 在 Drawing API-2 中有个bug， caps 属性用none代替round
        graphicsStroke.caps = (!caps) ? CapsStyle.ROUND : caps;

        // 给GraphicsStroke的fill属性赋值一个 GraphicsSolidFill 对象(属性为alpha,color)
        var graphicsSolidFill:GraphicsSolidFill = new GraphicsSolidFill();
        graphicsSolidFill.color = color;
        graphicsSolidFill.alpha = alpha;
        graphicsStroke.fill = graphicsSolidFill;

        return graphicsStroke;
    }

    private function dispatchStrokeChangedEvent(prop:String, oldValue:*,  value:*):void
    {
        if (hasEventListener("propertyChange"))
            dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, prop,
                oldValue, value));
    }
}

}

参考文献
1.
2.