private bool TryFindNodeByServerItem(string serverItem, TreeNodeServerItem startNode, out TreeNodeServerItem foundNode)
{
foundNode = null;
if (treeView.Nodes.Count == 0 || !(treeView.Nodes[0] is TreeNodeServerItem))
{
return(false);
}
if (startNode == null)
{
foundNode = (TreeNodeServerItem)treeView.Nodes[0];
}
else
{
foundNode = startNode;
}
while (foundNode.ServerItem.Length < serverItem.Length)
{
if (this.NodeNeedsExpansion(foundNode))
{
return(false);
}
int num = BinarySearchForNextNode(foundNode, serverItem);
if (num < 0)
{
return(false);
}
foundNode = (TreeNodeServerItem)foundNode.Nodes[num];
}
return(true);
}
private void treeView_BeforeSelect(object sender, TreeViewCancelEventArgs e)
{
if (e.Node is TreeNodeServerItem)
{
TreeNodeServerItem treeNodeServerFolder = (TreeNodeServerItem)e.Node;
treeView.BeginUpdate();
if (ModifierKeys.HasFlag(Keys.Shift))
{
SetExistingNodeSelection(treeNodeServerFolder, ModifierKeys.HasFlag(Keys.Control));
TreeNodeServerItem prevItem = treeNodeServerFolder.PrevVisibleNode as TreeNodeServerItem;
while (prevItem != null && !prevItem.IsMultiSelect)
{
SetExistingNodeSelection(prevItem, ModifierKeys.HasFlag(Keys.Control));
prevItem = prevItem.PrevVisibleNode as TreeNodeServerItem;
}
}
else
{
if (!ModifierKeys.HasFlag(Keys.Control))
{
ClearExistingNodeSelection(new string[] { treeNodeServerFolder.ServerItem });
}
SetExistingNodeSelection(treeNodeServerFolder, ModifierKeys.HasFlag(Keys.Control));
}
treeView.EndUpdate();
e.Cancel = true;
this.m_lastSelectedPath = treeNodeServerFolder.ServerItem;
if (LastSelectedServerItemChanged != null)
{
LastSelectedServerItemChanged(this, new EventArgs());
}
}
}
private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (BackgroundWorkEnded != null)
{
BackgroundWorkEnded(this, EventArgs.Empty);
}
if (e.Cancelled)
{
return;
}
TempItemSet[] itemSets = e.Result as TempItemSet[];
if (itemSets != null)
{
treeView.BeginUpdate();
TreeNodeServerItem treeNodeServerFolder = null;
foreach (TempItemSet itemSet in itemSets)
{
if (itemSet.QueryPath != null)
{
if (treeNodeServerFolder != null && !VersionControlPath.IsSubItem(itemSet.QueryPath, treeNodeServerFolder.ServerItem))
{
treeNodeServerFolder = null;
}
TreeNodeServerItem treeNodeServerFolder2;
if (TryFindNodeByServerItem(itemSet.QueryPath, treeNodeServerFolder, out treeNodeServerFolder2) && NodeNeedsExpansion(treeNodeServerFolder2))
{
treeNodeServerFolder2.Nodes.Clear();
foreach (ExtendedItem i in itemSet.Items)
{
AttachTreeNode(treeNodeServerFolder2, i);
}
if (!treeNodeServerFolder2.IsExpanded && m_navigateToWhenLoaded == null)
{
treeNodeServerFolder2.Expand();
}
treeNodeServerFolder = treeNodeServerFolder2;
}
}
}
if (m_navigateToWhenLoaded != null)
{
TreeNodeServerItem treeNodeServerFolder3;
TryFindNodeByServerItem(m_navigateToWhenLoaded, null, out treeNodeServerFolder3);
if (treeNodeServerFolder3 != null)
{
treeNodeServerFolder3.EnsureVisible();
treeView.SelectedNode = treeNodeServerFolder3;
}
m_navigateToWhenLoaded = null;
}
treeView.EndUpdate();
}
}
private void treeView_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
if (e.Node is TreeNodeServerItem)
{
TreeNodeServerItem treeNodeServerFolder = (TreeNodeServerItem)e.Node;
if (NodeNeedsExpansion(e.Node))
{
m_toExpand.Add(treeNodeServerFolder.ServerItem);
StartBackgroundWorkerIfNeeded();
e.Cancel = true;
}
}
}
void PurgeSelectionReferences(TreeNodeServerItem root)
{
if (root.IsMultiSelect)
{
m_selectedItems[root.ServerItem] = null;
}
foreach (TreeNode n in root.Nodes)
{
if (n is TreeNodeServerItem)
{
PurgeSelectionReferences((TreeNodeServerItem)n);
}
}
}
private void SetExistingNodeSelection(TreeNodeServerItem treeNodeServerFolder, bool toggle)
{
if (m_selectedItems.ContainsKey(treeNodeServerFolder.ServerItem))
{
if (toggle)
{
treeNodeServerFolder.ColorUnselected();
m_selectedItems.Remove(treeNodeServerFolder.ServerItem);
}
}
else
{
treeNodeServerFolder.ColorSelected();
m_selectedItems.Add(treeNodeServerFolder.ServerItem, treeNodeServerFolder);
}
}
private int BinarySearchForNextNode(TreeNodeServerItem node, string serverItem)
{
int num = node.ServerItem.Length;
if (serverItem[num] == '/')
{
num++;
}
int num2 = serverItem.IndexOf('/', num);
int num3 = ((num2 < 0) ? serverItem.Length : num2) - num;
int i = 0;
int num4 = node.Nodes.Count - 1;
while (i <= num4)
{
int num5 = i + (num4 - i >> 1);
TreeNodeServerItem treeNodeServerFolder = (TreeNodeServerItem)node.Nodes[num5];
int num6 = treeNodeServerFolder.ServerItem.IndexOf('/', num);
int num7 = ((num6 < 0) ? treeNodeServerFolder.ServerItem.Length : num6) - num;
int num8 = string.Compare(treeNodeServerFolder.ServerItem, num, serverItem, num, Math.Min(num3, num7), StringComparison.OrdinalIgnoreCase);
if (num8 == 0)
{
if (num3 == num7)
{
return(num5);
}
num8 = num7 - num3;
}
if (num8 < 0)
{
i = num5 + 1;
}
else
{
num4 = num5 - 1;
}
}
return(~i);
}
public void Navigate(string initialPath)
{
if (initialPath != null && initialPath.StartsWith("$/") && initialPath.Length > 2)
{
initialPath = VersionControlPath.GetFullPath(initialPath);
TreeNodeServerItem foundItem = null;
if (TryFindNodeByServerItem(initialPath, null, out foundItem))
{
foundItem.EnsureVisible();
m_navigateToWhenLoaded = null;
return;
}
string[] folders = initialPath.Substring(2).Split('/');
string curPath = "$/";
string prevPath = curPath;
foundItem = null;
m_navigateToWhenLoaded = null;
for (int i = 0; i < folders.Length; i++)
{
prevPath = curPath;
curPath = curPath + "/" + folders[i];
if (TryFindNodeByServerItem(curPath, foundItem, out foundItem))
{
foundItem.EnsureVisible();
}
else
{
m_toExpand.Add(prevPath);
m_navigateToWhenLoaded = initialPath;
}
}
StartBackgroundWorkerIfNeeded();
}
}
private void treeView_DrawNode(object sender, DrawTreeNodeEventArgs e)
{
TreeNodeServerItem titem = e.Node as TreeNodeServerItem;
if (titem != null)
{
VisualStyleElement element = VisualStyleElement.TreeView.Item.Normal;
if (e.State.HasFlag(TreeNodeStates.Selected) || titem.IsMultiSelect)
{
element = e.Node.TreeView.Focused ? VisualStyleElement.TreeView.Item.Selected : VisualStyleElement.TreeView.Item.SelectedNotFocus;
}
else if (e.State.HasFlag(TreeNodeStates.Hot))
{
element = VisualStyleElement.TreeView.Item.Hot;
}
VisualStyleRenderer vsr = new VisualStyleRenderer("Explorer::TreeView", element.Part, element.State);
Point drawLoc = titem.Bounds.Location;
drawLoc.X -= imageListIcons.ImageSize.Width;
using (SolidBrush b = new SolidBrush(titem.BackColor))
{
e.Graphics.FillRectangle(b, drawLoc.X, drawLoc.Y, titem.Bounds.Width + imageListIcons.ImageSize.Width, titem.Bounds.Height);
}
Rectangle textRect = vsr.GetBackgroundContentRectangle(e.Graphics, titem.Bounds);
var pixelSize = DpiHelper.LogicalToDeviceUnits(new Size(1, 1));
textRect.Offset(pixelSize.Width, pixelSize.Height);
bool disabled = titem.ExItem != null ? !titem.ExItem.IsInWorkspace : false;
vsr.DrawText(e.Graphics, textRect, titem.Text, disabled, TextFormatFlags.VerticalCenter | TextFormatFlags.LeftAndRightPadding);
imageListIcons.Draw(e.Graphics, drawLoc, titem.IsExpanded ? titem.ExpandedImageIndex : titem.CollapsedImageIndex);
ExtendedItem item = titem.ExItem;
if (item != null)
{
if (item.ChangeType.HasFlag(ChangeType.Add))
{
imageListOverlays.Draw(e.Graphics, drawLoc, 0);
}
else if (item.ChangeType.HasFlag(ChangeType.Delete))
{
imageListOverlays.Draw(e.Graphics, drawLoc, 3);
}
else if (item.ChangeType.HasFlag(ChangeType.Rollback))
{
imageListOverlays.Draw(e.Graphics, drawLoc, 8);
}
else if (item.ChangeType.HasFlag(ChangeType.Merge))
{
imageListOverlays.Draw(e.Graphics, drawLoc, 5);
}
else if (item.ChangeType.HasFlag(ChangeType.Edit))
{
imageListOverlays.Draw(e.Graphics, drawLoc, 2);
}
if (!item.IsLatest && item.IsInWorkspace)
{
imageListOverlays.Draw(e.Graphics, drawLoc, 1);
}
if (item.HasOtherPendingChange)
{
imageListOverlays.Draw(e.Graphics, drawLoc, 7);
}
}
}
}
private TreeNodeServerItem AttachTreeNode(TreeNode parent, ExtendedItem item)
{
TreeNodeServerItem node;
if (item == null)
{
//the root
node = new TreeNodeServerItem(item, m_sourceControl.TeamProjectCollection.Name, 6, 6);
node.Nodes.Add(new TreeNodeWorking());
}
else
{
string fileName = VersionControlPath.GetFileName(item.TargetServerItem);
if (item.IsBranch)
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 2, 2);
}
else
{
node = new TreeNodeServerItem(item, fileName, 1, 1);
}
node.Nodes.Add(new TreeNodeWorking());
}
else if (item.ItemType == ItemType.Folder)
{
if (VersionControlPath.GetFolderDepth(item.TargetServerItem) == 1)
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 3, 3);
}
else
{
node = new TreeNodeServerItem(item, fileName, 7, 7);
}
}
else
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 3, 3);
}
else
{
node = new TreeNodeServerItem(item, fileName, 4, 5);
}
}
node.Nodes.Add(new TreeNodeWorking());
}
else if (item.ItemType == ItemType.File)
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 3, 3);
}
else
{
node = new TreeNodeServerItem(item, fileName, 12, 12);
}
}
else
{
return(null);
}
}
if (parent != null)
{
parent.Nodes.Add(node);
}
else
{
treeView.Nodes.Add(node);
}
if (m_selectedItems.ContainsKey(node.ServerItem))
{
node.ColorSelected();
m_selectedItems[node.ServerItem] = node;
}
return(node);
}
