void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
SortAndFilter((AggregateUpdateContext)traversalContext);
break;
case ProcessingStages.RunningValues:
CalculateRunningValues((AggregateUpdateContext)traversalContext);
break;
case ProcessingStages.CreateGroupTree:
CreateInstances((CreateInstancesTraversalContext)traversalContext);
break;
case ProcessingStages.UpdateAggregates:
UpdateAggregates((AggregateUpdateContext)traversalContext);
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
public override void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
RuntimeGroupRootObj runtimeGroupRootObj = base.m_owner as RuntimeGroupRootObj;
Global.Tracer.Assert(null != runtimeGroupRootObj, "(null != groupRootOwner)");
runtimeGroupRootObj.GroupOrDetailSortTree.Traverse(operation, ascending, traversalContext);
}
public override void Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (this.m_hierarchyNode != null)
{
this.m_hierarchyNode.Traverse(operation, traversalContext);
}
}
private void Traverse(ProcessingStages operation, AggregateUpdateContext context)
{
if (Count == 0)
{
return;
}
int num = m_firstCellKey;
int num2;
do
{
num2 = num;
IDisposable cleanupRef;
RuntimeCell andPinCell = GetAndPinCell(num2, out cleanupRef);
switch (operation)
{
case ProcessingStages.SortAndFilter:
andPinCell.SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
andPinCell.UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown operation in Traverse");
break;
}
num = andPinCell.NextCell;
cleanupRef?.Dispose();
}
while (num2 != m_lastCellKey);
}
internal override void Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (m_hierarchyNode != null)
{
m_hierarchyNode.Traverse(operation, traversalContext);
}
}
private void Traverse(ProcessingStages operation, AggregateUpdateContext context)
{
for (int i = 0; i < this.m_dataRegionObjs.Count; i++)
{
RuntimeDataRegionObjReference runtimeDataRegionObjReference = this.m_dataRegionObjs[i];
if ((BaseReference)runtimeDataRegionObjReference != (object)null)
{
using (runtimeDataRegionObjReference.PinValue())
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
runtimeDataRegionObjReference.Value().SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
runtimeDataRegionObjReference.Value().UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(false, "Unknown ProcessingStage in Traverse");
break;
}
}
}
}
}
private void Traverse(ProcessingStages operation, AggregateUpdateContext aggContext)
{
if (m_grouping != null)
{
m_grouping.Traverse(ProcessingStages.SortAndFilter, ascending: true, aggContext);
}
if (m_hierarchyObjs == null)
{
return;
}
for (int i = 0; i < m_hierarchyObjs.Count; i++)
{
IReference <RuntimeHierarchyObj> reference = m_hierarchyObjs[i];
using (reference.PinValue())
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
reference.Value().SortAndFilter(aggContext);
break;
case ProcessingStages.UpdateAggregates:
reference.Value().UpdateAggregates(aggContext);
break;
}
}
}
}
internal override void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
RuntimeGroupRootObj runtimeGroupRootObj = m_owner as RuntimeGroupRootObj;
Global.Tracer.Assert(runtimeGroupRootObj != null, "(null != groupRootOwner)");
runtimeGroupRootObj.TraverseLinkedGroupLeaves(operation, ascending, traversalContext);
}
void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (this.m_sortHierarchyStruct != null)
{
bool ascending = true;
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = this.m_sortHierarchyStruct.SortInfo.Value();
if (runtimeSortFilterEventInfo.EventSource.UserSort.SortExpressionScope == null)
{
ascending = runtimeSortFilterEventInfo.SortDirection;
}
this.m_sortHierarchyStruct.SortTree.Traverse(operation, ascending, traversalContext);
}
if (this.m_dataHolder != null)
{
using (this.m_dataHolder.PinValue())
{
this.m_dataHolder.Value().Traverse(operation, traversalContext);
}
}
if (this.m_dataRowHolder != null)
{
using (this.m_hierarchyRoot.PinValue())
{
this.m_dataRowHolder.Traverse(operation, traversalContext, this.m_hierarchyRoot.Value());
}
}
}
private void Traverse(ProcessingStages operation, AggregateUpdateContext context)
{
if (this.Count != 0)
{
int num = this.m_firstCellKey;
int num2;
do
{
num2 = num;
IDisposable disposable = default(IDisposable);
RuntimeCell andPinCell = this.GetAndPinCell(num2, out disposable);
switch (operation)
{
case ProcessingStages.SortAndFilter:
andPinCell.SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
andPinCell.UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(false, "Unknown operation in Traverse");
break;
}
num = andPinCell.NextCell;
if (disposable != null)
{
disposable.Dispose();
}
}while (num2 != this.m_lastCellKey);
}
}
protected override void Traverse(ProcessingStages operation, ITraversalContext context)
{
base.Traverse(operation, context);
if (this.m_dataRegionScopedItems != null)
{
this.TraverseDataRegionScopedItems(operation, context);
}
}
internal void TraverseLinkedGroupLeaves(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
if (null != m_firstChild)
{
using (m_firstChild.PinValue())
{
m_firstChild.Value().TraverseAllLeafNodes(operation, traversalContext);
}
}
}
void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (this.m_dataRowHolder != null)
{
this.m_dataRowHolder.Traverse(operation, traversalContext, this);
}
else
{
this.m_sortTree.Traverse(operation, this.m_sortExpression.Direction, traversalContext);
}
}
protected void TraverseGroupOrSortTree(ProcessingStages operation, ITraversalContext traversalContext)
{
if (m_detailUserSortTargetInfo != null && m_groupingType != 0)
{
m_detailUserSortTargetInfo.SortTree.Traverse(operation, GetDetailSortDirection(), traversalContext);
}
else
{
m_grouping.Traverse(operation, m_expression == null || m_expression.Direction, traversalContext);
}
}
internal void VisitChild(ProcessingStages operation, bool ascending, ScalableList <BTreeNode> nodeList, ITraversalContext traversalContext)
{
if (-1 != m_childIndex)
{
BTreeNode item;
using (nodeList.GetAndPin(m_childIndex, out item))
{
item.Traverse(operation, ascending, nodeList, traversalContext);
}
}
}
public void VisitChild(ProcessingStages operation, bool ascending, ScalableList <BTreeNode> nodeList, ITraversalContext traversalContext)
{
if (-1 != this.m_childIndex)
{
BTreeNode bTreeNode = default(BTreeNode);
using (nodeList.GetAndPin(this.m_childIndex, out bTreeNode))
{
bTreeNode.Traverse(operation, ascending, nodeList, traversalContext);
}
}
}
private void Traverse(DataFieldRow dataRow, ProcessingStages operation, DataRowSortOwnerTraversalContext context, IHierarchyObj owner)
{
dataRow.SetFields(owner.OdpContext.ReportObjectModel.FieldsImpl);
if (operation == ProcessingStages.UserSortFilter)
{
owner.ReadRow();
}
else
{
context.SortOwner.PostDataRowSortNextRow();
}
}
internal override bool SortAndFilter(AggregateUpdateContext aggContext)
{
if (m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope))
{
CopyDomainScopeGroupInstancesFromTarget();
}
RuntimeGroupingObj grouping = m_grouping;
bool ascending = DetermineTraversalDirection();
bool result = true;
bool processSecondPassSorting = ProcessSecondPassSorting;
bool flag = (SecondPassOperations.FilteringOrAggregatesOrDomainScope & m_odpContext.SecondPassOperation) != 0 && (m_hierarchyDef.HasFilters || m_hierarchyDef.HasInnerFilters);
if (processSecondPassSorting)
{
m_expression = new RuntimeExpressionInfo(m_hierarchyDef.Sorting.SortExpressions, m_hierarchyDef.Sorting.ExprHost, m_hierarchyDef.Sorting.SortDirections, 0);
m_groupingType = RuntimeGroupingObj.GroupingTypes.Sort;
m_grouping = new RuntimeGroupingObjTree(this, m_objectType);
}
else if (flag)
{
m_groupingType = RuntimeGroupingObj.GroupingTypes.None;
m_grouping = new RuntimeGroupingObjLinkedList(this, m_objectType);
}
if (flag)
{
m_groupFilters = new Filters(Filters.FilterTypes.GroupFilter, (IReference <Microsoft.ReportingServices.ReportProcessing.ReportProcessing.IFilterOwner>)base.SelfReference, m_hierarchyDef.Grouping.Filters, Microsoft.ReportingServices.ReportProcessing.ObjectType.Grouping, m_hierarchyDef.Grouping.Name, m_odpContext, base.Depth + 1);
}
m_processingStage = ProcessingStages.SortAndFilter;
m_lastChild = null;
grouping.Traverse(ProcessingStages.SortAndFilter, ascending, aggContext);
if (flag)
{
m_groupFilters.FinishReadingGroups(aggContext);
if (!processSecondPassSorting && null == m_lastChild)
{
if (m_firstChild != null)
{
m_firstChild.Free();
}
m_firstChild = null;
result = false;
}
}
if (grouping != m_grouping)
{
grouping.Cleanup();
}
return(result);
}
internal void Traverse(ProcessingStages operation, bool ascending, ScalableList <BTreeNode> nodes, ITraversalContext traversalContext)
{
if (ascending)
{
for (int i = 0; i < m_tuples.Count; i++)
{
m_tuples[i].Traverse(operation, ascending, nodes, traversalContext);
}
return;
}
for (int num = m_tuples.Count - 1; num >= 0; num--)
{
m_tuples[num].Traverse(operation, ascending, nodes, traversalContext);
}
}
public void Traverse(ProcessingStages operation, ITraversalContext traversalContext, IHierarchyObj owner)
{
Global.Tracer.Assert(ProcessingStages.UserSortFilter == operation || owner.InDataRowSortPhase, "Invalid call to RuntimeSortDataHolder.Traverse. Must be in UserSortFilter stage or InDataRowSortPhase");
if (this.m_firstRow != null)
{
DataRowSortOwnerTraversalContext context = traversalContext as DataRowSortOwnerTraversalContext;
this.Traverse(this.m_firstRow, operation, context, owner);
if (this.m_dataRows != null)
{
for (int i = 0; i < this.m_dataRows.Count; i++)
{
this.Traverse(this.m_dataRows[i], operation, context, owner);
}
}
}
}
public void Traverse(ProcessingStages operation, bool ascending, ScalableList <BTreeNode> nodes, ITraversalContext traversalContext)
{
if (ascending)
{
for (int i = 0; i < this.m_tuples.Count; i++)
{
this.m_tuples[i].Traverse(operation, ascending, nodes, traversalContext);
}
}
else
{
for (int num = this.m_tuples.Count - 1; num >= 0; num--)
{
this.m_tuples[num].Traverse(operation, ascending, nodes, traversalContext);
}
}
}
private void TraverseDataRegionScopedItems(ProcessingStages operation, ITraversalContext context)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
this.m_dataRegionScopedItems.SortAndFilter((AggregateUpdateContext)context);
break;
case ProcessingStages.UpdateAggregates:
this.m_dataRegionScopedItems.UpdateAggregates((AggregateUpdateContext)context);
break;
default:
Global.Tracer.Assert(false, "Unknown ProcessingStage for TraverseDataRegionScopedItems");
break;
}
}
internal void Traverse(ProcessingStages operation, bool ascending, ScalableList <BTreeNode> nodeList, ITraversalContext traversalContext)
{
if (ascending)
{
if (m_value != null)
{
m_value.Traverse(operation, traversalContext);
}
VisitChild(operation, ascending, nodeList, traversalContext);
}
else
{
VisitChild(operation, ascending, nodeList, traversalContext);
if (m_value != null)
{
m_value.Traverse(operation, traversalContext);
}
}
}
protected override void TraverseCellContents(ProcessingStages operation, AggregateUpdateContext context)
{
if (m_cellContents != null)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
m_cellContents.SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
m_cellContents.UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(condition: false, "Invalid operation for TraverseCellContents.");
break;
}
}
}
protected override void TraverseStaticContents(ProcessingStages operation, AggregateUpdateContext context)
{
if (m_groupScopedItems != null)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
m_groupScopedItems.SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
m_groupScopedItems.UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown operation in TraverseStaticContents.");
break;
}
}
}
private void TraverseMember(IReference <RuntimeMemberObj> memberRef, ProcessingStages operation, ITraversalContext context)
{
using (memberRef.PinValue())
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
memberRef.Value().SortAndFilter((AggregateUpdateContext)context);
break;
case ProcessingStages.UpdateAggregates:
memberRef.Value().UpdateAggregates((AggregateUpdateContext)context);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown ProcessingStage in TraverseMember");
break;
}
}
}
protected virtual void Traverse(ProcessingStages operation, ITraversalContext context)
{
bool num = base.DataRegionDef.ProcessingInnerGrouping == Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion.ProcessingInnerGroupings.Column;
IReference <RuntimeMemberObj>[] array = num ? m_outerGroupings : m_innerGroupings;
IReference <RuntimeMemberObj>[] array2 = num ? m_innerGroupings : m_outerGroupings;
if (array != null)
{
for (int i = 0; i < array.Length; i++)
{
TraverseMember(array[i], operation, context);
}
}
if (array2 != null)
{
for (int j = 0; j < array2.Length; j++)
{
TraverseMember(array2[j], operation, context);
}
}
}
private void Save()
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Access DB file (*.mdb)|*.mdb";
if (sfd.ShowDialog() == DialogResult.OK)
{
Repository rep = new Repository(settingsManager);
try
{
rep.CreateAndExportLegacyFile(sfd.FileName, cells);
Status = ProcessingStages.Ready;
}
catch
{
ShowError();
}
}
}
private void InitWorker()
{
worker.WorkerReportsProgress = true;
worker.DoWork += (o, e) =>
{
Status = ProcessingStages.Processing;
var imageProcessor = new ImageProcessor(SourceImage.ToBitmap(), settingsManager);
imageProcessor.ProccessImage(worker);
e.Result = imageProcessor;
};
worker.ProgressChanged += (o, e) =>
{
Progress = e.ProgressPercentage;
};
worker.RunWorkerCompleted += (o, e) =>
{
if (e.Error != null)
{
ShowError(e.Error.Message);
Status = ProcessingStages.Error;
}
else
{
Status = ProcessingStages.Completed;
Progress = 0;
var imageProcessor = e.Result as ImageProcessor;
cells = imageProcessor.Cells;
RaisePropertyChanged(() => Cells);
RaisePropertyChanged(() => IsBusy);
RaiseCommandsExecute();
}
};
}
void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
Global.Tracer.Assert(condition: false);
}
