internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)this.Align);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highcharts.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);
        }
        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.Text != this.Text_DefaultValue)
            {
                hashtable.Add((object)"text", (object)this.Text);
            }
            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)Highcharts.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);
        }
Exemple #3
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                SubtitleAlign align = this.Align;
                hashtables.Add("align", Highcharts.FirstCharacterToLower(align.ToString()));
            }
            bool?floating             = this.Floating;
            bool?floatingDefaultValue = this.Floating_DefaultValue;

            if ((floating.GetValueOrDefault() == floatingDefaultValue.GetValueOrDefault() ? floating.HasValue != floatingDefaultValue.HasValue : true))
            {
                hashtables.Add("floating", this.Floating);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtables.Add("style", this.Style);
            }
            if (this.Text != this.Text_DefaultValue)
            {
                hashtables.Add("text", this.Text);
            }
            floatingDefaultValue = this.UseHTML;
            floating             = this.UseHTML_DefaultValue;
            if ((floatingDefaultValue.GetValueOrDefault() == floating.GetValueOrDefault() ? floatingDefaultValue.HasValue != floating.HasValue : true))
            {
                hashtables.Add("useHTML", this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                SubtitleVerticalAlign verticalAlign = this.VerticalAlign;
                hashtables.Add("verticalAlign", Highcharts.FirstCharacterToLower(verticalAlign.ToString()));
            }
            double?widthAdjust             = this.WidthAdjust;
            double?widthAdjustDefaultValue = this.WidthAdjust_DefaultValue;

            if ((widthAdjust.GetValueOrDefault() == widthAdjustDefaultValue.GetValueOrDefault() ? widthAdjust.HasValue != widthAdjustDefaultValue.HasValue : true))
            {
                hashtables.Add("widthAdjust", this.WidthAdjust);
            }
            widthAdjustDefaultValue = this.X;
            widthAdjust             = this.X_DefaultValue;
            if ((widthAdjustDefaultValue.GetValueOrDefault() == widthAdjust.GetValueOrDefault() ? widthAdjustDefaultValue.HasValue != widthAdjust.HasValue : true))
            {
                hashtables.Add("x", this.X);
            }
            widthAdjust             = this.Y;
            widthAdjustDefaultValue = this.Y_DefaultValue;
            if ((widthAdjust.GetValueOrDefault() == widthAdjustDefaultValue.GetValueOrDefault() ? widthAdjust.HasValue != widthAdjustDefaultValue.HasValue : true))
            {
                hashtables.Add("y", this.Y);
            }
            return(hashtables);
        }
Exemple #4
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)Highcharts.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);
        }
Exemple #5
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Data.Any <SeriesData>())
            {
                hashtables.Add("data", base.HashifyList(this.Data));
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtables.Add("id", this.Id);
            }
            double?index             = this.Index;
            double?indexDefaultValue = this.Index_DefaultValue;

            if ((index.GetValueOrDefault() == indexDefaultValue.GetValueOrDefault() ? index.HasValue != indexDefaultValue.HasValue : true))
            {
                hashtables.Add("index", this.Index);
            }
            indexDefaultValue = this.LegendIndex;
            index             = this.LegendIndex_DefaultValue;
            if ((indexDefaultValue.GetValueOrDefault() == index.GetValueOrDefault() ? indexDefaultValue.HasValue != index.HasValue : true))
            {
                hashtables.Add("legendIndex", this.LegendIndex);
            }
            if (this.Name != this.Name_DefaultValue)
            {
                hashtables.Add("name", this.Name);
            }
            if (this.Stack != this.Stack_DefaultValue)
            {
                hashtables.Add("stack", this.Stack);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                SeriesType type = this.Type;
                hashtables.Add("type", Highcharts.FirstCharacterToLower(type.ToString()));
            }
            if (this.XAxis != this.XAxis_DefaultValue)
            {
                hashtables.Add("xAxis", this.XAxis);
            }
            if (this.YAxis != this.YAxis_DefaultValue)
            {
                hashtables.Add("yAxis", this.YAxis);
            }
            index             = this.ZIndex;
            indexDefaultValue = this.ZIndex_DefaultValue;
            if ((index.GetValueOrDefault() == indexDefaultValue.GetValueOrDefault() ? index.HasValue != indexDefaultValue.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            return(hashtables);
        }
Exemple #6
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highcharts.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);
        }
Exemple #7
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)Highcharts.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 hashtables = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtables.Add("align", this.Align);
            }
            double?rotation             = this.Rotation;
            double?rotationDefaultValue = this.Rotation_DefaultValue;

            if ((rotation.GetValueOrDefault() == rotationDefaultValue.GetValueOrDefault() ? rotation.HasValue != rotationDefaultValue.HasValue : true))
            {
                hashtables.Add("rotation", this.Rotation);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtables.Add("style", this.Style);
            }
            if (this.Text != this.Text_DefaultValue)
            {
                hashtables.Add("text", this.Text);
            }
            if (this.TextAlign != this.TextAlign_DefaultValue)
            {
                hashtables.Add("textAlign", this.TextAlign);
            }
            bool?useHTML             = this.UseHTML;
            bool?useHTMLDefaultValue = this.UseHTML_DefaultValue;

            if ((useHTML.GetValueOrDefault() == useHTMLDefaultValue.GetValueOrDefault() ? useHTML.HasValue != useHTMLDefaultValue.HasValue : true))
            {
                hashtables.Add("useHTML", this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                ZAxisPlotLinesLabelVerticalAlign verticalAlign = this.VerticalAlign;
                hashtables.Add("verticalAlign", Highcharts.FirstCharacterToLower(verticalAlign.ToString()));
            }
            rotationDefaultValue = this.X;
            rotation             = this.X_DefaultValue;
            if ((rotationDefaultValue.GetValueOrDefault() == rotation.GetValueOrDefault() ? rotationDefaultValue.HasValue != rotation.HasValue : true))
            {
                hashtables.Add("x", this.X);
            }
            rotation             = this.Y;
            rotationDefaultValue = this.Y_DefaultValue;
            if ((rotation.GetValueOrDefault() == rotationDefaultValue.GetValueOrDefault() ? rotation.HasValue != rotationDefaultValue.HasValue : true))
            {
                hashtables.Add("y", this.Y);
            }
            return(hashtables);
        }
