Пример #1
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable         = new Hashtable();
            double?   count             = this.Count;
            double?   countDefaultValue = this.Count_DefaultValue;

            if (count.GetValueOrDefault() != countDefaultValue.GetValueOrDefault() ||
                count.HasValue != countDefaultValue.HasValue)
            {
                hashtable.Add((object)"count", (object)this.Count);
            }
            if (this.DataGrouping != this.DataGrouping_DefaultValue)
            {
                hashtable.Add((object)"dataGrouping", this.DataGrouping);
            }
            if (this.Text != this.Text_DefaultValue)
            {
                hashtable.Add((object)"text", (object)this.Text);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                hashtable.Add((object)"type", (object)Highstock.FirstCharacterToLower(this.Type.ToString()));
            }
            return(hashtable);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highstock.FirstCharacterToLower(this.Align.ToString()));
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highstock.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            double?nullable1 = this.X;
            double?nullable2 = this.X_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable2 = this.Y;
            nullable1 = this.Y_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            return(hashtable);
        }
Пример #3
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highstock.FirstCharacterToLower(this.Align.ToString()));
            }
            bool?nullable1 = this.Floating;
            bool?nullable2 = this.Floating_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"floating", (object)this.Floating);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            if (this.Text != this.Text_DefaultValue)
            {
                hashtable.Add((object)"text", (object)this.Text);
            }
            nullable2 = this.UseHTML;
            nullable1 = this.UseHTML_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highstock.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            double?nullable3 = this.WidthAdjust;
            double?nullable4 = this.WidthAdjust_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"widthAdjust", (object)this.WidthAdjust);
            }
            nullable4 = this.X;
            nullable3 = this.X_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable3 = this.Y;
            nullable4 = this.Y_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            return(hashtable);
        }
Пример #4
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.VMLRadialGradientURL != this.VMLRadialGradientURL_DefaultValue)
            {
                hashtable.Add((object)"vMLRadialGradientURL", (object)this.VMLRadialGradientURL);
            }
            if (this.GetTimezoneOffset != this.GetTimezoneOffset_DefaultValue)
            {
                hashtable.Add((object)"getTimezoneOffset", (object)this.GetTimezoneOffset);
                Highstock.AddFunction("GlobalGetTimezoneOffset.getTimezoneOffset", this.GetTimezoneOffset);
            }
            if (this.Timezone != this.Timezone_DefaultValue)
            {
                hashtable.Add((object)"timezone", (object)this.Timezone);
            }
            double?timezoneOffset     = this.TimezoneOffset;
            double?offsetDefaultValue = this.TimezoneOffset_DefaultValue;

            if (timezoneOffset.GetValueOrDefault() != offsetDefaultValue.GetValueOrDefault() ||
                timezoneOffset.HasValue != offsetDefaultValue.HasValue)
            {
                hashtable.Add((object)"timezoneOffset", (object)this.TimezoneOffset);
            }
            bool?useUtc             = this.UseUTC;
            bool?useUtcDefaultValue = this.UseUTC_DefaultValue;

            if (useUtc.GetValueOrDefault() != useUtcDefaultValue.GetValueOrDefault() ||
                useUtc.HasValue != useUtcDefaultValue.HasValue)
            {
                hashtable.Add((object)"useUTC", (object)this.UseUTC);
            }
            return(hashtable);
        }
Пример #5
0
        public HtmlString GetHighstock(Highstock chart, string id)
        {
            HighstockRenderer highstockRenderer = new HighstockRenderer(chart);

            chart.ID             = id;
            chart.Chart.RenderTo = id;
            return(new HtmlString(highstockRenderer.RenderHtml()));
        }
Пример #6
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)this.Align);
            }
            if (this.BackgroundColor != this.BackgroundColor_DefaultValue)
            {
                hashtable.Add((object)"backgroundColor", (object)this.BackgroundColor);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            double?nullable1 = this.BorderRadius;
            double?nullable2 = this.BorderRadius_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"borderRadius", (object)this.BorderRadius);
            }
            nullable2 = this.BorderWidth;
            nullable1 = this.BorderWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"borderWidth", (object)this.BorderWidth);
            }
            if (this.Format != this.Format_DefaultValue)
            {
                hashtable.Add((object)"format", (object)this.Format);
            }
            if (this.Formatter != this.Formatter_DefaultValue)
            {
                hashtable.Add((object)"formatter", (object)this.Formatter);
                Highstock.AddFunction("YAxisCrosshairLabelFormatter.formatter", this.Formatter);
            }
            nullable1 = this.Padding;
            nullable2 = this.Padding_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtable.Add((object)"shape", (object)this.Shape);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            return(hashtable);
        }
Пример #7
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Data.Any <SeriesData>())
            {
                hashtable.Add((object)"data", (object)this.HashifyList((IEnumerable)this.Data));
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtable.Add((object)"id", (object)this.Id);
            }
            double?nullable1 = this.Index;
            double?nullable2 = this.Index_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"index", (object)this.Index);
            }
            nullable2 = this.LegendIndex;
            nullable1 = this.LegendIndex_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"legendIndex", (object)this.LegendIndex);
            }
            if (this.Name != this.Name_DefaultValue)
            {
                hashtable.Add((object)"name", (object)this.Name);
            }
            if (this.Stack != this.Stack_DefaultValue)
            {
                hashtable.Add((object)"stack", (object)this.Stack);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                hashtable.Add((object)"type", (object)Highstock.FirstCharacterToLower(this.Type.ToString()));
            }
            if (this.XAxis != this.XAxis_DefaultValue)
            {
                hashtable.Add((object)"xAxis", (object)this.XAxis);
            }
            if (this.YAxis != this.YAxis_DefaultValue)
            {
                hashtable.Add((object)"yAxis", (object)this.YAxis);
            }
            nullable1 = this.ZIndex;
            nullable2 = this.ZIndex_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"zIndex", (object)this.ZIndex);
            }
            return(hashtable);
        }
Пример #8
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highstock.FirstCharacterToLower(this.Align.ToString()));
            }
            double?nullable1 = this.Margin;
            double?nullable2 = this.Margin_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"margin", (object)this.Margin);
            }
            nullable2 = this.Offset;
            nullable1 = this.Offset_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"offset", (object)this.Offset);
            }
            nullable1 = this.Rotation;
            nullable2 = this.Rotation_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"rotation", (object)this.Rotation);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            if (this.Text != this.Text_DefaultValue)
            {
                hashtable.Add((object)"text", (object)this.Text);
            }
            nullable2 = this.X;
            nullable1 = this.X_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable1 = this.Y;
            nullable2 = this.Y_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            return(hashtable);
        }
Пример #9
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)this.Align);
            }
            double?nullable1 = this.Rotation;
            double?nullable2 = this.Rotation_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"rotation", (object)this.Rotation);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            if (this.TextAlign != this.TextAlign_DefaultValue)
            {
                hashtable.Add((object)"textAlign", (object)this.TextAlign);
            }
            bool?useHtml          = this.UseHTML;
            bool?htmlDefaultValue = this.UseHTML_DefaultValue;

            if (useHtml.GetValueOrDefault() != htmlDefaultValue.GetValueOrDefault() ||
                useHtml.HasValue != htmlDefaultValue.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highstock.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            nullable2 = this.X;
            nullable1 = this.X_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable1 = this.Y;
            nullable2 = this.Y_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            return(hashtable);
        }
