Exemple #1
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("PlotOptionsGaugeTooltipPointFormatter.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 #2
0
        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?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);
            }
            if (this.ConnectorColor != this.ConnectorColor_DefaultValue)
            {
                hashtables.Add("connectorColor", this.ConnectorColor);
            }
            borderRadius             = this.ConnectorPadding;
            borderRadiusDefaultValue = this.ConnectorPadding_DefaultValue;
            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.HasValue : true))
            {
                hashtables.Add("connectorPadding", this.ConnectorPadding);
            }
            borderRadiusDefaultValue = this.ConnectorWidth;
            borderRadius             = this.ConnectorWidth_DefaultValue;
            if ((borderRadiusDefaultValue.GetValueOrDefault() == borderRadius.GetValueOrDefault() ? borderRadiusDefaultValue.HasValue != borderRadius.HasValue : true))
            {
                hashtables.Add("connectorWidth", this.ConnectorWidth);
            }
            bool?crop             = this.Crop;
            bool?cropDefaultValue = this.Crop_DefaultValue;

            if ((crop.GetValueOrDefault() == cropDefaultValue.GetValueOrDefault() ? crop.HasValue != cropDefaultValue.HasValue : true))
            {
                hashtables.Add("crop", this.Crop);
            }
            cropDefaultValue = this.Defer;
            crop             = this.Defer_DefaultValue;
            if ((cropDefaultValue.GetValueOrDefault() == crop.GetValueOrDefault() ? cropDefaultValue.HasValue != crop.HasValue : true))
            {
                hashtables.Add("defer", this.Defer);
            }
            borderRadius             = this.Distance;
            borderRadiusDefaultValue = this.Distance_DefaultValue;
            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.HasValue : true))
            {
                hashtables.Add("distance", this.Distance);
            }
            crop             = this.Enabled;
            cropDefaultValue = this.Enabled_DefaultValue;
            if ((crop.GetValueOrDefault() == cropDefaultValue.GetValueOrDefault() ? crop.HasValue != cropDefaultValue.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("FunnelSeriesDataLabelsFormatter.formatter", this.Formatter);
            }
            cropDefaultValue = this.Inside;
            crop             = this.Inside_DefaultValue;
            if ((cropDefaultValue.GetValueOrDefault() == crop.GetValueOrDefault() ? cropDefaultValue.HasValue != crop.HasValue : true))
            {
                hashtables.Add("inside", this.Inside);
            }
            if (this.Overflow != this.Overflow_DefaultValue)
            {
                FunnelSeriesDataLabelsOverflow overflow = this.Overflow;
                hashtables.Add("overflow", Highcharts.FirstCharacterToLower(overflow.ToString()));
            }
            borderRadiusDefaultValue = this.Padding;
            borderRadius             = this.Padding_DefaultValue;
            if ((borderRadiusDefaultValue.GetValueOrDefault() == borderRadius.GetValueOrDefault() ? borderRadiusDefaultValue.HasValue != borderRadius.HasValue : true))
            {
                hashtables.Add("padding", this.Padding);
            }
            borderRadius             = this.Rotation;
            borderRadiusDefaultValue = this.Rotation_DefaultValue;
            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.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);
            }
            crop             = this.SoftConnector;
            cropDefaultValue = this.SoftConnector_DefaultValue;
            if ((crop.GetValueOrDefault() == cropDefaultValue.GetValueOrDefault() ? crop.HasValue != cropDefaultValue.HasValue : true))
            {
                hashtables.Add("softConnector", this.SoftConnector);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtables.Add("style", this.Style);
            }
            cropDefaultValue = this.UseHTML;
            crop             = this.UseHTML_DefaultValue;
            if ((cropDefaultValue.GetValueOrDefault() == crop.GetValueOrDefault() ? cropDefaultValue.HasValue != crop.HasValue : true))
            {
                hashtables.Add("useHTML", this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                FunnelSeriesDataLabelsVerticalAlign verticalAlign = this.VerticalAlign;
                hashtables.Add("verticalAlign", Highcharts.FirstCharacterToLower(verticalAlign.ToString()));
            }
            borderRadiusDefaultValue = this.X;
            borderRadius             = this.X_DefaultValue;
            if ((borderRadiusDefaultValue.GetValueOrDefault() == borderRadius.GetValueOrDefault() ? borderRadiusDefaultValue.HasValue != borderRadius.HasValue : true))
            {
                hashtables.Add("x", this.X);
            }
            borderRadius             = this.Y;
            borderRadiusDefaultValue = this.Y_DefaultValue;
            if ((borderRadius.GetValueOrDefault() == borderRadiusDefaultValue.GetValueOrDefault() ? borderRadius.HasValue != borderRadiusDefaultValue.HasValue : true))
            {
                hashtables.Add("y", this.Y);
            }
            borderRadiusDefaultValue = this.ZIndex;
            borderRadius             = this.ZIndex_DefaultValue;
            if ((borderRadiusDefaultValue.GetValueOrDefault() == borderRadius.GetValueOrDefault() ? borderRadiusDefaultValue.HasValue != borderRadius.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            return(hashtables);
        }
        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("ColumnSeriesTooltipPointFormatter.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);
        }
        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?nullable1 = this.BorderRadius;
            double?nullable2 = this.BorderRadius_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"borderRadius", (object)this.BorderRadius);
            }
            nullable2 = this.BorderWidth;
            nullable1 = this.BorderWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"borderWidth", (object)this.BorderWidth);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Color != this.Color_DefaultValue)
            {
                hashtable.Add((object)"color", (object)this.Color);
            }
            if (this.ConnectorColor != this.ConnectorColor_DefaultValue)
            {
                hashtable.Add((object)"connectorColor", (object)this.ConnectorColor);
            }
            nullable1 = this.ConnectorPadding;
            nullable2 = this.ConnectorPadding_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"connectorPadding", (object)this.ConnectorPadding);
            }
            nullable2 = this.ConnectorWidth;
            nullable1 = this.ConnectorWidth_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"connectorWidth", (object)this.ConnectorWidth);
            }
            bool?nullable3 = this.Crop;
            bool?nullable4 = this.Crop_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"crop", (object)this.Crop);
            }
            nullable4 = this.Defer;
            nullable3 = this.Defer_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"defer", (object)this.Defer);
            }
            nullable1 = this.Distance;
            nullable2 = this.Distance_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"distance", (object)this.Distance);
            }
            nullable3 = this.Enabled;
            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("PieSeriesDataLabelsFormatter.formatter", this.Formatter);
            }
            nullable4 = this.Inside;
            nullable3 = this.Inside_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"inside", (object)this.Inside);
            }
            if (this.Overflow != this.Overflow_DefaultValue)
            {
                hashtable.Add((object)"overflow", (object)Highcharts.FirstCharacterToLower(this.Overflow.ToString()));
            }
            nullable2 = this.Padding;
            nullable1 = this.Padding_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"padding", (object)this.Padding);
            }
            nullable1 = this.Rotation;
            nullable2 = this.Rotation_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"rotation", (object)this.Rotation);
            }
            if (this.Shadow.IsDirty())
            {
                hashtable.Add((object)"shadow", (object)this.Shadow.ToHashtable());
            }
            if (this.Shape != this.Shape_DefaultValue)
            {
                hashtable.Add((object)"shape", (object)this.Shape);
            }
            nullable3 = this.SoftConnector;
            nullable4 = this.SoftConnector_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"softConnector", (object)this.SoftConnector);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtable.Add((object)"style", (object)this.Style);
            }
            nullable4 = this.UseHTML;
            nullable3 = this.UseHTML_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"useHTML", (object)this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                hashtable.Add((object)"verticalAlign",
                              (object)Highcharts.FirstCharacterToLower(this.VerticalAlign.ToString()));
            }
            nullable2 = this.X;
            nullable1 = this.X_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"x", (object)this.X);
            }
            nullable1 = this.Y;
            nullable2 = this.Y_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"y", (object)this.Y);
            }
            nullable2 = this.ZIndex;
            nullable1 = this.ZIndex_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"zIndex", (object)this.ZIndex);
            }
            return(hashtable);
        }