Exemple #9
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtables.Add("color", this.Color);
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                YAxisPlotLinesDashStyle dashStyle = this.DashStyle;
                hashtables.Add("dashStyle", Highcharts.FirstCharacterToLower(dashStyle.ToString()));
            }
            if (this.Events != this.Events_DefaultValue)
            {
                hashtables.Add("events", this.Events);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtables.Add("id", this.Id);
            }
            if (this.Label.IsDirty())
            {
                hashtables.Add("label", this.Label.ToHashtable());
            }
            double?value             = this.Value;
            double?valueDefaultValue = this.Value_DefaultValue;

            if ((value.GetValueOrDefault() == valueDefaultValue.GetValueOrDefault() ? value.HasValue != valueDefaultValue.HasValue : true))
            {
                hashtables.Add("value", this.Value);
            }
            valueDefaultValue = this.Width;
            value             = this.Width_DefaultValue;
            if ((valueDefaultValue.GetValueOrDefault() == value.GetValueOrDefault() ? valueDefaultValue.HasValue != value.HasValue : true))
            {
                hashtables.Add("width", this.Width);
            }
            value             = this.ZIndex;
            valueDefaultValue = this.ZIndex_DefaultValue;
            if ((value.GetValueOrDefault() == valueDefaultValue.GetValueOrDefault() ? value.HasValue != valueDefaultValue.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            return(hashtables);
        }
Exemple #10
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                ZAxisTitleAlign align = this.Align;
                hashtables.Add("align", Highcharts.FirstCharacterToLower(align.ToString()));
            }
            if (this.Margin != this.Margin_DefaultValue)
            {
                hashtables.Add("margin", this.Margin);
            }
            double?offset             = this.Offset;
            double?offsetDefaultValue = this.Offset_DefaultValue;

            if ((offset.GetValueOrDefault() == offsetDefaultValue.GetValueOrDefault() ? offset.HasValue != offsetDefaultValue.HasValue : true))
            {
                hashtables.Add("offset", this.Offset);
            }
            offsetDefaultValue = this.Rotation;
            offset             = this.Rotation_DefaultValue;
            if ((offsetDefaultValue.GetValueOrDefault() == offset.GetValueOrDefault() ? offsetDefaultValue.HasValue != offset.HasValue : true))
            {
                hashtables.Add("rotation", this.Rotation);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtables.Add("style", this.Style);
            }
            if (this.Text != this.Text_DefaultValue)
            {
                hashtables.Add("text", this.Text);
            }
            offset             = this.X;
            offsetDefaultValue = this.X_DefaultValue;
            if ((offset.GetValueOrDefault() == offsetDefaultValue.GetValueOrDefault() ? offset.HasValue != offsetDefaultValue.HasValue : true))
            {
                hashtables.Add("x", this.X);
            }
            offsetDefaultValue = this.Y;
            offset             = this.Y_DefaultValue;
            if ((offsetDefaultValue.GetValueOrDefault() == offset.GetValueOrDefault() ? offsetDefaultValue.HasValue != offset.HasValue : true))
            {
                hashtables.Add("y", this.Y);
            }
            return(hashtables);
        }
Exemple #11
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            if (this.BorderDashStyle != this.BorderDashStyle_DefaultValue)
            {
                hashtable.Add((object)"borderDashStyle", (object)this.BorderDashStyle);
            }
            double?nullable1 = this.BorderWidth;
            double?nullable2 = this.BorderWidth_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"borderWidth", (object)this.BorderWidth);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtable.Add((object)"color", (object)this.Color);
            }
            if (this.DataLabels.IsDirty())
            {
                hashtable.Add((object)"dataLabels", (object)this.DataLabels.ToHashtable());
            }
            if (this.LayoutAlgorithm != this.LayoutAlgorithm_DefaultValue)
            {
                hashtable.Add((object)"layoutAlgorithm",
                              (object)Highcharts.FirstCharacterToLower(this.LayoutAlgorithm.ToString()));
            }
            if (this.LayoutStartingDirection != this.LayoutStartingDirection_DefaultValue)
            {
                hashtable.Add((object)"layoutStartingDirection",
                              (object)Highcharts.FirstCharacterToLower(this.LayoutStartingDirection.ToString()));
            }
            nullable2 = this.Level;
            nullable1 = this.Level_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"level", (object)this.Level);
            }
            return(hashtable);
        }
Exemple #12
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtables.Add("borderColor", this.BorderColor);
            }
            if (this.BorderDashStyle != this.BorderDashStyle_DefaultValue)
            {
                hashtables.Add("borderDashStyle", this.BorderDashStyle);
            }
            double?borderWidth             = this.BorderWidth;
            double?borderWidthDefaultValue = this.BorderWidth_DefaultValue;

            if ((borderWidth.GetValueOrDefault() == borderWidthDefaultValue.GetValueOrDefault() ? borderWidth.HasValue != borderWidthDefaultValue.HasValue : true))
            {
                hashtables.Add("borderWidth", this.BorderWidth);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtables.Add("color", this.Color);
            }
            if (this.DataLabels != this.DataLabels_DefaultValue)
            {
                hashtables.Add("dataLabels", this.DataLabels);
            }
            if (this.LayoutAlgorithm != this.LayoutAlgorithm_DefaultValue)
            {
                TreemapSeriesLevelsLayoutAlgorithm layoutAlgorithm = this.LayoutAlgorithm;
                hashtables.Add("layoutAlgorithm", Highcharts.FirstCharacterToLower(layoutAlgorithm.ToString()));
            }
            if (this.LayoutStartingDirection != this.LayoutStartingDirection_DefaultValue)
            {
                TreemapSeriesLevelsLayoutStartingDirection layoutStartingDirection = this.LayoutStartingDirection;
                hashtables.Add("layoutStartingDirection", Highcharts.FirstCharacterToLower(layoutStartingDirection.ToString()));
            }
            borderWidthDefaultValue = this.Level;
            borderWidth             = this.Level_DefaultValue;
            if ((borderWidthDefaultValue.GetValueOrDefault() == borderWidth.GetValueOrDefault() ? borderWidthDefaultValue.HasValue != borderWidth.HasValue : true))
            {
                hashtables.Add("level", this.Level);
            }
            return(hashtables);
        }
        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)Highcharts.FirstCharacterToLower(this.RelativeTo.ToString()));
            }
            if (this.Theme != this.Theme_DefaultValue)
            {
                hashtable.Add((object)"theme", this.Theme);
            }
            return(hashtable);
        }
Exemple #14
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Position.Count > 0)
            {
                hashtables.Add("position", this.Position);
            }
            if (this.RelativeTo != this.RelativeTo_DefaultValue)
            {
                ChartResetZoomButtonRelativeTo relativeTo = this.RelativeTo;
                hashtables.Add("relativeTo", Highcharts.FirstCharacterToLower(relativeTo.ToString()));
            }
            if (this.Theme != this.Theme_DefaultValue)
            {
                hashtables.Add("theme", this.Theme);
            }
            return(hashtables);
        }
Exemple #15
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)Highcharts.FirstCharacterToLower(this.DashStyle.ToString()));
            }
            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);
        }
Exemple #16
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtables.Add("color", this.Color);
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                YAxisCrosshairDashStyle dashStyle = this.DashStyle;
                hashtables.Add("dashStyle", Highcharts.FirstCharacterToLower(dashStyle.ToString()));
            }
            bool?snap             = this.Snap;
            bool?snapDefaultValue = this.Snap_DefaultValue;

            if ((snap.GetValueOrDefault() == snapDefaultValue.GetValueOrDefault() ? snap.HasValue != snapDefaultValue.HasValue : true))
            {
                hashtables.Add("snap", this.Snap);
            }
            double?width             = this.Width;
            double?widthDefaultValue = this.Width_DefaultValue;

            if ((width.GetValueOrDefault() == widthDefaultValue.GetValueOrDefault() ? width.HasValue != widthDefaultValue.HasValue : true))
            {
                hashtables.Add("width", this.Width);
            }
            widthDefaultValue = this.ZIndex;
            width             = this.ZIndex_DefaultValue;
            if ((widthDefaultValue.GetValueOrDefault() == width.GetValueOrDefault() ? widthDefaultValue.HasValue != width.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            return(hashtables);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.BackgroundColor != this.BackgroundColor_DefaultValue)
            {
                hashtables.Add("backgroundColor", this.BackgroundColor);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtables.Add("borderColor", this.BorderColor);
            }
            double?borderWidth             = this.BorderWidth;
            double?borderWidthDefaultValue = this.BorderWidth_DefaultValue;

            if ((borderWidth.GetValueOrDefault() == borderWidthDefaultValue.GetValueOrDefault() ? borderWidth.HasValue != borderWidthDefaultValue.HasValue : true))
            {
                hashtables.Add("borderWidth", this.BorderWidth);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            if (this.InnerRadius != this.InnerRadius_DefaultValue)
            {
                hashtables.Add("innerRadius", this.InnerRadius);
            }
            if (this.OuterRadius != this.OuterRadius_DefaultValue)
            {
                hashtables.Add("outerRadius", this.OuterRadius);
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                PaneBackgroundShape shape = this.Shape;
                hashtables.Add("shape", Highcharts.FirstCharacterToLower(shape.ToString()));
            }
            return(hashtables);
        }
Exemple #18
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            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?borderWidth       = this.BorderWidth;
            double?widthDefaultValue = this.BorderWidth_DefaultValue;

            if (borderWidth.GetValueOrDefault() != widthDefaultValue.GetValueOrDefault() ||
                borderWidth.HasValue != widthDefaultValue.HasValue)
            {
                hashtable.Add((object)"borderWidth", (object)this.BorderWidth);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.InnerRadius != this.InnerRadius_DefaultValue)
            {
                hashtable.Add((object)"innerRadius", (object)this.InnerRadius);
            }
            if (this.OuterRadius != this.OuterRadius_DefaultValue)
            {
                hashtable.Add((object)"outerRadius", (object)this.OuterRadius);
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtable.Add((object)"shape", (object)Highcharts.FirstCharacterToLower(this.Shape.ToString()));
            }
            return(hashtable);
        }