Пример #10
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtable.Add((object)"color", (object)this.Color);
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                hashtable.Add((object)"dashStyle",
                              (object)Highstock.FirstCharacterToLower(this.DashStyle.ToString()));
            }
            if (this.Events != this.Events_DefaultValue)
            {
                hashtable.Add((object)"events", this.Events);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtable.Add((object)"id", (object)this.Id);
            }
            if (this.Label.IsDirty())
            {
                hashtable.Add((object)"label", (object)this.Label.ToHashtable());
            }
            double?nullable1 = this.Value;
            double?nullable2 = this.Value_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"value", (object)this.Value);
            }
            nullable2 = this.Width;
            nullable1 = this.Width_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            nullable1 = this.ZIndex;
            nullable2 = this.ZIndex_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"zIndex", (object)this.ZIndex);
            }
            return(hashtable);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.AfterAnimate != this.AfterAnimate_DefaultValue)
            {
                hashtable.Add((object)"afterAnimate", (object)this.AfterAnimate);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsAfterAnimate.afterAnimate", this.AfterAnimate);
            }
            if (this.CheckboxClick != this.CheckboxClick_DefaultValue)
            {
                hashtable.Add((object)"checkboxClick", (object)this.CheckboxClick);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsCheckboxClick.checkboxClick",
                                      this.CheckboxClick);
            }
            if (this.Click != this.Click_DefaultValue)
            {
                hashtable.Add((object)"click", (object)this.Click);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsClick.click", this.Click);
            }
            if (this.Hide != this.Hide_DefaultValue)
            {
                hashtable.Add((object)"hide", (object)this.Hide);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsHide.hide", this.Hide);
            }
            if (this.LegendItemClick != this.LegendItemClick_DefaultValue)
            {
                hashtable.Add((object)"legendItemClick", (object)this.LegendItemClick);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsLegendItemClick.legendItemClick",
                                      this.LegendItemClick);
            }
            if (this.MouseOut != this.MouseOut_DefaultValue)
            {
                hashtable.Add((object)"mouseOut", (object)this.MouseOut);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsMouseOut.mouseOut", this.MouseOut);
            }
            if (this.MouseOver != this.MouseOver_DefaultValue)
            {
                hashtable.Add((object)"mouseOver", (object)this.MouseOver);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsMouseOver.mouseOver", this.MouseOver);
            }
            if (this.Show != this.Show_DefaultValue)
            {
                hashtable.Add((object)"show", (object)this.Show);
                Highstock.AddFunction("PlotOptionsAreasplinerangeEventsShow.show", this.Show);
            }
            return(hashtable);
        }
Пример #12
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.AddSeries != this.AddSeries_DefaultValue)
            {
                hashtable.Add((object)"addSeries", (object)this.AddSeries);
                Highstock.AddFunction("ChartEventsAddSeries.addSeries", this.AddSeries);
            }
            if (this.AfterPrint != this.AfterPrint_DefaultValue)
            {
                hashtable.Add((object)"afterPrint", (object)this.AfterPrint);
                Highstock.AddFunction("ChartEventsAfterPrint.afterPrint", this.AfterPrint);
            }
            if (this.BeforePrint != this.BeforePrint_DefaultValue)
            {
                hashtable.Add((object)"beforePrint", (object)this.BeforePrint);
                Highstock.AddFunction("ChartEventsBeforePrint.beforePrint", this.BeforePrint);
            }
            if (this.Click != this.Click_DefaultValue)
            {
                hashtable.Add((object)"click", (object)this.Click);
                Highstock.AddFunction("ChartEventsClick.click", this.Click);
            }
            if (this.Load != this.Load_DefaultValue)
            {
                hashtable.Add((object)"load", (object)this.Load);
                Highstock.AddFunction("ChartEventsLoad.load", this.Load);
            }
            if (this.Redraw != this.Redraw_DefaultValue)
            {
                hashtable.Add((object)"redraw", (object)this.Redraw);
                Highstock.AddFunction("ChartEventsRedraw.redraw", this.Redraw);
            }
            if (this.Render != this.Render_DefaultValue)
            {
                hashtable.Add((object)"render", (object)this.Render);
                Highstock.AddFunction("ChartEventsRender.render", this.Render);
            }
            if (this.Selection != this.Selection_DefaultValue)
            {
                hashtable.Add((object)"selection", (object)this.Selection);
                Highstock.AddFunction("ChartEventsSelection.selection", this.Selection);
            }
            return(hashtable);
        }
Пример #13
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtable.Add((object)"color", (object)this.Color);
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                hashtable.Add((object)"dashStyle",
                              (object)Highstock.FirstCharacterToLower(this.DashStyle.ToString()));
            }
            if (this.Label.IsDirty())
            {
                hashtable.Add((object)"label", (object)this.Label.ToHashtable());
            }
            bool?snap             = this.Snap;
            bool?snapDefaultValue = this.Snap_DefaultValue;

            if (snap.GetValueOrDefault() != snapDefaultValue.GetValueOrDefault() ||
                snap.HasValue != snapDefaultValue.HasValue)
            {
                hashtable.Add((object)"snap", (object)this.Snap);
            }
            double?nullable1 = this.Width;
            double?nullable2 = this.Width_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            nullable2 = this.ZIndex;
            nullable1 = this.ZIndex_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"zIndex", (object)this.ZIndex);
            }
            return(hashtable);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Approximation != this.Approximation_DefaultValue)
            {
                hashtable.Add((object)"approximation", (object)this.Approximation);
                Highstock.AddFunction("PlotOptionsColumnrangeDataGroupingApproximation.approximation",
                                      this.Approximation);
            }
            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtable.Add((object)"dateTimeLabelFormats", (object)this.DateTimeLabelFormats);
            }
            bool?nullable1 = this.Enabled;
            bool?nullable2 = this.Enabled_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            nullable2 = this.Forced;
            nullable1 = this.Forced_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"forced", (object)this.Forced);
            }
            double?groupPixelWidth   = this.GroupPixelWidth;
            double?widthDefaultValue = this.GroupPixelWidth_DefaultValue;

            if (groupPixelWidth.GetValueOrDefault() != widthDefaultValue.GetValueOrDefault() ||
                groupPixelWidth.HasValue != widthDefaultValue.HasValue)
            {
                hashtable.Add((object)"groupPixelWidth", (object)this.GroupPixelWidth);
            }
            nullable1 = this.Smoothed;
            nullable2 = this.Smoothed_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"smoothed", (object)this.Smoothed);
            }
            return(hashtable);
        }
Пример #15
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Position.Count > 0)
            {
                hashtable.Add((object)"position", (object)this.Position);
            }
            if (this.RelativeTo != this.RelativeTo_DefaultValue)
            {
                hashtable.Add((object)"relativeTo",
                              (object)Highstock.FirstCharacterToLower(this.RelativeTo.ToString()));
            }
            if (this.Theme != this.Theme_DefaultValue)
            {
                hashtable.Add((object)"theme", this.Theme);
            }
            return(hashtable);
        }
Пример #16
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Click != this.Click_DefaultValue)
            {
                hashtable.Add((object)"click", (object)this.Click);
                Highstock.AddFunction("SplineSeriesDataEventsClick.click", this.Click);
            }
            if (this.MouseOut != this.MouseOut_DefaultValue)
            {
                hashtable.Add((object)"mouseOut", (object)this.MouseOut);
                Highstock.AddFunction("SplineSeriesDataEventsMouseOut.mouseOut", this.MouseOut);
            }
            if (this.MouseOver != this.MouseOver_DefaultValue)
            {
                hashtable.Add((object)"mouseOver", (object)this.MouseOver);
                Highstock.AddFunction("SplineSeriesDataEventsMouseOver.mouseOver", this.MouseOver);
            }
            if (this.Remove != this.Remove_DefaultValue)
            {
                hashtable.Add((object)"remove", (object)this.Remove);
                Highstock.AddFunction("SplineSeriesDataEventsRemove.remove", this.Remove);
            }
            if (this.Select != this.Select_DefaultValue)
            {
                hashtable.Add((object)"select", (object)this.Select);
                Highstock.AddFunction("SplineSeriesDataEventsSelect.select", this.Select);
            }
            if (this.Unselect != this.Unselect_DefaultValue)
            {
                hashtable.Add((object)"unselect", (object)this.Unselect);
                Highstock.AddFunction("SplineSeriesDataEventsUnselect.unselect", this.Unselect);
            }
            if (this.Update != this.Update_DefaultValue)
            {
                hashtable.Add((object)"update", (object)this.Update);
                Highstock.AddFunction("SplineSeriesDataEventsUpdate.update", this.Update);
            }
            return(hashtable);
        }
