internal void GetSelectedItemsForDrillthroughContext(ObjectModelImpl objectModel, IActionOwner actionOwner)
{
}
internal override void SetExprHost(MapAppearanceRuleExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
base.SetExprHost(exprHost, reportObjectModel);
}
public void SetExprHost(MapTileExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
this.m_exprHost = exprHost;
this.m_exprHost.SetReportObjectModel(reportObjectModel);
}
public void SetExprHost(ChartLegendColumnHeaderExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
base.SetExprHost(exprHost, reportObjectModel);
this.m_exprHost = exprHost;
}
public void SetExprHost(IndexedExprHost queryParamsExprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(queryParamsExprHost != null && reportObjectModel != null);
this.m_queryParamsExprHost = queryParamsExprHost;
this.m_queryParamsExprHost.SetReportObjectModel(reportObjectModel);
}
internal void SetExprHost(MapPolygonTemplateExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
SetExprHost((MapSpatialElementTemplateExprHost)exprHost, reportObjectModel);
}
public void SetJoinConditionExprHost(IList <JoinConditionExprHost> joinConditionExprHost, ObjectModelImpl reportObjectModel)
{
if (this.m_relationships != null)
{
foreach (IdcRelationship relationship in this.m_relationships)
{
relationship.SetExprHost(joinConditionExprHost, reportObjectModel);
}
}
}
public void SetExprHost(MapLineTemplateExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
base.SetExprHost(exprHost, reportObjectModel);
}
private void SetupObjectModels(OnDemandMode mode, bool needDeepCopyPath, int moveNextInstanceIndex, string scopeName)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataRegionInstance dataRegionInstance = null;
IMemberHierarchy memberHierarchy = null;
int num = -1;
ScopeInstance scopeInstance = m_odpContext.CurrentReportInstance;
List <InstancePathItem> lastInstancePath = m_lastInstancePath;
List <InstancePathItem> list = null;
int num2 = 0;
Microsoft.ReportingServices.ReportIntermediateFormat.Report reportDefinition = m_odpContext.ReportDefinition;
ObjectModelImpl reportObjectModel = m_odpContext.ReportObjectModel;
bool flag = false;
bool flag2 = false;
int i = 0;
try
{
if (m_lastRIFObject.InstancePath != null)
{
list = m_lastRIFObject.InstancePath;
num2 = list.Count;
}
if (mode != OnDemandMode.InScope)
{
m_odpContext.EnsureCultureIsSetOnCurrentThread();
}
if (mode == OnDemandMode.InScope && 1 == reportDefinition.DataSetsNotOnlyUsedInParameters && InScopeCompare(reportDefinition.FirstDataSet.Name, scopeName))
{
return;
}
int num3 = 0;
if (m_odpContext.InSubreport)
{
num3 = InstancePathItem.GetParentReportIndex(m_lastRIFObject.InstancePath, m_lastRIFObject.InstancePathItem.Type == InstancePathItemType.SubReport);
}
bool identicalPaths;
int sharedPathIndex = InstancePathItem.GetSharedPathIndex(num3, lastInstancePath, list, reportObjectModel.AllFieldsCleared, out identicalPaths);
for (int j = m_specialLastGroupingValues.Count; j < num3; j++)
{
m_specialLastGroupingValues.Add(null);
}
for (int k = num3; k < num2; k++)
{
InstancePathItem instancePathItem = list[k];
bool flag3 = false;
if (mode != OnDemandMode.InScope)
{
flag3 = (k <= sharedPathIndex);
}
if (!flag3 && mode == OnDemandMode.FullSetup)
{
if (m_specialLastGroupingValues.Count < num2)
{
m_specialLastGroupingValues.Add(null);
}
else
{
m_specialLastGroupingValues[k] = null;
}
}
switch (instancePathItem.Type)
{
case InstancePathItemType.SubReport:
{
if (scopeInstance.SubreportInstances == null || instancePathItem.IndexInCollection >= scopeInstance.SubreportInstances.Count)
{
break;
}
IReference <Microsoft.ReportingServices.ReportIntermediateFormat.SubReportInstance> reference = scopeInstance.SubreportInstances[instancePathItem.IndexInCollection];
using (reference.PinValue())
{
Microsoft.ReportingServices.ReportIntermediateFormat.SubReportInstance subReportInstance = reference.Value();
subReportInstance.SubReportDef.CurrentSubReportInstance = reference;
if (mode != OnDemandMode.InScope && !subReportInstance.Initialized)
{
if (m_odpContext.IsTablixProcessingMode || m_odpContext.IsTopLevelSubReportProcessing)
{
return;
}
SubReportInitializer.InitializeSubReport(subReportInstance.SubReportDef);
reference.PinValue();
}
Global.Tracer.Assert(k == num2 - 1, "SubReport not last in instance path.");
}
break;
}
case InstancePathItemType.DataRegion:
if (scopeInstance is Microsoft.ReportingServices.ReportIntermediateFormat.ReportInstance && (scopeInstance.DataRegionInstances == null || scopeInstance.DataRegionInstances.Count <= instancePathItem.IndexInCollection || scopeInstance.DataRegionInstances[instancePathItem.IndexInCollection] == null || scopeInstance.DataRegionInstances[instancePathItem.IndexInCollection].Value() == null))
{
Global.Tracer.Assert(instancePathItem.IndexInCollection < reportDefinition.TopLevelDataRegions.Count, "(newItem.IndexInCollection < m_reportDefinition.TopLevelDataRegions.Count)");
Microsoft.ReportingServices.ReportIntermediateFormat.DataSet dataSet = reportDefinition.TopLevelDataRegions[instancePathItem.IndexInCollection].GetDataSet(reportDefinition);
if (mode == OnDemandMode.InScope && InScopeCompare(dataSet.Name, scopeName))
{
return;
}
PerformOnDemandTablixProcessing(dataSet);
}
scopeInstance = scopeInstance.DataRegionInstances[instancePathItem.IndexInCollection].Value();
flag = (m_inRecursiveColumnHierarchy = false);
flag2 = (m_inRecursiveRowHierarchy = false);
num = -1;
dataRegionInstance = (scopeInstance as Microsoft.ReportingServices.ReportIntermediateFormat.DataRegionInstance);
memberHierarchy = dataRegionInstance;
if (mode == OnDemandMode.InScope && InScopeCompare(dataRegionInstance.DataRegionDef.Name, scopeName))
{
return;
}
if (dataRegionInstance.DataSetIndexInCollection >= 0 && m_odpContext.CurrentDataSetIndex != dataRegionInstance.DataSetIndexInCollection && mode != OnDemandMode.InScope)
{
if (!flag3)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataSetInstance dataSetInstance = m_odpContext.CurrentReportInstance.GetDataSetInstance(dataRegionInstance.DataSetIndexInCollection, m_odpContext);
if (dataSetInstance != null)
{
dataSetInstance.SetupEnvironment(m_odpContext, newDataSetDefinition: true);
i = 0;
}
}
else
{
i = k + 1;
}
}
if (mode == OnDemandMode.InScope)
{
break;
}
if (!flag3)
{
dataRegionInstance.SetupEnvironment(m_odpContext);
i = 0;
if (dataRegionInstance.NoRows)
{
dataRegionInstance.DataRegionDef.NoRows = true;
dataRegionInstance.DataRegionDef.ResetTopLevelDynamicMemberInstanceCount();
return;
}
dataRegionInstance.DataRegionDef.NoRows = false;
}
else
{
i = k + 1;
}
break;
case InstancePathItemType.ColumnMemberInstanceIndexTopMost:
scopeInstance = dataRegionInstance;
break;
case InstancePathItemType.Cell:
{
if (-1 == num)
{
num = 0;
}
IList <Microsoft.ReportingServices.ReportIntermediateFormat.DataCellInstance> cellInstances = memberHierarchy.GetCellInstances(num);
if (cellInstances == null)
{
if (flag2 && flag)
{
reportObjectModel.ResetFieldValues();
}
}
else
{
if (cellInstances.Count <= instancePathItem.IndexInCollection)
{
break;
}
Microsoft.ReportingServices.ReportIntermediateFormat.DataCellInstance dataCellInstance = cellInstances[instancePathItem.IndexInCollection];
if (dataCellInstance != null)
{
scopeInstance = dataCellInstance;
if (!flag3)
{
dataCellInstance.SetupEnvironment(m_odpContext, m_odpContext.CurrentDataSetIndex);
i = 0;
}
else
{
i = k + 1;
}
}
}
break;
}
case InstancePathItemType.None:
continue;
}
if (!instancePathItem.IsDynamicMember)
{
continue;
}
IList <DataRegionMemberInstance> childMemberInstances = ((IMemberHierarchy)scopeInstance).GetChildMemberInstances(instancePathItem.Type == InstancePathItemType.RowMemberInstanceIndex, instancePathItem.IndexInCollection);
if (childMemberInstances == null)
{
reportObjectModel.ResetFieldValues();
return;
}
int num4 = (k != num2 - 1 || moveNextInstanceIndex < 0 || moveNextInstanceIndex >= childMemberInstances.Count) ? ((instancePathItem.InstanceIndex >= 0) ? instancePathItem.InstanceIndex : 0) : moveNextInstanceIndex;
if (num4 >= childMemberInstances.Count)
{
instancePathItem.ResetContext();
num4 = 0;
}
DataRegionMemberInstance dataRegionMemberInstance = childMemberInstances[num4];
if (mode == OnDemandMode.FullSetup)
{
dataRegionMemberInstance.MemberDef.InstanceCount = childMemberInstances.Count;
dataRegionMemberInstance.MemberDef.CurrentMemberIndex = num4;
}
scopeInstance = dataRegionMemberInstance;
m_lastRecursiveLevel = dataRegionMemberInstance.RecursiveLevel;
Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode memberDef = dataRegionMemberInstance.MemberDef;
if (mode == OnDemandMode.InScope && InScopeCompare(memberDef.Grouping.Name, scopeName))
{
return;
}
if (instancePathItem.Type == InstancePathItemType.RowMemberInstanceIndex)
{
memberHierarchy = dataRegionMemberInstance;
flag2 = true;
}
else
{
num = dataRegionMemberInstance.MemberInstanceIndexWithinScopeLevel;
flag = true;
}
if (mode == OnDemandMode.FullSetup && !flag3)
{
dataRegionMemberInstance.SetupEnvironment(m_odpContext, m_odpContext.CurrentDataSetIndex);
i = 0;
Microsoft.ReportingServices.ReportIntermediateFormat.Grouping grouping = memberDef.Grouping;
if (grouping.Parent != null)
{
if (memberDef.IsColumn)
{
m_inRecursiveColumnHierarchy = true;
}
else
{
m_inRecursiveRowHierarchy = true;
}
if (memberDef.IsTablixMember)
{
memberDef.SetMemberInstances(childMemberInstances);
memberDef.SetRecursiveParentIndex(dataRegionMemberInstance.RecursiveParentIndex);
memberDef.SetInstanceHasRecursiveChildren(dataRegionMemberInstance.HasRecursiveChildren);
}
}
else if (memberDef.IsColumn)
{
m_inRecursiveColumnHierarchy = false;
}
else
{
m_inRecursiveRowHierarchy = false;
}
grouping.RecursiveLevel = m_lastRecursiveLevel;
grouping.SetGroupInstanceExpressionValues(dataRegionMemberInstance.GroupExprValues);
if (mode != 0 || grouping == null || grouping.GroupExpressions == null || grouping.GroupExpressions.Count <= 0)
{
continue;
}
Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = grouping.GroupExpressions[0];
if (expressionInfo.Type != Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Field)
{
continue;
}
Microsoft.ReportingServices.ReportIntermediateFormat.Field field = memberDef.DataRegionDef.GetDataSet(reportDefinition).Fields[expressionInfo.IntValue];
if (field.DataField != null)
{
string dataField = field.DataField;
object second = dataRegionMemberInstance.GroupExprValues[0];
PairObj <string, object> pairObj = m_specialLastGroupingValues[k];
if (pairObj == null)
{
pairObj = new PairObj <string, object>(dataField, second);
m_specialLastGroupingValues[k] = pairObj;
}
else
{
pairObj.First = dataField;
pairObj.Second = second;
}
}
}
else
{
i = k + 1;
}
}
if (mode == OnDemandMode.FullSetup && !identicalPaths && scopeInstance != null && i > 0)
{
for (; i < m_lastInstancePath.Count; i++)
{
if (m_lastInstancePath[i].IsScope)
{
scopeInstance.SetupFields(m_odpContext, m_odpContext.CurrentDataSetIndex);
break;
}
}
}
if (mode != 0 || m_odpContext.IsTablixProcessingMode || m_odpContext.CurrentReportInstance == null || dataRegionInstance != null || reportDefinition.DataSetsNotOnlyUsedInParameters != 1)
{
return;
}
Microsoft.ReportingServices.ReportIntermediateFormat.DataSet firstDataSet = reportDefinition.FirstDataSet;
Microsoft.ReportingServices.ReportIntermediateFormat.DataSetInstance dataSetInstance2 = m_odpContext.CurrentReportInstance.GetDataSetInstance(firstDataSet, m_odpContext);
if (dataSetInstance2 != null)
{
bool flag4 = true;
if (!m_odpContext.IsTablixProcessingComplete(firstDataSet.IndexInCollection))
{
PerformOnDemandTablixProcessing(firstDataSet);
flag4 = false;
}
if (m_odpContext.CurrentOdpDataSetInstance == dataSetInstance2)
{
flag4 = false;
}
if (flag4)
{
dataSetInstance2.SetupEnvironment(m_odpContext, newDataSetDefinition: true);
}
else if (!dataSetInstance2.NoRows)
{
dataSetInstance2.SetupFields(m_odpContext, dataSetInstance2);
}
}
}
finally
{
if (needDeepCopyPath)
{
InstancePathItem.DeepCopyPath(list, ref m_lastInstancePath);
}
}
}
public void SetExprHost(GaugeInputValueExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null);
this.m_exprHost = exprHost;
this.m_exprHost.SetReportObjectModel(reportObjectModel);
}
internal void SetExprHost(GaugeTickMarksExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null);
SetExprHost((TickMarkStyleExprHost)exprHost, reportObjectModel);
m_exprHost = exprHost;
}
public void SetExprHost(ChartFormulaParameterExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
this.m_exprHost = exprHost;
this.m_exprHost.SetReportObjectModel(reportObjectModel);
}
public override void SetExprHostMapMember(MapSpatialDataExprHost exprHost, ObjectModelImpl reportObjectModel)
{
base.SetExprHostInternal(exprHost, reportObjectModel);
}
internal override void DataRegionContentsSetExprHost(ObjectModelImpl reportObjectModel, bool traverseDataRegions)
{
}
internal void SetExprHostMapMember(MapBindingFieldPairExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
m_exprHostMapMember = exprHost;
m_exprHostMapMember.SetReportObjectModel(reportObjectModel);
}
public override void SetExprHost(IMemberNode memberExprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(memberExprHost != null && reportObjectModel != null);
base.MemberNodeSetExprHost(memberExprHost, reportObjectModel);
}
public abstract void SetExprHost(ReportExprHost reportExprHost, ObjectModelImpl reportObjectModel);
internal void SetJoinConditionExprHost(IList <JoinConditionExprHost> joinConditionExprHost, ObjectModelImpl reportObjectModel)
{
if (m_relationships == null)
{
return;
}
foreach (IdcRelationship relationship in m_relationships)
{
relationship.SetExprHost(joinConditionExprHost, reportObjectModel);
}
}
public void SetExprHost(ChartAxisScaleBreakExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
base.SetExprHost(exprHost, reportObjectModel);
this.m_exprHost = exprHost;
}
internal void SetFilterExprHost(ObjectModelImpl reportObjectModel)
{
m_dataSetCore.SetFilterExprHost(reportObjectModel);
}
public void ReportHierarchyNodeSetExprHost(GroupingExprHost groupingExprHost, SortingExprHost sortingExprHost, ObjectModelImpl reportObjectModel)
{
if (groupingExprHost != null)
{
Global.Tracer.Assert(this.m_grouping != null);
this.m_grouping.SetExprHost(groupingExprHost, reportObjectModel);
}
if (sortingExprHost != null)
{
Global.Tracer.Assert(this.m_sorting != null);
this.m_sorting.SetExprHost(sortingExprHost, reportObjectModel);
}
}
public void SetExprHost(IList <JoinConditionExprHost> joinConditionExprHost, ObjectModelImpl reportObjectModel)
{
if (this.m_exprHostID >= 0)
{
Global.Tracer.Assert(joinConditionExprHost != null && reportObjectModel != null, "(joinConditionExprHost != null && reportObjectModel != null)");
this.m_exprHost = joinConditionExprHost[this.m_exprHostID];
this.m_exprHost.SetReportObjectModel(reportObjectModel);
}
}
internal void SetExprHost(ChartMarkerExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
base.SetExprHost(exprHost, reportObjectModel);
m_exprHost = exprHost;
}
public override void MemberContentsSetExprHost(ObjectModelImpl reportObjectModel, bool traverseDataRegions)
{
}
internal virtual void SetExprHost(MapViewExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
m_exprHost = exprHost;
m_exprHost.SetReportObjectModel(reportObjectModel);
}
public override void DataRegionContentsSetExprHost(ObjectModelImpl reportObjectModel, bool traverseDataRegions)
{
if (this.m_exprHost != null)
{
IList <LinearGaugeExprHost> linearGaugesHostsRemotable = this.m_exprHost.LinearGaugesHostsRemotable;
if (this.m_linearGauges != null && linearGaugesHostsRemotable != null)
{
for (int i = 0; i < this.m_linearGauges.Count; i++)
{
LinearGauge linearGauge = this.m_linearGauges[i];
if (linearGauge != null && linearGauge.ExpressionHostID > -1)
{
linearGauge.SetExprHost(linearGaugesHostsRemotable[linearGauge.ExpressionHostID], reportObjectModel);
}
}
}
IList <RadialGaugeExprHost> radialGaugesHostsRemotable = this.m_exprHost.RadialGaugesHostsRemotable;
if (this.m_radialGauges != null && radialGaugesHostsRemotable != null)
{
for (int j = 0; j < this.m_radialGauges.Count; j++)
{
RadialGauge radialGauge = this.m_radialGauges[j];
if (radialGauge != null && radialGauge.ExpressionHostID > -1)
{
radialGauge.SetExprHost(radialGaugesHostsRemotable[radialGauge.ExpressionHostID], reportObjectModel);
}
}
}
IList <NumericIndicatorExprHost> numericIndicatorsHostsRemotable = this.m_exprHost.NumericIndicatorsHostsRemotable;
if (this.m_numericIndicators != null && numericIndicatorsHostsRemotable != null)
{
for (int k = 0; k < this.m_numericIndicators.Count; k++)
{
NumericIndicator numericIndicator = this.m_numericIndicators[k];
if (numericIndicator != null && numericIndicator.ExpressionHostID > -1)
{
numericIndicator.SetExprHost(numericIndicatorsHostsRemotable[numericIndicator.ExpressionHostID], reportObjectModel);
}
}
}
IList <StateIndicatorExprHost> stateIndicatorsHostsRemotable = this.m_exprHost.StateIndicatorsHostsRemotable;
if (this.m_stateIndicators != null && stateIndicatorsHostsRemotable != null)
{
for (int l = 0; l < this.m_stateIndicators.Count; l++)
{
StateIndicator stateIndicator = this.m_stateIndicators[l];
if (stateIndicator != null && stateIndicator.ExpressionHostID > -1)
{
stateIndicator.SetExprHost(stateIndicatorsHostsRemotable[stateIndicator.ExpressionHostID], reportObjectModel);
}
}
}
IList <GaugeImageExprHost> gaugeImagesHostsRemotable = this.m_exprHost.GaugeImagesHostsRemotable;
if (this.m_gaugeImages != null && gaugeImagesHostsRemotable != null)
{
for (int m = 0; m < this.m_gaugeImages.Count; m++)
{
GaugeImage gaugeImage = this.m_gaugeImages[m];
if (gaugeImage != null && gaugeImage.ExpressionHostID > -1)
{
gaugeImage.SetExprHost(gaugeImagesHostsRemotable[gaugeImage.ExpressionHostID], reportObjectModel);
}
}
}
IList <GaugeLabelExprHost> gaugeLabelsHostsRemotable = this.m_exprHost.GaugeLabelsHostsRemotable;
if (this.m_gaugeLabels != null && gaugeLabelsHostsRemotable != null)
{
for (int n = 0; n < this.m_gaugeLabels.Count; n++)
{
GaugeLabel gaugeLabel = this.m_gaugeLabels[n];
if (gaugeLabel != null && gaugeLabel.ExpressionHostID > -1)
{
gaugeLabel.SetExprHost(gaugeLabelsHostsRemotable[gaugeLabel.ExpressionHostID], reportObjectModel);
}
}
}
if (this.m_backFrame != null && this.m_exprHost.BackFrameHost != null)
{
this.m_backFrame.SetExprHost(this.m_exprHost.BackFrameHost, reportObjectModel);
}
if (this.m_topImage != null && this.m_exprHost.TopImageHost != null)
{
this.m_topImage.SetExprHost(this.m_exprHost.TopImageHost, reportObjectModel);
}
IList <GaugeCellExprHost> cellHostsRemotable = this.m_exprHost.CellHostsRemotable;
if (cellHostsRemotable != null && this.GaugeRow != null && cellHostsRemotable.Count > 0 && this.GaugeRow.GaugeCell != null)
{
this.GaugeRow.GaugeCell.SetExprHost(cellHostsRemotable[0], reportObjectModel);
}
}
}
public void SetExprHost(ChartCustomPaletteColorExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null, "(exprHost != null && reportObjectModel != null)");
this.m_exprHost = exprHost;
this.m_exprHost.SetReportObjectModel(reportObjectModel);
}
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);
}
}
}
}
}
}
public void SetExprHost(GaugeTickMarksExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null);
base.SetExprHost(exprHost, reportObjectModel);
base.m_exprHost = exprHost;
}
internal void SetExprHost(CapImageExprHost exprHost, ObjectModelImpl reportObjectModel)
{
Global.Tracer.Assert(exprHost != null && reportObjectModel != null);
SetExprHost((BaseGaugeImageExprHost)exprHost, reportObjectModel);
m_exprHost = exprHost;
}
