Example #1
0
 public ChartSmartLabel(Chart chart, ChartSeries chartSeries)
 {
     this.m_chart       = chart;
     this.m_chartSeries = chartSeries;
 }
Example #2
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(ChartSmartLabel.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Chart:
                    this.m_chart = reader.ReadReference <Chart>(this);
                    break;

                case MemberName.ChartSeries:
                    this.m_chartSeries = reader.ReadReference <ChartSeries>(this);
                    break;

                case MemberName.AllowOutSidePlotArea:
                    this.m_allowOutSidePlotArea = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CalloutBackColor:
                    this.m_calloutBackColor = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CalloutLineAnchor:
                    this.m_calloutLineAnchor = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CalloutLineColor:
                    this.m_calloutLineColor = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CalloutLineStyle:
                    this.m_calloutLineStyle = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CalloutLineWidth:
                    this.m_calloutLineWidth = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CalloutStyle:
                    this.m_calloutStyle = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.ShowOverlapped:
                    this.m_showOverlapped = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.MarkerOverlapping:
                    this.m_markerOverlapping = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.MaxMovingDistance:
                    this.m_maxMovingDistance = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.MinMovingDistance:
                    this.m_minMovingDistance = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.NoMoveDirections:
                    this.m_noMoveDirections = (ChartNoMoveDirections)reader.ReadRIFObject();
                    break;

                case MemberName.Disabled:
                    this.m_disabled = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
 public ChartNoMoveDirections(Chart chart, ChartSeries chartSeries)
 {
     this.m_chart       = chart;
     this.m_chartSeries = chartSeries;
 }
 public ChartEmptyPoints(Chart chart, ChartSeries chartSeries)
     : base(chart)
 {
     this.m_chartSeries = chartSeries;
 }
 public ChartItemInLegend(Chart chart, ChartSeries chartSeries)
 {
     this.m_chart       = chart;
     this.m_chartSeries = chartSeries;
 }
 public InternalChartSeries(Chart chart, int seriesIndex, AspNetCore.ReportingServices.ReportIntermediateFormat.ChartSeries seriesDef)
     : base(chart, seriesIndex)
 {
     this.m_chartSeriesDef = seriesDef;
 }
 public ChartDataLabel(Chart chart, ChartSeries chartSeries)
     : base(chart)
 {
     this.m_chartSeries = chartSeries;
 }
 public ChartMarker(Chart chart, ChartSeries chartSeries)
     : base(chart)
 {
     this.m_chartSeries = chartSeries;
 }
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(ChartSeries.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    this.m_name = reader.ReadString();
                    break;

                case MemberName.ChartDataPoints:
                    this.m_dataPoints = reader.ReadListOfRIFObjects <ChartDataPointList>();
                    break;

                case MemberName.ExprHostID:
                    this.m_exprHostID = reader.ReadInt32();
                    break;

                case MemberName.Chart:
                    this.m_chart = reader.ReadReference <Chart>(this);
                    break;

                case MemberName.ChartMember:
                    this.m_parentChartMember = reader.ReadReference <ChartMember>(this);
                    break;

                case MemberName.SourceSeries:
                    this.m_sourceSeries = reader.ReadReference <ChartSeries>(this);
                    break;

                case MemberName.Action:
                    this.m_action = (Action)reader.ReadRIFObject();
                    break;

                case MemberName.Type:
                    this.m_type = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.Subtype:
                    this.m_subtype = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.EmptyPoints:
                    this.m_emptyPoints = (ChartEmptyPoints)reader.ReadRIFObject();
                    break;

                case MemberName.LegendName:
                    this.m_legendName = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.LegendText:
                    this.m_legendText = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.ChartAreaName:
                    this.m_chartAreaName = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.ValueAxisName:
                    this.m_valueAxisName = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CategoryAxisName:
                    this.m_categoryAxisName = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.StyleClass:
                    this.m_styleClass = (Style)reader.ReadRIFObject();
                    break;

                case MemberName.Hidden:
                    this.m_hidden = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.HideInLegend:
                    this.m_hideInLegend = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.ChartSmartLabel:
                    this.m_chartSmartLabel = (ChartSmartLabel)reader.ReadRIFObject();
                    break;

                case MemberName.CustomProperties:
                    this.m_customProperties = reader.ReadListOfRIFObjects <DataValueList>();
                    break;

                case MemberName.DataLabel:
                    this.m_dataLabel = (ChartDataLabel)reader.ReadRIFObject();
                    break;

                case MemberName.Marker:
                    this.m_marker = (ChartMarker)reader.ReadRIFObject();
                    break;

                case MemberName.ToolTip:
                    this.m_toolTip = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.ChartItemInLegend:
                    this.m_chartItemInLegend = (ChartItemInLegend)reader.ReadRIFObject();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public override object PublishClone(AutomaticSubtotalContext context)
        {
            ChartSeries chartSeries = (ChartSeries)base.PublishClone(context);

            chartSeries.m_chart = (Chart)context.CurrentDataRegionClone;
            if (this.m_dataPoints != null)
            {
                chartSeries.m_dataPoints = new ChartDataPointList(this.m_dataPoints.Count);
                foreach (ChartDataPoint dataPoint in this.m_dataPoints)
                {
                    chartSeries.m_dataPoints.Add((ChartDataPoint)dataPoint.PublishClone(context));
                }
            }
            if (this.m_customProperties != null)
            {
                chartSeries.m_customProperties = new DataValueList(this.m_customProperties.Count);
                foreach (DataValue customProperty in this.m_customProperties)
                {
                    chartSeries.m_customProperties.Add((DataValue)customProperty.PublishClone(context));
                }
            }
            if (this.m_styleClass != null)
            {
                chartSeries.m_styleClass = (Style)this.m_styleClass.PublishClone(context);
            }
            if (this.m_action != null)
            {
                chartSeries.m_action = (Action)this.m_action.PublishClone(context);
            }
            if (this.m_type != null)
            {
                chartSeries.m_type = (ExpressionInfo)this.m_type.PublishClone(context);
            }
            if (this.m_subtype != null)
            {
                chartSeries.m_subtype = (ExpressionInfo)this.m_subtype.PublishClone(context);
            }
            if (this.m_emptyPoints != null)
            {
                chartSeries.m_emptyPoints = (ChartEmptyPoints)this.m_emptyPoints.PublishClone(context);
            }
            if (this.m_legendName != null)
            {
                chartSeries.m_legendName = (ExpressionInfo)this.m_legendName.PublishClone(context);
            }
            if (this.m_legendText != null)
            {
                chartSeries.m_legendText = (ExpressionInfo)this.m_legendText.PublishClone(context);
            }
            if (this.m_chartAreaName != null)
            {
                chartSeries.m_chartAreaName = (ExpressionInfo)this.m_chartAreaName.PublishClone(context);
            }
            if (this.m_valueAxisName != null)
            {
                chartSeries.m_valueAxisName = (ExpressionInfo)this.m_valueAxisName.PublishClone(context);
            }
            if (this.m_categoryAxisName != null)
            {
                chartSeries.m_categoryAxisName = (ExpressionInfo)this.m_categoryAxisName.PublishClone(context);
            }
            if (this.m_hidden != null)
            {
                chartSeries.m_hidden = (ExpressionInfo)this.m_hidden.PublishClone(context);
            }
            if (this.m_hideInLegend != null)
            {
                chartSeries.m_hideInLegend = (ExpressionInfo)this.m_hideInLegend.PublishClone(context);
            }
            if (this.m_chartSmartLabel != null)
            {
                chartSeries.m_chartSmartLabel = (ChartSmartLabel)this.m_chartSmartLabel.PublishClone(context);
            }
            if (this.m_dataLabel != null)
            {
                chartSeries.m_dataLabel = (ChartDataLabel)this.m_dataLabel.PublishClone(context);
            }
            if (this.m_marker != null)
            {
                chartSeries.m_marker = (ChartMarker)this.m_marker.PublishClone(context);
            }
            if (this.m_toolTip != null)
            {
                chartSeries.m_toolTip = (ExpressionInfo)this.m_toolTip.PublishClone(context);
            }
            if (this.m_chartItemInLegend != null)
            {
                chartSeries.m_chartItemInLegend = (ChartItemInLegend)this.m_chartItemInLegend.PublishClone(context);
            }
            return(chartSeries);
        }
Example #11
0
 public override void DataRegionContentsSetExprHost(ObjectModelImpl reportObjectModel, bool traverseDataRegions)
 {
     if (this.m_chartExprHost != null)
     {
         IList <ChartAreaExprHost> chartAreasHostsRemotable = this.m_chartExprHost.ChartAreasHostsRemotable;
         if (this.m_chartAreas != null && chartAreasHostsRemotable != null)
         {
             for (int i = 0; i < this.m_chartAreas.Count; i++)
             {
                 ChartArea chartArea = this.m_chartAreas[i];
                 if (chartArea != null && chartArea.ExpressionHostID > -1)
                 {
                     chartArea.SetExprHost(chartAreasHostsRemotable[chartArea.ExpressionHostID], reportObjectModel);
                 }
             }
         }
         IList <ChartTitleExprHost> titlesHostsRemotable = this.m_chartExprHost.TitlesHostsRemotable;
         if (this.m_titles != null && titlesHostsRemotable != null)
         {
             for (int j = 0; j < this.m_titles.Count; j++)
             {
                 ChartTitle chartTitle = this.m_titles[j];
                 if (chartTitle != null && chartTitle.ExpressionHostID > -1)
                 {
                     chartTitle.SetExprHost(titlesHostsRemotable[chartTitle.ExpressionHostID], reportObjectModel);
                 }
             }
         }
         IList <ChartLegendExprHost> legendsHostsRemotable = this.m_chartExprHost.LegendsHostsRemotable;
         if (this.m_legends != null && legendsHostsRemotable != null)
         {
             for (int k = 0; k < this.m_legends.Count; k++)
             {
                 ChartLegend chartLegend = this.m_legends[k];
                 if (chartLegend != null && chartLegend.ExpressionHostID > -1)
                 {
                     chartLegend.SetExprHost(legendsHostsRemotable[chartLegend.ExpressionHostID], reportObjectModel);
                 }
             }
         }
         IList <ChartCustomPaletteColorExprHost> customPaletteColorHostsRemotable = this.m_chartExprHost.CustomPaletteColorHostsRemotable;
         if (this.m_customPaletteColors != null && customPaletteColorHostsRemotable != null)
         {
             for (int l = 0; l < this.m_customPaletteColors.Count; l++)
             {
                 ChartCustomPaletteColor chartCustomPaletteColor = this.m_customPaletteColors[l];
                 if (chartCustomPaletteColor != null && chartCustomPaletteColor.ExpressionHostID > -1)
                 {
                     chartCustomPaletteColor.SetExprHost(customPaletteColorHostsRemotable[chartCustomPaletteColor.ExpressionHostID], reportObjectModel);
                 }
             }
         }
         if (this.m_codeParameters != null && this.m_chartExprHost.CodeParametersHostsRemotable != null)
         {
             this.m_codeParameters.SetExprHost(this.m_chartExprHost.CodeParametersHostsRemotable, reportObjectModel);
         }
         if (this.m_borderSkin != null && this.m_chartExprHost.BorderSkinHost != null)
         {
             this.m_borderSkin.SetExprHost(this.m_chartExprHost.BorderSkinHost, reportObjectModel);
         }
         if (this.m_noDataMessage != null && this.m_chartExprHost.NoDataMessageHost != null)
         {
             this.m_noDataMessage.SetExprHost(this.m_chartExprHost.NoDataMessageHost, reportObjectModel);
         }
         IList <ChartSeriesExprHost>    seriesCollectionHostsRemotable = this.m_chartExprHost.SeriesCollectionHostsRemotable;
         IList <ChartDataPointExprHost> cellHostsRemotable             = this.m_chartExprHost.CellHostsRemotable;
         Global.Tracer.Assert(this.m_chartSeriesCollection != null, "(m_chartSeriesCollection != null)");
         for (int m = 0; m < this.m_chartSeriesCollection.Count; m++)
         {
             ChartSeries chartSeries = this.m_chartSeriesCollection[m];
             Global.Tracer.Assert(null != chartSeries, "(null != series)");
             if (seriesCollectionHostsRemotable != null && chartSeries.ExpressionHostID > -1)
             {
                 chartSeries.SetExprHost(seriesCollectionHostsRemotable[chartSeries.ExpressionHostID], reportObjectModel);
             }
             if (cellHostsRemotable != null)
             {
                 Global.Tracer.Assert(null != chartSeries.DataPoints, "(null != series.DataPoints)");
                 for (int n = 0; n < chartSeries.DataPoints.Count; n++)
                 {
                     ChartDataPoint chartDataPoint = chartSeries.DataPoints[n];
                     Global.Tracer.Assert(null != chartDataPoint, "(null != dataPoint)");
                     if (chartDataPoint.ExpressionHostID > -1)
                     {
                         chartDataPoint.SetExprHost(cellHostsRemotable[chartDataPoint.ExpressionHostID], reportObjectModel);
                     }
                 }
             }
         }
     }
 }