Пример #17
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.AfterSetExtremes != this.AfterSetExtremes_DefaultValue)
            {
                hashtable.Add((object)"afterSetExtremes", (object)this.AfterSetExtremes);
                Highstock.AddFunction("YAxisEventsAfterSetExtremes.afterSetExtremes", this.AfterSetExtremes);
            }
            if (this.PointInBreak != this.PointInBreak_DefaultValue)
            {
                hashtable.Add((object)"pointInBreak", (object)this.PointInBreak);
                Highstock.AddFunction("YAxisEventsPointInBreak.pointInBreak", this.PointInBreak);
            }
            if (this.SetExtremes != this.SetExtremes_DefaultValue)
            {
                hashtable.Add((object)"setExtremes", (object)this.SetExtremes);
                Highstock.AddFunction("YAxisEventsSetExtremes.setExtremes", this.SetExtremes);
            }
            return(hashtable);
        }
Пример #18
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Callback != this.Callback_DefaultValue)
            {
                hashtable.Add((object)"callback", (object)this.Callback);
                Highstock.AddFunction("ResponsiveRulesConditionCallback.callback", this.Callback);
            }
            double?nullable1 = this.MaxHeight;
            double?nullable2 = this.MaxHeight_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"maxHeight", (object)this.MaxHeight);
            }
            nullable2 = this.MaxWidth;
            nullable1 = this.MaxWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"maxWidth", (object)this.MaxWidth);
            }
            nullable1 = this.MinHeight;
            nullable2 = this.MinHeight_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"minHeight", (object)this.MinHeight);
            }
            nullable2 = this.MinWidth;
            nullable1 = this.MinWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"minWidth", (object)this.MinWidth);
            }
            return(hashtable);
        }
Пример #19
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Animation.IsDirty())
            {
                hashtable.Add((object)"animation", (object)this.Animation.ToJSON());
            }
            if (this.BackgroundColor != this.BackgroundColor_DefaultValue)
            {
                hashtable.Add((object)"backgroundColor", (object)this.BackgroundColor);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            double?nullable1 = this.BorderRadius;
            double?nullable2 = this.BorderRadius_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"borderRadius", (object)this.BorderRadius);
            }
            nullable2 = this.BorderWidth;
            nullable1 = this.BorderWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"borderWidth", (object)this.BorderWidth);
            }
            nullable1 = this.ChangeDecimals;
            nullable2 = this.ChangeDecimals_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"changeDecimals", (object)this.ChangeDecimals);
            }
            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtable.Add((object)"dateTimeLabelFormats", (object)this.DateTimeLabelFormats);
            }
            bool?nullable3 = this.Enabled;
            bool?nullable4 = this.Enabled_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            nullable4 = this.FollowPointer;
            nullable3 = this.FollowPointer_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"followPointer", (object)this.FollowPointer);
            }
            nullable3 = this.FollowTouchMove;
            nullable4 = this.FollowTouchMove_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"followTouchMove", (object)this.FollowTouchMove);
            }
            if (this.Formatter != this.Formatter_DefaultValue)
            {
                hashtable.Add((object)"formatter", (object)this.Formatter);
                Highstock.AddFunction("TooltipFormatter.formatter", this.Formatter);
            }
            if (this.HeaderFormat != this.HeaderFormat_DefaultValue)
            {
                hashtable.Add((object)"headerFormat", (object)this.HeaderFormat);
            }
            nullable2 = this.Padding;
            nullable1 = this.Padding_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            if (this.PointFormat != this.PointFormat_DefaultValue)
            {
                hashtable.Add((object)"pointFormat", (object)this.PointFormat);
            }
            if (this.PointFormatter != this.PointFormatter_DefaultValue)
            {
                hashtable.Add((object)"pointFormatter", (object)this.PointFormatter);
                Highstock.AddFunction("TooltipPointFormatter.pointFormatter", this.PointFormatter);
            }
            if (this.Positioner != this.Positioner_DefaultValue)
            {
                hashtable.Add((object)"positioner", (object)this.Positioner);
                Highstock.AddFunction("TooltipPositioner.positioner", this.Positioner);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtable.Add((object)"shape", (object)this.Shape);
            }
            nullable4 = this.Shared;
            nullable3 = this.Shared_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"shared", (object)this.Shared);
            }
            nullable1 = this.Snap;
            nullable2 = this.Snap_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"snap", (object)this.Snap);
            }
            nullable3 = this.Split;
            nullable4 = this.Split_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"split", (object)this.Split);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            nullable4 = this.UseHTML;
            nullable3 = this.UseHTML_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            nullable2 = this.ValueDecimals;
            nullable1 = this.ValueDecimals_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"valueDecimals", (object)this.ValueDecimals);
            }
            if (this.ValuePrefix != this.ValuePrefix_DefaultValue)
            {
                hashtable.Add((object)"valuePrefix", (object)this.ValuePrefix);
            }
            if (this.ValueSuffix != this.ValueSuffix_DefaultValue)
            {
                hashtable.Add((object)"valueSuffix", (object)this.ValueSuffix);
            }
            if (this.XDateFormat != this.XDateFormat_DefaultValue)
            {
                hashtable.Add((object)"xDateFormat", (object)this.XDateFormat);
            }
            return(hashtable);
        }