Exemple #5
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.DescribeSingleSeries;
            bool?     nullable2 = this.DescribeSingleSeries_DefaultValue;

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

            if (descriptionThreshold.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                descriptionThreshold.HasValue != nullable3.HasValue)
            {
                nullable3 = this.PointDescriptionThreshold;
                if (nullable3.HasValue)
                {
                    hashtable.Add((object)"pointDescriptionThreshold", (object)this.PointDescriptionThreshold);
                }
                else
                {
                    hashtable.Add((object)"pointDescriptionThreshold", (object)false);
                }
            }
            if (this.ScreenReaderSectionFormatter != this.ScreenReaderSectionFormatter_DefaultValue)
            {
                hashtable.Add((object)"screenReaderSectionFormatter", (object)this.ScreenReaderSectionFormatter);
                Highcharts.AddFunction("AccessibilityScreenReaderSectionFormatter.screenReaderSectionFormatter",
                                       this.ScreenReaderSectionFormatter);
            }
            if (this.SeriesDescriptionFormatter != this.SeriesDescriptionFormatter_DefaultValue)
            {
                hashtable.Add((object)"seriesDescriptionFormatter", (object)this.SeriesDescriptionFormatter);
                Highcharts.AddFunction("AccessibilitySeriesDescriptionFormatter.seriesDescriptionFormatter",
                                       this.SeriesDescriptionFormatter);
            }
            return(hashtable);
        }