Exemple #19
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);
            }
            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.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            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.Center != this.Center_DefaultValue)
            {
                hashtable.Add((object)"center", (object)this.Center);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            nullable3 = this.ColorIndex;
            nullable4 = this.ColorIndex_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"colorIndex", (object)this.ColorIndex);
            }
            if (this.Colors != this.Colors_DefaultValue)
            {
                hashtable.Add((object)"colors", (object)this.Colors);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                hashtable.Add((object)"cursor", (object)Highcharts.FirstCharacterToLower(this.Cursor.ToString()));
            }
            if (this.DataLabels.IsDirty())
            {
                hashtable.Add((object)"dataLabels", (object)this.DataLabels.ToHashtable());
            }
            nullable4 = this.Depth;
            nullable3 = this.Depth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"depth", (object)this.Depth);
            }
            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);
            }
            if (this.Height != this.Height_DefaultValue)
            {
                hashtable.Add((object)"height", (object)this.Height);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtable.Add((object)"keys", (object)this.Keys);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtable.Add((object)"linkedTo", (object)this.LinkedTo);
            }
            nullable3 = this.MinSize;
            nullable4 = this.MinSize_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minSize", (object)this.MinSize);
            }
            if (this.Point.IsDirty())
            {
                hashtable.Add((object)"point", (object)this.Point.ToHashtable());
            }
            nullable2 = this.Reversed;
            nullable1 = this.Reversed_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"reversed", (object)this.Reversed);
            }
            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.ShowInLegend;
            nullable1 = this.ShowInLegend_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showInLegend", (object)this.ShowInLegend);
            }
            nullable4 = this.SlicedOffset;
            nullable3 = this.SlicedOffset_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"slicedOffset", (object)this.SlicedOffset);
            }
            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.Visible;
            nullable1 = this.Visible_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"visible", (object)this.Visible);
            }
            if (this.Width != this.Width_DefaultValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            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);
        }
Exemple #20
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables            = new Hashtable();
            bool?     allowHTML             = this.AllowHTML;
            bool?     allowHTMLDefaultValue = this.AllowHTML_DefaultValue;

            if ((allowHTML.GetValueOrDefault() == allowHTMLDefaultValue.GetValueOrDefault() ? allowHTML.HasValue != allowHTMLDefaultValue.HasValue : true))
            {
                hashtables.Add("allowHTML", this.AllowHTML);
            }
            if (this.Buttons.IsDirty())
            {
                hashtables.Add("buttons", this.Buttons.ToHashtable());
            }
            if (this.ChartOptions != this.ChartOptions_DefaultValue)
            {
                hashtables.Add("chartOptions", this.ChartOptions);
            }
            allowHTMLDefaultValue = this.Enabled;
            allowHTML             = this.Enabled_DefaultValue;
            if ((allowHTMLDefaultValue.GetValueOrDefault() == allowHTML.GetValueOrDefault() ? allowHTMLDefaultValue.HasValue != allowHTML.HasValue : true))
            {
                hashtables.Add("enabled", this.Enabled);
            }
            if (this.Error != this.Error_DefaultValue)
            {
                hashtables.Add("error", this.Error);
                Highcharts.AddFunction("ExportingError.error", this.Error);
            }
            allowHTML             = this.FallbackToExportServer;
            allowHTMLDefaultValue = this.FallbackToExportServer_DefaultValue;
            if ((allowHTML.GetValueOrDefault() == allowHTMLDefaultValue.GetValueOrDefault() ? allowHTML.HasValue != allowHTMLDefaultValue.HasValue : true))
            {
                hashtables.Add("fallbackToExportServer", this.FallbackToExportServer);
            }
            if (this.Filename != this.Filename_DefaultValue)
            {
                hashtables.Add("filename", this.Filename);
            }
            if (this.FormAttributes != this.FormAttributes_DefaultValue)
            {
                hashtables.Add("formAttributes", this.FormAttributes);
            }
            if (this.LibURL != this.LibURL_DefaultValue)
            {
                hashtables.Add("libURL", this.LibURL);
            }
            double?printMaxWidth             = this.PrintMaxWidth;
            double?printMaxWidthDefaultValue = this.PrintMaxWidth_DefaultValue;

            if ((printMaxWidth.GetValueOrDefault() == printMaxWidthDefaultValue.GetValueOrDefault() ? printMaxWidth.HasValue != printMaxWidthDefaultValue.HasValue : true))
            {
                hashtables.Add("printMaxWidth", this.PrintMaxWidth);
            }
            printMaxWidthDefaultValue = this.Scale;
            printMaxWidth             = this.Scale_DefaultValue;
            if ((printMaxWidthDefaultValue.GetValueOrDefault() == printMaxWidth.GetValueOrDefault() ? printMaxWidthDefaultValue.HasValue != printMaxWidth.HasValue : true))
            {
                hashtables.Add("scale", this.Scale);
            }
            printMaxWidth             = this.SourceHeight;
            printMaxWidthDefaultValue = this.SourceHeight_DefaultValue;
            if ((printMaxWidth.GetValueOrDefault() == printMaxWidthDefaultValue.GetValueOrDefault() ? printMaxWidth.HasValue != printMaxWidthDefaultValue.HasValue : true))
            {
                hashtables.Add("sourceHeight", this.SourceHeight);
            }
            printMaxWidthDefaultValue = this.SourceWidth;
            printMaxWidth             = this.SourceWidth_DefaultValue;
            if ((printMaxWidthDefaultValue.GetValueOrDefault() == printMaxWidth.GetValueOrDefault() ? printMaxWidthDefaultValue.HasValue != printMaxWidth.HasValue : true))
            {
                hashtables.Add("sourceWidth", this.SourceWidth);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                ExportingType type = this.Type;
                hashtables.Add("type", Highcharts.FirstCharacterToLower(type.ToString()));
            }
            if (this.Url != this.Url_DefaultValue)
            {
                hashtables.Add("url", this.Url);
            }
            printMaxWidth             = this.Width;
            printMaxWidthDefaultValue = this.Width_DefaultValue;
            if ((printMaxWidth.GetValueOrDefault() == printMaxWidthDefaultValue.GetValueOrDefault() ? printMaxWidth.HasValue != printMaxWidthDefaultValue.HasValue : true))
            {
                hashtables.Add("width", this.Width);
            }
            return(hashtables);
        }
Exemple #21
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highcharts.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.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?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);
                Highcharts.AddFunction("PlotOptionsAreasplineDataLabelsFormatter.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)Highcharts.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)Highcharts.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);
        }