Пример #20
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.AllowPointSelect;
            bool?     nullable2 = this.AllowPointSelect_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"allowPointSelect", (object)this.AllowPointSelect);
            }
            if (this.Animation.IsDirty())
            {
                hashtable.Add((object)"animation", (object)this.Animation.ToJSON());
            }
            double?nullable3 = this.AnimationLimit;
            double?nullable4 = this.AnimationLimit_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"animationLimit", (object)this.AnimationLimit);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtable.Add((object)"color", (object)this.Color);
            }
            nullable4 = this.ColorIndex;
            nullable3 = this.ColorIndex_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"colorIndex", (object)this.ColorIndex);
            }
            if (this.Compare != this.Compare_DefaultValue)
            {
                hashtable.Add((object)"compare", (object)this.Compare);
            }
            if (this.CompareBase != this.CompareBase_DefaultValue)
            {
                hashtable.Add((object)"compareBase",
                              (object)Highstock.FirstCharacterToLower(this.CompareBase.ToString()));
            }
            nullable2 = this.ConnectNulls;
            nullable1 = this.ConnectNulls_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"connectNulls", (object)this.ConnectNulls);
            }
            nullable3 = this.CropThreshold;
            nullable4 = this.CropThreshold_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"cropThreshold", (object)this.CropThreshold);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                hashtable.Add((object)"cursor", (object)Highstock.FirstCharacterToLower(this.Cursor.ToString()));
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                hashtable.Add((object)"dashStyle",
                              (object)Highstock.FirstCharacterToLower(this.DashStyle.ToString()));
            }
            if (this.DataGrouping.IsDirty())
            {
                hashtable.Add((object)"dataGrouping", (object)this.DataGrouping.ToHashtable());
            }
            if (this.DataLabels.IsDirty())
            {
                hashtable.Add((object)"dataLabels", (object)this.DataLabels.ToHashtable());
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtable.Add((object)"description", (object)this.Description);
            }
            nullable1 = this.EnableMouseTracking;
            nullable2 = this.EnableMouseTracking_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"enableMouseTracking", (object)this.EnableMouseTracking);
            }
            if (this.Events.IsDirty())
            {
                hashtable.Add((object)"events", (object)this.Events.ToHashtable());
            }
            if (this.FillColor != this.FillColor_DefaultValue)
            {
                hashtable.Add((object)"fillColor", this.FillColor);
            }
            nullable4 = this.FillOpacity;
            nullable3 = this.FillOpacity_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"fillOpacity", (object)this.FillOpacity);
            }
            nullable3 = this.GapSize;
            nullable4 = this.GapSize_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"gapSize", (object)this.GapSize);
            }
            nullable2 = this.GetExtremesFromAll;
            nullable1 = this.GetExtremesFromAll_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"getExtremesFromAll", (object)this.GetExtremesFromAll);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtable.Add((object)"keys", (object)this.Keys);
            }
            nullable4 = this.LegendIndex;
            nullable3 = this.LegendIndex_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"legendIndex", (object)this.LegendIndex);
            }
            if (this.LineColor != this.LineColor_DefaultValue)
            {
                hashtable.Add((object)"lineColor", (object)this.LineColor);
            }
            nullable3 = this.LineWidth;
            nullable4 = this.LineWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"lineWidth", (object)this.LineWidth);
            }
            if (this.Linecap != this.Linecap_DefaultValue)
            {
                hashtable.Add((object)"linecap", (object)Highstock.FirstCharacterToLower(this.Linecap.ToString()));
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtable.Add((object)"linkedTo", (object)this.LinkedTo);
            }
            if (this.NavigatorOptions != this.NavigatorOptions_DefaultValue)
            {
                hashtable.Add((object)"navigatorOptions", this.NavigatorOptions);
            }
            if (this.NegativeColor != this.NegativeColor_DefaultValue)
            {
                hashtable.Add((object)"negativeColor", (object)this.NegativeColor);
            }
            if (this.Point.IsDirty())
            {
                hashtable.Add((object)"point", (object)this.Point.ToHashtable());
            }
            nullable4 = this.PointInterval;
            nullable3 = this.PointInterval_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"pointInterval", (object)this.PointInterval);
            }
            if (this.PointIntervalUnit != this.PointIntervalUnit_DefaultValue)
            {
                hashtable.Add((object)"pointIntervalUnit",
                              (object)Highstock.FirstCharacterToLower(this.PointIntervalUnit.ToString()));
            }
            if (this.PointPlacement.IsDirty())
            {
                nullable3 = this.PointPlacement.Value;
                if (nullable3.HasValue)
                {
                    hashtable.Add((object)"pointPlacement", (object)this.PointPlacement.Value);
                }
                else
                {
                    hashtable.Add((object)"pointPlacement", (object)this.PointPlacement.ToJSON());
                }
            }
            nullable3 = this.PointRange;
            nullable4 = this.PointRange_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"pointRange", (object)this.PointRange);
            }
            nullable4 = this.PointStart;
            nullable3 = this.PointStart_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"pointStart", (object)this.PointStart);
            }
            nullable1 = this.Selected;
            nullable2 = this.Selected_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"selected", (object)this.Selected);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            nullable2 = this.ShowCheckbox;
            nullable1 = this.ShowCheckbox_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showCheckbox", (object)this.ShowCheckbox);
            }
            nullable1 = this.ShowInLegend;
            nullable2 = this.ShowInLegend_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"showInLegend", (object)this.ShowInLegend);
            }
            nullable2 = this.ShowInNavigator;
            nullable1 = this.ShowInNavigator_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showInNavigator", (object)this.ShowInNavigator);
            }
            if (this.Stacking != this.Stacking_DefaultValue)
            {
                hashtable.Add((object)"stacking", (object)Highstock.FirstCharacterToLower(this.Stacking.ToString()));
            }
            if (this.States.IsDirty())
            {
                hashtable.Add((object)"states", (object)this.States.ToHashtable());
            }
            nullable1 = this.StickyTracking;
            nullable2 = this.StickyTracking_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"stickyTracking", (object)this.StickyTracking);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtable.Add((object)"tooltip", (object)this.Tooltip.ToHashtable());
            }
            nullable2 = this.TrackByArea;
            nullable1 = this.TrackByArea_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"trackByArea", (object)this.TrackByArea);
            }
            nullable3 = this.TurboThreshold;
            nullable4 = this.TurboThreshold_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"turboThreshold", (object)this.TurboThreshold);
            }
            nullable1 = this.Visible;
            nullable2 = this.Visible_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"visible", (object)this.Visible);
            }
            if (this.ZoneAxis != this.ZoneAxis_DefaultValue)
            {
                hashtable.Add((object)"zoneAxis", (object)this.ZoneAxis);
            }
            if (this.Zones != this.Zones_DefaultValue)
            {
                hashtable.Add((object)"zones", (object)this.HashifyList((IEnumerable)this.Zones));
            }
            return(hashtable);
        }
Пример #21
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highstock.FirstCharacterToLower(this.Align.ToString()));
            }
            bool?nullable1 = this.AllowOverlap;
            bool?nullable2 = this.AllowOverlap_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"allowOverlap", (object)this.AllowOverlap);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            double?nullable3 = this.BorderRadius;
            double?nullable4 = this.BorderRadius_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"borderRadius", (object)this.BorderRadius);
            }
            nullable4 = this.BorderWidth;
            nullable3 = this.BorderWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"borderWidth", (object)this.BorderWidth);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtable.Add((object)"color", (object)this.Color);
            }
            nullable2 = this.Crop;
            nullable1 = this.Crop_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"crop", (object)this.Crop);
            }
            nullable1 = this.Defer;
            nullable2 = this.Defer_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"defer", (object)this.Defer);
            }
            nullable2 = this.Enabled;
            nullable1 = this.Enabled_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            if (this.Format != this.Format_DefaultValue)
            {
                hashtable.Add((object)"format", (object)this.Format);
            }
            if (this.Formatter != this.Formatter_DefaultValue)
            {
                hashtable.Add((object)"formatter", (object)this.Formatter);
                Highstock.AddFunction("PlotOptionsOhlcDataLabelsFormatter.formatter", this.Formatter);
            }
            nullable1 = this.Inside;
            nullable2 = this.Inside_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"inside", (object)this.Inside);
            }
            if (this.Overflow != this.Overflow_DefaultValue)
            {
                hashtable.Add((object)"overflow", (object)Highstock.FirstCharacterToLower(this.Overflow.ToString()));
            }
            nullable3 = this.Padding;
            nullable4 = this.Padding_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            nullable4 = this.Rotation;
            nullable3 = this.Rotation_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"rotation", (object)this.Rotation);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtable.Add((object)"shape", (object)this.Shape);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            nullable2 = this.UseHTML;
            nullable1 = this.UseHTML_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highstock.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            nullable3 = this.X;
            nullable4 = this.X_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable4 = this.Y;
            nullable3 = this.Y_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            nullable3 = this.ZIndex;
            nullable4 = this.ZIndex_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"zIndex", (object)this.ZIndex);
            }
            return(hashtable);
        }
