royale-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From alinak...@apache.org
Subject [royale-asjs] branch feature/MXRoyale updated: LineSeries.as Added
Date Thu, 10 May 2018 12:15:49 GMT
This is an automated email from the ASF dual-hosted git repository.

alinakazi pushed a commit to branch feature/MXRoyale
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git


The following commit(s) were added to refs/heads/feature/MXRoyale by this push:
     new d117640  LineSeries.as Added
d117640 is described below

commit d1176402b8486e8e551d9b40c7856a372e2775bf
Author: alinakazi <ALINAKAZI1990@GMAIL.COM>
AuthorDate: Thu May 10 17:15:45 2018 +0500

    LineSeries.as Added
---
 .../src/main/royale/mx/charts/series/LineSeries.as | 2225 ++++++++++++++++++++
 1 file changed, 2225 insertions(+)

diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/charts/series/LineSeries.as b/frameworks/projects/MXRoyale/src/main/royale/mx/charts/series/LineSeries.as
new file mode 100644
index 0000000..564d7ce
--- /dev/null
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/charts/series/LineSeries.as
@@ -0,0 +1,2225 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package mx.charts.series
+{
+
+/* import flash.display.DisplayObject;
+import flash.display.Graphics;
+import flash.geom.Point;
+import flash.geom.Rectangle;
+import flash.utils.Dictionary;
+
+import mx.charts.DateTimeAxis;
+import mx.charts.HitData;
+import mx.charts.chartClasses.BoundedValue;
+import mx.charts.chartClasses.CartesianChart;
+import mx.charts.chartClasses.CartesianTransform;
+import mx.charts.chartClasses.DataDescription;
+import mx.charts.chartClasses.GraphicsUtilities;
+import mx.charts.chartClasses.IAxis;
+import mx.charts.chartClasses.InstanceCache;
+import mx.charts.chartClasses.LegendData;
+import mx.charts.chartClasses.NumericAxis;
+import mx.charts.chartClasses.Series;
+import mx.charts.renderers.LineRenderer;
+import mx.charts.series.items.LineSeriesItem;
+import mx.charts.series.items.LineSeriesSegment;
+import mx.charts.series.renderData.LineSeriesRenderData;
+import mx.charts.styles.HaloDefaults;
+import mx.collections.CursorBookmark;
+import mx.core.ClassFactory;
+import mx.core.IDataRenderer;
+import mx.core.IFactory;
+import mx.core.IFlexDisplayObject;
+import mx.core.IFlexModuleFactory;
+import mx.core.mx_internal;
+import mx.graphics.IFill;
+import mx.graphics.IStroke;
+import mx.graphics.LinearGradientStroke;
+import mx.graphics.SolidColor;
+import mx.graphics.SolidColorStroke;
+import mx.graphics.Stroke;
+import mx.styles.CSSStyleDeclaration;
+import mx.styles.ISimpleStyleClient;
+
+use namespace mx_internal;
+
+include "../styles/metadata/FillStrokeStyles.as"
+include "../styles/metadata/ItemRendererStyles.as"
+ */
+ import org.apache.royale.charts.supportClasses.LineSeries;
+ 
+/**
+ *  Specifies the number of pixels by which radius of the chart item is to be 
+ *  increased when highlighted or selected.
+ * 
+ *  @default 2
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Flex 3
+ */
+//[Style(name="adjustedRadius", type="Number", format="Length", inherit="yes")]
+
+/**
+ *  Specifies an Array of fill objects that define the fill for
+ *  each item in the series. This takes precedence over the <code>fill</code> style property.
+ *  If a custom method is specified by the <code>fillFunction</code> property, that takes precedence over this Array.
+ *  If you do not provide enough Array elements for every item,
+ *  Flex repeats the fill from the beginning of the Array.
+ *  
+ *  <p>To set the value of this property using CSS:
+ *   <pre>
+ *    LineSeries {
+ *      fills:#CC66FF, #9966CC, #9999CC;
+ *    }
+ *   </pre>
+ *  </p>
+ *  
+ *  <p>To set the value of this property using MXML:
+ *   <pre>
+ *    &lt;mx:LineSeries ... &gt;
+ *     &lt;mx:fills&gt;
+ *      &lt;mx:SolidColor color="0xCC66FF"/&gt;
+ *      &lt;mx:SolidColor color="0x9966CC"/&gt;
+ *      &lt;mx:SolidColor color="0x9999CC"/&gt;
+ *     &lt;/mx:fills&gt;
+ *    &lt;/mx:LineSeries&gt;
+ *   </pre>
+ *  </p>
+ *  
+ *  <p>
+ *  If you specify the <code>fills</code> property and you
+ *  want to have a Legend control, you must manually create a Legend control and 
+ *  add LegendItems to it.
+ *  </p>
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Flex 3
+ */
+//[Style(name="fills", type="Array", arrayType="mx.graphics.IFill", inherit="no")]
+
+/**
+ *  Specifies the line type for the chart.
+ *  Possible values are:
+ *  <ul>
+ *    <li><code>"curve"</code>:
+ *    Draws curves between data points.</li>
+ *    
+ *    <li><code>"horizontal"</code>:
+ *    Draws only the vertical line from the x-coordinate
+ *    of the first point to the x-coordinate of the second point
+ *    at the y-coordinate of the second point.
+ *    Repeats this for each data point.</li>
+ *    
+ *    <li><code>"vertical"</code>:
+ *    Draws only the vertical line from the y-coordinate
+ *    of the first point to the y-coordinate of the second point
+ *    at the x-coordinate of the second point.
+ *    Repeats this for each data point.</li>
+ *    
+ *    <li><code>"segment"</code>:
+ *    Draws lines as connected segments that are angled
+ *    to connect at each data point in the series.</li>
+ *    
+ *    <li><code>"step"</code>:
+ *    Draws lines as horizontal segments.
+ *    At the first data point, draws a horizontal line
+ *    and then a vertical line to the second point,
+ *    and repeats for each data point.</li>
+ *    
+ *    <li><code>"reverseStep"</code>:
+ *    Draws lines as horizontal segments.
+ *    At the first data point, draws a vertical line
+ *    and then a horizontal line to the second point,
+ *    and repeats for each data point.</li>
+ *  </ul>
+ *  The default is <code>"segment"</code>.
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Flex 3
+ */
+//[Style(name="form", type="String", enumeration="segment,step,reverseStep,vertical,horizontal,curve", inherit="no")]
+
+/**
+ *  A factory that represents the class the series uses
+ *  to represent the individual line segments in the series.
+ *  This class is instantiated once
+ *  for each distinct segment of the series.
+ *  Classes used as lineSegmentRenderers should implement
+ *  the IFlexDisplayObject, ISimpleStyleClient, and IDataRenderer interfaces.
+ *  The <code>data</code> property is assigned an instance of
+ *  mx.charts.series.items.LineSeriesSegment
+ *  that describes the segment to render.
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Flex 3
+ */
+[Style(name="lineSegmentRenderer", type="mx.core.IFactory", inherit="no")]
+
+/** 
+  *  Sets the stroke for the actual line segments. 
+  *  The default value for a LineChart control is orange (<code>0xE48701</code>). 
+  *  The default color for a LineSeries used in a CartesianChart control is black (<code>0x000000</code>). 
+  *  The default value for the width is 3.
+  *  
+  *  @langversion 3.0
+  *  @playerversion Flash 9
+  *  @playerversion AIR 1.1
+  *  @productversion Flex 3
+  */
+[Style(name="lineStroke", type="mx.graphics.IStroke", inherit="no")]
+
+/** 
+ *  Specifies the radius, in pixels, of the chart elements for the data points.
+ *  This property applies only if you specify an item renderer
+ *  using the <code>itemRenderer</code> property.  
+ *  You can specify the <code>itemRenderer</code> in MXML or using styles.  
+ *  
+ *  @default 4 
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Flex 3
+ */
+//[Style(name="radius", type="Number", format="Length", inherit="no")]
+
+/**
+ *  Defines a data series for a LineChart control.
+ *  By default, this class uses the ShadowLineRenderer class. 
+ *  Optionally, you can define an itemRenderer for the data series.
+ *  The itemRenderer must implement the IDataRenderer interface. 
+ *
+ *  @mxml
+ *  
+ *  <p>The <code>&lt;mx:LineSeries&gt;</code> tag inherits all the properties
+ *  of its parent classes and adds the following properties:</p>
+ *  
+ *  <pre>
+ *  &lt;mx:LineSeries
+ *    <strong>Properties</strong>
+ *    fillFunction="<i>Internal fill function</i>"
+ *    horizontalAxis="<i>No default</i>"
+ *    interpolateValues="false|true"
+ *    sortOnXField="false|true"
+ *    verticalAxis="<i>No default</i>"
+ *    xField="null"
+ *    yField="null"
+ * 
+ *    <strong>Styles</strong>
+ *    adjustedRadius="2"
+ *    fill="0xFFFFFF"
+ *    fills="<i>IFill; no default</i>"
+ *    form="segment|curve|horizontal|reverseStep|step|vertical"
+ *    itemRenderer="<i>itemRenderer</i>"
+ *    legendMarkerRenderer="<i>Defaults to series's itemRenderer</i>"
+ *    lineSegmentRenderer="<i>ShadowLineRenderer</i>"
+ *    lineStroke="Stroke(0xE47801,3)"
+ *    radius="4"
+ *    stroke="<i>IStroke; no default</i>" 
+ *  /&gt;
+ *  </pre>
+ *  
+ *  @see mx.charts.LineChart
+ *  @see mx.core.IDataRenderer
+ *  
+ *  @includeExample ../examples/Line_AreaChartExample.mxml
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Flex 3
+ */
+public class LineSeries extends org.apache.royale.charts.supportClasses.LineSeries
+{     //extends Series
+    //include "../../core/Version.as";
+
+    //--------------------------------------------------------------------------
+    //
+    //  Class initialization
+    //
+    //--------------------------------------------------------------------------
+
+
+    //--------------------------------------------------------------------------
+    //
+    //  Constructor
+    //
+    //--------------------------------------------------------------------------
+    
+    /**
+     *  Constructor.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    public function LineSeries()
+    {
+        super();
+
+      /*   _pointInstanceCache = new InstanceCache(null, this, 1000);
+        _pointInstanceCache.creationCallback = applyItemRendererProperties;
+        
+        _segmentInstanceCache = new InstanceCache(null, this, 0);
+        _segmentInstanceCache.properties = { styleName: this };
+        
+        dataTransform = new CartesianTransform();
+
+        // our style settings
+        initStyles(); */
+    }
+
+    //--------------------------------------------------------------------------
+    //
+    //  Variables
+    //
+    //--------------------------------------------------------------------------
+    
+	 //----------------------------------
+    //  displayName copied from Series
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the displayName property.
+     */
+    private var _displayName:String;
+
+    [Inspectable(category="Display")]
+
+    /**
+     *  The name of the series, for display to the user.
+     *  This property is used to represent the series in user-visible labels,
+     *  such as data tips.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    public function get displayName():String
+    {
+        return _displayName;
+    }
+    
+    /**
+     *  @private
+     */
+    public function set displayName(value:String):void
+    {
+        _displayName = value;
+
+      /*   var c:ChartBase = chart;
+        if (c)
+            c.legendDataChanged(); */
+    }
+	
+	
+	//----------------------------------
+    //  styleName copied from UIComponent
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the styleName property.
+     */
+    private var _styleName:Object /* String, CSSStyleDeclaration, or UIComponent */;
+
+    [Inspectable(category="General")]
+
+    /**
+     *  The class style used by this component. This can be a String, CSSStyleDeclaration
+     *  or an IStyleClient.
+     *
+     *  <p>If this is a String, it is the name of one or more whitespace delimited class
+     *  declarations in an <code>&lt;fx:Style&gt;</code> tag or CSS file. You do not include the period
+     *  in the <code>styleName</code>. For example, if you have a class style named <code>".bigText"</code>,
+     *  set the <code>styleName</code> property to <code>"bigText"</code> (no period).</p>
+     *
+     *  <p>If this is an IStyleClient (typically a UIComponent), all styles in the
+     *  <code>styleName</code> object are used by this component.</p>
+     *
+     *  @default null
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    public function get styleName():Object /* String, CSSStyleDeclaration, or UIComponent */
+    {
+        return _styleName;
+    }
+
+    /**
+     *  @private
+     */
+    public function set styleName(value:Object /* String, CSSStyleDeclaration, or UIComponent */):void
+    {
+        if (_styleName === value)
+            return;
+
+        _styleName = value;
+
+        // If inheritingStyles is undefined, then this object is being
+        // initialized and we haven't yet generated the proto chain.
+        // To avoid redundant work, don't bother to create
+        // the proto chain here.
+       /*  if (inheritingStyles == StyleProtoChain.STYLE_UNINITIALIZED)
+            return;
+
+        regenerateStyleCache(true);
+
+        initThemeColor();
+
+        styleChanged("styleName");
+
+        notifyStyleChangeInChildren("styleName", true); */
+    }
+	
+	
+    /**
+     *  @private
+     */
+    //private static var _moduleFactoryInitialized:Dictionary = new Dictionary(true);
+
+    
+    /**
+     *  @private
+     */
+    //private var _pointInstanceCache:InstanceCache;
+    
+    /**
+     *  @private
+     */
+    //private var _renderData:LineSeriesRenderData;   
+
+    /**
+     *  @private
+     */
+    //private var _segmentInstanceCache:InstanceCache;
+    
+    /**
+     *  @private
+     */
+    //private var _localFills:Array /* of IFill */;
+    
+        
+    /**
+     *  @private
+     */
+    //private var _fillCount:int;
+     
+    /**
+     * @private
+     */
+   // private var _bAxesDirty:Boolean = false;
+     
+    //--------------------------------------------------------------------------
+    //
+    //  Overridden properties
+    //
+    //--------------------------------------------------------------------------
+
+    //----------------------------------
+    //  legendData
+    //----------------------------------
+
+    /**
+     *  @private
+     */
+    // override public function get legendData():Array /* of LegendData */
+    // {
+        // if (fillFunction!=defaultFillFunction || _fillCount!=0)
+        // {
+            // var keyItems:Array /* of LegendData */ = [];
+            // return keyItems;
+        // }
+        // var radius:Number = getStyle("radius")
+        // var itemRenderer:IFactory = getStyle("itemRenderer");
+
+        // var markerAspectRatio:Number;
+        // var color:int = 0;
+        // var marker:IFlexDisplayObject;
+        
+        // var ld:LegendData = new LegendData();
+        // ld.element = this;
+        // ld.label = displayName; 
+        
+        
+        // var markerFactory:IFactory = getStyle("legendMarkerRenderer");
+        // if (markerFactory)
+        // {
+            // marker = markerFactory.newInstance();
+            // if (marker is ISimpleStyleClient)
+                // (marker as ISimpleStyleClient).styleName = this;
+            // ld.aspectRatio = 1;
+        // }
+        // else if (!itemRenderer || radius == 0 || isNaN(radius))
+        // {
+            // marker = new LineSeriesLegendMarker(this);          
+        // }
+        // else
+        // {
+            // markerFactory = getStyle("itemRenderer");
+            // marker = markerFactory.newInstance();
+            // ld.aspectRatio = 1;
+            // if (marker as ISimpleStyleClient)
+                // (marker as ISimpleStyleClient).styleName = this;
+        // }
+
+        // ld.marker = marker;
+        
+        // return [ld];
+    // }
+ 
+    //----------------------------------
+    //  renderData
+    //----------------------------------
+
+    /**
+     *  @private
+     */
+    /* override protected function get renderData():Object
+    {
+        if (!_renderData||
+            !(_renderData.cache) ||
+            _renderData.cache.length == 0)
+        {
+            var renderDataType:Class = this.renderDataType;
+            var ld:LineSeriesRenderData = new renderDataType();
+            ld.cache = ld.filteredCache = [];
+            ld.segments = [];
+            ld.radius = 0;
+            return ld;
+        }
+
+        _renderData.radius = getStyle("radius");
+
+        return _renderData;
+    } */
+    
+    //--------------------------------------------------------------------------
+    //
+    //  Properties
+    //
+    //--------------------------------------------------------------------------
+
+    //-----------------------------------
+    // fillFunction
+    //-----------------------------------
+    
+    /* [Bindable]
+    [Inspectable(category="General")] */
+    
+    /**
+     * @private
+     * Storage for fillFunction property
+     */
+   /*  private var _fillFunction:Function=defaultFillFunction;
+     */
+    /**
+     * Specifies a method that returns the fill for the current chart item in the series.
+     * If this property is set, the return value of the custom fill function takes precedence over the 
+     * <code>fill</code> and <code>fills</code> style properties.
+     * But if it returns null, then <code>fills</code> and <code>fill</code> will be 
+     * prefered in that order.  
+     * 
+     * <p>The custom <code>fillFunction</code> has the following signature:
+     *  
+     * <pre>
+     * <i>function_name</i> (item:ChartItem, index:Number):IFill { ... }
+     * </pre>
+     * 
+     * <code>item</code> is a reference to the chart item that is being rendered.
+     * <code>index</code> is the index of the chart item in the renderData's cache. This is different
+     * from the index of the chart's data provider because it is sorted based on the x, y, and z values.
+     * This function returns an object that implements the <code>IFill</code> interface.
+     * </p>
+     *  
+     * <p>An example usage of a customized <code>fillFunction</code> is to return a fill
+     * based on some threshold.</p>
+     *   
+     * @example
+     * <pre>
+     * public function myFillFunction(item:ChartItem, index:Number):IFill {
+     *      var curItem:LineSeriesItem = LineSeriesItem(item);
+     *      if (curItem.yNumber > 10)
+     *          return(new SolidColor(0x123456, .75));
+     *      else
+     *          return(new SolidColor(0x563412, .75));
+     * }
+     * </pre>
+     *   
+     * <p>
+     *  If you specify a custom fill function for your chart series and you
+     *  want to have a Legend control, you must manually create a Legend control and 
+     *  add LegendItems to it.
+     *  </p>
+     *
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    /* public function get fillFunction():Function
+    {
+        return _fillFunction;
+    } */
+   
+    /**
+     * @private
+     */
+   /*  public function set fillFunction(value:Function):void
+    {
+        if (value ==_fillFunction)
+            return;
+            
+        if (value != null)
+            _fillFunction = value;
+        
+        else
+            _fillFunction = defaultFillFunction;
+        
+        invalidateDisplayList();
+        legendDataChanged();        
+    } */
+    
+    //----------------------------------
+    //  horizontalAxis
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the horizontalAxis property.
+     */
+   /*  private var _horizontalAxis:IAxis;
+    
+    [Inspectable(category="Data")]
+ */
+    /**
+     *  Defines the labels, tick marks, and data position
+     *  for items on the x-axis.
+     *  Use either the LinearAxis class or the CategoryAxis class
+     *  to set the properties of the horizontalAxis as a child tag in MXML
+     *  or create a LinearAxis or CategoryAxis object in ActionScript.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    /* public function get horizontalAxis():IAxis
+    {
+        return _horizontalAxis;
+    } */
+    
+    /**
+     *  @private
+     */
+   /*  public function set horizontalAxis(value:IAxis):void
+    {
+        _horizontalAxis = value;
+        _bAxesDirty = true;
+
+        invalidateData();
+        invalidateProperties();
+    } */
+    
+    //----------------------------------
+    //  interpolateValues
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the interpolateValues property.
+     */
+    /* private var _interpolateValues:Boolean = false; 
+
+    [Inspectable(category="General")] */
+
+    /** 
+     *  Specifies how to represent missing data.
+     *
+     *  <p>Set to <code>false</code> to break the line at the missing value.
+     *  Set to <code>true</code> to draw a continuous line by interpolating the missing value.</p>
+     *  
+     *  @default false
+    *  
+    *  @langversion 3.0
+    *  @playerversion Flash 9
+    *  @playerversion AIR 1.1
+    *  @productversion Flex 3
+    */
+    /* public function get interpolateValues():Boolean
+    {
+        return _interpolateValues;
+    } */
+
+    /**
+     *  @private
+     */
+   /*  public function set interpolateValues(value:Boolean):void
+    {
+        if (_interpolateValues != value)
+        {
+            _interpolateValues = value;
+
+            invalidateData();
+        }       
+    } */
+
+    //----------------------------------
+    //  items
+    //----------------------------------
+
+    /**
+     *  @inheritDoc
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    // override public function get items():Array /* of LineSeriesItem */
+    // {
+        // return _renderData ?
+               // _renderData.filteredCache :
+               // null;
+    // }
+
+    //----------------------------------
+    //  itemType
+    //----------------------------------
+
+   // [Inspectable(environment="none")]
+
+    /**
+     *  The subtype of ChartItem used by this series
+     *  to represent individual items.
+     *  Subclasses can override and return a more specialized class
+     *  if they need to store additional information in the items.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+   /*  protected function get itemType():Class
+    {
+        return LineSeriesItem;
+    } */
+    
+    //----------------------------------
+    //  lineSegmentType
+    //----------------------------------
+
+    //[Inspectable(environment="none")]
+
+    /**
+     *  The class used by this series to store all data
+     *  necessary to represent a line segment.
+     *  Subclasses can override and return a more specialized class
+     *  if they need to store additional information for rendering.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    /* protected function get lineSegmentType():Class
+    {
+        return LineSeriesSegment;
+    }
+ */
+    //----------------------------------
+    //  radius
+    //----------------------------------
+
+    //[Inspectable(category="Styles")]
+
+    /** 
+     *  Specifies the radius, in pixels, of the chart elements
+     *  for the data points.
+     *  This property applies only if you specify an item renderer
+     *  using the <code>itemRenderer</code> property.  
+     *  You can specify the <code>itemRenderer</code> in MXML or using styles.  
+     *  
+     *  @default 0
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+   /*  public function get radius():Number
+    {
+        return getStyle("radius");
+    } */
+    
+    /**
+     *  @private
+     */
+   /*  public function set radius(value:Number):void
+    {
+        setStyle("radius", value);
+    } */
+
+    //----------------------------------
+    //  renderDataType
+    //----------------------------------
+
+    //[Inspectable(environment="none")]
+
+    /**
+     *  The subtype of ChartRenderData used by this series
+     *  to store all data necessary to render.
+     *  Subclasses can override and return a more specialized class
+     *  if they need to store additional information for rendering.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+   /*  protected function get renderDataType():Class
+    {
+        return LineSeriesRenderData;
+    }  */   
+    
+    //----------------------------------
+    //  sortOnXField
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the sortOnXField property.
+     */
+   /*  private var _sortOnXField:Boolean = true;
+
+    [Inspectable] */
+
+    /** 
+     *  Requests the line datapoints be sorted from left to right
+     *  before rendering.
+     *
+     *  <p>By default, the LineSeries renders points from left to right.
+     *  Set this property to <code>false</code> to render the items
+     *  in the order they appear in the data provider.</p>
+     *
+     *  @default true
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+   /*  public function get sortOnXField():Boolean
+    {
+        return _sortOnXField;
+    } */
+
+    /**
+     *  @private
+     */
+    /* public function set sortOnXField(value:Boolean):void 
+    {
+        if (_sortOnXField == value)
+            return;
+        _sortOnXField = value;
+
+        invalidateMapping();
+    } */
+
+    //----------------------------------
+    //  verticalAxis
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the verticalAxis property.
+     */
+   /*  private var _verticalAxis:IAxis;
+
+    [Inspectable(category="Data")] */
+
+    /**
+     *  Defines the labels, tick marks, and data position
+     *  for items on the y-axis.
+     *  Use either the LinearAxis class or the CategoryAxis class
+     *  to set the properties of the verticalAxis as a child tag in MXML
+     *  or create a LinearAxis or CategoryAxis object in ActionScript.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+   /*  public function get verticalAxis():IAxis
+    {
+        return _verticalAxis;
+    } */
+    
+    /**
+     *  @private
+     */
+    /* public function set verticalAxis(value:IAxis):void
+    {
+        _verticalAxis = value;
+        _bAxesDirty = true;
+
+        invalidateData();
+        //invalidateChildOrder();
+        invalidateProperties();
+    } */
+    
+    //----------------------------------
+    //  xField
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the xField property.
+     */
+    /* private var _xField:String = "";
+    
+    [Inspectable(category="General")]
+ */
+    /**
+     *  Specifies the field of the data provider
+     *  that determines the x-axis location of each data point. 
+     *  If <code>null</code>, the data points are rendered
+     *  in the order they appear in the data provider.
+     *
+     *  @default null
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+   /*  public function get xField():String
+    {
+        return _xField;
+    } */
+    
+    /**
+     *  @private
+     */
+   /*  public function set xField(value:String):void
+    {
+        _xField = value;
+
+        dataChanged();
+    } */
+
+    //----------------------------------
+    //  yField
+    //----------------------------------
+
+    /**
+     *  @private
+     *  Storage for the yField property.
+     */
+    /* private var _yField:String = "";    
+    
+    [Inspectable(category="General")] */
+
+    /**
+     *  Specifies the field of the data provider
+     *  that determines the y-axis location of each data point. 
+     *  If <code>null</code>, the LineSeries assumes the data provider
+     *  is an Array of numbers, and uses the numbers as values. 
+     *
+     *  @default null
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+   /*  public function get yField():String
+    {
+        return _yField;
+    }
+     */
+    /**
+     *  @private
+     */
+    /* public function set yField(value:String):void
+    {
+        _yField = value;
+
+        dataChanged();
+    } */
+    
+    
+    //--------------------------------------------------------------------------
+    //
+    //  Overridden methods: UIComponent
+    //
+    //--------------------------------------------------------------------------
+
+	/**
+     *  @private
+     */
+    /* private function initStyles():void
+    {
+        HaloDefaults.init(styleManager);
+
+		var lineSeriesStyle:CSSStyleDeclaration = HaloDefaults.findStyleDeclaration(styleManager, "mx.charts.series.LineSeries");
+
+
+		if (lineSeriesStyle)
+		{
+			lineSeriesStyle.setStyle("lineSegmentRenderer", new ClassFactory(LineRenderer));
+			lineSeriesStyle.setStyle("fill", new SolidColor(0xFFFFFF));
+			lineSeriesStyle.setStyle("fills", []);
+			lineSeriesStyle.setStyle("lineStroke", new SolidColorStroke(0,3));
+		}
+        else
+        {
+            //Fallback to set the style to this chart directly.
+			setStyle("lineSegmentRenderer", new ClassFactory(LineRenderer));
+			setStyle("fill", new SolidColor(0xFFFFFF));
+			setStyle("fills", []);
+			setStyle("lineStroke", new SolidColorStroke(0,3));
+        }
+    } */
+
+
+    /**
+     *  @inheritDoc
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    /* override public function set moduleFactory(factory:IFlexModuleFactory):void
+    {
+        super.moduleFactory = factory;
+        
+        if (_moduleFactoryInitialized[factory])
+            return;
+        
+        _moduleFactoryInitialized[factory] = true;
+    } */
+    
+    /**
+     *  @inheritDoc
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    /* override protected function commitProperties():void
+    {
+        super.commitProperties();
+        
+        if (dataTransform)
+        {
+            if (_horizontalAxis)
+            {
+                _horizontalAxis.chartDataProvider = dataProvider;
+                CartesianTransform(dataTransform).setAxis(
+                    CartesianTransform.HORIZONTAL_AXIS,_horizontalAxis);
+            }
+              
+            if (_verticalAxis)
+            {
+                _verticalAxis.chartDataProvider = dataProvider;
+                CartesianTransform(dataTransform).setAxis(
+                    CartesianTransform.VERTICAL_AXIS, _verticalAxis);
+            } 
+        }
+        
+        var c:CartesianChart = CartesianChart(chart);
+        if (c)
+        {
+            if (!_horizontalAxis)
+            {
+                if (dataTransform.axes[CartesianTransform.HORIZONTAL_AXIS] != c.horizontalAxis)
+                        CartesianTransform(dataTransform).setAxis(
+                            CartesianTransform.HORIZONTAL_AXIS,c.horizontalAxis);
+            }
+                            
+            if (!_verticalAxis)
+            {
+                if (dataTransform.axes[CartesianTransform.VERTICAL_AXIS] != c.verticalAxis)
+                        CartesianTransform(dataTransform).setAxis(
+                            CartesianTransform.VERTICAL_AXIS, c.verticalAxis);
+            }
+        }
+        dataTransform.elements = [this];
+    } */
+    
+    /**
+     *  @private
+     */
+    // override protected function updateDisplayList(unscaledWidth:Number,
+                                                  // unscaledHeight:Number):void
+    // {
+        // super.updateDisplayList(unscaledWidth, unscaledHeight);
+        
+        // var renderData:LineSeriesRenderData = (transitionRenderData)? LineSeriesRenderData(transitionRenderData) :_renderData; 
+        // if (!renderData || !(renderData.filteredCache))
+            // return;
+        
+        // var g:Graphics = graphics;
+        
+        // g.clear();
+
+        // var radius:Number = getStyle("radius");     
+        // var sampleCount:int = renderData.filteredCache.length;
+        // var i:int;
+            
+        
+        // var segCount:int = renderData.segments.length;
+
+    
+        // var activeRenderCache:Array /* of LineSeriesItem */;
+        
+        ////figure out what cache we're rendering from. If there's a bounds based transtion underway, we need
+        ////to rebuild our cache from the bounds
+        // if (renderData == transitionRenderData && renderData.elementBounds)
+        // {
+            // var elementBounds:Array /* of Rectangle */ = renderData.elementBounds;
+            // sampleCount= elementBounds.length;
+            // activeRenderCache = renderData.filteredCache;
+
+
+            // for (i = 0; i < sampleCount; i++)
+            // {
+                // var rcBounds:Object = elementBounds[i];
+                // var localData:LineSeriesItem = activeRenderCache[i];
+                // localData.x = (rcBounds.left + rcBounds.right)/2;
+                // localData.y = (rcBounds.bottom + rcBounds.top)/2;
+            // }
+        // }
+        // else
+        // {
+            // activeRenderCache = renderData.filteredCache;
+        // }
+
+        ////now position each segment
+        
+        // _segmentInstanceCache.factory = getStyle("lineSegmentRenderer");
+        // _segmentInstanceCache.count = segCount;
+        // var instances:Array /* of IFlexDisplayObject */ = _segmentInstanceCache.instances;
+        // var v:LineSeriesItem;
+        
+        // for (i = 0; i < segCount; i++)
+        // {
+            // var segment:IFlexDisplayObject = instances[i];
+            // if (segment is IDataRenderer)
+                // IDataRenderer(segment).data = renderData.segments[i];
+            // segment.setActualSize(unscaledWidth,unscaledHeight);
+        // }       
+        
+        
+        ////if the user has asked for markers at each datapoint, position those as well
+        // if (radius > 0)
+        // {
+            // _pointInstanceCache.factory = getStyle("itemRenderer");
+            // _pointInstanceCache.count = renderData.validPoints;         
+
+            // instances = _pointInstanceCache.instances;
+            // var nextInstanceIdx:int = 0;
+
+            // var bSetData:Boolean = (sampleCount > 0 && (instances[0] is IDataRenderer))
+
+            // var rc:Rectangle;
+            // var inst:IFlexDisplayObject;
+            
+            // if (renderData == transitionRenderData && renderData.elementBounds)
+            // {
+                // for (i = 0; i < sampleCount; i++)
+                // {
+                    // v = activeRenderCache[i];
+                    // inst = instances[nextInstanceIdx++];
+                    // v.itemRenderer = inst;
+                    // v.fill = fillFunction(v,i);
+                    // if (!(v.fill))
+                        // v.fill = defaultFillFunction(v,i);
+                    // if (v.itemRenderer && (v.itemRenderer as Object).hasOwnProperty('invalidateDisplayList'))
+                        // (v.itemRenderer as Object).invalidateDisplayList();
+                    // if (inst)
+                    // {
+                        // if (bSetData)
+                            // IDataRenderer(inst).data = v;
+                        // rc = elementBounds[i];
+                        // inst.move(rc.left,rc.top);
+                        // inst.setActualSize(rc.width,rc.height);
+                    // }
+                // }
+            // }
+            // else
+            // {
+                // for (i = 0; i < sampleCount; i++)
+                // {
+                    // v  = activeRenderCache[i];
+                    // var e:Object = renderData.filteredCache[i];
+                   //// if (filterData && (isNaN(e.xFilter) || isNaN(e.yFilter)))
+                    // if(filterFunction == defaultFilterFunction && 
+                            // ((filterDataValues == "outsideRange" && (isNaN(e.xFilter) || isNaN(e.yFilter))) ||
+                             // (filterDataValues == "nulls" && (isNaN(e.xNumber) || isNaN(e.yNumber)))))
+                        // continue;
+
+                    // inst = instances[nextInstanceIdx++];
+                    // v.itemRenderer = inst;
+                    // v.fill = fillFunction(v,i);
+                    // if (!(v.fill))
+                        // v.fill = defaultFillFunction(v,i);
+                    // if (v.itemRenderer && (v.itemRenderer as Object).hasOwnProperty('invalidateDisplayList'))
+                        // (v.itemRenderer as Object).invalidateDisplayList();
+                    // if (inst)
+                    // {
+                        // if (bSetData)
+                            // IDataRenderer(inst).data = v;
+                        // inst.move(v.x-radius,v.y - radius);
+                        // inst.setActualSize(2*radius,2*radius);
+                    // }
+                // }
+                // if (chart && allSeriesTransform && chart.chartState == 0)
+                    // chart.updateAllDataTips();
+            // }               
+        // }
+    // }
+    
+    /**
+     *  @private
+     */
+    /* override public function stylesInitialized():void
+    {
+        _localFills = getStyle('fills');
+        if (_localFills != null)
+            _fillCount = _localFills.length;
+        else
+            _fillCount = 0;
+        super.stylesInitialized();
+    } */
+
+    /**
+     *  @private
+     */
+    /* override public function styleChanged(styleProp:String):void
+    {
+        super.styleChanged(styleProp);
+        var styles:String = "fills"
+        if (styles.indexOf(styleProp)!=-1)
+        {
+            _localFills = getStyle('fills');
+            if (_localFills != null)
+                _fillCount = _localFills.length;
+            else
+                _fillCount = 0;                
+        }
+        if (styleProp == "itemRenderer")
+        {
+            _pointInstanceCache.remove = true;
+            _pointInstanceCache.discard = true;
+            _pointInstanceCache.count = 0;
+            _pointInstanceCache.discard = false;
+            _pointInstanceCache.remove = false;
+        }
+        if (styleProp == "lineSegmentRenderer")
+        {
+            _segmentInstanceCache.remove = true;
+            _segmentInstanceCache.discard = true;
+            _segmentInstanceCache.count = 0;
+            _segmentInstanceCache.discard = false;
+            _segmentInstanceCache.remove = false;
+        }
+
+        invalidateDisplayList();
+
+        legendDataChanged();
+    } */
+
+    //--------------------------------------------------------------------------
+    //
+    //  Overridden methods: ???
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  @private
+     */
+    /* override protected function updateData():void
+    {
+        var renderDataType:Class = this.renderDataType;
+        _renderData= new renderDataType();
+
+        _renderData.cache = [];
+
+        if (dataProvider)
+        {           
+            cursor.seek(CursorBookmark.FIRST);
+            var i:int = 0;
+            var itemClass:Class = itemType;
+            while (!cursor.afterLast)
+            {
+                _renderData.cache[i] = new itemClass(this,cursor.current,i);
+                i++;
+                cursor.moveNext();
+            }
+
+            cacheDefaultValues(_yField,_renderData.cache,"yValue");
+            cacheIndexValues(_xField,_renderData.cache,"xValue");
+        }
+        if(dataTransform && dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS) is NumericAxis &&
+            !(dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS) is DateTimeAxis) && 
+            (dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS) as NumericAxis).direction == "inverted")  
+            _renderData.cache = reverseYValues(_renderData.cache);
+        if(dataTransform && dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS) is NumericAxis &&
+            !(dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS) is DateTimeAxis) &&
+            (dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS) as NumericAxis).direction == "inverted")  
+            _renderData.cache = reverseXValues(_renderData.cache);  
+        _renderData.validPoints = _renderData.cache.length;
+        super.updateData();
+    } */
+
+    /**
+     *  @private
+     */
+    /* override protected function updateMapping():void
+    {
+        dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS).mapCache(_renderData.cache,"xValue","xNumber", (_xField == ""));
+        dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS).mapCache(_renderData.cache,"yValue","yNumber");
+        // now convert
+        if (_xField != "" && _sortOnXField)
+            _renderData.cache.sortOn("xNumber",Array.NUMERIC);      
+
+        super.updateMapping();
+
+    } */
+
+    /**
+     *  @private
+     */
+    /* override protected function updateFilter():void
+    {
+        _renderData.segments = [];
+        var lineSegmentType:Class = this.lineSegmentType;
+        _renderData.filteredCache = filterFunction(_renderData.cache);
+    
+        if(filterFunction != defaultFilterFunction)
+        // we do this only for custom filter function because default filter function
+        //already does this as part of the function.
+        {
+            createLineSegments(_renderData.filteredCache);
+        }
+        super.updateFilter();
+    } */
+    
+    /**
+     *  @private
+     */
+    /* override protected function updateTransform():void
+    {
+        dataTransform.transformCache(_renderData.filteredCache,"xNumber","x","yNumber","y");
+        super.updateTransform();
+        allSeriesTransform = true;
+            
+        if (chart && chart is CartesianChart)
+        {   
+            var cChart:CartesianChart = CartesianChart(chart);  
+            var n:int = cChart.series.length;
+            
+            for (var i:int = 0; i < n; i++)
+            {
+                if (cChart.getSeriesTransformState(cChart.series[i]))
+                    allSeriesTransform = false;
+            }
+            if (allSeriesTransform)
+                cChart.measureLabels();
+        }   
+    }
+ */
+    /**
+     *  @private
+     */
+    // override public function describeData(dimension:String,
+                                          // requiredFields:uint):Array /* of DataDescription */
+    // {
+        // validateData();
+
+        // if (_renderData.cache.length == 0)
+            // return [];
+            
+        // var description:DataDescription = new DataDescription();
+        // description.boundedValues = null;
+
+        // var dataMargin:Number;
+        // var stroke:IStroke;
+        // var radius:Number;
+        // var renderer:Object;
+
+        // if (dimension == CartesianTransform.VERTICAL_AXIS)
+        // {
+            // extractMinMax(_renderData.cache,"yNumber",description);
+            // if ((requiredFields & DataDescription.REQUIRED_BOUNDED_VALUES) != 0)
+            // {
+                // dataMargin = 0;
+                
+                // stroke = getStyle("lineStroke");
+                // if (stroke)
+                    // dataMargin = stroke.weight/2;
+                
+                // radius = getStyle("radius");
+                // renderer = getStyle("itemRenderer");
+                // if (radius > 0 && renderer)
+                // {
+                    // stroke = getStyle("stroke");
+                    // if (stroke)
+                        // radius += stroke.weight/2;
+                        
+                    // dataMargin = Math.max(radius,dataMargin);
+                // }
+
+                // if (dataMargin > 0)
+                // {
+                    // description.boundedValues= [];
+                    // description.boundedValues.push(new BoundedValue(description.max,0,dataMargin));
+                    // description.boundedValues.push(new BoundedValue(description.min,dataMargin,0));
+                // }
+            // }
+        // }
+        // else if (dimension == CartesianTransform.HORIZONTAL_AXIS)
+        // {
+            // if (_xField != "")
+            // {
+                // if ((requiredFields & DataDescription.REQUIRED_MIN_INTERVAL) != 0)
+                // {
+                  ////  if we need to know the min interval, then we rely on the cache being in order. So we need to sort it if it
+                  ////  hasn't already been sorted
+                    // var cache:Array /* of LineSeriesItem */ = _renderData.cache;
+                    // if (_sortOnXField == false)
+                    // {
+                        // cache = _renderData.cache.concat();
+                        // cache.sortOn("xNumber",Array.NUMERIC);      
+                    // }
+                    // extractMinMax(cache,"xNumber",description,(0 != (requiredFields & DataDescription.REQUIRED_MIN_INTERVAL)));
+                // }
+                // else
+                // {
+                    // extractMinMax(_renderData.cache,"xNumber",description, (requiredFields & DataDescription.REQUIRED_MIN_INTERVAL) != 0);
+                // }
+            // }
+            // else 
+            // {
+                // description.min = _renderData.cache[0].xNumber;
+                // description.max = _renderData.cache[_renderData.cache.length-1].xNumber;
+                // if ((requiredFields & DataDescription.REQUIRED_MIN_INTERVAL) != 0)
+                // {
+                    // extractMinInterval(_renderData.cache,"xNumber",description);
+                // }
+            // }
+
+            // if ((requiredFields & DataDescription.REQUIRED_BOUNDED_VALUES) != 0)
+            // {
+                // dataMargin = 0;
+                
+                // stroke = getStyle("lineStroke");
+                // if (stroke)
+                    // dataMargin = stroke.weight/2;
+                
+                // radius = getStyle("radius");
+                // renderer = getStyle("itemRenderer");
+                // if (radius > 0 && renderer)
+                // {
+                    // stroke = getStyle("stroke");
+                    // if (stroke)
+                        // radius += stroke.weight/2;
+                        
+                    // dataMargin = Math.max(radius,dataMargin);
+                // }
+
+                // if (dataMargin > 0)
+                // {
+                    // description.boundedValues= [];
+                    // description.boundedValues.push(new BoundedValue(description.max,0,dataMargin));
+                    // description.boundedValues.push(new BoundedValue(description.min,dataMargin,0));
+                // }
+            // }
+        // }
+        // else
+        // {
+            // return [];
+        // }
+            
+        // return [ description ];
+    // }
+    
+    /**
+     *  @private
+     */
+    // override public function getAllDataPoints():Array /* of HitData */
+    // {
+        // if (!_renderData)
+            // return [];
+        // if (!(_renderData.filteredCache))
+            // return [];
+        
+        // var itemArr:Array /* of LineSeriesItem */ = [];
+        // if (chart && chart.dataTipItemsSet && dataTipItems)
+            // itemArr = dataTipItems;
+        // else if (chart && chart.showAllDataTips && _renderData.filteredCache)
+            // itemArr = _renderData.filteredCache;
+        // else
+            // itemArr = [];
+        
+        // var n:uint = itemArr.length;
+        // var i:uint;
+        // var result:Array /* of HitData */ = [];
+        
+        // for (i = 0; i < n; i++)
+        // {
+            // var v:LineSeriesItem = itemArr[i];
+            // if (_renderData.filteredCache.indexOf(v) == -1)
+            // {
+                // var itemExists:Boolean = false;
+                // var m:int  = _renderData.filteredCache.length;
+                // for (var j:int = 0; j < m; j++)
+                // {
+                    // if (v.item == _renderData.filteredCache[j].item)
+                    // {   
+                        // v = _renderData.filteredCache[j];
+                        // itemExists = true;
+                        // break;
+                    // }
+                // }
+                // if (!itemExists)
+                    // continue;
+            // }
+            // if (v)
+            // {
+                // var hd:HitData = new HitData(createDataID(v.index),Math.sqrt(0),v.x,v.y,v);
+
+                // var istroke:IStroke = getStyle("lineStroke");
+                // if (istroke is SolidColorStroke)
+                    // hd.contextColor = SolidColorStroke(istroke).color;
+                // else if (istroke is LinearGradientStroke)
+                // {
+                    // var gb:LinearGradientStroke = LinearGradientStroke(istroke);
+                    // if (gb.entries.length > 0)
+                        // hd.contextColor = gb.entries[0].color;
+                // }
+                // hd.dataTipFunction = formatDataTip;
+                // result.push(hd);
+            // }
+        // }
+        // return result;
+    // }
+
+    /**
+     *  @private
+     */
+    // override public function findDataPoints(x:Number,y:Number,sensitivity:Number):Array /* of HitData */
+    // {
+       // // esg, 8/7/06: if your mouse is over a series when it gets added and displayed for the first time, this can get called
+       // // before updateData, and before and render data is constructed. The right long term fix is to make sure a stubbed out 
+       // // render data is _always_ present, but that's a little disruptive right now.
+       // // if (interactive == false || !_renderData)
+            // return [];
+
+        // var pr:Number = getStyle("radius");
+        // var minDist2:Number  = pr + sensitivity;
+        // minDist2 *= minDist2;
+        // var minItem:LineSeriesItem = null;     
+        // var pr2:Number = pr * pr;
+        
+        // var n:int = _renderData.filteredCache.length;
+
+        // if (n == 0)
+            // return [];
+
+        // if (sortOnXField == true)
+        // {            
+            // var low:Number = 0;
+            // var high:Number = n;
+            // var cur:Number = Math.floor((low+high)/2);
+    
+            // var bFirstIsNaN:Boolean = isNaN(_renderData.filteredCache[0]);
+    
+            // while (true)
+            // {
+                // var v:LineSeriesItem = _renderData.filteredCache[cur];          
+                // if (!isNaN(v.yNumber) && !isNaN(v.xNumber))
+                // {
+                    // var dist:Number = (v.x  - x)*(v.x  - x) + (v.y - y)*(v.y -y);
+                    // if (dist <= minDist2)
+                    // {
+                        // minDist2 = dist;
+                        // minItem = v;                
+                    // }
+                // }
+                // var a:Number;
+                // var b:Number;
+                // if(dataTransform && dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS) is NumericAxis &&
+                // (dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS) as NumericAxis).direction == "inverted")
+                // {
+                    // a = x;
+                    // b = v.x;
+                // }
+                // else
+                // {
+                    // a = v.x;
+                    // b = x;
+                // }
+               //// if there are NaNs in this array, it's for one of a couple of reasons:
+               //// 1) there were NaNs in the data, which menas an xField was provided, which means they got sorted to the end
+               //// 2) some values got filtered out, in which case we can (sort of) safely assumed that the got filtered from one side, the other, or the entire thing.
+               //// we'll assume that an axis hasn't filtered a middle portion of the array.
+               //// since we can assume that any NaNs are at the beginning or the end, we'll rely on that in our binary search.  If there was a NaN in the first slot,
+               //// then we'll assume it's safe to move up the array if we encounter a NaN.  It's possible the entire array is NaN, but then nothing will match, so that's ok.
+                // if (a < b || (isNaN(v.x) && bFirstIsNaN))
+                // {
+                    // low = cur;
+                    // cur = Math.floor((low + high)/2);
+                    // if (cur == low)
+                        // break;
+                // }
+                // else
+                // {
+                    // high = cur;
+                    // cur = Math.floor((low + high)/2);
+                    // if (cur == high)
+                        // break;
+                // }
+            // }
+        // }
+        // else
+        // {
+            // var i:uint;
+            // for (i = 0; i < n; i++)
+            // {
+               // v = _renderData.filteredCache[i];          
+               // if (!isNaN(v.yNumber) && !isNaN(v.xNumber))
+                // {
+                   // dist = (v.x  - x)*(v.x  - x) + (v.y - y)*(v.y -y);
+                   // if (dist <= minDist2)
+                   // {
+                       // minDist2 = dist;
+                       // minItem = v;               
+                   // }
+                // }
+           // }
+        // }
+        
+        // if (minItem)
+        // {
+            // var hd:HitData = new HitData(createDataID(minItem.index),Math.sqrt(minDist2),minItem.x,minItem.y,minItem);
+
+            // var istroke:IStroke = getStyle("lineStroke");
+            // if (istroke is SolidColorStroke)
+                // hd.contextColor = SolidColorStroke(istroke).color;
+            // else if (istroke is LinearGradientStroke)
+            // {
+                // var gb:LinearGradientStroke = LinearGradientStroke(istroke);
+                // if (gb.entries.length > 0)
+                    // hd.contextColor = gb.entries[0].color;
+            // }
+            // hd.dataTipFunction = formatDataTip;
+            // return [ hd ];
+        // }
+
+        // return [];
+    // }
+
+
+    /**
+     *  @private
+     */
+    // override public function getElementBounds(renderData:Object):void
+    // {
+        // var cache :Array /* of LineSeriesItem */ = renderData.cache;
+        // var segments:Array /* of LineSeriesSegment */ = renderData.segments;
+        
+        // var rb :Array /* of Rectangle */ = [];
+        // var sampleCount:int = cache.length;     
+
+        // if (sampleCount == 0)
+            // maxBounds  = new Rectangle();
+        // else
+        // {
+            // var radius:Number = renderData.radius;
+
+            // if (radius == 0 || isNaN(radius))
+                // radius = 1;
+
+            // var segCount:int = segments.length;
+            // if (segCount)
+            // {
+                // var v:Object = cache[renderData.segments[0].start];
+                // var maxBounds:Rectangle = new Rectangle(v.x,v.y,0,0);
+            // }
+
+
+            // for (var i:int = 0; i < segCount; i++)
+            // {       
+                // var j:int;    
+                // var seg:Object = renderData.segments[i];
+                // if (i > 0){
+                    // var prevSeg:Object = renderData.segments[i-1];
+                    // if (seg.start > prevSeg.end + 1){
+                        // for (j = prevSeg.end + 1; j < seg.start ; j++){
+                            // var rect:Rectangle = new Rectangle(0, 0, 0, 0);
+                            // rb[j] = rect; 
+                        // }
+                    // }
+                // }
+                // for (j = seg.start; j <= seg.end; j++)
+                // {
+                    // v = cache[j];
+                    // var b:Rectangle = new Rectangle(v.x-radius,v.y-radius,2*radius,2*radius);
+
+                    // maxBounds.left = Math.min(maxBounds.left,b.left);
+                    // maxBounds.top = Math.min(maxBounds.top,b.top);
+                    // maxBounds.right = Math.max(maxBounds.right,b.right);
+                    // maxBounds.bottom = Math.max(maxBounds.bottom,b.bottom);
+                    // rb[j] = b;
+                // }
+            // }
+        // }
+        
+
+        // renderData.elementBounds = rb;
+        // renderData.bounds =  maxBounds;
+    // }
+
+    /**
+     *  @private
+     */
+    // override public function beginInterpolation(sourceRenderData:Object,
+                                                // destRenderData:Object):Object
+    // {
+        // var idata:Object = initializeInterpolationData(
+            // sourceRenderData.cache, destRenderData.cache,
+            // { x: true, y: true }, itemType,
+            // { sourceRenderData: sourceRenderData,
+              // destRenderData: destRenderData });
+
+        // var interpolationRenderData:LineSeriesRenderData = LineSeriesRenderData(destRenderData.clone());
+
+        // interpolationRenderData.cache = idata.cache;    
+        // interpolationRenderData.filteredCache = idata.cache;    
+
+        // /* the segments in the renderdata have pointers back to the filetered cache.  since we just replaced the filtered cache, we need to iterate through and 
+        // /  update those */
+        // var segs:Array /* of LineSeriesSegment */ = interpolationRenderData.segments;
+        // var n:int = segs.length;
+        // for (var i:int = 0; i < n; i++)
+        // {
+            // segs[i].items = idata.cache;
+        // }
+        
+        // transitionRenderData = interpolationRenderData;
+        // return idata;
+    // }
+
+    /**
+     *  @private
+     */
+    // override protected function getMissingInterpolationValues(
+                                    // sourceProps:Object, srcCache:Array /* of LineSeriesItem */,
+                                    // destProps:Object, destCache:Array /* of LineSeriesItem */,
+                                    // index:Number, customData:Object):void
+    // {
+        // var cache:Array /* of LineSeriesItem */ = customData.sourceRenderData.cache;
+        // var dstCache:Array /* of LineSeriesItem */ = customData.destRenderData.cache;
+        
+        // for (var p:String in sourceProps)
+        // {
+            // var src:Number = sourceProps[p];
+            // var dst:Number = destProps[p];
+
+
+            // var lastValidIndex:int = index;
+            // if (isNaN(src))
+            // {
+                // if (cache.length == 0)
+                // {
+                    // src = (p == "x")? dstCache[index].x : unscaledHeight;
+                // }
+                // else
+                // {
+                    // if (lastValidIndex >= cache.length)
+                        // lastValidIndex = cache.length-1;
+                    // while (lastValidIndex >= 0 && isNaN(cache[lastValidIndex][p]))
+                    // {
+                        // lastValidIndex--;
+                    // }
+                    // if (lastValidIndex >= 0)
+                        // src =   cache[lastValidIndex][p] + .01 * (lastValidIndex - index);
+                    // if (isNaN(src))
+                    // {
+                        // lastValidIndex = index+1;
+                        // var cachelen:int = cache.length;
+                        // while (lastValidIndex < cachelen && isNaN(cache[lastValidIndex][p]))
+                        // {
+                            // lastValidIndex++;
+                        // }
+                        // if (lastValidIndex < cachelen)
+                        // {
+                            // src = cache[lastValidIndex][p] + .01 * (lastValidIndex - index);
+                        // }
+                    // }           
+                // }
+            // }
+            
+            // sourceProps[p] = src;
+            // destProps[p] = dst;
+        // }
+    // }
+
+    /**
+     *  @private
+     */
+    // override public function dataToLocal(... dataValues):Point
+    // {
+        // var data:Object = {};
+        // var da:Array /* of Object */ = [ data ];
+        // var n:int = dataValues.length;
+        
+        // if (n > 0)
+        // {
+            // data["d0"] = dataValues[0];
+            // dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS).
+                // mapCache(da, "d0", "v0");
+        // }
+        
+        // if (n > 1)
+        // {
+            // data["d1"] = dataValues[1];
+            // dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS).
+                // mapCache(da, "d1", "v1");           
+        // }
+
+        // dataTransform.transformCache(da,"v0","s0","v1","s1");
+        
+        // return new Point(data.s0 + this.x,
+                         // data.s1 + this.y);
+    // }
+
+    /**
+     *  @private
+     */
+    // override public function localToData(v:Point):Array /* of Object */
+    // {
+        // var values:Array /* of Object */ = dataTransform.invertTransform(
+                                            // v.x - this.x,
+                                            // v.y - this.y);
+        // return values;
+    // }
+
+    /**
+     *  @private
+     */
+    // override public function getItemsInRegion(r:Rectangle):Array /* of LineSeriesItem */
+    // {
+        // if (interactive == false || !_renderData)
+            // return [];
+        
+        // var arrItems:Array /* of LineSeriesItem */ = [];    
+        // var rc:Rectangle = new Rectangle();
+        // var localRectangle:Rectangle = new Rectangle();
+        // var n:uint = _renderData.filteredCache.length;
+        
+        // localRectangle.topLeft = globalToLocal(r.topLeft);
+        // localRectangle.bottomRight = globalToLocal(r.bottomRight);
+
+        
+        // for (var i:int = 0; i < n; i++)
+        // {
+            // var v:LineSeriesItem = _renderData.filteredCache[i];
+                
+            // if (localRectangle.contains(v.x,v.y))
+                // arrItems.push(v);
+        // }
+        // return arrItems;
+    // }
+    
+     /**
+     * @private
+     */ 
+    // override protected function defaultFilterFunction(cache:Array /*of LineSeriesItem */ ):Array /*of LineeriesItem*/
+    // {
+        // var filteredCache:Array /*of LineSeriesItem*/ = [];
+        // var start:int;
+        // var end:int = -1;
+        // var n:int;
+        // var i:int;
+        // var v:LineSeriesItem;
+        
+        // if (filterDataValues == "outsideRange")
+        // {
+            // filteredCache = cache.concat();
+            
+            // dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS).filterCache(filteredCache,"xNumber","xFilter")
+            // dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS).filterCache(filteredCache,"yNumber","yFilter");
+
+          ////  since all nulls will end up out at the edges, we can safely strip this early
+
+           // if (xField != "" && sortOnXField)
+                // stripNaNs(filteredCache,"xFilter");
+                
+            // _renderData.validPoints = filteredCache.length;
+
+            // if (_interpolateValues == false)
+            // {
+                // n = filteredCache.length;
+                
+                // while (end<n)
+                // {
+                    // for (i = end + 1; i < n; i++)
+                    // {
+                        // v = LineSeriesItem(filteredCache[i]);
+                        // if (!isNaN(v.xFilter) && !isNaN(v.yFilter))
+                            // break;
+                        // _renderData.validPoints--;
+                    // }
+                    // if (i == n)
+                        // break;              
+
+                    // start = i;
+
+                    // for (i = start + 1; i < n; i++)
+                    // {
+                        // v = LineSeriesItem(filteredCache[i]);
+                        // if (isNaN(v.xFilter) || isNaN(v.yFilter))
+                            // break;                  
+                    // }
+                    // end = i-1;
+                    // if (end != start)
+                    // {
+                        // _renderData.segments.push(new lineSegmentType(this,_renderData.segments.length,filteredCache,start,end));
+                    // }
+                // }
+            // }
+            // else
+            // {
+                // stripNaNs(filteredCache,"yFilter");
+                // _renderData.validPoints = filteredCache.length;
+                // if (filteredCache.length > 1)
+                    // _renderData.segments.push(new lineSegmentType(this,0,filteredCache,start,filteredCache.length-1));
+            // }
+        // }
+        // else if (filterDataValues == "nulls")
+        // {
+            // filteredCache = cache.concat();
+             ////since all nulls will end up out at the edges, we can safely strip this early
+            // if (xField != "" && sortOnXField)
+                // stripNaNs(filteredCache,"xNumber");
+                
+            // _renderData.validPoints = filteredCache.length;
+
+            // if (_interpolateValues == false)
+            // {
+                // n = filteredCache.length;
+                // while (end<n)
+                // {
+                    // for (i = end + 1; i < n; i++)
+                    // {
+                        // v = LineSeriesItem(filteredCache[i]);
+                        // if (!isNaN(v.xNumber) && !isNaN(v.yNumber))
+                            // break;
+                        // _renderData.validPoints--;
+                    // }
+                    // if (i == n)
+                        // break;              
+
+                    // start = i;
+
+                    // for (i = start + 1; i < n; i++)
+                    // {
+                        // v = LineSeriesItem(filteredCache[i]);
+                        // if (isNaN(v.xNumber) || isNaN(v.yNumber))
+                            // break;                  
+                    // }
+                    // end = i-1;
+                    // if (end != start)
+                    // {
+                        // _renderData.segments.push(new lineSegmentType(this,_renderData.segments.length,filteredCache,start,end));
+                    // }
+                // }
+            // }
+            
+            // else
+            // {
+                // stripNaNs(filteredCache,"yNumber");
+                // _renderData.validPoints = filteredCache.length;
+                // if (filteredCache.length > 1)
+                    // _renderData.segments.push(new lineSegmentType(this,0,filteredCache,start,filteredCache.length-1));
+            // }
+        // }
+        // else if (filterDataValues == "none")
+        // {
+            // filteredCache = cache;
+            // _renderData.segments.push(new lineSegmentType(this,0,filteredCache,start,filteredCache.length-1));
+        // }
+        // return filteredCache;
+    // }
+
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    
+    /**
+     *  @private
+     *  This method is to create line segments for the cache returned
+     *  by custom filter function
+     */
+    // private function createLineSegments(filteredCache:Array /* of LineSeriesItem */):void
+    // {
+            // _renderData.validPoints = filteredCache.length;
+
+            // if (_interpolateValues == false)
+            // {
+                // var start:int;
+                // var end:int = -1;
+                // var n:int = filteredCache.length;
+                // var i:int;
+                // var v:LineSeriesItem;
+                
+                // while (end<n)
+                // {
+                    // for (i = end + 1; i < n; i++)
+                    // {
+                        // v = LineSeriesItem(filteredCache[i]);
+                        // if (!isNaN(v.xNumber) && !isNaN(v.yNumber))
+                            // break;
+                        // _renderData.validPoints--;
+                    // }
+                    // if (i == n)
+                        // break;              
+
+                    // start = i;
+
+                    // for (i = start + 1; i < n; i++)
+                    // {
+                        // v = LineSeriesItem(filteredCache[i]);
+                        // if (isNaN(v.xNumber) || isNaN(v.yNumber))
+                            // break;                  
+                    // }
+                    // end = i-1;
+                    // if (end != start)
+                    // {
+                        // _renderData.segments.push(new lineSegmentType(this,_renderData.segments.length,filteredCache,start,end));
+                    // }
+                // }
+            // }
+            
+            // else
+            // {
+                // _renderData.validPoints = filteredCache.length;
+                // if (filteredCache.length > 1)
+                    // _renderData.segments.push(new lineSegmentType(this,0,filteredCache,start,filteredCache.length-1));
+            // }
+    // }  
+
+    /**
+     *  Customizes the item renderer instances that are used to represent the chart. This method is called automatically
+     *  whenever a new item renderer is needed while the chart is being rendered. You can override this method to add your own customization as necessary.
+     *  @param instance The new item renderer instance that is being created.
+     *  @param cache The InstanceCache that is used to manage the item renderer instances.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Flex 3
+     */
+    // protected function applyItemRendererProperties(instance:DisplayObject,
+                                                   // cache:InstanceCache):void
+    // {
+        // if (instance is ISimpleStyleClient)
+            // ISimpleStyleClient(instance).styleName = this;
+    // }
+
+    /**
+     *  @private
+     */
+    // private function formatDataTip(hd:HitData):String
+    // {
+        // var dt:String = "";
+        
+        // var n:String = displayName;
+        // if (n && n != "")
+            // dt += "<b>" + n + "</b><BR/>";
+
+        // var xName:String = dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS).displayName;
+        // if (xName != "")
+            // dt += "<i>" + xName+ ":</i> ";
+        // dt += dataTransform.getAxis(CartesianTransform.HORIZONTAL_AXIS).formatForScreen(
+            // LineSeriesItem(hd.chartItem).xValue) + "\n";
+        
+        // var yName:String = dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS).displayName;
+        // if (yName != "")
+            // dt += "<i>" + yName + ":</i> ";
+        // dt += dataTransform.getAxis(CartesianTransform.VERTICAL_AXIS).formatForScreen(
+            // LineSeriesItem(hd.chartItem).yValue) + "\n";
+        
+        // return dt;
+    // }
+    
+    /**
+     * @private
+     */
+    /* private function defaultFillFunction(element:LineSeriesItem,i:Number):IFill
+    {
+        if (_fillCount!=0)
+        {
+          return(GraphicsUtilities.fillFromStyle(_localFills[i % _fillCount]));
+        }
+        else
+          return(GraphicsUtilities.fillFromStyle(getStyle("fill")));
+    } */
+    
+    
+    /* private function reverseYValues(cache:Array):Array
+    {
+        var i:int = 0;
+        var n:int = cache.length;
+        for(i = 0; i < n ; i++)
+        {
+            cache[i]["yValue"] = -(cache[i]["yValue"]);
+        }  
+        return cache;
+    }
+     */
+    /* private function reverseXValues(cache:Array):Array
+    {
+        var i:int = 0;
+        var n:int = cache.length;
+        for(i = 0; i < n ; i++)
+        {
+            cache[i]["xValue"] = -(cache[i]["xValue"]);
+        }  
+        return cache;
+    } */
+}
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Helper class: LineSeriesLegendMarker
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/* 
+import flash.display.Graphics;
+
+import mx.charts.series.LineSeries;
+import mx.graphics.IStroke;
+import mx.graphics.LinearGradientStroke;
+import mx.graphics.SolidColorStroke;
+import mx.skins.ProgrammaticSkin;
+ */
+/**
+ *  @private
+ */
+//class LineSeriesLegendMarker extends ProgrammaticSkin
+//{
+    //--------------------------------------------------------------------------
+    //
+    //  Constructor
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  @private
+     *  Constructor.
+     */
+   /*  public function LineSeriesLegendMarker(element:LineSeries)
+    {
+        super();
+
+        _element = element;
+        styleName = _element;
+    } */
+
+    //--------------------------------------------------------------------------
+    //
+    //  Variables
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  @private
+     */
+    //private var _element:LineSeries;
+    
+
+    //--------------------------------------------------------------------------
+    //
+    //  Overridden methods
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  @private
+     */
+    /* override protected function updateDisplayList(unscaledWidth:Number,
+                                                  unscaledHeight:Number):void
+    {
+        super.updateDisplayList(unscaledWidth,unscaledHeight);
+
+        var fillStroke:IStroke = getStyle("lineStroke");
+        var color:Number;
+
+        if (fillStroke is SolidColorStroke)
+        {
+            color = SolidColorStroke(fillStroke).color;
+        }
+        else if (fillStroke is LinearGradientStroke)
+        {
+            var gb:LinearGradientStroke = LinearGradientStroke(fillStroke);
+            if (gb.entries.length > 0)
+                color = gb.entries[0].color;
+        }
+
+        var g:Graphics = graphics;
+        g.clear();
+        g.moveTo(0, 0);
+        g.lineStyle(0, 0, 0);
+        g.beginFill(color);
+        g.lineTo(width, 0);
+        g.lineTo(width, height);
+        g.lineTo(0, height);
+        g.lineTo(0, 0);
+        g.endFill();
+    } */
+//}

-- 
To stop receiving notification emails like this one, please contact
alinakazi@apache.org.

Mime
View raw message