Exemple #22
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables                   = new Hashtable();
            bool?     allowPointSelect             = this.AllowPointSelect;
            bool?     allowPointSelectDefaultValue = this.AllowPointSelect_DefaultValue;

            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("allowPointSelect", this.AllowPointSelect);
            }
            if (this.Animation.IsDirty())
            {
                hashtables.Add("animation", this.Animation.ToJSON());
            }
            double?animationLimit             = this.AnimationLimit;
            double?animationLimitDefaultValue = this.AnimationLimit_DefaultValue;

            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("animationLimit", this.AnimationLimit);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtables.Add("color", this.Color);
            }
            animationLimitDefaultValue = this.ColorIndex;
            animationLimit             = this.ColorIndex_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("colorIndex", this.ColorIndex);
            }
            animationLimit             = this.CropThreshold;
            animationLimitDefaultValue = this.CropThreshold_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("cropThreshold", this.CropThreshold);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                BubbleSeriesCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                BubbleSeriesDashStyle dashStyle = this.DashStyle;
                hashtables.Add("dashStyle", Highcharts.FirstCharacterToLower(dashStyle.ToString()));
            }
            if (this.Data.Any <BubbleSeriesData>())
            {
                hashtables.Add("data", base.HashifyList(this.Data));
            }
            if (this.DataLabels.IsDirty())
            {
                hashtables.Add("dataLabels", this.DataLabels.ToHashtable());
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtables.Add("description", this.Description);
            }
            allowPointSelectDefaultValue = this.DisplayNegative;
            allowPointSelect             = this.DisplayNegative_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("displayNegative", this.DisplayNegative);
            }
            allowPointSelect             = this.EnableMouseTracking;
            allowPointSelectDefaultValue = this.EnableMouseTracking_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("enableMouseTracking", this.EnableMouseTracking);
            }
            if (this.Events.IsDirty())
            {
                hashtables.Add("events", this.Events.ToHashtable());
            }
            allowPointSelectDefaultValue = this.GetExtremesFromAll;
            allowPointSelect             = this.GetExtremesFromAll_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("getExtremesFromAll", this.GetExtremesFromAll);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtables.Add("id", this.Id);
            }
            animationLimitDefaultValue = this.Index;
            animationLimit             = this.Index_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("index", this.Index);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            animationLimit             = this.LegendIndex;
            animationLimitDefaultValue = this.LegendIndex_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("legendIndex", this.LegendIndex);
            }
            animationLimitDefaultValue = this.LineWidth;
            animationLimit             = this.LineWidth_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("lineWidth", this.LineWidth);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtables.Add("linkedTo", this.LinkedTo);
            }
            if (this.Marker.IsDirty())
            {
                hashtables.Add("marker", this.Marker.ToHashtable());
            }
            if (this.MaxSize != this.MaxSize_DefaultValue)
            {
                hashtables.Add("maxSize", this.MaxSize);
            }
            if (this.MinSize != this.MinSize_DefaultValue)
            {
                hashtables.Add("minSize", this.MinSize);
            }
            if (this.Name != this.Name_DefaultValue)
            {
                hashtables.Add("name", this.Name);
            }
            if (this.NegativeColor != this.NegativeColor_DefaultValue)
            {
                hashtables.Add("negativeColor", this.NegativeColor);
            }
            if (this.Point.IsDirty())
            {
                hashtables.Add("point", this.Point.ToHashtable());
            }
            animationLimit             = this.PointInterval;
            animationLimitDefaultValue = this.PointInterval_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("pointInterval", this.PointInterval);
            }
            if (this.PointIntervalUnit != this.PointIntervalUnit_DefaultValue)
            {
                BubbleSeriesPointIntervalUnit pointIntervalUnit = this.PointIntervalUnit;
                hashtables.Add("pointIntervalUnit", Highcharts.FirstCharacterToLower(pointIntervalUnit.ToString()));
            }
            animationLimitDefaultValue = this.PointStart;
            animationLimit             = this.PointStart_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("pointStart", this.PointStart);
            }
            allowPointSelect             = this.Selected;
            allowPointSelectDefaultValue = this.Selected_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("selected", this.Selected);
            }
            if (this.Shadow != this.Shadow_DefaultValue)
            {
                hashtables.Add("shadow", this.Shadow);
            }
            allowPointSelectDefaultValue = this.ShowCheckbox;
            allowPointSelect             = this.ShowCheckbox_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("showCheckbox", this.ShowCheckbox);
            }
            allowPointSelect             = this.ShowInLegend;
            allowPointSelectDefaultValue = this.ShowInLegend_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("showInLegend", this.ShowInLegend);
            }
            if (this.SizeBy != this.SizeBy_DefaultValue)
            {
                BubbleSeriesSizeBy sizeBy = this.SizeBy;
                hashtables.Add("sizeBy", Highcharts.FirstCharacterToLower(sizeBy.ToString()));
            }
            allowPointSelectDefaultValue = this.SizeByAbsoluteValue;
            allowPointSelect             = this.SizeByAbsoluteValue_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("sizeByAbsoluteValue", this.SizeByAbsoluteValue);
            }
            allowPointSelect             = this.SoftThreshold;
            allowPointSelectDefaultValue = this.SoftThreshold_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("softThreshold", this.SoftThreshold);
            }
            if (this.States.IsDirty())
            {
                hashtables.Add("states", this.States.ToHashtable());
            }
            allowPointSelectDefaultValue = this.StickyTracking;
            allowPointSelect             = this.StickyTracking_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("stickyTracking", this.StickyTracking);
            }
            animationLimit             = this.Threshold;
            animationLimitDefaultValue = this.Threshold_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("threshold", this.Threshold);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtables.Add("tooltip", this.Tooltip.ToHashtable());
            }
            if (this.Type != this.Type_DefaultValue)
            {
                BubbleSeriesType type = this.Type;
                hashtables.Add("type", Highcharts.FirstCharacterToLower(type.ToString()));
            }
            allowPointSelect             = this.Visible;
            allowPointSelectDefaultValue = this.Visible_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("visible", this.Visible);
            }
            if (this.XAxis != this.XAxis_DefaultValue)
            {
                hashtables.Add("xAxis", this.XAxis);
            }
            if (this.YAxis != this.YAxis_DefaultValue)
            {
                hashtables.Add("yAxis", this.YAxis);
            }
            animationLimitDefaultValue = this.ZIndex;
            animationLimit             = this.ZIndex_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            animationLimit             = this.ZMax;
            animationLimitDefaultValue = this.ZMax_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("zMax", this.ZMax);
            }
            animationLimitDefaultValue = this.ZMin;
            animationLimit             = this.ZMin_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("zMin", this.ZMin);
            }
            animationLimit             = this.ZThreshold;
            animationLimitDefaultValue = this.ZThreshold_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("zThreshold", this.ZThreshold);
            }
            if (this.ZoneAxis != this.ZoneAxis_DefaultValue)
            {
                hashtables.Add("zoneAxis", this.ZoneAxis);
            }
            if (this.Zones.IsDirty())
            {
                hashtables.Add("zones", this.Zones.ToHashtable());
            }
            return(hashtables);
        }
