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

            if (this.Click != this.Click_DefaultValue)
            {
                hashtables.Add("click", this.Click);
                Highcharts.AddFunction("AreaSeriesDataEventsClick.click", this.Click);
            }
            if (this.MouseOut != this.MouseOut_DefaultValue)
            {
                hashtables.Add("mouseOut", this.MouseOut);
                Highcharts.AddFunction("AreaSeriesDataEventsMouseOut.mouseOut", this.MouseOut);
            }
            if (this.MouseOver != this.MouseOver_DefaultValue)
            {
                hashtables.Add("mouseOver", this.MouseOver);
                Highcharts.AddFunction("AreaSeriesDataEventsMouseOver.mouseOver", this.MouseOver);
            }
            if (this.Remove != this.Remove_DefaultValue)
            {
                hashtables.Add("remove", this.Remove);
                Highcharts.AddFunction("AreaSeriesDataEventsRemove.remove", this.Remove);
            }
            if (this.Select != this.Select_DefaultValue)
            {
                hashtables.Add("select", this.Select);
                Highcharts.AddFunction("AreaSeriesDataEventsSelect.select", this.Select);
            }
            if (this.Unselect != this.Unselect_DefaultValue)
            {
                hashtables.Add("unselect", this.Unselect);
                Highcharts.AddFunction("AreaSeriesDataEventsUnselect.unselect", this.Unselect);
            }
            if (this.Update != this.Update_DefaultValue)
            {
                hashtables.Add("update", this.Update);
                Highcharts.AddFunction("AreaSeriesDataEventsUpdate.update", this.Update);
            }
            return(hashtables);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

            if (this.Click != this.Click_DefaultValue)
            {
                hashtable.Add((object)"click", (object)this.Click);
                Highcharts.AddFunction("PlotOptionsBoxplotPointEventsClick.click", this.Click);
            }
            if (this.MouseOut != this.MouseOut_DefaultValue)
            {
                hashtable.Add((object)"mouseOut", (object)this.MouseOut);
                Highcharts.AddFunction("PlotOptionsBoxplotPointEventsMouseOut.mouseOut", this.MouseOut);
            }
            if (this.MouseOver != this.MouseOver_DefaultValue)
            {
                hashtable.Add((object)"mouseOver", (object)this.MouseOver);
                Highcharts.AddFunction("PlotOptionsBoxplotPointEventsMouseOver.mouseOver", this.MouseOver);
            }
            if (this.Remove != this.Remove_DefaultValue)
            {
                hashtable.Add((object)"remove", (object)this.Remove);
                Highcharts.AddFunction("PlotOptionsBoxplotPointEventsRemove.remove", this.Remove);
            }
            if (this.Select != this.Select_DefaultValue)
            {
                hashtable.Add((object)"select", (object)this.Select);
                Highcharts.AddFunction("PlotOptionsBoxplotPointEventsSelect.select", this.Select);
            }
            if (this.Unselect != this.Unselect_DefaultValue)
            {
                hashtable.Add((object)"unselect", (object)this.Unselect);
                Highcharts.AddFunction("PlotOptionsBoxplotPointEventsUnselect.unselect", this.Unselect);
            }
            if (this.Update != this.Update_DefaultValue)
            {
                hashtable.Add((object)"update", (object)this.Update);
                Highcharts.AddFunction("PlotOptionsBoxplotPointEventsUpdate.update", this.Update);
            }
            return(hashtable);
        }
Exemple #3
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (Click != Click_DefaultValue)
            {
                hashtables.Add("click", Click);
                Highcharts.AddFunction("SplineSeriesDataEventsClick.click", Click);
            }
            if (MouseOut != MouseOut_DefaultValue)
            {
                hashtables.Add("mouseOut", MouseOut);
                Highcharts.AddFunction("SplineSeriesDataEventsMouseOut.mouseOut", MouseOut);
            }
            if (MouseOver != MouseOver_DefaultValue)
            {
                hashtables.Add("mouseOver", MouseOver);
                Highcharts.AddFunction("SplineSeriesDataEventsMouseOver.mouseOver", MouseOver);
            }
            if (Remove != Remove_DefaultValue)
            {
                hashtables.Add("remove", Remove);
                Highcharts.AddFunction("SplineSeriesDataEventsRemove.remove", Remove);
            }
            if (Select != Select_DefaultValue)
            {
                hashtables.Add("select", Select);
                Highcharts.AddFunction("SplineSeriesDataEventsSelect.select", Select);
            }
            if (Unselect != Unselect_DefaultValue)
            {
                hashtables.Add("unselect", Unselect);
                Highcharts.AddFunction("SplineSeriesDataEventsUnselect.unselect", Unselect);
            }
            if (Update != Update_DefaultValue)
            {
                hashtables.Add("update", Update);
                Highcharts.AddFunction("SplineSeriesDataEventsUpdate.update", Update);
            }
            return(hashtables);
        }
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

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

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"maxHeight", (object)this.MaxHeight);
            }
            nullable2 = this.MaxWidth;
            nullable1 = this.MaxWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"maxWidth", (object)this.MaxWidth);
            }
            nullable1 = this.MinHeight;
            nullable2 = this.MinHeight_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"minHeight", (object)this.MinHeight);
            }
            nullable2 = this.MinWidth;
            nullable1 = this.MinWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"minWidth", (object)this.MinWidth);
            }
            return(hashtable);
        }
