public void Create(CalendarAnalysisResult result_)
    {
      m_analysisResult = result_;

      reloadChart();

      lineChartDataDisplay1.Chart.ChartDataClicked -= handleChartDataClicked;
      lineChartDataDisplay1.Chart.ChartDataClicked += handleChartDataClicked;

      boundInfraGrid1.Bind(m_range);

      boundInfraGrid1.AddClickHandler("TradeDirection", (x, y) =>
      {
        var row = y.ListObject as CalendarAnalysisTradeRange;

        if (row == null) return;

        switch (row.TradeDirection)
        {
          case TradeDirection.Long:
            row.TradeDirection = TradeDirection.Short;
            break;
          case TradeDirection.Short:
            row.TradeDirection = TradeDirection.Flat;
            break;
          case TradeDirection.Flat:
            row.TradeDirection = TradeDirection.Long;
            break;
        }
      });

      boundInfraGrid1.AddClickHandler("DeleteImage", (x, y) =>
      {
        if (m_mode == ListeningMode.Listening) return;

                  var row = y.ListObject as CalendarAnalysisTradeRange;

          if (row == null) return;


        if ((ModifierKeys & Keys.Shift) != 0)
        {
          var stats = CalendarAnalysisHelper.GetTradeRuleHistoricalStats(row, m_analysisResult);

          if (stats == null) return;

          var list = new BindingList<CalendarAnalysisTradeRangeResult> {stats};
          var grid = new SI.Controls.BoundInfraGrid();
          grid.Bind(list);
          grid.DisplayInShowForm("blah");
        }
        else
        {
          m_range.Remove(row);
        }
      });
    }
    public void Create(DatedDataCollectionGen<double> fullseries)
    {
      llTestPattern.Visible = false;
      lcdYearlyLevels.ClearSeries();
      lcdYearlyNormalized.ClearSeries();
      lcdSeasonalPattern.ClearSeries();

      lcdYearlyLevels.EnableZoom();
      lcdYearlyNormalized.EnableZoom();
      lcdSeasonalPattern.EnableZoom();

      if (fullseries == null) return;

      m_result = CalendarAnalysisHelper.FindSeasonalPattern(fullseries, m_args);

      if (m_result == null) return;


      var monthlyBars = m_args.ReturnMode == ReturnMode.CurrentMinusOriginal ? m_result.ProcessedSeries.ToDifferences().ToMonths(DoubleCollationType.Sum)
                                                                                : m_result.ProcessedSeries.ToReturns().ToMonths(DoubleCollationType.Sum);
      {
        var tY = toYears(monthlyBars);
        ssccMonths.Create(tY);
        if (m_args.ReturnMode == ReturnMode.CurrentMinusOriginal)
          ssccMonths.setuptooltip(false);
        else
          ssccMonths.setuptooltip(true);

        swccProbabilities.Create(tY.ColumnHeadings, tY.ColumnHeadings.Select(
          (x, i) => ProbabilityCalc.CalcProb(tY.GetColumnValues(i), m_args.ProbCalcType))
          .ToArray(), ExtensionMethods.CreateArrayRep(Color.White, 12));

        swccProbabilities.SetYAxisScaleRange(ProbabilityCalc.GetMaxValue(m_args.ProbCalcType));
      }

      foreach (var year in m_result.IndividualsYears.Keys)
      {
        if (year==DateTime.Today.Year)
        {
          lcdYearlyLevels.AddSeries(m_result.IndividualsYears[year].Dates, m_result.IndividualsYears[year].Data, year.ToString(), 40, "###0.0###", Color.Yellow, 3);
        }
        else
        {
          lcdYearlyLevels.AddSeries(m_result.IndividualsYears[year], year.ToString(), 40, "###0.0###");
          lcdYearlyNormalized.AddSeries(m_result.IndividualYearsNormalised[year], year.ToString(), 40, "###0.0###");
        }
      }

      lcdSeasonalPattern.AddSeries(m_result.SeasonalPattern, "Seasonal Pattern", 40, "###0.0#");
      llTestPattern.Visible = true;

      {

        var today = new DateTime(commonYear, DateTime.Today.Month, DateTime.Today.Day);

        // mark today's point
        lcdSeasonalPattern.AddScatterSeries(
          new[] { today },
          new[] { m_result.SeasonalPattern.ValueOnDate(today) },
          "Now", Color.Red, 40, "##0.0#");


        {
          var indivYearsFromFullSeries = fullseries.SplitIntoSection(
                  bucketingFunction_: (date) => date.Year,
                  dateTransform_: (date) => new DateTime(commonYear, date.Month, date.Day));

          if (indivYearsFromFullSeries.ContainsKey(DateTime.Today.Year))
          {
            var thisYear = indivYearsFromFullSeries[DateTime.Today.Year];
            var lastDate = thisYear.Dates.Last();
            var finalSubSet = m_result.SeasonalPattern.GetSubValues(m_result.SeasonalPattern.Dates[0], new DateTime(commonYear, lastDate.Month, lastDate.Day));
            if (finalSubSet.Data[0] == 0d) finalSubSet.Data[0] = finalSubSet.Data[1];


            var finalMin = finalSubSet.Data.Where(d => !double.IsNaN(d)).Min();
            var finalMax = finalSubSet.Data.Where(d => !double.IsNaN(d)).Max();

            var thisYearMin = thisYear.Data.Where(d => !double.IsNaN(d)).Min();
            var thisYearMax = thisYear.Data.Where(d => !double.IsNaN(d)).Max();


            lcdSeasonalPattern.AddSeries(thisYear.Dates, thisYear.Data, DateTime.Today.Year.ToString(), 40, "##0.0##",
              Color.Yellow, 3);

            // set secondary y-axis
            var key = string.Format("{0}_chart", DateTime.Today.Year.ToString());
            var chartAppearance = lcdSeasonalPattern.Chart.CompositeChart.ChartLayers.FromKey(key);
            chartAppearance.AxisY = lcdSeasonalPattern.FindYAxis(40, "##0.000", AxisNumber.Y2_Axis);
            chartAppearance.AxisY.RangeType = AxisRangeType.Custom;
            chartAppearance.AxisY.LineColor = Color.Yellow;
            chartAppearance.AxisY.Labels.FontColor = Color.Yellow;
            chartAppearance.AxisY.Labels.SeriesLabels.FontColor = Color.Yellow;
            double xmin;
            if (finalMin == 0)
            {
              xmin = thisYearMin;
            }
            else
            {
              xmin = ((finalMax / finalMin) * thisYearMin - thisYearMax) /
                      ((finalMax / finalMin) * (1 - finalMin) - (1 - finalMax));
            }
            var xmax = (thisYearMax - (1 - finalMax) * xmin) / finalMax;
            chartAppearance.AxisY.RangeMax = xmax;
            chartAppearance.AxisY.RangeMin = xmin;
            chartAppearance.AxisY.MajorGridLines.Visible = false;
          }


        }


        // min to max
        {
          var dict = new SortedDictionary<int, double>();

          foreach (var year in m_result.IndividualsYears.Keys)
            dict.Add(year, m_result.IndividualsYears[year].Data.Max() - m_result.IndividualsYears[year].Data.Min());

          var values = dict.Keys.Select(x => dict[x]).ToArray();

          swccMinToMax.Create(dict.Keys.Select(x => x.ToString()).ToArray(), values);

          swccMinToMax.SetYAxisFormat("##0.0#");
          swccMinToMax.SetYAxisScaleRange(0, values.Max());
        }
      }

      lcdYearlyLevels.SetXAxisFormat("dd-MMM");
      lcdYearlyNormalized.SetXAxisFormat("dd-MMM");
      lcdSeasonalPattern.SetXAxisFormat("dd-MMM");
    }
 public CalendarAnalysisTradeRangeResult(CalendarAnalysisResult source_)
 {
   m_source = source_;
 }