Exemple #23
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                AreasplineSeriesDataLabelsAlign align = this.Align;
                hashtables.Add("align", Highcharts.FirstCharacterToLower(align.ToString()));
            }
            bool?allowOverlap             = this.AllowOverlap;
            bool?allowOverlapDefaultValue = this.AllowOverlap_DefaultValue;

            if ((allowOverlap.GetValueOrDefault() == allowOverlapDefaultValue.GetValueOrDefault() ? allowOverlap.HasValue != allowOverlapDefaultValue.HasValue : true))
            {
                hashtables.Add("allowOverlap", this.AllowOverlap);
            }
            if (this.BackgroundColor != this.BackgroundColor_DefaultValue)
            {
                hashtables.Add("backgroundColor", this.BackgroundColor);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtables.Add("borderColor", this.BorderColor);
            }
            double?borderRadius             = this.BorderRadius;
            double?borderRadiusDefaultValue = this.BorderRadius_DefaultValue;

            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.HasValue : true))
            {
                hashtables.Add("borderRadius", this.BorderRadius);
            }
            borderRadiusDefaultValue = this.BorderWidth;
            borderRadius             = this.BorderWidth_DefaultValue;
            if ((borderRadiusDefaultValue.GetValueOrDefault() == borderRadius.GetValueOrDefault() ? borderRadiusDefaultValue.HasValue != borderRadius.HasValue : true))
            {
                hashtables.Add("borderWidth", this.BorderWidth);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtables.Add("color", this.Color);
            }
            allowOverlapDefaultValue = this.Crop;
            allowOverlap             = this.Crop_DefaultValue;
            if ((allowOverlapDefaultValue.GetValueOrDefault() == allowOverlap.GetValueOrDefault() ? allowOverlapDefaultValue.HasValue != allowOverlap.HasValue : true))
            {
                hashtables.Add("crop", this.Crop);
            }
            allowOverlap             = this.Defer;
            allowOverlapDefaultValue = this.Defer_DefaultValue;
            if ((allowOverlap.GetValueOrDefault() == allowOverlapDefaultValue.GetValueOrDefault() ? allowOverlap.HasValue != allowOverlapDefaultValue.HasValue : true))
            {
                hashtables.Add("defer", this.Defer);
            }
            allowOverlapDefaultValue = this.Enabled;
            allowOverlap             = this.Enabled_DefaultValue;
            if ((allowOverlapDefaultValue.GetValueOrDefault() == allowOverlap.GetValueOrDefault() ? allowOverlapDefaultValue.HasValue != allowOverlap.HasValue : true))
            {
                hashtables.Add("enabled", this.Enabled);
            }
            if (this.Format != this.Format_DefaultValue)
            {
                hashtables.Add("format", this.Format);
            }
            if (this.Formatter != this.Formatter_DefaultValue)
            {
                hashtables.Add("formatter", this.Formatter);
                Highcharts.AddFunction("AreasplineSeriesDataLabelsFormatter.formatter", this.Formatter);
            }
            allowOverlap             = this.Inside;
            allowOverlapDefaultValue = this.Inside_DefaultValue;
            if ((allowOverlap.GetValueOrDefault() == allowOverlapDefaultValue.GetValueOrDefault() ? allowOverlap.HasValue != allowOverlapDefaultValue.HasValue : true))
            {
                hashtables.Add("inside", this.Inside);
            }
            if (this.Overflow != this.Overflow_DefaultValue)
            {
                AreasplineSeriesDataLabelsOverflow overflow = this.Overflow;
                hashtables.Add("overflow", Highcharts.FirstCharacterToLower(overflow.ToString()));
            }
            borderRadius             = this.Padding;
            borderRadiusDefaultValue = this.Padding_DefaultValue;
            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.HasValue : true))
            {
                hashtables.Add("padding", this.Padding);
            }
            borderRadiusDefaultValue = this.Rotation;
            borderRadius             = this.Rotation_DefaultValue;
            if ((borderRadiusDefaultValue.GetValueOrDefault() == borderRadius.GetValueOrDefault() ? borderRadiusDefaultValue.HasValue != borderRadius.HasValue : true))
            {
                hashtables.Add("rotation", this.Rotation);
            }
            if (this.Shadow != this.Shadow_DefaultValue)
            {
                hashtables.Add("shadow", this.Shadow);
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtables.Add("shape", this.Shape);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtables.Add("style", this.Style);
            }
            allowOverlapDefaultValue = this.UseHTML;
            allowOverlap             = this.UseHTML_DefaultValue;
            if ((allowOverlapDefaultValue.GetValueOrDefault() == allowOverlap.GetValueOrDefault() ? allowOverlapDefaultValue.HasValue != allowOverlap.HasValue : true))
            {
                hashtables.Add("useHTML", this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                AreasplineSeriesDataLabelsVerticalAlign verticalAlign = this.VerticalAlign;
                hashtables.Add("verticalAlign", Highcharts.FirstCharacterToLower(verticalAlign.ToString()));
            }
            borderRadius             = this.X;
            borderRadiusDefaultValue = this.X_DefaultValue;
            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.HasValue : true))
            {
                hashtables.Add("x", this.X);
            }
            borderRadiusDefaultValue = this.Y;
            borderRadius             = this.Y_DefaultValue;
            if ((borderRadiusDefaultValue.GetValueOrDefault() == borderRadius.GetValueOrDefault() ? borderRadiusDefaultValue.HasValue != borderRadius.HasValue : true))
            {
                hashtables.Add("y", this.Y);
            }
            borderRadius             = this.ZIndex;
            borderRadiusDefaultValue = this.ZIndex_DefaultValue;
            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            return(hashtables);
        }