Exemple #5
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 #7
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 #8
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Callback != this.Callback_DefaultValue)
            {
                hashtables.Add("callback", this.Callback);
                Highcharts.AddFunction("ResponsiveRulesConditionCallback.callback", this.Callback);
            }
            double?maxHeight             = this.MaxHeight;
            double?maxHeightDefaultValue = this.MaxHeight_DefaultValue;

            if ((maxHeight.GetValueOrDefault() == maxHeightDefaultValue.GetValueOrDefault() ? maxHeight.HasValue != maxHeightDefaultValue.HasValue : true))
            {
                hashtables.Add("maxHeight", this.MaxHeight);
            }
            maxHeightDefaultValue = this.MaxWidth;
            maxHeight             = this.MaxWidth_DefaultValue;
            if ((maxHeightDefaultValue.GetValueOrDefault() == maxHeight.GetValueOrDefault() ? maxHeightDefaultValue.HasValue != maxHeight.HasValue : true))
            {
                hashtables.Add("maxWidth", this.MaxWidth);
            }
            maxHeight             = this.MinHeight;
            maxHeightDefaultValue = this.MinHeight_DefaultValue;
            if ((maxHeight.GetValueOrDefault() == maxHeightDefaultValue.GetValueOrDefault() ? maxHeight.HasValue != maxHeightDefaultValue.HasValue : true))
            {
                hashtables.Add("minHeight", this.MinHeight);
            }
            maxHeightDefaultValue = this.MinWidth;
            maxHeight             = this.MinWidth_DefaultValue;
            if ((maxHeightDefaultValue.GetValueOrDefault() == maxHeight.GetValueOrDefault() ? maxHeightDefaultValue.HasValue != maxHeight.HasValue : true))
            {
                hashtables.Add("minWidth", this.MinWidth);
            }
            return(hashtables);
        }
Exemple #9
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Columns != this.Columns_DefaultValue)
            {
                hashtables.Add("columns", this.Columns);
            }
            if (this.Complete != this.Complete_DefaultValue)
            {
                hashtables.Add("complete", this.Complete);
                Highcharts.AddFunction("DataComplete.complete", this.Complete);
            }
            if (this.Csv != this.Csv_DefaultValue)
            {
                hashtables.Add("csv", this.Csv);
            }
            if (this.DateFormat != this.DateFormat_DefaultValue)
            {
                hashtables.Add("dateFormat", this.DateFormat);
            }
            if (this.DecimalPoint != this.DecimalPoint_DefaultValue)
            {
                hashtables.Add("decimalPoint", this.DecimalPoint);
            }
            double?endColumn             = this.EndColumn;
            double?endColumnDefaultValue = this.EndColumn_DefaultValue;

            if ((endColumn.GetValueOrDefault() == endColumnDefaultValue.GetValueOrDefault() ? endColumn.HasValue != endColumnDefaultValue.HasValue : true))
            {
                hashtables.Add("endColumn", this.EndColumn);
            }
            endColumnDefaultValue = this.EndRow;
            endColumn             = this.EndRow_DefaultValue;
            if ((endColumnDefaultValue.GetValueOrDefault() == endColumn.GetValueOrDefault() ? endColumnDefaultValue.HasValue != endColumn.HasValue : true))
            {
                hashtables.Add("endRow", this.EndRow);
            }
            bool?firstRowAsNames             = this.FirstRowAsNames;
            bool?firstRowAsNamesDefaultValue = this.FirstRowAsNames_DefaultValue;

            if ((firstRowAsNames.GetValueOrDefault() == firstRowAsNamesDefaultValue.GetValueOrDefault() ? firstRowAsNames.HasValue != firstRowAsNamesDefaultValue.HasValue : true))
            {
                hashtables.Add("firstRowAsNames", this.FirstRowAsNames);
            }
            if (this.GoogleSpreadsheetKey != this.GoogleSpreadsheetKey_DefaultValue)
            {
                hashtables.Add("googleSpreadsheetKey", this.GoogleSpreadsheetKey);
            }
            if (this.GoogleSpreadsheetWorksheet != this.GoogleSpreadsheetWorksheet_DefaultValue)
            {
                hashtables.Add("googleSpreadsheetWorksheet", this.GoogleSpreadsheetWorksheet);
            }
            if (this.ItemDelimiter != this.ItemDelimiter_DefaultValue)
            {
                hashtables.Add("itemDelimiter", this.ItemDelimiter);
            }
            if (this.LineDelimiter != this.LineDelimiter_DefaultValue)
            {
                hashtables.Add("lineDelimiter", this.LineDelimiter);
            }
            if (this.ParseDate != this.ParseDate_DefaultValue)
            {
                hashtables.Add("parseDate", this.ParseDate);
                Highcharts.AddFunction("DataParseDate.parseDate", this.ParseDate);
            }
            if (this.Parsed != this.Parsed_DefaultValue)
            {
                hashtables.Add("parsed", this.Parsed);
                Highcharts.AddFunction("DataParsed.parsed", this.Parsed);
            }
            if (this.Rows != this.Rows_DefaultValue)
            {
                hashtables.Add("rows", this.Rows);
            }
            if (this.SeriesMapping != this.SeriesMapping_DefaultValue)
            {
                hashtables.Add("seriesMapping", this.SeriesMapping);
            }
            endColumn             = this.StartColumn;
            endColumnDefaultValue = this.StartColumn_DefaultValue;
            if ((endColumn.GetValueOrDefault() == endColumnDefaultValue.GetValueOrDefault() ? endColumn.HasValue != endColumnDefaultValue.HasValue : true))
            {
                hashtables.Add("startColumn", this.StartColumn);
            }
            endColumnDefaultValue = this.StartRow;
            endColumn             = this.StartRow_DefaultValue;
            if ((endColumnDefaultValue.GetValueOrDefault() == endColumn.GetValueOrDefault() ? endColumnDefaultValue.HasValue != endColumn.HasValue : true))
            {
                hashtables.Add("startRow", this.StartRow);
            }
            firstRowAsNamesDefaultValue = this.SwitchRowsAndColumns;
            firstRowAsNames             = this.SwitchRowsAndColumns_DefaultValue;
            if ((firstRowAsNamesDefaultValue.GetValueOrDefault() == firstRowAsNames.GetValueOrDefault() ? firstRowAsNamesDefaultValue.HasValue != firstRowAsNames.HasValue : true))
            {
                hashtables.Add("switchRowsAndColumns", this.SwitchRowsAndColumns);
            }
            if (this.Table != this.Table_DefaultValue)
            {
                hashtables.Add("table", this.Table);
            }
            return(hashtables);
        }