Exemple #6
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                XAxisLabelsAlign align = this.Align;
                hashtables.Add("align", Highcharts.FirstCharacterToLower(align.ToString()));
            }
            if (this.AutoRotation != this.AutoRotation_DefaultValue)
            {
                hashtables.Add("autoRotation", this.AutoRotation);
            }
            double?autoRotationLimit             = this.AutoRotationLimit;
            double?autoRotationLimitDefaultValue = this.AutoRotationLimit_DefaultValue;

            if ((autoRotationLimit.GetValueOrDefault() == autoRotationLimitDefaultValue.GetValueOrDefault() ? autoRotationLimit.HasValue != autoRotationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("autoRotationLimit", this.AutoRotationLimit);
            }
            autoRotationLimitDefaultValue = this.Distance;
            autoRotationLimit             = this.Distance_DefaultValue;
            if ((autoRotationLimitDefaultValue.GetValueOrDefault() == autoRotationLimit.GetValueOrDefault() ? autoRotationLimitDefaultValue.HasValue != autoRotationLimit.HasValue : true))
            {
                hashtables.Add("distance", this.Distance);
            }
            bool?enabled             = this.Enabled;
            bool?enabledDefaultValue = this.Enabled_DefaultValue;

            if ((enabled.GetValueOrDefault() == enabledDefaultValue.GetValueOrDefault() ? enabled.HasValue != enabledDefaultValue.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("XAxisLabelsFormatter.formatter", this.Formatter);
            }
            autoRotationLimit             = this.Padding;
            autoRotationLimitDefaultValue = this.Padding_DefaultValue;
            if ((autoRotationLimit.GetValueOrDefault() == autoRotationLimitDefaultValue.GetValueOrDefault() ? autoRotationLimit.HasValue != autoRotationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("padding", this.Padding);
            }
            enabledDefaultValue = this.ReserveSpace;
            enabled             = this.ReserveSpace_DefaultValue;
            if ((enabledDefaultValue.GetValueOrDefault() == enabled.GetValueOrDefault() ? enabledDefaultValue.HasValue != enabled.HasValue : true))
            {
                hashtables.Add("reserveSpace", this.ReserveSpace);
            }
            autoRotationLimitDefaultValue = this.Rotation;
            autoRotationLimit             = this.Rotation_DefaultValue;
            if ((autoRotationLimitDefaultValue.GetValueOrDefault() == autoRotationLimit.GetValueOrDefault() ? autoRotationLimitDefaultValue.HasValue != autoRotationLimit.HasValue : true))
            {
                hashtables.Add("rotation", this.Rotation);
            }
            autoRotationLimit             = this.StaggerLines;
            autoRotationLimitDefaultValue = this.StaggerLines_DefaultValue;
            if ((autoRotationLimit.GetValueOrDefault() == autoRotationLimitDefaultValue.GetValueOrDefault() ? autoRotationLimit.HasValue != autoRotationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("staggerLines", this.StaggerLines);
            }
            autoRotationLimitDefaultValue = this.Step;
            autoRotationLimit             = this.Step_DefaultValue;
            if ((autoRotationLimitDefaultValue.GetValueOrDefault() == autoRotationLimit.GetValueOrDefault() ? autoRotationLimitDefaultValue.HasValue != autoRotationLimit.HasValue : true))
            {
                hashtables.Add("step", this.Step);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtables.Add("style", this.Style);
            }
            enabled             = this.UseHTML;
            enabledDefaultValue = this.UseHTML_DefaultValue;
            if ((enabled.GetValueOrDefault() == enabledDefaultValue.GetValueOrDefault() ? enabled.HasValue != enabledDefaultValue.HasValue : true))
            {
                hashtables.Add("useHTML", this.UseHTML);
            }
            autoRotationLimit             = this.X;
            autoRotationLimitDefaultValue = this.X_DefaultValue;
            if ((autoRotationLimit.GetValueOrDefault() == autoRotationLimitDefaultValue.GetValueOrDefault() ? autoRotationLimit.HasValue != autoRotationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("x", this.X);
            }
            autoRotationLimitDefaultValue = this.Y;
            autoRotationLimit             = this.Y_DefaultValue;
            if ((autoRotationLimitDefaultValue.GetValueOrDefault() == autoRotationLimit.GetValueOrDefault() ? autoRotationLimitDefaultValue.HasValue != autoRotationLimit.HasValue : true))
            {
                hashtables.Add("y", this.Y);
            }
            autoRotationLimit             = this.ZIndex;
            autoRotationLimitDefaultValue = this.ZIndex_DefaultValue;
            if ((autoRotationLimit.GetValueOrDefault() == autoRotationLimitDefaultValue.GetValueOrDefault() ? autoRotationLimit.HasValue != autoRotationLimitDefaultValue.HasValue : true))
            {
                hashtables.Add("zIndex", this.ZIndex);
            }
            return(hashtables);
        }
Exemple #7
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();
            bool?     nullable1 = this.AllowDecimals;
            bool?     nullable2 = this.AllowDecimals_DefaultValue;

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"allowDecimals", (object)this.AllowDecimals);
            }
            if (this.AlternateGridColor != this.AlternateGridColor_DefaultValue)
            {
                hashtable.Add((object)"alternateGridColor", (object)this.AlternateGridColor);
            }
            double?nullable3 = this.Angle;
            double?nullable4 = this.Angle_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"angle", (object)this.Angle);
            }
            if (this.Breaks.IsDirty())
            {
                hashtable.Add((object)"breaks", (object)this.Breaks.ToHashtable());
            }
            if (this.Categories != this.Categories_DefaultValue)
            {
                hashtable.Add((object)"categories", (object)this.Categories);
            }
            nullable4 = this.Ceiling;
            nullable3 = this.Ceiling_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"ceiling", (object)this.Ceiling);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtable.Add((object)"className", (object)this.ClassName);
            }
            if (this.Crosshair.IsDirty())
            {
                hashtable.Add((object)"crosshair", (object)this.Crosshair.ToHashtable());
            }
            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtable.Add((object)"dateTimeLabelFormats", (object)this.DateTimeLabelFormats);
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtable.Add((object)"description", (object)this.Description);
            }
            nullable2 = this.EndOnTick;
            nullable1 = this.EndOnTick_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"endOnTick", (object)this.EndOnTick);
            }
            if (this.Events.IsDirty())
            {
                hashtable.Add((object)"events", (object)this.Events.ToHashtable());
            }
            nullable3 = this.Floor;
            nullable4 = this.Floor_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"floor", (object)this.Floor);
            }
            if (this.GridLineColor != this.GridLineColor_DefaultValue)
            {
                hashtable.Add((object)"gridLineColor", (object)this.GridLineColor);
            }
            if (this.GridLineDashStyle != this.GridLineDashStyle_DefaultValue)
            {
                hashtable.Add((object)"gridLineDashStyle",
                              (object)Highcharts.FirstCharacterToLower(this.GridLineDashStyle.ToString()));
            }
            if (this.GridLineInterpolation != this.GridLineInterpolation_DefaultValue)
            {
                hashtable.Add((object)"gridLineInterpolation",
                              (object)Highcharts.FirstCharacterToLower(this.GridLineInterpolation.ToString()));
            }
            nullable4 = this.GridLineWidth;
            nullable3 = this.GridLineWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"gridLineWidth", (object)this.GridLineWidth);
            }
            nullable3 = this.GridZIndex;
            nullable4 = this.GridZIndex_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"gridZIndex", (object)this.GridZIndex);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtable.Add((object)"id", (object)this.Id);
            }
            if (this.Labels.IsDirty())
            {
                hashtable.Add((object)"labels", (object)this.Labels.ToHashtable());
            }
            if (this.LineColor != this.LineColor_DefaultValue)
            {
                hashtable.Add((object)"lineColor", (object)this.LineColor);
            }
            nullable4 = this.LineWidth;
            nullable3 = this.LineWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"lineWidth", (object)this.LineWidth);
            }
            nullable3 = this.LinkedTo;
            nullable4 = this.LinkedTo_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"linkedTo", (object)this.LinkedTo);
            }
            nullable4 = this.Max;
            nullable3 = this.Max_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"max", (object)this.Max);
            }
            if (this.MaxColor != this.MaxColor_DefaultValue)
            {
                hashtable.Add((object)"maxColor", (object)this.MaxColor);
            }
            nullable3 = this.MaxPadding;
            nullable4 = this.MaxPadding_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"maxPadding", (object)this.MaxPadding);
            }
            nullable4 = this.Min;
            nullable3 = this.Min_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"min", (object)this.Min);
            }
            if (this.MinColor != this.MinColor_DefaultValue)
            {
                hashtable.Add((object)"minColor", (object)this.MinColor);
            }
            nullable3 = this.MinPadding;
            nullable4 = this.MinPadding_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minPadding", (object)this.MinPadding);
            }
            nullable4 = this.MinRange;
            nullable3 = this.MinRange_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"minRange", (object)this.MinRange);
            }
            nullable3 = this.MinTickInterval;
            nullable4 = this.MinTickInterval_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minTickInterval", (object)this.MinTickInterval);
            }
            if (this.MinorGridLineColor != this.MinorGridLineColor_DefaultValue)
            {
                hashtable.Add((object)"minorGridLineColor", (object)this.MinorGridLineColor);
            }
            if (this.MinorGridLineDashStyle != this.MinorGridLineDashStyle_DefaultValue)
            {
                hashtable.Add((object)"minorGridLineDashStyle",
                              (object)Highcharts.FirstCharacterToLower(this.MinorGridLineDashStyle.ToString()));
            }
            nullable4 = this.MinorGridLineWidth;
            nullable3 = this.MinorGridLineWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"minorGridLineWidth", (object)this.MinorGridLineWidth);
            }
            if (this.MinorTickColor != this.MinorTickColor_DefaultValue)
            {
                hashtable.Add((object)"minorTickColor", (object)this.MinorTickColor);
            }
            if (this.MinorTickInterval != this.MinorTickInterval_DefaultValue)
            {
                hashtable.Add((object)"minorTickInterval", (object)this.MinorTickInterval);
            }
            nullable3 = this.MinorTickLength;
            nullable4 = this.MinorTickLength_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"minorTickLength", (object)this.MinorTickLength);
            }
            if (this.MinorTickPosition != this.MinorTickPosition_DefaultValue)
            {
                hashtable.Add((object)"minorTickPosition",
                              (object)Highcharts.FirstCharacterToLower(this.MinorTickPosition.ToString()));
            }
            nullable4 = this.MinorTickWidth;
            nullable3 = this.MinorTickWidth_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"minorTickWidth", (object)this.MinorTickWidth);
            }
            nullable3 = this.Offset;
            nullable4 = this.Offset_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"offset", (object)this.Offset);
            }
            nullable1 = this.Opposite;
            nullable2 = this.Opposite_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"opposite", (object)this.Opposite);
            }
            if (this.PlotBands != this.PlotBands_DefaultValue)
            {
                hashtable.Add((object)"plotBands", (object)this.HashifyList((IEnumerable)this.PlotBands));
            }
            if (this.PlotLines != this.PlotLines_DefaultValue)
            {
                hashtable.Add((object)"plotLines", (object)this.HashifyList((IEnumerable)this.PlotLines));
            }
            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.ReversedStacks;
            nullable2 = this.ReversedStacks_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"reversedStacks", (object)this.ReversedStacks);
            }
            nullable2 = this.ShowEmpty;
            nullable1 = this.ShowEmpty_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showEmpty", (object)this.ShowEmpty);
            }
            nullable1 = this.ShowFirstLabel;
            nullable2 = this.ShowFirstLabel_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"showFirstLabel", (object)this.ShowFirstLabel);
            }
            nullable2 = this.ShowLastLabel;
            nullable1 = this.ShowLastLabel_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"showLastLabel", (object)this.ShowLastLabel);
            }
            nullable4 = this.SoftMax;
            nullable3 = this.SoftMax_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"softMax", (object)this.SoftMax);
            }
            nullable3 = this.SoftMin;
            nullable4 = this.SoftMin_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"softMin", (object)this.SoftMin);
            }
            if (this.StackLabels.IsDirty())
            {
                hashtable.Add((object)"stackLabels", (object)this.StackLabels.ToHashtable());
            }
            nullable4 = this.StartOfWeek;
            nullable3 = this.StartOfWeek_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"startOfWeek", (object)this.StartOfWeek);
            }
            nullable1 = this.StartOnTick;
            nullable2 = this.StartOnTick_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"startOnTick", (object)this.StartOnTick);
            }
            if (this.Stops.Any <Stop>())
            {
                hashtable.Add((object)"stops", (object)this.GetLists((IEnumerable)this.Stops));
            }
            nullable3 = this.TickAmount;
            nullable4 = this.TickAmount_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"tickAmount", (object)this.TickAmount);
            }
            if (this.TickColor != this.TickColor_DefaultValue)
            {
                hashtable.Add((object)"tickColor", (object)this.TickColor);
            }
            nullable4 = this.TickInterval;
            nullable3 = this.TickInterval_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"tickInterval", (object)this.TickInterval);
            }
            nullable3 = this.TickLength;
            nullable4 = this.TickLength_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"tickLength", (object)this.TickLength);
            }
            nullable4 = this.TickPixelInterval;
            nullable3 = this.TickPixelInterval_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"tickPixelInterval", (object)this.TickPixelInterval);
            }
            if (this.TickPosition != this.TickPosition_DefaultValue)
            {
                hashtable.Add((object)"tickPosition",
                              (object)Highcharts.FirstCharacterToLower(this.TickPosition.ToString()));
            }
            if (this.TickPositioner != this.TickPositioner_DefaultValue)
            {
                hashtable.Add((object)"tickPositioner", (object)this.TickPositioner);
                Highcharts.AddFunction("YAxisTickPositioner.tickPositioner", this.TickPositioner);
            }
            if (this.TickPositions != this.TickPositions_DefaultValue)
            {
                hashtable.Add((object)"tickPositions", (object)this.TickPositions);
            }
            nullable3 = this.TickWidth;
            nullable4 = this.TickWidth_DefaultValue;
            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"tickWidth", (object)this.TickWidth);
            }
            if (this.TickmarkPlacement != this.TickmarkPlacement_DefaultValue)
            {
                hashtable.Add((object)"tickmarkPlacement",
                              (object)Highcharts.FirstCharacterToLower(this.TickmarkPlacement.ToString()));
            }
            if (this.Title.IsDirty())
            {
                hashtable.Add((object)"title", (object)this.Title.ToHashtable());
            }
            if (this.Type != this.Type_DefaultValue)
            {
                hashtable.Add((object)"type", (object)Highcharts.FirstCharacterToLower(this.Type.ToString()));
            }
            nullable2 = this.Visible;
            nullable1 = this.Visible_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"visible", (object)this.Visible);
            }
            return(hashtable);
        }