Exemple #24
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.AlignTicks;
            bool?     nullable2 = this.AlignTicks_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"alignTicks", (object)this.AlignTicks);
            }
            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?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);
            }
            nullable3 = this.ColorCount;
            nullable4 = this.ColorCount_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"colorCount", (object)this.ColorCount);
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtable.Add((object)"description", (object)this.Description);
            }
            if (this.Events.IsDirty())
            {
                hashtable.Add((object)"events", (object)this.Events.ToHashtable());
            }
            nullable4 = this.Height;
            nullable3 = this.Height_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"height", (object)this.Height);
            }
            nullable2 = this.IgnoreHiddenSeries;
            nullable1 = this.IgnoreHiddenSeries_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"ignoreHiddenSeries", (object)this.IgnoreHiddenSeries);
            }
            nullable1 = this.Inverted;
            nullable2 = this.Inverted_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"inverted", (object)this.Inverted);
            }
            if (this.Margin != this.Margin_DefaultValue)
            {
                hashtable.Add((object)"margin", (object)this.Margin);
            }
            nullable3 = this.MarginBottom;
            nullable4 = this.MarginBottom_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"marginBottom", (object)this.MarginBottom);
            }
            nullable4 = this.MarginLeft;
            nullable3 = this.MarginLeft_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"marginLeft", (object)this.MarginLeft);
            }
            nullable3 = this.MarginRight;
            nullable4 = this.MarginRight_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"marginRight", (object)this.MarginRight);
            }
            nullable4 = this.MarginTop;
            nullable3 = this.MarginTop_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"marginTop", (object)this.MarginTop);
            }
            if (this.Options3d.IsDirty())
            {
                hashtable.Add((object)"options3d", (object)this.Options3d.ToHashtable());
            }
            if (this.PanKey != this.PanKey_DefaultValue)
            {
                hashtable.Add((object)"panKey", (object)Highcharts.FirstCharacterToLower(this.PanKey.ToString()));
            }
            nullable2 = this.Panning;
            nullable1 = this.Panning_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"panning", (object)this.Panning);
            }
            if (this.PinchType != this.PinchType_DefaultValue)
            {
                hashtable.Add((object)"pinchType",
                              (object)Highcharts.FirstCharacterToLower(this.PinchType.ToString()));
            }
            if (this.PlotBackgroundColor != this.PlotBackgroundColor_DefaultValue)
            {
                hashtable.Add((object)"plotBackgroundColor", (object)this.PlotBackgroundColor);
            }
            if (this.PlotBackgroundImage != this.PlotBackgroundImage_DefaultValue)
            {
                hashtable.Add((object)"plotBackgroundImage", (object)this.PlotBackgroundImage);
            }
            if (this.PlotBorderColor != this.PlotBorderColor_DefaultValue)
            {
                hashtable.Add((object)"plotBorderColor", (object)this.PlotBorderColor);
            }
            nullable3 = this.PlotBorderWidth;
            nullable4 = this.PlotBorderWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"plotBorderWidth", (object)this.PlotBorderWidth);
            }
            if (this.PlotShadow.IsDirty())
            {
                hashtable.Add((object)"plotShadow", (object)this.PlotShadow.ToJSON());
            }
            nullable1 = this.Polar;
            nullable2 = this.Polar_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"polar", (object)this.Polar);
            }
            nullable2 = this.Reflow;
            nullable1 = this.Reflow_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"reflow", (object)this.Reflow);
            }
            if (this.RenderTo != this.RenderTo_DefaultValue)
            {
                hashtable.Add((object)"renderTo", (object)this.RenderTo);
            }
            if (this.ResetZoomButton.IsDirty())
            {
                hashtable.Add((object)"resetZoomButton", (object)this.ResetZoomButton.ToHashtable());
            }
            if (this.SelectionMarkerFill != this.SelectionMarkerFill_DefaultValue)
            {
                hashtable.Add((object)"selectionMarkerFill", (object)this.SelectionMarkerFill);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            nullable1 = this.ShowAxes;
            nullable2 = this.ShowAxes_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"showAxes", (object)this.ShowAxes);
            }
            nullable4 = this.SpacingBottom;
            nullable3 = this.SpacingBottom_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"spacingBottom", (object)this.SpacingBottom);
            }
            nullable3 = this.SpacingLeft;
            nullable4 = this.SpacingLeft_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"spacingLeft", (object)this.SpacingLeft);
            }
            nullable4 = this.SpacingRight;
            nullable3 = this.SpacingRight_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"spacingRight", (object)this.SpacingRight);
            }
            nullable3 = this.SpacingTop;
            nullable4 = this.SpacingTop_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"spacingTop", (object)this.SpacingTop);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                hashtable.Add((object)"type", (object)Highcharts.FirstCharacterToLower(this.Type.ToString()));
            }
            if (this.TypeDescription != this.TypeDescription_DefaultValue)
            {
                hashtable.Add((object)"typeDescription", (object)this.TypeDescription);
            }
            nullable4 = this.Width;
            nullable3 = this.Width_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            if (this.ZoomType != this.ZoomType_DefaultValue)
            {
                hashtable.Add((object)"zoomType", (object)Highcharts.FirstCharacterToLower(this.ZoomType.ToString()));
            }
            return(hashtable);
        }
Exemple #25
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables                   = new Hashtable();
            bool?     allowPointSelect             = this.AllowPointSelect;
            bool?     allowPointSelectDefaultValue = this.AllowPointSelect_DefaultValue;

            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("allowPointSelect", this.AllowPointSelect);
            }
            if (this.Animation.IsDirty())
            {
                hashtables.Add("animation", this.Animation.ToJSON());
            }
            double?animationLimit             = this.AnimationLimit;
            double?animationLimitDefaultValue = this.AnimationLimit_DefaultValue;

            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("animationLimit", this.AnimationLimit);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtables.Add("borderColor", this.BorderColor);
            }
            animationLimitDefaultValue = this.BorderWidth;
            animationLimit             = this.BorderWidth_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("borderWidth", this.BorderWidth);
            }
            if (this.Center != this.Center_DefaultValue)
            {
                hashtables.Add("center", this.Center);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            animationLimit             = this.ColorIndex;
            animationLimitDefaultValue = this.ColorIndex_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("colorIndex", this.ColorIndex);
            }
            if (this.Colors != this.Colors_DefaultValue)
            {
                hashtables.Add("colors", this.Colors);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                PlotOptionsPieCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            if (this.DataLabels.IsDirty())
            {
                hashtables.Add("dataLabels", this.DataLabels.ToHashtable());
            }
            animationLimitDefaultValue = this.Depth;
            animationLimit             = this.Depth_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("depth", this.Depth);
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtables.Add("description", this.Description);
            }
            allowPointSelectDefaultValue = this.EnableMouseTracking;
            allowPointSelect             = this.EnableMouseTracking_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("enableMouseTracking", this.EnableMouseTracking);
            }
            animationLimit             = this.EndAngle;
            animationLimitDefaultValue = this.EndAngle_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("endAngle", this.EndAngle);
            }
            if (this.Events.IsDirty())
            {
                hashtables.Add("events", this.Events.ToHashtable());
            }
            allowPointSelect             = this.GetExtremesFromAll;
            allowPointSelectDefaultValue = this.GetExtremesFromAll_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("getExtremesFromAll", this.GetExtremesFromAll);
            }
            allowPointSelectDefaultValue = this.IgnoreHiddenPoint;
            allowPointSelect             = this.IgnoreHiddenPoint_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("ignoreHiddenPoint", this.IgnoreHiddenPoint);
            }
            if (this.InnerSize != this.InnerSize_DefaultValue)
            {
                hashtables.Add("innerSize", this.InnerSize);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtables.Add("linkedTo", this.LinkedTo);
            }
            animationLimitDefaultValue = this.MinSize;
            animationLimit             = this.MinSize_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("minSize", this.MinSize);
            }
            if (this.Point.IsDirty())
            {
                hashtables.Add("point", this.Point.ToHashtable());
            }
            allowPointSelect             = this.Selected;
            allowPointSelectDefaultValue = this.Selected_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("selected", this.Selected);
            }
            if (this.Shadow != this.Shadow_DefaultValue)
            {
                hashtables.Add("shadow", this.Shadow);
            }
            allowPointSelectDefaultValue = this.ShowInLegend;
            allowPointSelect             = this.ShowInLegend_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("showInLegend", this.ShowInLegend);
            }
            if (this.Size != this.Size_DefaultValue)
            {
                hashtables.Add("size", this.Size);
            }
            animationLimit             = this.SlicedOffset;
            animationLimitDefaultValue = this.SlicedOffset_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("slicedOffset", this.SlicedOffset);
            }
            animationLimitDefaultValue = this.StartAngle;
            animationLimit             = this.StartAngle_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("startAngle", this.StartAngle);
            }
            if (this.States.IsDirty())
            {
                hashtables.Add("states", this.States.ToHashtable());
            }
            allowPointSelect             = this.StickyTracking;
            allowPointSelectDefaultValue = this.StickyTracking_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("stickyTracking", this.StickyTracking);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtables.Add("tooltip", this.Tooltip.ToHashtable());
            }
            allowPointSelectDefaultValue = this.Visible;
            allowPointSelect             = this.Visible_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("visible", this.Visible);
            }
            if (this.ZoneAxis != this.ZoneAxis_DefaultValue)
            {
                hashtables.Add("zoneAxis", this.ZoneAxis);
            }
            if (this.Zones.IsDirty())
            {
                hashtables.Add("zones", this.Zones.ToHashtable());
            }
            return(hashtables);
        }