Exemple #10
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 #11
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 #12
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);
        }
Exemple #13
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 #14
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 #15
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables                       = new Hashtable();
            bool?     describeSingleSeries             = DescribeSingleSeries;
            bool?     describeSingleSeriesDefaultValue = DescribeSingleSeries_DefaultValue;

            if ((describeSingleSeries.GetValueOrDefault() == describeSingleSeriesDefaultValue.GetValueOrDefault()
                                ? describeSingleSeries.HasValue != describeSingleSeriesDefaultValue.HasValue
                                : true))
            {
                hashtables.Add("describeSingleSeries", DescribeSingleSeries);
            }
            describeSingleSeriesDefaultValue = Enabled;
            describeSingleSeries             = Enabled_DefaultValue;
            if ((describeSingleSeriesDefaultValue.GetValueOrDefault() == describeSingleSeries.GetValueOrDefault()
                                ? describeSingleSeriesDefaultValue.HasValue != describeSingleSeries.HasValue
                                : true))
            {
                hashtables.Add("enabled", Enabled);
            }
            if (KeyboardNavigation.IsDirty())
            {
                hashtables.Add("keyboardNavigation", KeyboardNavigation.ToHashtable());
            }
            if (OnTableAnchorClick != OnTableAnchorClick_DefaultValue)
            {
                hashtables.Add("onTableAnchorClick", OnTableAnchorClick);
                Highcharts.AddFunction("AccessibilityOnTableAnchorClick.onTableAnchorClick", OnTableAnchorClick);
            }
            if (PointDateFormat != PointDateFormat_DefaultValue)
            {
                hashtables.Add("pointDateFormat", PointDateFormat);
            }
            if (PointDateFormatter != PointDateFormatter_DefaultValue)
            {
                hashtables.Add("pointDateFormatter", PointDateFormatter);
                Highcharts.AddFunction("AccessibilityPointDateFormatter.pointDateFormatter", PointDateFormatter);
            }
            if (PointDescriptionFormatter != PointDescriptionFormatter_DefaultValue)
            {
                hashtables.Add("pointDescriptionFormatter", PointDescriptionFormatter);
                Highcharts.AddFunction("AccessibilityPointDescriptionFormatter.pointDescriptionFormatter", PointDescriptionFormatter);
            }
            long?pointDescriptionThreshold             = PointDescriptionThreshold;
            long?pointDescriptionThresholdDefaultValue = PointDescriptionThreshold_DefaultValue;

            if ((pointDescriptionThreshold.GetValueOrDefault() == pointDescriptionThresholdDefaultValue.GetValueOrDefault()
                                ? pointDescriptionThreshold.HasValue != pointDescriptionThresholdDefaultValue.HasValue
                                : true))
            {
                pointDescriptionThresholdDefaultValue = PointDescriptionThreshold;
                if (!pointDescriptionThresholdDefaultValue.HasValue)
                {
                    hashtables.Add("pointDescriptionThreshold", false);
                }
                else
                {
                    hashtables.Add("pointDescriptionThreshold", PointDescriptionThreshold);
                }
            }
            if (ScreenReaderSectionFormatter != ScreenReaderSectionFormatter_DefaultValue)
            {
                hashtables.Add("screenReaderSectionFormatter", ScreenReaderSectionFormatter);
                Highcharts.AddFunction("AccessibilityScreenReaderSectionFormatter.screenReaderSectionFormatter",
                                       ScreenReaderSectionFormatter);
            }
            if (SeriesDescriptionFormatter != SeriesDescriptionFormatter_DefaultValue)
            {
                hashtables.Add("seriesDescriptionFormatter", SeriesDescriptionFormatter);
                Highcharts.AddFunction("AccessibilitySeriesDescriptionFormatter.seriesDescriptionFormatter",
                                       SeriesDescriptionFormatter);
            }
            return(hashtables);
        }
        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);
            }
            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);
            }
            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);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                PlotOptionsErrorbarCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            animationLimit             = this.Depth;
            animationLimitDefaultValue = this.Depth_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.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);
            }
            animationLimitDefaultValue = this.EdgeWidth;
            animationLimit             = this.EdgeWidth_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.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);
            }
            animationLimit             = this.GroupZPadding;
            animationLimitDefaultValue = this.GroupZPadding_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("groupZPadding", this.GroupZPadding);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            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);
            }
            animationLimit             = this.MaxPointWidth;
            animationLimitDefaultValue = this.MaxPointWidth_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("maxPointWidth", this.MaxPointWidth);
            }
            if (this.NegativeColor != this.NegativeColor_DefaultValue)
            {
                hashtables.Add("negativeColor", this.NegativeColor);
            }
            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)
            {
                PlotOptionsErrorbarPointIntervalUnit 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);
            }
            allowPointSelect             = this.Selected;
            allowPointSelectDefaultValue = this.Selected_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("selected", this.Selected);
            }
            if (this.States.IsDirty())
            {
                hashtables.Add("states", this.States.ToHashtable());
            }
            if (this.StemColor != this.StemColor_DefaultValue)
            {
                hashtables.Add("stemColor", this.StemColor);
            }
            if (this.StemDashStyle != this.StemDashStyle_DefaultValue)
            {
                PlotOptionsErrorbarStemDashStyle stemDashStyle = this.StemDashStyle;
                hashtables.Add("stemDashStyle", Highcharts.FirstCharacterToLower(stemDashStyle.ToString()));
            }
            animationLimit             = this.StemWidth;
            animationLimitDefaultValue = this.StemWidth_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("stemWidth", this.StemWidth);
            }
            allowPointSelectDefaultValue = this.StickyTracking;
            allowPointSelect             = this.StickyTracking_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("stickyTracking", this.StickyTracking);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtables.Add("tooltip", this.Tooltip.ToHashtable());
            }
            animationLimitDefaultValue = this.TurboThreshold;
            animationLimit             = this.TurboThreshold_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("turboThreshold", this.TurboThreshold);
            }
            allowPointSelect             = this.Visible;
            allowPointSelectDefaultValue = this.Visible_DefaultValue;
            if ((allowPointSelect.GetValueOrDefault() == allowPointSelectDefaultValue.GetValueOrDefault() ? allowPointSelect.HasValue != allowPointSelectDefaultValue.HasValue : true))
            {
                hashtables.Add("visible", this.Visible);
            }
            if (this.WhiskerColor != this.WhiskerColor_DefaultValue)
            {
                hashtables.Add("whiskerColor", this.WhiskerColor);
            }
            if (this.WhiskerLength != this.WhiskerLength_DefaultValue)
            {
                hashtables.Add("whiskerLength", this.WhiskerLength);
            }
            animationLimit             = this.WhiskerWidth;
            animationLimitDefaultValue = this.WhiskerWidth_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("whiskerWidth", this.WhiskerWidth);
            }
            if (this.ZoneAxis != this.ZoneAxis_DefaultValue)
            {
                hashtables.Add("zoneAxis", this.ZoneAxis);
            }
            if (this.Zones.IsDirty())
            {
                hashtables.Add("zones", this.Zones.ToHashtable());
            }
            return(hashtables);
        }
        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 #18
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)
            {
                PlotOptionsPolygonCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            if (this.DashStyle != this.DashStyle_DefaultValue)
            {
                PlotOptionsPolygonDashStyle dashStyle = this.DashStyle;
                hashtables.Add("dashStyle", Highcharts.FirstCharacterToLower(dashStyle.ToString()));
            }
            if (this.DataLabels.IsDirty())
            {
                hashtables.Add("dataLabels", this.DataLabels.ToHashtable());
            }
            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);
            }
            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);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            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.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)
            {
                PlotOptionsPolygonPointIntervalUnit 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);
            }
            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);
            }
            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 #19
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

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

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"followPointer", (object)this.FollowPointer);
            }
            nullable2 = this.FollowTouchMove;
            nullable1 = this.FollowTouchMove_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"followTouchMove", (object)this.FollowTouchMove);
            }
            if (this.FooterFormat != this.FooterFormat_DefaultValue)
            {
                hashtable.Add((object)"footerFormat", (object)this.FooterFormat);
            }
            if (this.HeaderFormat != this.HeaderFormat_DefaultValue)
            {
                hashtable.Add((object)"headerFormat", (object)this.HeaderFormat);
            }
            double?nullable3 = this.HideDelay;
            double?nullable4 = this.HideDelay_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"hideDelay", (object)this.HideDelay);
            }
            nullable4 = this.Padding;
            nullable3 = this.Padding_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            if (this.PointFormat != this.PointFormat_DefaultValue)
            {
                hashtable.Add((object)"pointFormat", (object)this.PointFormat);
            }
            if (this.PointFormatter != this.PointFormatter_DefaultValue)
            {
                hashtable.Add((object)"pointFormatter", (object)this.PointFormatter);
                Highcharts.AddFunction("PlotOptionsAreaTooltipPointFormatter.pointFormatter", this.PointFormatter);
            }
            nullable1 = this.Split;
            nullable2 = this.Split_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"split", (object)this.Split);
            }
            nullable3 = this.ValueDecimals;
            nullable4 = this.ValueDecimals_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"valueDecimals", (object)this.ValueDecimals);
            }
            if (this.ValuePrefix != this.ValuePrefix_DefaultValue)
            {
                hashtable.Add((object)"valuePrefix", (object)this.ValuePrefix);
            }
            if (this.ValueSuffix != this.ValueSuffix_DefaultValue)
            {
                hashtable.Add((object)"valueSuffix", (object)this.ValueSuffix);
            }
            if (this.XDateFormat != this.XDateFormat_DefaultValue)
            {
                hashtable.Add((object)"xDateFormat", (object)this.XDateFormat);
            }
            return(hashtable);
        }