Пример #22
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.DescribeSingleSeries;
            bool?     nullable2 = this.DescribeSingleSeries_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"describeSingleSeries", (object)this.DescribeSingleSeries);
            }
            nullable2 = this.Enabled;
            nullable1 = this.Enabled_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            if (this.KeyboardNavigation.IsDirty())
            {
                hashtable.Add((object)"keyboardNavigation", (object)this.KeyboardNavigation.ToHashtable());
            }
            if (this.OnTableAnchorClick != this.OnTableAnchorClick_DefaultValue)
            {
                hashtable.Add((object)"onTableAnchorClick", (object)this.OnTableAnchorClick);
                Highstock.AddFunction("AccessibilityOnTableAnchorClick.onTableAnchorClick", this.OnTableAnchorClick);
            }
            if (this.PointDateFormat != this.PointDateFormat_DefaultValue)
            {
                hashtable.Add((object)"pointDateFormat", (object)this.PointDateFormat);
            }
            if (this.PointDateFormatter != this.PointDateFormatter_DefaultValue)
            {
                hashtable.Add((object)"pointDateFormatter", (object)this.PointDateFormatter);
                Highstock.AddFunction("AccessibilityPointDateFormatter.pointDateFormatter", this.PointDateFormatter);
            }
            if (this.PointDescriptionFormatter != this.PointDescriptionFormatter_DefaultValue)
            {
                hashtable.Add((object)"pointDescriptionFormatter", (object)this.PointDescriptionFormatter);
                Highstock.AddFunction("AccessibilityPointDescriptionFormatter.pointDescriptionFormatter",
                                      this.PointDescriptionFormatter);
            }
            long?descriptionThreshold = this.PointDescriptionThreshold;
            long?nullable3            = this.PointDescriptionThreshold_DefaultValue;

            if (descriptionThreshold.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                descriptionThreshold.HasValue != nullable3.HasValue)
            {
                nullable3 = this.PointDescriptionThreshold;
                if (nullable3.HasValue)
                {
                    hashtable.Add((object)"pointDescriptionThreshold", (object)this.PointDescriptionThreshold);
                }
                else
                {
                    hashtable.Add((object)"pointDescriptionThreshold", (object)false);
                }
            }
            if (this.ScreenReaderSectionFormatter != this.ScreenReaderSectionFormatter_DefaultValue)
            {
                hashtable.Add((object)"screenReaderSectionFormatter", (object)this.ScreenReaderSectionFormatter);
                Highstock.AddFunction("AccessibilityScreenReaderSectionFormatter.screenReaderSectionFormatter",
                                      this.ScreenReaderSectionFormatter);
            }
            if (this.SeriesDescriptionFormatter != this.SeriesDescriptionFormatter_DefaultValue)
            {
                hashtable.Add((object)"seriesDescriptionFormatter", (object)this.SeriesDescriptionFormatter);
                Highstock.AddFunction("AccessibilitySeriesDescriptionFormatter.seriesDescriptionFormatter",
                                      this.SeriesDescriptionFormatter);
            }
            return(hashtable);
        }
Пример #23
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.AllowPointSelect;
            bool?     nullable2 = this.AllowPointSelect_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"allowPointSelect", (object)this.AllowPointSelect);
            }
            if (this.Animation.IsDirty())
            {
                hashtable.Add((object)"animation", (object)this.Animation.ToJSON());
            }
            double?nullable3 = this.AnimationLimit;
            double?nullable4 = this.AnimationLimit_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"animationLimit", (object)this.AnimationLimit);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtable.Add((object)"color", (object)this.Color);
            }
            nullable4 = this.ColorIndex;
            nullable3 = this.ColorIndex_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"colorIndex", (object)this.ColorIndex);
            }
            if (this.Colors != this.Colors_DefaultValue)
            {
                hashtable.Add((object)"colors", (object)this.Colors);
            }
            if (this.CompareBase != this.CompareBase_DefaultValue)
            {
                hashtable.Add((object)"compareBase",
                              (object)Highstock.FirstCharacterToLower(this.CompareBase.ToString()));
            }
            nullable3 = this.CropThreshold;
            nullable4 = this.CropThreshold_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"cropThreshold", (object)this.CropThreshold);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                hashtable.Add((object)"cursor", (object)Highstock.FirstCharacterToLower(this.Cursor.ToString()));
            }
            if (this.Data.Any <CandleStickSeriesData>())
            {
                hashtable.Add((object)"data", (object)this.HashifyList((IEnumerable)this.Data));
            }
            if (this.DataGrouping.IsDirty())
            {
                hashtable.Add((object)"dataGrouping", (object)this.DataGrouping.ToHashtable());
            }
            if (this.DataLabels.IsDirty())
            {
                hashtable.Add((object)"dataLabels", (object)this.DataLabels.ToHashtable());
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtable.Add((object)"description", (object)this.Description);
            }
            nullable2 = this.EnableMouseTracking;
            nullable1 = this.EnableMouseTracking_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"enableMouseTracking", (object)this.EnableMouseTracking);
            }
            if (this.Events.IsDirty())
            {
                hashtable.Add((object)"events", (object)this.Events.ToHashtable());
            }
            nullable1 = this.GetExtremesFromAll;
            nullable2 = this.GetExtremesFromAll_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"getExtremesFromAll", (object)this.GetExtremesFromAll);
            }
            nullable4 = this.GroupPadding;
            nullable3 = this.GroupPadding_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"groupPadding", (object)this.GroupPadding);
            }
            nullable2 = this.Grouping;
            nullable1 = this.Grouping_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"grouping", (object)this.Grouping);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtable.Add((object)"id", (object)this.Id);
            }
            nullable3 = this.Index;
            nullable4 = this.Index_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"index", (object)this.Index);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtable.Add((object)"keys", (object)this.Keys);
            }
            nullable4 = this.LegendIndex;
            nullable3 = this.LegendIndex_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"legendIndex", (object)this.LegendIndex);
            }
            if (this.LineColor != this.LineColor_DefaultValue)
            {
                hashtable.Add((object)"lineColor", (object)this.LineColor);
            }
            nullable3 = this.LineWidth;
            nullable4 = this.LineWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"lineWidth", (object)this.LineWidth);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtable.Add((object)"linkedTo", (object)this.LinkedTo);
            }
            nullable4 = this.MaxPointWidth;
            nullable3 = this.MaxPointWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"maxPointWidth", (object)this.MaxPointWidth);
            }
            nullable3 = this.MinPointLength;
            nullable4 = this.MinPointLength_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minPointLength", (object)this.MinPointLength);
            }
            if (this.Name != this.Name_DefaultValue)
            {
                hashtable.Add((object)"name", (object)this.Name);
            }
            if (this.NavigatorOptions != this.NavigatorOptions_DefaultValue)
            {
                hashtable.Add((object)"navigatorOptions", this.NavigatorOptions);
            }
            if (this.NegativeColor != this.NegativeColor_DefaultValue)
            {
                hashtable.Add((object)"negativeColor", (object)this.NegativeColor);
            }
            if (this.Point.IsDirty())
            {
                hashtable.Add((object)"point", (object)this.Point.ToHashtable());
            }
            nullable4 = this.PointInterval;
            nullable3 = this.PointInterval_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"pointInterval", (object)this.PointInterval);
            }
            if (this.PointIntervalUnit != this.PointIntervalUnit_DefaultValue)
            {
                hashtable.Add((object)"pointIntervalUnit",
                              (object)Highstock.FirstCharacterToLower(this.PointIntervalUnit.ToString()));
            }
            nullable3 = this.PointPadding;
            nullable4 = this.PointPadding_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"pointPadding", (object)this.PointPadding);
            }
            if (this.PointPlacement.IsDirty())
            {
                nullable4 = this.PointPlacement.Value;
                if (nullable4.HasValue)
                {
                    hashtable.Add((object)"pointPlacement", (object)this.PointPlacement.Value);
                }
                else
                {
                    hashtable.Add((object)"pointPlacement", (object)this.PointPlacement.ToJSON());
                }
            }
            nullable4 = this.PointRange;
            nullable3 = this.PointRange_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"pointRange", (object)this.PointRange);
            }
            nullable3 = this.PointStart;
            nullable4 = this.PointStart_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"pointStart", (object)this.PointStart);
            }
            nullable4 = this.PointWidth;
            nullable3 = this.PointWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"pointWidth", (object)this.PointWidth);
            }
            nullable1 = this.Selected;
            nullable2 = this.Selected_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"selected", (object)this.Selected);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            nullable2 = this.ShowCheckbox;
            nullable1 = this.ShowCheckbox_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showCheckbox", (object)this.ShowCheckbox);
            }
            nullable1 = this.ShowInLegend;
            nullable2 = this.ShowInLegend_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"showInLegend", (object)this.ShowInLegend);
            }
            nullable2 = this.ShowInNavigator;
            nullable1 = this.ShowInNavigator_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showInNavigator", (object)this.ShowInNavigator);
            }
            nullable1 = this.SoftThreshold;
            nullable2 = this.SoftThreshold_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"softThreshold", (object)this.SoftThreshold);
            }
            if (this.Stack != this.Stack_DefaultValue)
            {
                hashtable.Add((object)"stack", (object)this.Stack);
            }
            if (this.States.IsDirty())
            {
                hashtable.Add((object)"states", (object)this.States.ToHashtable());
            }
            nullable2 = this.StickyTracking;
            nullable1 = this.StickyTracking_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"stickyTracking", (object)this.StickyTracking);
            }
            nullable3 = this.Threshold;
            nullable4 = this.Threshold_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"threshold", (object)this.Threshold);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtable.Add((object)"tooltip", (object)this.Tooltip.ToHashtable());
            }
            nullable4 = this.TurboThreshold;
            nullable3 = this.TurboThreshold_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"turboThreshold", (object)this.TurboThreshold);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                hashtable.Add((object)"type", (object)Highstock.FirstCharacterToLower(this.Type.ToString()));
            }
            if (this.UpColor != this.UpColor_DefaultValue)
            {
                hashtable.Add((object)"upColor", (object)this.UpColor);
            }
            if (this.UpLineColor != this.UpLineColor_DefaultValue)
            {
                hashtable.Add((object)"upLineColor", (object)this.UpLineColor);
            }
            nullable1 = this.Visible;
            nullable2 = this.Visible_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"visible", (object)this.Visible);
            }
            if (this.XAxis != this.XAxis_DefaultValue)
            {
                hashtable.Add((object)"xAxis", (object)this.XAxis);
            }
            if (this.YAxis != this.YAxis_DefaultValue)
            {
                hashtable.Add((object)"yAxis", (object)this.YAxis);
            }
            nullable3 = this.ZIndex;
            nullable4 = this.ZIndex_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"zIndex", (object)this.ZIndex);
            }
            if (this.ZoneAxis != this.ZoneAxis_DefaultValue)
            {
                hashtable.Add((object)"zoneAxis", (object)this.ZoneAxis);
            }
            if (this.Zones != this.Zones_DefaultValue)
            {
                hashtable.Add((object)"zones", (object)this.HashifyList((IEnumerable)this.Zones));
            }
            return(hashtable);
        }