Exemple #26
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables                   = new Hashtable();
            bool?     allowPointSelect             = this.AllowPointSelect;
            bool?     allowPointSelectDefaultValue = this.AllowPointSelect_DefaultValue;

            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("allowPointSelect", this.AllowPointSelect);
            }
            if (this.Animation.IsDirty())
            {
                hashtables.Add("animation", this.Animation.ToJSON());
            }
            double?animationLimit             = this.AnimationLimit;
            double?animationLimitDefaultValue = this.AnimationLimit_DefaultValue;

            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("animationLimit", this.AnimationLimit);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtables.Add("borderColor", this.BorderColor);
            }
            animationLimitDefaultValue = this.BorderRadius;
            animationLimit             = this.BorderRadius_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("borderRadius", this.BorderRadius);
            }
            animationLimit             = this.BorderWidth;
            animationLimitDefaultValue = this.BorderWidth_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("borderWidth", this.BorderWidth);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtables.Add("color", this.Color);
            }
            allowPointSelectDefaultValue = this.ColorByPoint;
            allowPointSelect             = this.ColorByPoint_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("colorByPoint", this.ColorByPoint);
            }
            animationLimitDefaultValue = this.ColorIndex;
            animationLimit             = this.ColorIndex_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("colorIndex", this.ColorIndex);
            }
            if (this.Colors != this.Colors_DefaultValue)
            {
                hashtables.Add("colors", this.Colors);
            }
            animationLimit             = this.CropThreshold;
            animationLimitDefaultValue = this.CropThreshold_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("cropThreshold", this.CropThreshold);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                PlotOptionsColumnrangeCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            if (this.DataLabels.IsDirty())
            {
                hashtables.Add("dataLabels", this.DataLabels.ToHashtable());
            }
            animationLimitDefaultValue = this.Depth;
            animationLimit             = this.Depth_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("depth", this.Depth);
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtables.Add("description", this.Description);
            }
            if (this.EdgeColor != this.EdgeColor_DefaultValue)
            {
                hashtables.Add("edgeColor", this.EdgeColor);
            }
            animationLimit             = this.EdgeWidth;
            animationLimitDefaultValue = this.EdgeWidth_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("edgeWidth", this.EdgeWidth);
            }
            allowPointSelect             = this.EnableMouseTracking;
            allowPointSelectDefaultValue = this.EnableMouseTracking_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("enableMouseTracking", this.EnableMouseTracking);
            }
            if (this.Events.IsDirty())
            {
                hashtables.Add("events", this.Events.ToHashtable());
            }
            allowPointSelectDefaultValue = this.GetExtremesFromAll;
            allowPointSelect             = this.GetExtremesFromAll_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("getExtremesFromAll", this.GetExtremesFromAll);
            }
            animationLimitDefaultValue = this.GroupPadding;
            animationLimit             = this.GroupPadding_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("groupPadding", this.GroupPadding);
            }
            animationLimit             = this.GroupZPadding;
            animationLimitDefaultValue = this.GroupZPadding_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("groupZPadding", this.GroupZPadding);
            }
            allowPointSelect             = this.Grouping;
            allowPointSelectDefaultValue = this.Grouping_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("grouping", this.Grouping);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtables.Add("linkedTo", this.LinkedTo);
            }
            animationLimitDefaultValue = this.MaxPointWidth;
            animationLimit             = this.MaxPointWidth_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("maxPointWidth", this.MaxPointWidth);
            }
            animationLimit             = this.MinPointLength;
            animationLimitDefaultValue = this.MinPointLength_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("minPointLength", this.MinPointLength);
            }
            if (this.Point.IsDirty())
            {
                hashtables.Add("point", this.Point.ToHashtable());
            }
            animationLimitDefaultValue = this.PointInterval;
            animationLimit             = this.PointInterval_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("pointInterval", this.PointInterval);
            }
            if (this.PointIntervalUnit != this.PointIntervalUnit_DefaultValue)
            {
                PlotOptionsColumnrangePointIntervalUnit pointIntervalUnit = this.PointIntervalUnit;
                hashtables.Add("pointIntervalUnit", Highcharts.FirstCharacterToLower(pointIntervalUnit.ToString()));
            }
            animationLimit             = this.PointPadding;
            animationLimitDefaultValue = this.PointPadding_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("pointPadding", this.PointPadding);
            }
            if (this.PointPlacement.IsDirty())
            {
                hashtables.Add("pointPlacement", this.PointPlacement.ToJSON());
            }
            animationLimitDefaultValue = this.PointRange;
            animationLimit             = this.PointRange_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("pointRange", this.PointRange);
            }
            animationLimit             = this.PointStart;
            animationLimitDefaultValue = this.PointStart_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("pointStart", this.PointStart);
            }
            animationLimitDefaultValue = this.PointWidth;
            animationLimit             = this.PointWidth_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("pointWidth", this.PointWidth);
            }
            allowPointSelectDefaultValue = this.Selected;
            allowPointSelect             = this.Selected_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("selected", this.Selected);
            }
            if (this.Shadow != this.Shadow_DefaultValue)
            {
                hashtables.Add("shadow", this.Shadow);
            }
            allowPointSelect             = this.ShowCheckbox;
            allowPointSelectDefaultValue = this.ShowCheckbox_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("showCheckbox", this.ShowCheckbox);
            }
            allowPointSelectDefaultValue = this.ShowInLegend;
            allowPointSelect             = this.ShowInLegend_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("showInLegend", this.ShowInLegend);
            }
            if (this.States.IsDirty())
            {
                hashtables.Add("states", this.States.ToHashtable());
            }
            allowPointSelect             = this.StickyTracking;
            allowPointSelectDefaultValue = this.StickyTracking_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("stickyTracking", this.StickyTracking);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtables.Add("tooltip", this.Tooltip.ToHashtable());
            }
            animationLimit             = this.TurboThreshold;
            animationLimitDefaultValue = this.TurboThreshold_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("turboThreshold", this.TurboThreshold);
            }
            allowPointSelectDefaultValue = this.Visible;
            allowPointSelect             = this.Visible_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("visible", this.Visible);
            }
            if (this.ZoneAxis != this.ZoneAxis_DefaultValue)
            {
                hashtables.Add("zoneAxis", this.ZoneAxis);
            }
            if (this.Zones.IsDirty())
            {
                hashtables.Add("zones", this.Zones.ToHashtable());
            }
            return(hashtables);
        }
Exemple #27
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);
            }
            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)Highcharts.FirstCharacterToLower(this.Cursor.ToString()));
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                hashtable.Add((object)"dashStyle",
                              (object)Highcharts.FirstCharacterToLower(this.DashStyle.ToString()));
            }
            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);
            }
            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);
            }
            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)Highcharts.FirstCharacterToLower(this.Linecap.ToString()));
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtable.Add((object)"linkedTo", (object)this.LinkedTo);
            }
            if (this.NegativeColor != this.NegativeColor_DefaultValue)
            {
                hashtable.Add((object)"negativeColor", (object)this.NegativeColor);
            }
            if (this.NegativeFillColor != this.NegativeFillColor_DefaultValue)
            {
                hashtable.Add((object)"negativeFillColor", (object)this.NegativeFillColor);
            }
            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)Highcharts.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.PointStart;
            nullable4 = this.PointStart_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.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);
            }
            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);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtable.Add((object)"tooltip", (object)this.Tooltip.ToHashtable());
            }
            nullable1 = this.TrackByArea;
            nullable2 = this.TrackByArea_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"trackByArea", (object)this.TrackByArea);
            }
            nullable4 = this.TurboThreshold;
            nullable3 = this.TurboThreshold_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"turboThreshold", (object)this.TurboThreshold);
            }
            nullable2 = this.Visible;
            nullable1 = this.Visible_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.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);
        }
