public void TestDateTimeWithTwoDataPoints()
        {
            Chart chart = new Chart();
            chart.Width = 500;
            chart.Height = 300;

            _isLoaded = false;
            chart.Loaded += new RoutedEventHandler(chart_Loaded);

            Random rand = new Random();

            DataSeries dataSeries = new DataSeries();

            dataSeries.DataPoints.Add(new DataPoint() { XValue = new DateTime(2009, 1, 1), YValue = rand.Next(10, 100) });
            dataSeries.DataPoints.Add(new DataPoint() { XValue = new DateTime(2009, 1, 2), YValue = rand.Next(10, 100) });

            chart.Series.Add(dataSeries);

            Window window = new Window();
            window.Content = chart;
            window.Show();
            if (_isLoaded)
            {
                Assert.AreEqual(2, chart.Series[0].DataPoints.Count);
                window.Dispatcher.InvokeShutdown();
                window.Close();
            }
        }

        public Chart CreateChart(ChartInformation ci)
        {
            Chart m_chart = new Chart();
            m_chart.BorderThickness = ci.m_BorderThickness;
            m_chart.Theme = ci.m_Theme;
            m_chart.View3D = ci.m_View3D;

            Axis m_axisX = new Axis();
            m_axisX.Title = ci.m_axisXTitle;
            m_chart.AxesX.Add(m_axisX);

            Axis m_asixY = new Axis();
            m_asixY.Title = ci.m_axisYTitle;
            m_asixY.Enabled = true;
            m_asixY.StartFromZero = true;
            m_asixY.AxisType = AxisTypes.Primary;
            m_asixY.AxisMaximum = ci.m_axisYMaximum;
            m_asixY.Interval = ci.m_axisYInterval;
            m_chart.AxesY.Add(m_asixY);
            for(int i = 0;i<ci.dsc.Count;i++)
            {
                DataSeries ds = new DataSeries();
                ds.LegendText = ci.dsc[i].LegendText;
                ds.RenderAs = ci.dsc[i].RenderAs;
                ds.AxisYType = ci.dsc[i].AxisYType;
                ds.DataPoints = new DataPointCollection(ci.dsc[i].DataPoints);
                m_chart.Series.Add(ds);
            }
            m_chart.Rendered+=new EventHandler(chart_Rendered);
            return m_chart;
        }

        public void TestDateTimeWithSingleDataPoint()
        {
            Chart chart = new Chart();
            chart.Width = 500;
            chart.Height = 300;

            _isLoaded = false;
            chart.Loaded += new RoutedEventHandler(chart_Loaded);

            Random rand = new Random();

            TestPanel.Children.Add(chart);

            EnqueueConditional(() => { return _isLoaded; });
            EnqueueDelay(_sleepTime);

            EnqueueCallback(() =>
            {
                DataSeries dataSeries = new DataSeries();
                DataPoint dataPoint = new DataPoint();
                dataPoint.XValue = new DateTime(2009, 1, 1);
                dataPoint.YValue = rand.Next(10, 100);
                dataSeries.DataPoints.Add(dataPoint);

                chart.Series.Add(dataSeries);
            });

            EnqueueCallback(() =>
            {
                Assert.AreEqual(1, chart.Series[0].DataPoints.Count);
            });

            EnqueueDelay(_sleepTime);
            EnqueueTestComplete();
        }

        /// <summary>
        /// Regresh chart
        /// </summary>
        private void button_Click(object sender, RoutedEventArgs e)
        {
            chart.Series.Clear();
            // Create series for each matrix size
            for (int size = 10; size <= 30; size += 5)
            {
                // Prepare series
                DataSeries series = new DataSeries();
                series.RenderAs = RenderAs.Line;
                series.ShowInLegend = true;
                series.LegendText = size.ToString();
                series.LineThickness = 2;

                // Get total count of cells in square matrix
                int cellCount = size * size;
                // Fill matrix with different percent of "zero" cells (from 1% to 100%)
                for (double arcPercent = 0.01; arcPercent <= 1; arcPercent += percentStep)
                {
                    // Calculate statistics of conflicts for all experiments
                    double conflicts = 0;
                    for (int experiment = 0; experiment < experiments; experiment++)
                        if (Matrix.HasConflict(Matrix.RandomMatrix(size, (int)(arcPercent * cellCount))))
                            conflicts++;
                    // Plot point (add to series)
                    DataPoint point = new DataPoint();
                    point.XValue = arcPercent * 100;
                    point.YValue = conflicts / experiments;
                    series.DataPoints.Add(point);
                }
                chart.Series.Add(series);
            }
        }

        public void ImportLineData(ArrayList values1, ArrayList values2)
        {
            dsc = new DataSeriesCollection();
            DataSeries ds1 = new DataSeries();
            ds1.RenderAs = RenderAs.Line;
            ds1.LegendText = "ObjValue";
            for (int i = 0; i < values1.Count; i = i + 4)
            {
                DataPoint dp = new DataPoint();
                dp.YValue = (double)values1[i];
                dp.XValue = i;
                ds1.DataPoints.Add(dp);
            }

            DataSeries ds2 = new DataSeries();
            ds2.RenderAs = RenderAs.Line;
            ds2.LegendText = "Variance";
            for (int i = 0; i < values2.Count; i = i + 4)
            {
                DataPoint dp = new DataPoint();
                dp.YValue = (double)values2[i];
                dp.XValue = i;
                ds2.DataPoints.Add(dp);
            }
            dsc.Add(ds1);
            dsc.Add(ds2);

        }

 //柱状图
 private void barGraph_Click(object sender, RoutedEventArgs e)
 {
     graphContainer.Children.Clear();
     Chart chart = new Chart();
     chart.Watermark = false;
     chart.View3D = true;
     chart.Width = 300;
     chart.Height = 200;
     Title title = new Title();
     title.Text = "人口类别统计图";
     chart.Titles.Add(title);
     for (int i = 0; i < 8; i++)
     {
         DataSeries dataSeries = new DataSeries();
         dataSeries.ShowInLegend = false;
         dataSeries.RenderAs = RenderAs.Column;
         for (int loopIndex = 0; loopIndex < 3; loopIndex++)
         {
             DataPoint dataPoint = new DataPoint();
             dataPoint.AxisXLabel = pop[loopIndex];
             dataPoint.YValue = points[i, loopIndex];
             dataSeries.DataPoints.Add(dataPoint);
         }
         chart.Series.Add(dataSeries);
     }
     //将柱状图添加到 Grid 控件以固定位置
     graphContainer.VerticalAlignment = VerticalAlignment.Top;
     graphContainer.HorizontalAlignment = HorizontalAlignment.Left;
     graphContainer.Children.Add(chart);
 }

 public static void AddDataToDataSerise(DataSeries ds,List<double> list)
 {
     double allCount = 100;
     double value = allCount / list.Count;
     for (int i = 0; i < list.Count; i++)
     {
         DataPoint dp = new DataPoint() { YValue = System.Math.Abs(list[i]) * 0.1, XValue = i * value };
         ds.DataPoints.Add(dp);
     }
 }

        /// <summary>
        /// Create Polar series
        /// </summary>
        /// <param name="chart"></param>
        /// <param name="series"></param>
        /// <param name="polarCanvas"></param>
        /// <param name="labelCanvas"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="plotGroup"></param>
        /// <param name="circularPlotDetails"></param>
        private static void CreatePolarSeries(Chart chart, DataSeries series, Canvas polarCanvas, Canvas labelCanvas, Double width, Double height, PlotGroup plotGroup, CircularPlotDetails circularPlotDetails)
        {
            List<List<DataPoint>> brokenLineDataPointsGroup = GetBrokenLineDataPointsGroup(series, circularPlotDetails, plotGroup);
            foreach (List<DataPoint> dataPointList in brokenLineDataPointsGroup)
            {
                foreach (DataPoint dataPoint in dataPointList)
                    DrawMarker(dataPoint, labelCanvas, width, height, circularPlotDetails.Center);

                DrawDataSeriesPath(series, dataPointList, polarCanvas);
            }
        }

        /// <summary>
        /// Show chart with data series
        /// </summary>
        /// <param name="dataSeries"></param>
        public void LoadPriceChart(TradeRobotics.Model.StockDataSeries dataSeries)
        {
            //List<Bar> bars = dataSeries.Bars;
            Visifire.Charts.DataSeries ds = new DataSeries();
            ds.RenderAs = RenderAs.CandleStick;
            ds.MarkerEnabled = true;
            ds.MovingMarkerEnabled = true;
            ds.LightingEnabled = true;
            ds.LineThickness = 1.5;
            //ds.XValueType = ChartValueTypes.DateTime;
            ds.LegendText = string.Concat(dataSeries.Symbol, " ", dataSeries.Period);
            ds.PriceUpColor = new SolidColorBrush(Colors.Green);
            ds.PriceDownColor = new SolidColorBrush(Colors.Red);

            //PriceChart.AxesY[0].AxisMinimum = bars.Min(bar => bar.Low);
            //PriceChart.AxesY[0].AxisMaximum = bars.Max(bar => bar.High);
            PriceChart.AxesY[0].StartFromZero = false;
            PriceChart.AxesY[0].ViewportRangeEnabled = true;

            if (dataSeries.Bars.Count > 0)
            {
                // Add points
                //for (int i = 0; i < dataSeries.Count; i++)
                foreach (Bar bar in dataSeries.Bars)
                {
                    ds.DataPoints.Add(new DataPoint
                    {
                        AxisXLabel = bar.Time.ToString("yyyy-MM-dd HH:mm"),
                        //ToolTipText = "aa\nbb",
                        //XValue = bar.Time, // a DateTime value
                        YValues = new double[] { bar.Open, bar.Close, bar.High, bar.Low }
                        //dataSeries.Close[i], dataSeries.High[i], dataSeries.Low[i] } // a double value
                    });
                }
            }
            else
            {
                foreach (Quote quote in dataSeries.Quotes)
                {
                    ds.DataPoints.Add(new DataPoint
                    {
                        AxisXLabel = quote.Time.ToString("yyyy-MM-dd HH:mm"),
                        //ToolTipText = "aa\nbb",
                        //XValue = bar.Time, // a DateTime value
                        YValues = new double[] { quote.Price, quote.Price, quote.Price, quote.Price }
                        //dataSeries.Close[i], dataSeries.High[i], dataSeries.Low[i] } // a double value
                    });
                }
            }

            PriceChart.Series.Add(ds);
            PriceChart.ZoomingEnabled = true;
        }

        public void ColumnChartPerformanceTest()
        {
            Double totalDuration = 0;
            DateTime start = DateTime.UtcNow;

            Chart chart = new Chart();
            chart.Width = 500;
            chart.Height = 300;
            chart.View3D = false;

            _isLoaded = false;
            chart.Loaded += new RoutedEventHandler(chart_Loaded);

            Axis axisX = new Axis();
            axisX.Interval = 1;
            chart.AxesX.Add(axisX);

            Random rand = new Random();

            Int32 numberOfSeries = 0;
            DataSeries dataSeries = null;
            Int32 numberofDataPoint = 0;

            String msg = Common.AssertAverageDuration(100, 1, delegate
            {
                dataSeries = new DataSeries();
                dataSeries.RenderAs = RenderAs.Column;

                for (Int32 i = 0; i < 1000; i++)
                {
                    DataPoint dataPoint = new DataPoint();
                    dataPoint.AxisXLabel = "a" + i;
                    dataPoint.YValue = rand.Next(-100, 100);
                    dataSeries.DataPoints.Add(dataPoint);
                    numberofDataPoint++;
                }
                numberOfSeries++;
                chart.Series.Add(dataSeries);
            });

            window = new Window();
            window.Content = chart;
            window.Show();
            if (_isLoaded)
            {
                DateTime end = DateTime.UtcNow;
                totalDuration = (end - start).TotalSeconds;

                MessageBox.Show("Total Chart Loading Time: " + totalDuration + "s" + "\n"  + "Number of Render Count: " + chart.ChartArea._renderCount + "\n" + "Series Calculation: " + msg);
            }
            window.Dispatcher.InvokeShutdown();
        }

 public void InitializeComponent() {
     if (_contentLoaded) {
         return;
     }
     _contentLoaded = true;
     System.Windows.Application.LoadComponent(this, new System.Uri("/Map;component/Chart1.xaml", System.UriKind.Relative));
     this.LayoutRoot = ((System.Windows.Controls.Grid)(this.FindName("LayoutRoot")));
     this.ContentPanel = ((System.Windows.Controls.Grid)(this.FindName("ContentPanel")));
     this.Chart = ((Visifire.Charts.Chart)(this.FindName("Chart")));
     this.DataSeries = ((Visifire.Charts.DataSeries)(this.FindName("DataSeries")));
     this.tb = ((System.Windows.Controls.TextBox)(this.FindName("tb")));
     this.MyGrid = ((Microsoft.Phone.Controls.LongListSelector)(this.FindName("MyGrid")));
 }

        public void Balance(int earning, int expense)
        {
            var chart = new Chart {Width = 500, Height = 300, View3D = true};
            chart.Titles.Add(new Title {Text = "Cân bằng tài chính"});
            var dataSeries = new DataSeries {RenderAs = RenderAs.Column};

            dataSeries.DataPoints.Add(new DataPoint {YValue = earning, AxisXLabel = "Tổng thu nhập"});
            dataSeries.DataPoints.Add(new DataPoint {YValue = expense, AxisXLabel = "Tổng chi tiêu"});

            chart.Series.Add(dataSeries);
            LayoutRoot.Children.Clear();
            LayoutRoot.Children.Add(chart);
        }

        public void TestDataPointPropertyChanged()
        {
            Chart chart = new Chart();
            chart.Width = 500;
            chart.Height = 300;

            _isLoaded = false;
            chart.Loaded += new RoutedEventHandler(chart_Loaded);

            Random rand = new Random();

            TestPanel.Children.Add(chart);

            EnqueueConditional(() => { return _isLoaded; });
            EnqueueDelay(_sleepTime);

            DataSeries dataSeries = new DataSeries();
            DataPoint dataPoint = null;

            for (Int32 i = 0; i < 10; i++)
            {
                dataPoint = new DataPoint();
                dataPoint.XValue = i + 1;
                dataPoint.YValue = rand.Next(10, 100);

                dataPoint.PropertyChanged += delegate(Object sender, System.ComponentModel.PropertyChangedEventArgs e)
                {
                    Assert.IsNotNull(e.PropertyName);
                    if (e.PropertyName == "XValue")
                        Assert.AreEqual("XValue", e.PropertyName);
                    else if (e.PropertyName == "YValue")
                        Assert.AreEqual("YValue", e.PropertyName);
                    else
                        Assert.IsNotNull(e.PropertyName);
                };

                dataSeries.DataPoints.Add(dataPoint);
            }

            chart.Series.Add(dataSeries);

            EnqueueCallback(() =>
            {
                dataPoint.XValue = 10;
                dataPoint.YValue = rand.Next(-100, 100);
            });

            EnqueueDelay(_sleepTime);
            EnqueueTestComplete();

        }

 private void SetChartData(DataTable dt,string strname, string linecolor)
 {
     Visifire.Charts.DataSeries dataSeries = new Visifire.Charts.DataSeries();
     AddDataSeries(strname, dataSeries, LineStyles.Solid, new SolidColorBrush((Color)ColorConverter.ConvertFromString(linecolor)), Visifire.Charts.RenderAs.QuickLine);
     for (int i = 0; i < dt.Rows.Count; i++)
     {
         Visifire.Charts.DataPoint dataPoint = new DataPoint();
         dataPoint.AxisXLabel = dt.Rows[i]["time"].ToString();
         dataPoint.Color = new SolidColorBrush(Colors.Blue);
         dataPoint.YValue = Convert.ToDouble(dt.Rows[i]["value"]);
         dataPoint.Tag = " ";
         dataSeries.DataPoints.Add(dataPoint);
     }
     this.chartC.Series.Add(dataSeries);
 }

 private void AddSeries(Chart c, List<double> list,bool showInLengend,string lengendText)
 {
     DataSeries ds = new DataSeries();
     ds.ShowInLegend = showInLengend;
     ds.RenderAs = RenderAs.QuickLine;
     if (showInLengend) {
         ds.Color = avgBrush;
         ds.LegendText = lengendText;
     }
     for (int i = 0; i < list.Count; i++)
     {
         DataPoint dp = new DataPoint() { YValue = Math.Abs(list[i]) };
         ds.DataPoints.Add(dp);
     }
     c.Series.Add(ds);
 }

        public PlotAnchorable(string ID)
        {
            this.ID = ID;

            this.Title = ID;
            this.Content = chart;

            chart.AnimationEnabled = false;
            chart.LightingEnabled = false;
            chart.ScrollingEnabled = false;
            chart.AxesX.Add(new Axis() { Interval = 8 });

            serie = new DataSeries();
            serie.RenderAs = RenderAs.QuickLine;

            chart.Series.Add(serie);
        }

 public static void InitDataSerise(DataSeries ds, bool showInLengend, string lengendText, Brush brush,RenderAs render)
 {
     if (ds == null)
     {
         ds = new DataSeries();
     }
     ds.ShowInLegend = showInLengend;
     ds.RenderAs = render;
     if (brush != null)
     {
         ds.Color = brush;
     }
     if (showInLengend)
     {
         ds.LegendText = lengendText;
     }
 }

        public void TestDataPointPropertyChanged()
        {
            Chart chart = new Chart();
            chart.Width = 500;
            chart.Height = 300;

            _isLoaded = false;
            chart.Loaded += new RoutedEventHandler(chart_Loaded);

            Random rand = new Random();

            DataSeries dataSeries = new DataSeries();
            DataPoint dataPoint = null;

            for (Int32 i = 0; i < 10; i++)
            {
                dataPoint = new DataPoint();
                dataPoint.XValue = i + 1;
                dataPoint.YValue = rand.Next(10, 100);

                dataPoint.PropertyChanged += delegate(Object sender, System.ComponentModel.PropertyChangedEventArgs e)
                {
                    Assert.IsNotNull(e.PropertyName);
                    if (e.PropertyName == "XValue")
                        Assert.AreEqual("XValue", e.PropertyName);
                    else
                        Assert.AreEqual("YValue", e.PropertyName);
                        
                };

                dataSeries.DataPoints.Add(dataPoint);
            }
            chart.Series.Add(dataSeries);
            
            Window window = new Window();
            window.Content = chart;
            window.Show();
            if (_isLoaded)
            {
                dataPoint.XValue = 10;
                dataPoint.YValue = rand.Next(-100, 100);
            }
       
            window.Dispatcher.InvokeShutdown();
            window.Close();
        }

        public MainWindow()
        {
            InitializeComponent();
            List<Task> tasks=  XMLModule.XMLLogic.XmlLogic.ReadXml(@"C:\Users\LaM\Desktop\TimeIsMoney\todoTimeIsMoney.tdl");
            MainList.ItemsSource = tasks;

            DataSeries serie = new DataSeries();
            serie.RenderAs = RenderAs.Column;

            Dictionary<DateTime, int> days = ReportEngine.GetCompletedTasksPerDay(tasks);

            foreach (KeyValuePair<DateTime, int> day in days)
            {
                serie.DataPoints.Add(new DataPoint() { XValue = day.Key, YValue = day.Value });
            }

            PlotChart.Series.Add(serie);
        }

        /// <summary>
        /// Apply animation for point chart
        /// </summary>
        /// <param name="pointGrid">Point chart grid</param>
        /// <param name="storyboard">Stroyboard</param>
        /// <param name="width">Width of the chart canvas</param>
        /// <param name="height">Height of the chart canvas</param>
        /// <returns>Storyboard</returns>
        private static Storyboard ApplyPointChartAnimation(DataSeries currentDataSeries, Panel pointGrid, Storyboard storyboard, Double width, Double height)
        {   
#if WPF
            if (storyboard != null && storyboard.GetValue(System.Windows.Media.Animation.Storyboard.TargetProperty) != null)
                storyboard.Stop();
#else
            if (storyboard != null)
                storyboard.Stop();
#endif

            TransformGroup group = new TransformGroup();
            ScaleTransform scaleTransform = new ScaleTransform() { ScaleX = 0, ScaleY = 0, CenterX = 0.5, CenterY = 0.5 };
            TranslateTransform translateTransform = new TranslateTransform() { X = 0, Y = 0 };
            group.Children.Add(scaleTransform);
            group.Children.Add(translateTransform);

            pointGrid.RenderTransform = group;

            Random rand = new Random((Int32)DateTime.Now.Ticks);
            double begin = rand.NextDouble();

            pointGrid.Measure(new Size(Double.MaxValue, Double.MaxValue));

            DoubleCollection times = Graphics.GenerateDoubleCollection(0, 0.5, 0.75, 1);
            DoubleCollection scaleValues = Graphics.GenerateDoubleCollection(0, 1, 0.5, 1);
            DoubleCollection translateXValues = Graphics.GenerateDoubleCollection(pointGrid.DesiredSize.Width / 2, 0, pointGrid.DesiredSize.Width / 4, 0);
            DoubleCollection translateYValues = Graphics.GenerateDoubleCollection(pointGrid.DesiredSize.Height / 2, 0, pointGrid.DesiredSize.Height / 4, 0);
            List<KeySpline> splines1 = AnimationHelper.GenerateKeySplineList(new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1));
            List<KeySpline> splines2 = AnimationHelper.GenerateKeySplineList(new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1));
            List<KeySpline> splines3 = AnimationHelper.GenerateKeySplineList(new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1));
            List<KeySpline> splines4 = AnimationHelper.GenerateKeySplineList(new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1), new Point(0, 0.5), new Point(0.5, 1));

            DoubleAnimationUsingKeyFrames xScaleAnimation = AnimationHelper.CreateDoubleAnimation(currentDataSeries, scaleTransform, "(ScaleTransform.ScaleX)", begin + 0.5, times, scaleValues, splines1);
            DoubleAnimationUsingKeyFrames yScaleAnimation = AnimationHelper.CreateDoubleAnimation(currentDataSeries, scaleTransform, "(ScaleTransform.ScaleY)", begin + 0.5, times, scaleValues, splines2);
            DoubleAnimationUsingKeyFrames xTranslateAnimation = AnimationHelper.CreateDoubleAnimation(currentDataSeries, translateTransform, "(TranslateTransform.X)", begin + 0.5, times, translateXValues, splines3);
            DoubleAnimationUsingKeyFrames yTranslateAnimation = AnimationHelper.CreateDoubleAnimation(currentDataSeries, translateTransform, "(TranslateTransform.Y)", begin + 0.5, times, translateYValues, splines4);

            storyboard.Children.Add(xScaleAnimation);
            storyboard.Children.Add(yScaleAnimation);
            storyboard.Children.Add(xTranslateAnimation);
            storyboard.Children.Add(yTranslateAnimation);

            return storyboard;
        }