Exemple #20
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            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);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                GaugeSeriesCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            if (this.Data.Any <GaugeSeriesData>())
            {
                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);
            }
            if (this.Dial.IsDirty())
            {
                hashtables.Add("dial", this.Dial.ToHashtable());
            }
            bool?enableMouseTracking             = this.EnableMouseTracking;
            bool?enableMouseTrackingDefaultValue = this.EnableMouseTracking_DefaultValue;

            if ((enableMouseTracking.GetValueOrDefault() == enableMouseTrackingDefaultValue.GetValueOrDefault() ? enableMouseTracking.HasValue != enableMouseTrackingDefaultValue.HasValue : true))
            {
                hashtables.Add("enableMouseTracking", this.EnableMouseTracking);
            }
            if (this.Events.IsDirty())
            {
                hashtables.Add("events", this.Events.ToHashtable());
            }
            enableMouseTrackingDefaultValue = this.GetExtremesFromAll;
            enableMouseTracking             = this.GetExtremesFromAll_DefaultValue;
            if ((enableMouseTrackingDefaultValue.GetValueOrDefault() == enableMouseTracking.GetValueOrDefault() ? enableMouseTrackingDefaultValue.HasValue != enableMouseTracking.HasValue : true))
            {
                hashtables.Add("getExtremesFromAll", this.GetExtremesFromAll);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtables.Add("id", this.Id);
            }
            animationLimit             = this.Index;
            animationLimitDefaultValue = this.Index_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("index", this.Index);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            animationLimitDefaultValue = this.LegendIndex;
            animationLimit             = this.LegendIndex_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("legendIndex", this.LegendIndex);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtables.Add("linkedTo", this.LinkedTo);
            }
            if (this.Name != this.Name_DefaultValue)
            {
                hashtables.Add("name", this.Name);
            }
            if (this.NegativeColor != this.NegativeColor_DefaultValue)
            {
                hashtables.Add("negativeColor", this.NegativeColor);
            }
            animationLimit             = this.Overshoot;
            animationLimitDefaultValue = this.Overshoot_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("overshoot", this.Overshoot);
            }
            if (this.Pivot.IsDirty())
            {
                hashtables.Add("pivot", this.Pivot.ToHashtable());
            }
            if (this.Point.IsDirty())
            {
                hashtables.Add("point", this.Point.ToHashtable());
            }
            enableMouseTracking             = this.Selected;
            enableMouseTrackingDefaultValue = this.Selected_DefaultValue;
            if ((enableMouseTracking.GetValueOrDefault() == enableMouseTrackingDefaultValue.GetValueOrDefault() ? enableMouseTracking.HasValue != enableMouseTrackingDefaultValue.HasValue : true))
            {
                hashtables.Add("selected", this.Selected);
            }
            enableMouseTrackingDefaultValue = this.ShowCheckbox;
            enableMouseTracking             = this.ShowCheckbox_DefaultValue;
            if ((enableMouseTrackingDefaultValue.GetValueOrDefault() == enableMouseTracking.GetValueOrDefault() ? enableMouseTrackingDefaultValue.HasValue != enableMouseTracking.HasValue : true))
            {
                hashtables.Add("showCheckbox", this.ShowCheckbox);
            }
            enableMouseTracking             = this.ShowInLegend;
            enableMouseTrackingDefaultValue = this.ShowInLegend_DefaultValue;
            if ((enableMouseTracking.GetValueOrDefault() == enableMouseTrackingDefaultValue.GetValueOrDefault() ? enableMouseTracking.HasValue != enableMouseTrackingDefaultValue.HasValue : true))
            {
                hashtables.Add("showInLegend", this.ShowInLegend);
            }
            enableMouseTrackingDefaultValue = this.StickyTracking;
            enableMouseTracking             = this.StickyTracking_DefaultValue;
            if ((enableMouseTrackingDefaultValue.GetValueOrDefault() == enableMouseTracking.GetValueOrDefault() ? enableMouseTrackingDefaultValue.HasValue != enableMouseTracking.HasValue : true))
            {
                hashtables.Add("stickyTracking", this.StickyTracking);
            }
            animationLimitDefaultValue = this.Threshold;
            animationLimit             = this.Threshold_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("threshold", this.Threshold);
            }
            if (this.Tooltip.IsDirty())
            {
                hashtables.Add("tooltip", this.Tooltip.ToHashtable());
            }
            if (this.Type != this.Type_DefaultValue)
            {
                GaugeSeriesType type = this.Type;
                hashtables.Add("type", Highcharts.FirstCharacterToLower(type.ToString()));
            }
            enableMouseTracking             = this.Visible;
            enableMouseTrackingDefaultValue = this.Visible_DefaultValue;
            if ((enableMouseTracking.GetValueOrDefault() == enableMouseTrackingDefaultValue.GetValueOrDefault() ? enableMouseTracking.HasValue != enableMouseTrackingDefaultValue.HasValue : true))
            {
                hashtables.Add("visible", this.Visible);
            }
            enableMouseTrackingDefaultValue = this.Wrap;
            enableMouseTracking             = this.Wrap_DefaultValue;
            if ((enableMouseTrackingDefaultValue.GetValueOrDefault() == enableMouseTracking.GetValueOrDefault() ? enableMouseTrackingDefaultValue.HasValue != enableMouseTracking.HasValue : true))
            {
                hashtables.Add("wrap", this.Wrap);
            }
            if (this.XAxis != this.XAxis_DefaultValue)
            {
                hashtables.Add("xAxis", this.XAxis);
            }
            if (this.YAxis != this.YAxis_DefaultValue)
            {
                hashtables.Add("yAxis", this.YAxis);
            }
            animationLimit             = this.ZIndex;
            animationLimitDefaultValue = this.ZIndex_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            return(hashtables);
        }