Exemple #28
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.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            nullable4 = this.BorderRadius;
            nullable3 = this.BorderRadius_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"borderRadius", (object)this.BorderRadius);
            }
            nullable3 = this.BorderWidth;
            nullable4 = this.BorderWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.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.ColorByPoint;
            nullable1 = this.ColorByPoint_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"colorByPoint", (object)this.ColorByPoint);
            }
            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);
            }
            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)Highcharts.FirstCharacterToLower(this.Cursor.ToString()));
            }
            if (this.Data.Any <BarSeriesData>())
            {
                hashtable.Add((object)"data", (object)this.HashifyList((IEnumerable)this.Data));
            }
            if (this.DataLabels.IsDirty())
            {
                hashtable.Add((object)"dataLabels", (object)this.DataLabels.ToHashtable());
            }
            nullable4 = this.Depth;
            nullable3 = this.Depth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"depth", (object)this.Depth);
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtable.Add((object)"description", (object)this.Description);
            }
            if (this.EdgeColor != this.EdgeColor_DefaultValue)
            {
                hashtable.Add((object)"edgeColor", (object)this.EdgeColor);
            }
            nullable3 = this.EdgeWidth;
            nullable4 = this.EdgeWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"edgeWidth", (object)this.EdgeWidth);
            }
            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());
            }
            nullable2 = this.GetExtremesFromAll;
            nullable1 = this.GetExtremesFromAll_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.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);
            }
            nullable3 = this.GroupZPadding;
            nullable4 = this.GroupZPadding_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"groupZPadding", (object)this.GroupZPadding);
            }
            nullable1 = this.Grouping;
            nullable2 = this.Grouping_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"grouping", (object)this.Grouping);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtable.Add((object)"id", (object)this.Id);
            }
            nullable4 = this.Index;
            nullable3 = this.Index_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"index", (object)this.Index);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtable.Add((object)"keys", (object)this.Keys);
            }
            nullable3 = this.LegendIndex;
            nullable4 = this.LegendIndex_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"legendIndex", (object)this.LegendIndex);
            }
            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.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)Highcharts.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);
            }
            nullable2 = this.Selected;
            nullable1 = this.Selected_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"selected", (object)this.Selected);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            nullable1 = this.ShowCheckbox;
            nullable2 = this.ShowCheckbox_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"showCheckbox", (object)this.ShowCheckbox);
            }
            nullable2 = this.ShowInLegend;
            nullable1 = this.ShowInLegend_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showInLegend", (object)this.ShowInLegend);
            }
            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.Stacking != this.Stacking_DefaultValue)
            {
                hashtable.Add((object)"stacking", (object)Highcharts.FirstCharacterToLower(this.Stacking.ToString()));
            }
            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)Highcharts.FirstCharacterToLower(this.Type.ToString()));
            }
            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);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.AllowDrillToNode != this.AllowDrillToNode_DefaultValue)
            {
                hashtable.Add((object)"allowDrillToNode",
                              (object)Highcharts.FirstCharacterToLower(this.AllowDrillToNode.ToString()));
            }
            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);
            }
            nullable2 = this.AlternateStartingDirection;
            nullable1 = this.AlternateStartingDirection_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"alternateStartingDirection", (object)this.AlternateStartingDirection);
            }
            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.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            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);
            }
            nullable1 = this.ColorByPoint;
            nullable2 = this.ColorByPoint_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"colorByPoint", (object)this.ColorByPoint);
            }
            nullable3 = this.ColorIndex;
            nullable4 = this.ColorIndex_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"colorIndex", (object)this.ColorIndex);
            }
            if (this.Colors != this.Colors_DefaultValue)
            {
                hashtable.Add((object)"colors", (object)this.Colors);
            }
            nullable4 = this.CropThreshold;
            nullable3 = this.CropThreshold_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"cropThreshold", (object)this.CropThreshold);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                hashtable.Add((object)"cursor", (object)Highcharts.FirstCharacterToLower(this.Cursor.ToString()));
            }
            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);
            }
            nullable2 = this.IgnoreHiddenPoint;
            nullable1 = this.IgnoreHiddenPoint_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"ignoreHiddenPoint", (object)this.IgnoreHiddenPoint);
            }
            nullable1 = this.InteractByLeaf;
            nullable2 = this.InteractByLeaf_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"interactByLeaf", (object)this.InteractByLeaf);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtable.Add((object)"keys", (object)this.Keys);
            }
            if (this.LayoutAlgorithm != this.LayoutAlgorithm_DefaultValue)
            {
                hashtable.Add((object)"layoutAlgorithm",
                              (object)Highcharts.FirstCharacterToLower(this.LayoutAlgorithm.ToString()));
            }
            if (this.LayoutStartingDirection != this.LayoutStartingDirection_DefaultValue)
            {
                hashtable.Add((object)"layoutStartingDirection",
                              (object)Highcharts.FirstCharacterToLower(this.LayoutStartingDirection.ToString()));
            }
            if (this.LevelIsConstant != this.LevelIsConstant_DefaultValue)
            {
                hashtable.Add((object)"levelIsConstant",
                              (object)Highcharts.FirstCharacterToLower(this.LevelIsConstant.ToString()));
            }
            if (this.Levels.IsDirty())
            {
                hashtable.Add((object)"levels", (object)this.Levels.ToHashtable());
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtable.Add((object)"linkedTo", (object)this.LinkedTo);
            }
            nullable3 = this.MaxPointWidth;
            nullable4 = this.MaxPointWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"maxPointWidth", (object)this.MaxPointWidth);
            }
            nullable4 = this.Opacity;
            nullable3 = this.Opacity_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"opacity", (object)this.Opacity);
            }
            if (this.Point.IsDirty())
            {
                hashtable.Add((object)"point", (object)this.Point.ToHashtable());
            }
            nullable2 = this.Selected;
            nullable1 = this.Selected_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"selected", (object)this.Selected);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            nullable1 = this.ShowCheckbox;
            nullable2 = this.ShowCheckbox_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"showCheckbox", (object)this.ShowCheckbox);
            }
            nullable2 = this.ShowInLegend;
            nullable1 = this.ShowInLegend_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showInLegend", (object)this.ShowInLegend);
            }
            nullable3 = this.SortIndex;
            nullable4 = this.SortIndex_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"sortIndex", (object)this.SortIndex);
            }
            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());
            }
            nullable4 = this.TurboThreshold;
            nullable3 = this.TurboThreshold_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"turboThreshold", (object)this.TurboThreshold);
            }
            nullable2 = this.Visible;
            nullable1 = this.Visible_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.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);
        }
Exemple #30
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                hashtable.Add((object)"align", (object)Highcharts.FirstCharacterToLower(this.Align.ToString()));
            }
            if (this.AutoRotation != this.AutoRotation_DefaultValue)
            {
                hashtable.Add((object)"autoRotation", (object)this.AutoRotation);
            }
            double?nullable1 = this.AutoRotationLimit;
            double?nullable2 = this.AutoRotationLimit_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"autoRotationLimit", (object)this.AutoRotationLimit);
            }
            nullable2 = this.Distance;
            nullable1 = this.Distance_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"distance", (object)this.Distance);
            }
            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);
            }
            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);
                Highcharts.AddFunction("XAxisLabelsFormatter.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);
            }
            nullable4 = this.ReserveSpace;
            nullable3 = this.ReserveSpace_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"reserveSpace", (object)this.ReserveSpace);
            }
            nullable2 = this.Rotation;
            nullable1 = this.Rotation_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"rotation", (object)this.Rotation);
            }
            nullable1 = this.StaggerLines;
            nullable2 = this.StaggerLines_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"staggerLines", (object)this.StaggerLines);
            }
            nullable2 = this.Step;
            nullable1 = this.Step_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"step", (object)this.Step);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            nullable3 = this.UseHTML;
            nullable4 = this.UseHTML_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            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);
            }
            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);
        }