Exemple #8
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("ZAxisLabelsFormatter.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 #9
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtables = new Hashtable();

            if (this.Align != this.Align_DefaultValue)
            {
                LegendAlign align = this.Align;
                hashtables.Add("align", Highcharts.FirstCharacterToLower(align.ToString()));
            }
            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);
            }
            bool?enabled             = this.Enabled;
            bool?enabledDefaultValue = this.Enabled_DefaultValue;

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

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

            if ((enabled.GetValueOrDefault() == enabledDefaultValue.GetValueOrDefault() ? enabled.HasValue != enabledDefaultValue.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("YAxisStackLabelsFormatter.formatter", this.Formatter);
            }
            double?rotation             = this.Rotation;
            double?rotationDefaultValue = this.Rotation_DefaultValue;

            if ((rotation.GetValueOrDefault() == rotationDefaultValue.GetValueOrDefault() ? rotation.HasValue != rotationDefaultValue.HasValue : true))
            {
                hashtables.Add("rotation", this.Rotation);
            }
            if (this.Style != this.Style_DefaultValue)
            {
                hashtables.Add("style", this.Style);
            }
            if (this.TextAlign != this.TextAlign_DefaultValue)
            {
                YAxisStackLabelsTextAlign textAlign = this.TextAlign;
                hashtables.Add("textAlign", Highcharts.FirstCharacterToLower(textAlign.ToString()));
            }
            enabledDefaultValue = this.UseHTML;
            enabled             = this.UseHTML_DefaultValue;
            if ((enabledDefaultValue.GetValueOrDefault() == enabled.GetValueOrDefault() ? enabledDefaultValue.HasValue != enabled.HasValue : true))
            {
                hashtables.Add("useHTML", this.UseHTML);
            }
            if (this.VerticalAlign != this.VerticalAlign_DefaultValue)
            {
                YAxisStackLabelsVerticalAlign verticalAlign = this.VerticalAlign;
                hashtables.Add("verticalAlign", Highcharts.FirstCharacterToLower(verticalAlign.ToString()));
            }
            rotationDefaultValue = this.X;
            rotation             = this.X_DefaultValue;
            if ((rotationDefaultValue.GetValueOrDefault() == rotation.GetValueOrDefault() ? rotationDefaultValue.HasValue != rotation.HasValue : true))
            {
                hashtables.Add("x", this.X);
            }
            rotation             = this.Y;
            rotationDefaultValue = this.Y_DefaultValue;
            if ((rotation.GetValueOrDefault() == rotationDefaultValue.GetValueOrDefault() ? rotation.HasValue != rotationDefaultValue.HasValue : true))
            {
                hashtables.Add("y", this.Y);
            }
            return(hashtables);
        }