Exemple #21
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.Colsize;
            animationLimitDefaultValue = this.Colsize_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("colsize", this.Colsize);
            }
            animationLimitDefaultValue = this.CropThreshold;
            animationLimit             = this.CropThreshold_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("cropThreshold", this.CropThreshold);
            }
            if (this.Cursor != this.Cursor_DefaultValue)
            {
                HeatmapSeriesCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            if (this.Data.Any <HeatmapSeriesData>())
            {
                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);
            }
            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);
            }
            animationLimit             = this.Index;
            animationLimitDefaultValue = this.Index_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("index", this.Index);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            animationLimitDefaultValue = this.LegendIndex;
            animationLimit             = this.LegendIndex_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("legendIndex", this.LegendIndex);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtables.Add("linkedTo", this.LinkedTo);
            }
            animationLimit             = this.MaxPointWidth;
            animationLimitDefaultValue = this.MaxPointWidth_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("maxPointWidth", this.MaxPointWidth);
            }
            if (this.Name != this.Name_DefaultValue)
            {
                hashtables.Add("name", this.Name);
            }
            if (this.Point.IsDirty())
            {
                hashtables.Add("point", this.Point.ToHashtable());
            }
            animationLimitDefaultValue = this.Rowsize;
            animationLimit             = this.Rowsize_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("rowsize", this.Rowsize);
            }
            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.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);
            }
            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);
            }
            if (this.Type != this.Type_DefaultValue)
            {
                HeatmapSeriesType 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);
            }
            if (this.ZoneAxis != this.ZoneAxis_DefaultValue)
            {
                hashtables.Add("zoneAxis", this.ZoneAxis);
            }
            if (this.Zones.IsDirty())
            {
                hashtables.Add("zones", this.Zones.ToHashtable());
            }
            return(hashtables);
        }
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);
            }
            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)
            {
                PyramidSeriesCursor cursor = this.Cursor;
                hashtables.Add("cursor", Highcharts.FirstCharacterToLower(cursor.ToString()));
            }
            if (this.Data.Any <PyramidSeriesData>())
            {
                hashtables.Add("data", base.HashifyList(this.Data));
            }
            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);
            }
            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);
            }
            if (this.Height != this.Height_DefaultValue)
            {
                hashtables.Add("height", this.Height);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtables.Add("id", this.Id);
            }
            animationLimit             = this.Index;
            animationLimitDefaultValue = this.Index_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("index", this.Index);
            }
            if (this.Keys != this.Keys_DefaultValue)
            {
                hashtables.Add("keys", this.Keys);
            }
            animationLimitDefaultValue = this.LegendIndex;
            animationLimit             = this.LegendIndex_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("legendIndex", this.LegendIndex);
            }
            if (this.LinkedTo != this.LinkedTo_DefaultValue)
            {
                hashtables.Add("linkedTo", this.LinkedTo);
            }
            animationLimit             = this.MinSize;
            animationLimitDefaultValue = this.MinSize_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("minSize", this.MinSize);
            }
            if (this.Name != this.Name_DefaultValue)
            {
                hashtables.Add("name", this.Name);
            }
            if (this.Point.IsDirty())
            {
                hashtables.Add("point", this.Point.ToHashtable());
            }
            allowPointSelectDefaultValue = this.Reversed;
            allowPointSelect             = this.Reversed_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("reversed", this.Reversed);
            }
            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);
            }
            animationLimitDefaultValue = this.SlicedOffset;
            animationLimit             = this.SlicedOffset_DefaultValue;
            if ((animationLimitDefaultValue.GetValueOrDefault() == animationLimit.GetValueOrDefault() ? animationLimitDefaultValue.HasValue != animationLimit.HasValue : true))
            {
                hashtables.Add("slicedOffset", this.SlicedOffset);
            }
            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());
            }
            if (this.Type != this.Type_DefaultValue)
            {
                PyramidSeriesType type = this.Type;
                hashtables.Add("type", Highcharts.FirstCharacterToLower(type.ToString()));
            }
            allowPointSelectDefaultValue = this.Visible;
            allowPointSelect             = this.Visible_DefaultValue;
            if ((allowPointSelectDefaultValue.GetValueOrDefault() == allowPointSelect.GetValueOrDefault() ? allowPointSelectDefaultValue.HasValue != allowPointSelect.HasValue : true))
            {
                hashtables.Add("visible", this.Visible);
            }
            if (this.Width != this.Width_DefaultValue)
            {
                hashtables.Add("width", this.Width);
            }
            animationLimit             = this.ZIndex;
            animationLimitDefaultValue = this.ZIndex_DefaultValue;
            if ((animationLimit.GetValueOrDefault() == animationLimitDefaultValue.GetValueOrDefault() ? animationLimit.HasValue != animationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            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();
            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 #24
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);
        }
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.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 #26
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 #27
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtables.Add("dateTimeLabelFormats", this.DateTimeLabelFormats);
            }
            bool?followPointer             = this.FollowPointer;
            bool?followPointerDefaultValue = this.FollowPointer_DefaultValue;

            if ((followPointer.GetValueOrDefault() == followPointerDefaultValue.GetValueOrDefault() ? followPointer.HasValue != followPointerDefaultValue.HasValue : true))
            {
                hashtables.Add("followPointer", this.FollowPointer);
            }
            followPointerDefaultValue = this.FollowTouchMove;
            followPointer             = this.FollowTouchMove_DefaultValue;
            if ((followPointerDefaultValue.GetValueOrDefault() == followPointer.GetValueOrDefault() ? followPointerDefaultValue.HasValue != followPointer.HasValue : true))
            {
                hashtables.Add("followTouchMove", this.FollowTouchMove);
            }
            if (this.FooterFormat != this.FooterFormat_DefaultValue)
            {
                hashtables.Add("footerFormat", this.FooterFormat);
            }
            if (this.HeaderFormat != this.HeaderFormat_DefaultValue)
            {
                hashtables.Add("headerFormat", this.HeaderFormat);
            }
            double?hideDelay             = this.HideDelay;
            double?hideDelayDefaultValue = this.HideDelay_DefaultValue;

            if ((hideDelay.GetValueOrDefault() == hideDelayDefaultValue.GetValueOrDefault() ? hideDelay.HasValue != hideDelayDefaultValue.HasValue : true))
            {
                hashtables.Add("hideDelay", this.HideDelay);
            }
            hideDelayDefaultValue = this.Padding;
            hideDelay             = this.Padding_DefaultValue;
            if ((hideDelayDefaultValue.GetValueOrDefault() == hideDelay.GetValueOrDefault() ? hideDelayDefaultValue.HasValue != hideDelay.HasValue : true))
            {
                hashtables.Add("padding", this.Padding);
            }
            if (this.PointFormat != this.PointFormat_DefaultValue)
            {
                hashtables.Add("pointFormat", this.PointFormat);
            }
            if (this.PointFormatter != this.PointFormatter_DefaultValue)
            {
                hashtables.Add("pointFormatter", this.PointFormatter);
                Highcharts.AddFunction("PieSeriesTooltipPointFormatter.pointFormatter", this.PointFormatter);
            }
            followPointer             = this.Split;
            followPointerDefaultValue = this.Split_DefaultValue;
            if ((followPointer.GetValueOrDefault() == followPointerDefaultValue.GetValueOrDefault() ? followPointer.HasValue != followPointerDefaultValue.HasValue : true))
            {
                hashtables.Add("split", this.Split);
            }
            hideDelay             = this.ValueDecimals;
            hideDelayDefaultValue = this.ValueDecimals_DefaultValue;
            if ((hideDelay.GetValueOrDefault() == hideDelayDefaultValue.GetValueOrDefault() ? hideDelay.HasValue != hideDelayDefaultValue.HasValue : true))
            {
                hashtables.Add("valueDecimals", this.ValueDecimals);
            }
            if (this.ValuePrefix != this.ValuePrefix_DefaultValue)
            {
                hashtables.Add("valuePrefix", this.ValuePrefix);
            }
            if (this.ValueSuffix != this.ValueSuffix_DefaultValue)
            {
                hashtables.Add("valueSuffix", this.ValueSuffix);
            }
            if (this.XDateFormat != this.XDateFormat_DefaultValue)
            {
                hashtables.Add("xDateFormat", this.XDateFormat);
            }
            return(hashtables);
        }
