/// <summary>
/// Create a new SynchronizeStateEventArgs.
/// </summary>
/// <param name="tree">Tree raising this event. Necessary to allow clients that handle synchronization themeselves to raise events back to the tree.</param>
/// <param name="itemsToSynchronize">Enumerator of items to be synchronized.</param>
/// <param name="matchBranch">Branch whose state should be matched.</param>
/// <param name="matchRow">Row whose state should be matched.</param>
/// <param name="matchColumn">Column whose state should be matched.</param>
public SynchronizeStateEventArgs(
ITree tree, ColumnItemEnumerator itemsToSynchronize, IBranch matchBranch, int matchRow, int matchColumn)
{
Handled = false;
myItemsToSynchronize = itemsToSynchronize;
myMatchBranch = matchBranch;
myMatchRow = matchRow;
myMatchColumn = matchColumn;
myTree = tree as VirtualTree;
}
internal PositionManagerEventArgs(VirtualTree owningTree)
{
myMultiColumnTree = (null != (owningTree as IMultiColumnTree)) ? owningTree : null;
myTable = new Hashtable();
}
private static TREENODE CreateTreeNode(
TREENODE startNode, IBranch branch, VirtualTree tree, bool allowMultiColumn, bool inSubItemColumn, bool multiColumnParent)
{
Debug.Assert(startNode == null || (startNode.Branch == null && startNode.GetType() == typeof(TREENODE_Complex)));
BranchFeatures tf;
TREENODE retVal;
tf = branch.Features;
var isDynamic = TREENODE.RequireDynamic(tf);
var supportMultiColumn = tree.MultiColumnSupport;
allowMultiColumn &= supportMultiColumn;
var isMultiColumn = false;
if (allowMultiColumn)
{
var mcTest = branch as IMultiColumnBranch;
// Checking the column count allows a single wrapper class to
// support either single or multicolumn branches
isMultiColumn = mcTest != null && mcTest.ColumnCount > 1;
}
if (isDynamic)
{
if (TREENODE.RequireUpdatable(tf))
{
retVal = isMultiColumn
? new TREENODE_Multi_Tracked_Updatable()
: (supportMultiColumn
? (multiColumnParent
? (new TREENODE_Complex_Tracked_Updatable()) as TREENODE
: new TREENODE_Single_Tracked_Updatable())
: new TREENODE_Tracked_Updatable());
}
else
{
retVal = isMultiColumn
? new TREENODE_Multi_Tracked()
: (supportMultiColumn
? (multiColumnParent
? (new TREENODE_Complex_Tracked()) as TREENODE
: new TREENODE_Single_Tracked())
: new TREENODE_Tracked());
}
}
else if (TREENODE.RequireUpdatable(tf))
{
retVal = isMultiColumn
? new TREENODE_Multi_Updatable()
: (supportMultiColumn
? (multiColumnParent
? (new TREENODE_Complex_Updatable()) as TREENODE
: new TREENODE_Single_Updatable())
: new TREENODE_Updatable());
}
else
{
retVal = isMultiColumn
? new TREENODE_Multi()
: (supportMultiColumn
? (multiColumnParent
? ((startNode == null) ? new TREENODE_Complex() : startNode)
: new TREENODE_Single())
: new TREENODE());
}
retVal.Branch = branch;
retVal.SetFlags(tf);
retVal.MultiColumn = isMultiColumn;
retVal.AllowMultiColumnChildren = allowMultiColumn;
retVal.InSubItemColumn = inSubItemColumn;
if (retVal.CallUpdate)
{
retVal.UpdateCounter = branch.UpdateCounter;
}
branch.OnBranchModification += tree.OnBranchModification;
if (startNode != null
&& startNode != retVal)
{
var subItem = startNode.FirstSubItem;
retVal.FirstSubItem = subItem;
retVal.ImmedSubItemGain = startNode.ImmedSubItemGain;
retVal.FullSubItemGain = startNode.FullSubItemGain;
while (subItem != null)
{
subItem.RootNode.Parent = retVal;
subItem = subItem.NextSibling;
}
TREENODE tnPrev = null;
var tnTest = startNode.Parent.FirstChild;
while (tnTest != startNode)
{
tnPrev = tnTest;
tnTest = tnTest.NextSibling;
}
if (tnPrev == null)
{
startNode.Parent.FirstChild = retVal;
retVal.NextSibling = startNode.NextSibling;
}
else
{
tnPrev.NextSibling = retVal;
retVal.NextSibling = startNode.NextSibling;
}
}
return retVal;
}
/// <summary>
/// Create a single column view on the parent tree
/// </summary>
/// <param name="parent">The parent tree object</param>
public SingleColumnView(VirtualTree parent)
{
myParent = parent;
}
public void QueryReattachObjects(
VirtualTree tree, TREENODE tnStartParent, int maxLevels, out int changeCount, out int subItemChangeCount)
{
// Return the ChangeCount wrt/tnParent
NODEPOSITIONTRACKER_Dynamic nptPrev = null;
var nptNext = this;
NODEPOSITIONTRACKER_Dynamic nptCur;
//TREENODE tnLastChildPrimary = null;
TREENODE tnLastChildSecondary;
int level;
int attachIndex;
int expansionCount;
TrackingObjectAction action;
TREENODE tnCurParent;
TREENODE tnNextParent;
changeCount = 0;
subItemChangeCount = 0;
while ((nptCur = nptNext) != null)
{
// Grab the next up front
nptNext = (NODEPOSITIONTRACKER_Dynamic)nptCur.myNextSibling;
// Walk the parents to see where this goes
for (level = 0, tnCurParent = tnStartParent; level <= maxLevels; ++level)
{
if (tnCurParent.NoTracking)
{
// Move along, reattach failed
nptPrev = nptCur;
break;
}
else
{
var locateData = tnCurParent.Branch.LocateObject(nptCur.myTrackerObject, ObjectStyle.TrackingObject, 0);
attachIndex = locateData.Row;
action = (TrackingObjectAction)locateData.Options;
// Protect against inconsistent data from clients
if (attachIndex == -1)
{
action = TrackingObjectAction.NotTracked;
}
switch (action)
{
case TrackingObjectAction.ThisLevel:
// Detach from the list of nodes to insert
if (nptPrev != null)
{
nptPrev.myNextSibling = nptNext;
}
nptCur.myNextSibling = tnCurParent.FirstPositionTracker;
tnCurParent.FirstPositionTracker = nptCur;
nptCur.myParentNode = tnCurParent;
// Easy to break out, just pretend we're at the last level and move on.
level = maxLevels;
break;
case TrackingObjectAction.NextLevel:
tnLastChildSecondary = null;
tnNextParent = FindIndexedNode(attachIndex, tnCurParent.FirstChild, ref tnLastChildSecondary);
if (tnNextParent != null)
{
if (!tnNextParent.Expanded)
{
tnNextParent.Expanded = true;
changeCount += tnNextParent.FullCount;
subItemChangeCount += tnNextParent.ExpandedSubItemGain;
// UNDONE_MC: Is ExpandedSubItemGain correct?
tree.ChangeFullCountRecursive(
tnCurParent, tnNextParent.FullCount, tnNextParent.ExpandedSubItemGain, tnStartParent);
}
}
else
{
int subItemIncr;
// UNDONE_MC: Need a column
tnNextParent = tree.ExpandTreeNode(
tnCurParent, null, attachIndex, COLUMN_ZERO, false, out expansionCount, out subItemIncr);
changeCount += tnNextParent.FullCount;
subItemChangeCount += subItemIncr;
tree.ChangeFullCountRecursive(tnCurParent, tnNextParent.FullCount, subItemIncr, tnStartParent);
InsertIndexedNode(tnCurParent, tnNextParent, ref tnLastChildSecondary);
}
tnCurParent = tnNextParent;
break;
case TrackingObjectAction.NotTracked:
case TrackingObjectAction.NotTrackedReturnParent:
// Break out
nptPrev = nptCur;
level = maxLevels;
break;
}
}
}
}
}
public ColumnItemEnumeratorSingleColumnImpl(VirtualTree tree, int[] rowFilter, bool markExcludedFilterItems)
:
base(0, null, false, rowFilter, markExcludedFilterItems)
{
myTree = tree;
}
public ColumnItemEnumeratorSingleColumnImpl(VirtualTree tree, int startRow, int endRow)
:
base(0, null, false, startRow, endRow, (tree as ITree).VisibleItemCount)
{
myTree = tree;
}
public ColumnItemEnumeratorImpl(
VirtualTree tree, int column, ColumnPermutation columnPermutation, bool returnBlankAnchors, int[] rowFilter,
bool markExcludedFilterItems)
:
base(column, columnPermutation, returnBlankAnchors, rowFilter, markExcludedFilterItems)
{
myTree = tree;
}
public ColumnItemEnumeratorImpl(
VirtualTree tree, int column, ColumnPermutation columnPermutation, bool returnBlankAnchors, int startRow, int endRow)
:
base(column, columnPermutation, returnBlankAnchors, startRow, endRow, (tree as ITree).VisibleItemCount)
{
myTree = tree;
}