Exemple #11
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

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

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

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

            if ((allowDecimals.GetValueOrDefault() == allowDecimalsDefaultValue.GetValueOrDefault() ? allowDecimals.HasValue != allowDecimalsDefaultValue.HasValue : true))
            {
                hashtables.Add("allowDecimals", this.AllowDecimals);
            }
            if (this.AlternateGridColor != this.AlternateGridColor_DefaultValue)
            {
                hashtables.Add("alternateGridColor", this.AlternateGridColor);
            }
            double?angle             = this.Angle;
            double?angleDefaultValue = this.Angle_DefaultValue;

            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("angle", this.Angle);
            }
            if (this.Breaks.IsDirty())
            {
                hashtables.Add("breaks", this.Breaks.ToHashtable());
            }
            if (this.Categories != this.Categories_DefaultValue)
            {
                hashtables.Add("categories", this.Categories);
            }
            angleDefaultValue = this.Ceiling;
            angle             = this.Ceiling_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("ceiling", this.Ceiling);
            }
            if (this.ClassName != this.ClassName_DefaultValue)
            {
                hashtables.Add("className", this.ClassName);
            }
            if (this.Crosshair.IsDirty())
            {
                hashtables.Add("crosshair", this.Crosshair.ToHashtable());
            }
            if (this.DateTimeLabelFormats != this.DateTimeLabelFormats_DefaultValue)
            {
                hashtables.Add("dateTimeLabelFormats", this.DateTimeLabelFormats);
            }
            if (this.Description != this.Description_DefaultValue)
            {
                hashtables.Add("description", this.Description);
            }
            allowDecimalsDefaultValue = this.EndOnTick;
            allowDecimals             = this.EndOnTick_DefaultValue;
            if ((allowDecimalsDefaultValue.GetValueOrDefault() == allowDecimals.GetValueOrDefault() ? allowDecimalsDefaultValue.HasValue != allowDecimals.HasValue : true))
            {
                hashtables.Add("endOnTick", this.EndOnTick);
            }
            if (this.Events.IsDirty())
            {
                hashtables.Add("events", this.Events.ToHashtable());
            }
            angle             = this.Floor;
            angleDefaultValue = this.Floor_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("floor", this.Floor);
            }
            if (this.GridLineColor != this.GridLineColor_DefaultValue)
            {
                hashtables.Add("gridLineColor", this.GridLineColor);
            }
            if (this.GridLineDashStyle != this.GridLineDashStyle_DefaultValue)
            {
                YAxisGridLineDashStyle gridLineDashStyle = this.GridLineDashStyle;
                hashtables.Add("gridLineDashStyle", Highcharts.FirstCharacterToLower(gridLineDashStyle.ToString()));
            }
            if (this.GridLineInterpolation != this.GridLineInterpolation_DefaultValue)
            {
                YAxisGridLineInterpolation gridLineInterpolation = this.GridLineInterpolation;
                hashtables.Add("gridLineInterpolation", Highcharts.FirstCharacterToLower(gridLineInterpolation.ToString()));
            }
            angleDefaultValue = this.GridLineWidth;
            angle             = this.GridLineWidth_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("gridLineWidth", this.GridLineWidth);
            }
            angle             = this.GridZIndex;
            angleDefaultValue = this.GridZIndex_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("gridZIndex", this.GridZIndex);
            }
            if (this.Id != this.Id_DefaultValue)
            {
                hashtables.Add("id", this.Id);
            }
            if (this.Labels.IsDirty())
            {
                hashtables.Add("labels", this.Labels.ToHashtable());
            }
            if (this.LineColor != this.LineColor_DefaultValue)
            {
                hashtables.Add("lineColor", this.LineColor);
            }
            angleDefaultValue = this.LineWidth;
            angle             = this.LineWidth_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("lineWidth", this.LineWidth);
            }
            angle             = this.LinkedTo;
            angleDefaultValue = this.LinkedTo_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("linkedTo", this.LinkedTo);
            }
            angleDefaultValue = this.Max;
            angle             = this.Max_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("max", this.Max);
            }
            if (this.MaxColor != this.MaxColor_DefaultValue)
            {
                hashtables.Add("maxColor", this.MaxColor);
            }
            angle             = this.MaxPadding;
            angleDefaultValue = this.MaxPadding_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("maxPadding", this.MaxPadding);
            }
            angleDefaultValue = this.Min;
            angle             = this.Min_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("min", this.Min);
            }
            if (this.MinColor != this.MinColor_DefaultValue)
            {
                hashtables.Add("minColor", this.MinColor);
            }
            angle             = this.MinPadding;
            angleDefaultValue = this.MinPadding_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("minPadding", this.MinPadding);
            }
            angleDefaultValue = this.MinRange;
            angle             = this.MinRange_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("minRange", this.MinRange);
            }
            angle             = this.MinTickInterval;
            angleDefaultValue = this.MinTickInterval_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("minTickInterval", this.MinTickInterval);
            }
            if (this.MinorGridLineColor != this.MinorGridLineColor_DefaultValue)
            {
                hashtables.Add("minorGridLineColor", this.MinorGridLineColor);
            }
            if (this.MinorGridLineDashStyle != this.MinorGridLineDashStyle_DefaultValue)
            {
                YAxisMinorGridLineDashStyle minorGridLineDashStyle = this.MinorGridLineDashStyle;
                hashtables.Add("minorGridLineDashStyle", Highcharts.FirstCharacterToLower(minorGridLineDashStyle.ToString()));
            }
            angleDefaultValue = this.MinorGridLineWidth;
            angle             = this.MinorGridLineWidth_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("minorGridLineWidth", this.MinorGridLineWidth);
            }
            if (this.MinorTickColor != this.MinorTickColor_DefaultValue)
            {
                hashtables.Add("minorTickColor", this.MinorTickColor);
            }
            if (this.MinorTickInterval != this.MinorTickInterval_DefaultValue)
            {
                hashtables.Add("minorTickInterval", this.MinorTickInterval);
            }
            angle             = this.MinorTickLength;
            angleDefaultValue = this.MinorTickLength_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("minorTickLength", this.MinorTickLength);
            }
            if (this.MinorTickPosition != this.MinorTickPosition_DefaultValue)
            {
                YAxisMinorTickPosition minorTickPosition = this.MinorTickPosition;
                hashtables.Add("minorTickPosition", Highcharts.FirstCharacterToLower(minorTickPosition.ToString()));
            }
            angleDefaultValue = this.MinorTickWidth;
            angle             = this.MinorTickWidth_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("minorTickWidth", this.MinorTickWidth);
            }
            angle             = this.Offset;
            angleDefaultValue = this.Offset_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("offset", this.Offset);
            }
            allowDecimals             = this.Opposite;
            allowDecimalsDefaultValue = this.Opposite_DefaultValue;
            if ((allowDecimals.GetValueOrDefault() == allowDecimalsDefaultValue.GetValueOrDefault() ? allowDecimals.HasValue != allowDecimalsDefaultValue.HasValue : true))
            {
                hashtables.Add("opposite", this.Opposite);
            }
            if (this.PlotBands != this.PlotBands_DefaultValue)
            {
                hashtables.Add("plotBands", base.HashifyList(this.PlotBands));
            }
            if (this.PlotLines != this.PlotLines_DefaultValue)
            {
                hashtables.Add("plotLines", base.HashifyList(this.PlotLines));
            }
            allowDecimalsDefaultValue = this.Reversed;
            allowDecimals             = this.Reversed_DefaultValue;
            if ((allowDecimalsDefaultValue.GetValueOrDefault() == allowDecimals.GetValueOrDefault() ? allowDecimalsDefaultValue.HasValue != allowDecimals.HasValue : true))
            {
                hashtables.Add("reversed", this.Reversed);
            }
            allowDecimals             = this.ReversedStacks;
            allowDecimalsDefaultValue = this.ReversedStacks_DefaultValue;
            if ((allowDecimals.GetValueOrDefault() == allowDecimalsDefaultValue.GetValueOrDefault() ? allowDecimals.HasValue != allowDecimalsDefaultValue.HasValue : true))
            {
                hashtables.Add("reversedStacks", this.ReversedStacks);
            }
            allowDecimalsDefaultValue = this.ShowEmpty;
            allowDecimals             = this.ShowEmpty_DefaultValue;
            if ((allowDecimalsDefaultValue.GetValueOrDefault() == allowDecimals.GetValueOrDefault() ? allowDecimalsDefaultValue.HasValue != allowDecimals.HasValue : true))
            {
                hashtables.Add("showEmpty", this.ShowEmpty);
            }
            allowDecimals             = this.ShowFirstLabel;
            allowDecimalsDefaultValue = this.ShowFirstLabel_DefaultValue;
            if ((allowDecimals.GetValueOrDefault() == allowDecimalsDefaultValue.GetValueOrDefault() ? allowDecimals.HasValue != allowDecimalsDefaultValue.HasValue : true))
            {
                hashtables.Add("showFirstLabel", this.ShowFirstLabel);
            }
            allowDecimalsDefaultValue = this.ShowLastLabel;
            allowDecimals             = this.ShowLastLabel_DefaultValue;
            if ((allowDecimalsDefaultValue.GetValueOrDefault() == allowDecimals.GetValueOrDefault() ? allowDecimalsDefaultValue.HasValue != allowDecimals.HasValue : true))
            {
                hashtables.Add("showLastLabel", this.ShowLastLabel);
            }
            angleDefaultValue = this.SoftMax;
            angle             = this.SoftMax_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("softMax", this.SoftMax);
            }
            angle             = this.SoftMin;
            angleDefaultValue = this.SoftMin_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("softMin", this.SoftMin);
            }
            if (this.StackLabels.IsDirty())
            {
                hashtables.Add("stackLabels", this.StackLabels.ToHashtable());
            }
            angleDefaultValue = this.StartOfWeek;
            angle             = this.StartOfWeek_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("startOfWeek", this.StartOfWeek);
            }
            allowDecimals             = this.StartOnTick;
            allowDecimalsDefaultValue = this.StartOnTick_DefaultValue;
            if ((allowDecimals.GetValueOrDefault() == allowDecimalsDefaultValue.GetValueOrDefault() ? allowDecimals.HasValue != allowDecimalsDefaultValue.HasValue : true))
            {
                hashtables.Add("startOnTick", this.StartOnTick);
            }
            if (this.Stops != this.Stops_DefaultValue)
            {
                hashtables.Add("stops", base.HashifyList(this.Stops));
            }
            angle             = this.TickAmount;
            angleDefaultValue = this.TickAmount_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("tickAmount", this.TickAmount);
            }
            if (this.TickColor != this.TickColor_DefaultValue)
            {
                hashtables.Add("tickColor", this.TickColor);
            }
            angleDefaultValue = this.TickInterval;
            angle             = this.TickInterval_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("tickInterval", this.TickInterval);
            }
            angle             = this.TickLength;
            angleDefaultValue = this.TickLength_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("tickLength", this.TickLength);
            }
            angleDefaultValue = this.TickPixelInterval;
            angle             = this.TickPixelInterval_DefaultValue;
            if ((angleDefaultValue.GetValueOrDefault() == angle.GetValueOrDefault() ? angleDefaultValue.HasValue != angle.HasValue : true))
            {
                hashtables.Add("tickPixelInterval", this.TickPixelInterval);
            }
            if (this.TickPosition != this.TickPosition_DefaultValue)
            {
                YAxisTickPosition tickPosition = this.TickPosition;
                hashtables.Add("tickPosition", Highcharts.FirstCharacterToLower(tickPosition.ToString()));
            }
            if (this.TickPositioner != this.TickPositioner_DefaultValue)
            {
                hashtables.Add("tickPositioner", this.TickPositioner);
                Highcharts.AddFunction("YAxisTickPositioner.tickPositioner", this.TickPositioner);
            }
            if (this.TickPositions != this.TickPositions_DefaultValue)
            {
                hashtables.Add("tickPositions", this.TickPositions);
            }
            angle             = this.TickWidth;
            angleDefaultValue = this.TickWidth_DefaultValue;
            if ((angle.GetValueOrDefault() == angleDefaultValue.GetValueOrDefault() ? angle.HasValue != angleDefaultValue.HasValue : true))
            {
                hashtables.Add("tickWidth", this.TickWidth);
            }
            if (this.TickmarkPlacement != this.TickmarkPlacement_DefaultValue)
            {
                YAxisTickmarkPlacement tickmarkPlacement = this.TickmarkPlacement;
                hashtables.Add("tickmarkPlacement", Highcharts.FirstCharacterToLower(tickmarkPlacement.ToString()));
            }
            if (this.Title.IsDirty())
            {
                hashtables.Add("title", this.Title.ToHashtable());
            }
            if (this.Type != this.Type_DefaultValue)
            {
                YAxisType type = this.Type;
                hashtables.Add("type", Highcharts.FirstCharacterToLower(type.ToString()));
            }
            allowDecimalsDefaultValue = this.Visible;
            allowDecimals             = this.Visible_DefaultValue;
            if ((allowDecimalsDefaultValue.GetValueOrDefault() == allowDecimals.GetValueOrDefault() ? allowDecimalsDefaultValue.HasValue != allowDecimals.HasValue : true))
            {
                hashtables.Add("visible", this.Visible);
            }
            return(hashtables);
        }