Exemple #28
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.BackgroundColor != this.BackgroundColor_DefaultValue)
            {
                hashtable.Add((object)"backgroundColor", (object)this.BackgroundColor);
            }
            if (this.BorderColor != this.BorderColor_DefaultValue)
            {
                hashtable.Add((object)"borderColor", (object)this.BorderColor);
            }
            double?nullable1 = this.BorderRadius;
            double?nullable2 = this.BorderRadius_DefaultValue;

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

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"enabled", (object)this.Enabled);
            }
            nullable4 = this.Floating;
            nullable3 = this.Floating_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"floating", (object)this.Floating);
            }
            nullable1 = this.ItemDistance;
            nullable2 = this.ItemDistance_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"itemDistance", (object)this.ItemDistance);
            }
            if (this.ItemHiddenStyle != this.ItemHiddenStyle_DefaultValue)
            {
                hashtable.Add((object)"itemHiddenStyle", (object)this.ItemHiddenStyle);
            }
            if (this.ItemHoverStyle != this.ItemHoverStyle_DefaultValue)
            {
                hashtable.Add((object)"itemHoverStyle", (object)this.ItemHoverStyle);
            }
            nullable2 = this.ItemMarginBottom;
            nullable1 = this.ItemMarginBottom_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"itemMarginBottom", (object)this.ItemMarginBottom);
            }
            nullable1 = this.ItemMarginTop;
            nullable2 = this.ItemMarginTop_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"itemMarginTop", (object)this.ItemMarginTop);
            }
            if (this.ItemStyle != this.ItemStyle_DefaultValue)
            {
                hashtable.Add((object)"itemStyle", (object)this.ItemStyle);
            }
            nullable2 = this.ItemWidth;
            nullable1 = this.ItemWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"itemWidth", (object)this.ItemWidth);
            }
            if (this.LabelFormat != this.LabelFormat_DefaultValue)
            {
                hashtable.Add((object)"labelFormat", (object)this.LabelFormat);
            }
            if (this.LabelFormatter != this.LabelFormatter_DefaultValue)
            {
                hashtable.Add((object)"labelFormatter", (object)this.LabelFormatter);
                Highcharts.AddFunction("LegendLabelFormatter.labelFormatter", this.LabelFormatter);
            }
            if (this.Layout != this.Layout_DefaultValue)
            {
                hashtable.Add((object)"layout", (object)Highcharts.FirstCharacterToLower(this.Layout.ToString()));
            }
            nullable1 = this.LineHeight;
            nullable2 = this.LineHeight_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"lineHeight", (object)this.LineHeight);
            }
            nullable2 = this.Margin;
            nullable1 = this.Margin_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"margin", (object)this.Margin);
            }
            nullable1 = this.MaxHeight;
            nullable2 = this.MaxHeight_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"maxHeight", (object)this.MaxHeight);
            }
            if (this.Navigation.IsDirty())
            {
                hashtable.Add((object)"navigation", (object)this.Navigation.ToHashtable());
            }
            nullable2 = this.Padding;
            nullable1 = this.Padding_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            nullable3 = this.Reversed;
            nullable4 = this.Reversed_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"reversed", (object)this.Reversed);
            }
            nullable4 = this.Rtl;
            nullable3 = this.Rtl_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"rtl", (object)this.Rtl);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            nullable3 = this.SquareSymbol;
            nullable4 = this.SquareSymbol_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"squareSymbol", (object)this.SquareSymbol);
            }
            nullable1 = this.SymbolHeight;
            nullable2 = this.SymbolHeight_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"symbolHeight", (object)this.SymbolHeight);
            }
            nullable2 = this.SymbolPadding;
            nullable1 = this.SymbolPadding_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"symbolPadding", (object)this.SymbolPadding);
            }
            nullable1 = this.SymbolRadius;
            nullable2 = this.SymbolRadius_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"symbolRadius", (object)this.SymbolRadius);
            }
            nullable2 = this.SymbolWidth;
            nullable1 = this.SymbolWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"symbolWidth", (object)this.SymbolWidth);
            }
            if (this.Title.IsDirty())
            {
                hashtable.Add((object)"title", (object)this.Title.ToHashtable());
            }
            nullable4 = this.UseHTML;
            nullable3 = this.UseHTML_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highcharts.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            nullable1 = this.Width;
            nullable2 = this.Width_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"width", (object)this.Width);
            }
            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 #29
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 #30
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);
        }