Пример #24
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.AllowDecimals;
            bool?     nullable2 = this.AllowDecimals_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"allowDecimals", (object)this.AllowDecimals);
            }
            if (this.AlternateGridColor != this.AlternateGridColor_DefaultValue)
            {
                hashtable.Add((object)"alternateGridColor", (object)this.AlternateGridColor);
            }
            if (this.Breaks.IsDirty())
            {
                hashtable.Add((object)"breaks", (object)this.Breaks.ToHashtable());
            }
            double?nullable3 = this.Ceiling;
            double?nullable4 = this.Ceiling_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"ceiling", (object)this.Ceiling);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Crosshair.IsDirty())
            {
                hashtable.Add((object)"crosshair", (object)this.Crosshair.ToHashtable());
            }
            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtable.Add((object)"dateTimeLabelFormats", (object)this.DateTimeLabelFormats);
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtable.Add((object)"description", (object)this.Description);
            }
            nullable2 = this.EndOnTick;
            nullable1 = this.EndOnTick_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"endOnTick", (object)this.EndOnTick);
            }
            if (this.Events.IsDirty())
            {
                hashtable.Add((object)"events", (object)this.Events.ToHashtable());
            }
            nullable4 = this.Floor;
            nullable3 = this.Floor_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"floor", (object)this.Floor);
            }
            if (this.GridLineColor != this.GridLineColor_DefaultValue)
            {
                hashtable.Add((object)"gridLineColor", (object)this.GridLineColor);
            }
            if (this.GridLineDashStyle != this.GridLineDashStyle_DefaultValue)
            {
                hashtable.Add((object)"gridLineDashStyle",
                              (object)Highstock.FirstCharacterToLower(this.GridLineDashStyle.ToString()));
            }
            nullable3 = this.GridLineWidth;
            nullable4 = this.GridLineWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"gridLineWidth", (object)this.GridLineWidth);
            }
            nullable4 = this.GridZIndex;
            nullable3 = this.GridZIndex_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"gridZIndex", (object)this.GridZIndex);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtable.Add((object)"id", (object)this.Id);
            }
            if (this.Labels.IsDirty())
            {
                hashtable.Add((object)"labels", (object)this.Labels.ToHashtable());
            }
            if (this.LineColor != this.LineColor_DefaultValue)
            {
                hashtable.Add((object)"lineColor", (object)this.LineColor);
            }
            nullable3 = this.LineWidth;
            nullable4 = this.LineWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"lineWidth", (object)this.LineWidth);
            }
            nullable4 = this.LinkedTo;
            nullable3 = this.LinkedTo_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"linkedTo", (object)this.LinkedTo);
            }
            nullable3 = this.Max;
            nullable4 = this.Max_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"max", (object)this.Max);
            }
            nullable4 = this.MaxPadding;
            nullable3 = this.MaxPadding_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"maxPadding", (object)this.MaxPadding);
            }
            nullable3 = this.Min;
            nullable4 = this.Min_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"min", (object)this.Min);
            }
            nullable4 = this.MinPadding;
            nullable3 = this.MinPadding_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"minPadding", (object)this.MinPadding);
            }
            nullable3 = this.MinRange;
            nullable4 = this.MinRange_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minRange", (object)this.MinRange);
            }
            nullable4 = this.MinTickInterval;
            nullable3 = this.MinTickInterval_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"minTickInterval", (object)this.MinTickInterval);
            }
            if (this.MinorGridLineColor != this.MinorGridLineColor_DefaultValue)
            {
                hashtable.Add((object)"minorGridLineColor", (object)this.MinorGridLineColor);
            }
            if (this.MinorGridLineDashStyle != this.MinorGridLineDashStyle_DefaultValue)
            {
                hashtable.Add((object)"minorGridLineDashStyle",
                              (object)Highstock.FirstCharacterToLower(this.MinorGridLineDashStyle.ToString()));
            }
            nullable3 = this.MinorGridLineWidth;
            nullable4 = this.MinorGridLineWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minorGridLineWidth", (object)this.MinorGridLineWidth);
            }
            if (this.MinorTickColor != this.MinorTickColor_DefaultValue)
            {
                hashtable.Add((object)"minorTickColor", (object)this.MinorTickColor);
            }
            if (this.MinorTickInterval != this.MinorTickInterval_DefaultValue)
            {
                hashtable.Add((object)"minorTickInterval", (object)this.MinorTickInterval);
            }
            nullable4 = this.MinorTickLength;
            nullable3 = this.MinorTickLength_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"minorTickLength", (object)this.MinorTickLength);
            }
            if (this.MinorTickPosition != this.MinorTickPosition_DefaultValue)
            {
                hashtable.Add((object)"minorTickPosition",
                              (object)Highstock.FirstCharacterToLower(this.MinorTickPosition.ToString()));
            }
            nullable3 = this.MinorTickWidth;
            nullable4 = this.MinorTickWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minorTickWidth", (object)this.MinorTickWidth);
            }
            nullable4 = this.Offset;
            nullable3 = this.Offset_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"offset", (object)this.Offset);
            }
            nullable1 = this.Opposite;
            nullable2 = this.Opposite_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"opposite", (object)this.Opposite);
            }
            nullable2 = this.Ordinal;
            nullable1 = this.Ordinal_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"ordinal", (object)this.Ordinal);
            }
            if (this.PlotBands != this.PlotBands_DefaultValue)
            {
                hashtable.Add((object)"plotBands", (object)this.HashifyList((IEnumerable)this.PlotBands));
            }
            if (this.PlotLines != this.PlotLines_DefaultValue)
            {
                hashtable.Add((object)"plotLines", (object)this.HashifyList((IEnumerable)this.PlotLines));
            }
            nullable3 = this.Range;
            nullable4 = this.Range_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"range", (object)this.Range);
            }
            nullable1 = this.Reversed;
            nullable2 = this.Reversed_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"reversed", (object)this.Reversed);
            }
            nullable2 = this.ShowEmpty;
            nullable1 = this.ShowEmpty_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showEmpty", (object)this.ShowEmpty);
            }
            nullable1 = this.ShowFirstLabel;
            nullable2 = this.ShowFirstLabel_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"showFirstLabel", (object)this.ShowFirstLabel);
            }
            nullable2 = this.ShowLastLabel;
            nullable1 = this.ShowLastLabel_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showLastLabel", (object)this.ShowLastLabel);
            }
            nullable4 = this.SoftMin;
            nullable3 = this.SoftMin_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"softMin", (object)this.SoftMin);
            }
            nullable3 = this.StartOfWeek;
            nullable4 = this.StartOfWeek_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"startOfWeek", (object)this.StartOfWeek);
            }
            nullable1 = this.StartOnTick;
            nullable2 = this.StartOnTick_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"startOnTick", (object)this.StartOnTick);
            }
            nullable4 = this.TickAmount;
            nullable3 = this.TickAmount_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"tickAmount", (object)this.TickAmount);
            }
            if (this.TickColor != this.TickColor_DefaultValue)
            {
                hashtable.Add((object)"tickColor", (object)this.TickColor);
            }
            nullable3 = this.TickInterval;
            nullable4 = this.TickInterval_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"tickInterval", (object)this.TickInterval);
            }
            nullable4 = this.TickLength;
            nullable3 = this.TickLength_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"tickLength", (object)this.TickLength);
            }
            nullable3 = this.TickPixelInterval;
            nullable4 = this.TickPixelInterval_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"tickPixelInterval", (object)this.TickPixelInterval);
            }
            if (this.TickPosition != this.TickPosition_DefaultValue)
            {
                hashtable.Add((object)"tickPosition",
                              (object)Highstock.FirstCharacterToLower(this.TickPosition.ToString()));
            }
            if (this.TickPositioner != this.TickPositioner_DefaultValue)
            {
                hashtable.Add((object)"tickPositioner", (object)this.TickPositioner);
                Highstock.AddFunction("XAxisTickPositioner.tickPositioner", this.TickPositioner);
            }
            if (this.TickPositions != this.TickPositions_DefaultValue)
            {
                hashtable.Add((object)"tickPositions", (object)this.TickPositions);
            }
            nullable4 = this.TickWidth;
            nullable3 = this.TickWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"tickWidth", (object)this.TickWidth);
            }
            if (this.Title.IsDirty())
            {
                hashtable.Add((object)"title", (object)this.Title.ToHashtable());
            }
            nullable2 = this.Visible;
            nullable1 = this.Visible_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"visible", (object)this.Visible);
            }
            return(hashtable);
        }