Exemple #13
0
        internal override Hashtable ToHashtable()
        {
            Hashtable hashtable = new Hashtable();

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

            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"endColumn", (object)this.EndColumn);
            }
            nullable2 = this.EndRow;
            nullable1 = this.EndRow_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"endRow", (object)this.EndRow);
            }
            bool?nullable3 = this.FirstRowAsNames;
            bool?nullable4 = this.FirstRowAsNames_DefaultValue;

            if (nullable3.GetValueOrDefault() != nullable4.GetValueOrDefault() ||
                nullable3.HasValue != nullable4.HasValue)
            {
                hashtable.Add((object)"firstRowAsNames", (object)this.FirstRowAsNames);
            }
            if (this.GoogleSpreadsheetKey != this.GoogleSpreadsheetKey_DefaultValue)
            {
                hashtable.Add((object)"googleSpreadsheetKey", (object)this.GoogleSpreadsheetKey);
            }
            if (this.GoogleSpreadsheetWorksheet != this.GoogleSpreadsheetWorksheet_DefaultValue)
            {
                hashtable.Add((object)"googleSpreadsheetWorksheet", (object)this.GoogleSpreadsheetWorksheet);
            }
            if (this.ItemDelimiter != this.ItemDelimiter_DefaultValue)
            {
                hashtable.Add((object)"itemDelimiter", (object)this.ItemDelimiter);
            }
            if (this.LineDelimiter != this.LineDelimiter_DefaultValue)
            {
                hashtable.Add((object)"lineDelimiter", (object)this.LineDelimiter);
            }
            if (this.ParseDate != this.ParseDate_DefaultValue)
            {
                hashtable.Add((object)"parseDate", (object)this.ParseDate);
                Highcharts.AddFunction("DataParseDate.parseDate", this.ParseDate);
            }
            if (this.Parsed != this.Parsed_DefaultValue)
            {
                hashtable.Add((object)"parsed", (object)this.Parsed);
                Highcharts.AddFunction("DataParsed.parsed", this.Parsed);
            }
            if (this.Rows != this.Rows_DefaultValue)
            {
                hashtable.Add((object)"rows", (object)this.Rows);
            }
            if (this.SeriesMapping != this.SeriesMapping_DefaultValue)
            {
                hashtable.Add((object)"seriesMapping", (object)this.SeriesMapping);
            }
            nullable1 = this.StartColumn;
            nullable2 = this.StartColumn_DefaultValue;
            if (nullable1.GetValueOrDefault() != nullable2.GetValueOrDefault() ||
                nullable1.HasValue != nullable2.HasValue)
            {
                hashtable.Add((object)"startColumn", (object)this.StartColumn);
            }
            nullable2 = this.StartRow;
            nullable1 = this.StartRow_DefaultValue;
            if (nullable2.GetValueOrDefault() != nullable1.GetValueOrDefault() ||
                nullable2.HasValue != nullable1.HasValue)
            {
                hashtable.Add((object)"startRow", (object)this.StartRow);
            }
            nullable4 = this.SwitchRowsAndColumns;
            nullable3 = this.SwitchRowsAndColumns_DefaultValue;
            if (nullable4.GetValueOrDefault() != nullable3.GetValueOrDefault() ||
                nullable4.HasValue != nullable3.HasValue)
            {
                hashtable.Add((object)"switchRowsAndColumns", (object)this.SwitchRowsAndColumns);
            }
            if (this.Table != this.Table_DefaultValue)
            {
                hashtable.Add((object)"table", (object)this.Table);
            }
            return(hashtable);
        }