Пример #25
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highstock.FirstCharacterToLower(this.Align.ToString()));
            }
            if (this.BackgroundColor != this.BackgroundColor_DefaultValue)
            {
                hashtable.Add((object)"backgroundColor", (object)this.BackgroundColor);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            double?nullable1 = this.BorderRadius;
            double?nullable2 = this.BorderRadius_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"borderRadius", (object)this.BorderRadius);
            }
            nullable2 = this.BorderWidth;
            nullable1 = this.BorderWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"borderWidth", (object)this.BorderWidth);
            }
            bool?nullable3 = this.Enabled;
            bool?nullable4 = this.Enabled_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            nullable4 = this.Floating;
            nullable3 = this.Floating_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"floating", (object)this.Floating);
            }
            nullable1 = this.ItemDistance;
            nullable2 = this.ItemDistance_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"itemDistance", (object)this.ItemDistance);
            }
            if (this.ItemHiddenStyle != this.ItemHiddenStyle_DefaultValue)
            {
                hashtable.Add((object)"itemHiddenStyle", (object)this.ItemHiddenStyle);
            }
            if (this.ItemHoverStyle != this.ItemHoverStyle_DefaultValue)
            {
                hashtable.Add((object)"itemHoverStyle", (object)this.ItemHoverStyle);
            }
            nullable2 = this.ItemMarginBottom;
            nullable1 = this.ItemMarginBottom_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"itemMarginBottom", (object)this.ItemMarginBottom);
            }
            nullable1 = this.ItemMarginTop;
            nullable2 = this.ItemMarginTop_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"itemMarginTop", (object)this.ItemMarginTop);
            }
            if (this.ItemStyle != this.ItemStyle_DefaultValue)
            {
                hashtable.Add((object)"itemStyle", (object)this.ItemStyle);
            }
            nullable2 = this.ItemWidth;
            nullable1 = this.ItemWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"itemWidth", (object)this.ItemWidth);
            }
            if (this.LabelFormat != this.LabelFormat_DefaultValue)
            {
                hashtable.Add((object)"labelFormat", (object)this.LabelFormat);
            }
            if (this.LabelFormatter != this.LabelFormatter_DefaultValue)
            {
                hashtable.Add((object)"labelFormatter", (object)this.LabelFormatter);
                Highstock.AddFunction("LegendLabelFormatter.labelFormatter", this.LabelFormatter);
            }
            if (this.Layout != this.Layout_DefaultValue)
            {
                hashtable.Add((object)"layout", (object)Highstock.FirstCharacterToLower(this.Layout.ToString()));
            }
            nullable1 = this.Margin;
            nullable2 = this.Margin_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"margin", (object)this.Margin);
            }
            nullable2 = this.MaxHeight;
            nullable1 = this.MaxHeight_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"maxHeight", (object)this.MaxHeight);
            }
            if (this.Navigation.IsDirty())
            {
                hashtable.Add((object)"navigation", (object)this.Navigation.ToHashtable());
            }
            nullable1 = this.Padding;
            nullable2 = this.Padding_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            nullable3 = this.Reversed;
            nullable4 = this.Reversed_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"reversed", (object)this.Reversed);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            nullable4 = this.SquareSymbol;
            nullable3 = this.SquareSymbol_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"squareSymbol", (object)this.SquareSymbol);
            }
            nullable2 = this.SymbolHeight;
            nullable1 = this.SymbolHeight_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"symbolHeight", (object)this.SymbolHeight);
            }
            nullable1 = this.SymbolPadding;
            nullable2 = this.SymbolPadding_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"symbolPadding", (object)this.SymbolPadding);
            }
            nullable2 = this.SymbolRadius;
            nullable1 = this.SymbolRadius_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"symbolRadius", (object)this.SymbolRadius);
            }
            nullable1 = this.SymbolWidth;
            nullable2 = this.SymbolWidth_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"symbolWidth", (object)this.SymbolWidth);
            }
            if (this.Title.IsDirty())
            {
                hashtable.Add((object)"title", (object)this.Title.ToHashtable());
            }
            nullable3 = this.UseHTML;
            nullable4 = this.UseHTML_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highstock.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            nullable2 = this.Width;
            nullable1 = this.Width_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            nullable1 = this.X;
            nullable2 = this.X_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable2 = this.Y;
            nullable1 = this.Y_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            return(hashtable);
        }
Пример #26
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.AllowHTML;
            bool?     nullable2 = this.AllowHTML_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"allowHTML", (object)this.AllowHTML);
            }
            if (this.Buttons.IsDirty())
            {
                hashtable.Add((object)"buttons", (object)this.Buttons.ToHashtable());
            }
            if (this.ChartOptions != this.ChartOptions_DefaultValue)
            {
                hashtable.Add((object)"chartOptions", this.ChartOptions);
            }
            nullable2 = this.Enabled;
            nullable1 = this.Enabled_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            if (this.Error != this.Error_DefaultValue)
            {
                hashtable.Add((object)"error", (object)this.Error);
                Highstock.AddFunction("ExportingError.error", this.Error);
            }
            nullable1 = this.FallbackToExportServer;
            nullable2 = this.FallbackToExportServer_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"fallbackToExportServer", (object)this.FallbackToExportServer);
            }
            if (this.Filename != this.Filename_DefaultValue)
            {
                hashtable.Add((object)"filename", (object)this.Filename);
            }
            if (this.FormAttributes != this.FormAttributes_DefaultValue)
            {
                hashtable.Add((object)"formAttributes", this.FormAttributes);
            }
            if (this.LibURL != this.LibURL_DefaultValue)
            {
                hashtable.Add((object)"libURL", (object)this.LibURL);
            }
            double?nullable3 = this.PrintMaxWidth;
            double?nullable4 = this.PrintMaxWidth_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"printMaxWidth", (object)this.PrintMaxWidth);
            }
            nullable4 = this.Scale;
            nullable3 = this.Scale_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"scale", (object)this.Scale);
            }
            nullable3 = this.SourceHeight;
            nullable4 = this.SourceHeight_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"sourceHeight", (object)this.SourceHeight);
            }
            nullable4 = this.SourceWidth;
            nullable3 = this.SourceWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"sourceWidth", (object)this.SourceWidth);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                hashtable.Add((object)"type", (object)Highstock.FirstCharacterToLower(this.Type.ToString()));
            }
            if (this.Url != this.Url_DefaultValue)
            {
                hashtable.Add((object)"url", (object)this.Url);
            }
            nullable3 = this.Width;
            nullable4 = this.Width_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            return(hashtable);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            double?   nullable1 = this.ChangeDecimals;
            double?   nullable2 = this.ChangeDecimals_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"changeDecimals", (object)this.ChangeDecimals);
            }
            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtable.Add((object)"dateTimeLabelFormats", (object)this.DateTimeLabelFormats);
            }
            bool?nullable3 = this.FollowPointer;
            bool?nullable4 = this.FollowPointer_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"followPointer", (object)this.FollowPointer);
            }
            nullable4 = this.FollowTouchMove;
            nullable3 = this.FollowTouchMove_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"followTouchMove", (object)this.FollowTouchMove);
            }
            if (this.HeaderFormat != this.HeaderFormat_DefaultValue)
            {
                hashtable.Add((object)"headerFormat", (object)this.HeaderFormat);
            }
            nullable2 = this.Padding;
            nullable1 = this.Padding_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            if (this.PointFormat != this.PointFormat_DefaultValue)
            {
                hashtable.Add((object)"pointFormat", (object)this.PointFormat);
            }
            if (this.PointFormatter != this.PointFormatter_DefaultValue)
            {
                hashtable.Add((object)"pointFormatter", (object)this.PointFormatter);
                Highstock.AddFunction("PlotOptionsAreasplineTooltipPointFormatter.pointFormatter", this.PointFormatter);
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtable.Add((object)"shape", (object)this.Shape);
            }
            nullable3 = this.Split;
            nullable4 = this.Split_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"split", (object)this.Split);
            }
            nullable1 = this.ValueDecimals;
            nullable2 = this.ValueDecimals_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"valueDecimals", (object)this.ValueDecimals);
            }
            if (this.ValuePrefix != this.ValuePrefix_DefaultValue)
            {
                hashtable.Add((object)"valuePrefix", (object)this.ValuePrefix);
            }
            if (this.ValueSuffix != this.ValueSuffix_DefaultValue)
            {
                hashtable.Add((object)"valueSuffix", (object)this.ValueSuffix);
            }
            if (this.XDateFormat != this.XDateFormat_DefaultValue)
            {
                hashtable.Add((object)"xDateFormat", (object)this.XDateFormat);
            }
            return(hashtable);
        }
Пример #28
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtable.Add((object)"dateTimeLabelFormats", (object)this.DateTimeLabelFormats);
            }
            bool?nullable1 = this.FollowPointer;
            bool?nullable2 = this.FollowPointer_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"followPointer", (object)this.FollowPointer);
            }
            nullable2 = this.FollowTouchMove;
            nullable1 = this.FollowTouchMove_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"followTouchMove", (object)this.FollowTouchMove);
            }
            if (this.HeaderFormat != this.HeaderFormat_DefaultValue)
            {
                hashtable.Add((object)"headerFormat", (object)this.HeaderFormat);
            }
            double?padding             = this.Padding;
            double?paddingDefaultValue = this.Padding_DefaultValue;

            if (padding.GetValueOrDefault() != paddingDefaultValue.GetValueOrDefault() ||
                padding.HasValue != paddingDefaultValue.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            if (this.PointFormat != this.PointFormat_DefaultValue)
            {
                hashtable.Add((object)"pointFormat", (object)this.PointFormat);
            }
            if (this.PointFormatter != this.PointFormatter_DefaultValue)
            {
                hashtable.Add((object)"pointFormatter", (object)this.PointFormatter);
                Highstock.AddFunction("FlagsSeriesTooltipPointFormatter.pointFormatter", this.PointFormatter);
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtable.Add((object)"shape", (object)this.Shape);
            }
            nullable1 = this.Split;
            nullable2 = this.Split_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"split", (object)this.Split);
            }
            if (this.XDateFormat != this.XDateFormat_DefaultValue)
            {
                hashtable.Add((object)"xDateFormat", (object)this.XDateFormat);
            }
            return(hashtable);
        }
Пример #29
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highstock.FirstCharacterToLower(this.Align.ToString()));
            }
            if (this.AutoRotation != this.AutoRotation_DefaultValue)
            {
                hashtable.Add((object)"autoRotation", (object)this.AutoRotation);
            }
            bool?nullable1 = this.Enabled;
            bool?nullable2 = this.Enabled_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            if (this.Format != this.Format_DefaultValue)
            {
                hashtable.Add((object)"format", (object)this.Format);
            }
            if (this.Formatter != this.Formatter_DefaultValue)
            {
                hashtable.Add((object)"formatter", (object)this.Formatter);
                Highstock.AddFunction("YAxisLabelsFormatter.formatter", this.Formatter);
            }
            double?nullable3 = this.Rotation;
            double?nullable4 = this.Rotation_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"rotation", (object)this.Rotation);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            nullable2 = this.UseHTML;
            nullable1 = this.UseHTML_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            nullable4 = this.X;
            nullable3 = this.X_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable3 = this.Y;
            nullable4 = this.Y_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            nullable4 = this.ZIndex;
            nullable3 = this.ZIndex_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"zIndex", (object)this.ZIndex);
            }
            return(hashtable);
        }
Пример #30
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highstock.FirstCharacterToLower(this.Align.ToString()));
            }
            bool?enabled             = this.Enabled;
            bool?enabledDefaultValue = this.Enabled_DefaultValue;

            if (enabled.GetValueOrDefault() != enabledDefaultValue.GetValueOrDefault() ||
                enabled.HasValue != enabledDefaultValue.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            double?nullable1 = this.Height;
            double?nullable2 = this.Height_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"height", (object)this.Height);
            }
            if (this.SymbolFill != this.SymbolFill_DefaultValue)
            {
                hashtable.Add((object)"symbolFill", (object)this.SymbolFill);
            }
            nullable2 = this.SymbolSize;
            nullable1 = this.SymbolSize_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"symbolSize", (object)this.SymbolSize);
            }
            if (this.SymbolStroke != this.SymbolStroke_DefaultValue)
            {
                hashtable.Add((object)"symbolStroke", (object)this.SymbolStroke);
            }
            nullable1 = this.SymbolStrokeWidth;
            nullable2 = this.SymbolStrokeWidth_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"symbolStrokeWidth", (object)this.SymbolStrokeWidth);
            }
            nullable2 = this.SymbolX;
            nullable1 = this.SymbolX_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"symbolX", (object)this.SymbolX);
            }
            nullable1 = this.SymbolY;
            nullable2 = this.SymbolY_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"symbolY", (object)this.SymbolY);
            }
            if (this.Text != this.Text_DefaultValue)
            {
                hashtable.Add((object)"text", (object)this.Text);
            }
            if (this.Theme != this.Theme_DefaultValue)
            {
                hashtable.Add((object)"theme", this.Theme);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highstock.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            nullable2 = this.Width;
            nullable1 = this.Width_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            nullable1 = this.Y;
            nullable2 = this.Y_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            return(hashtable);
        }