private void treeView_BeforeSelect(object sender, TreeViewCancelEventArgs e)
{
if (e.Node is TreeNodeLocalItem)
{
TreeNodeLocalItem treeNodeServerFolder = (TreeNodeLocalItem)e.Node;
treeView.BeginUpdate();
if (ModifierKeys.HasFlag(Keys.Shift))
{
SetExistingNodeSelection(treeNodeServerFolder, ModifierKeys.HasFlag(Keys.Control));
TreeNodeLocalItem prevItem = treeNodeServerFolder.PrevVisibleNode as TreeNodeLocalItem;
while (prevItem != null && !prevItem.IsMultiSelect)
{
SetExistingNodeSelection(prevItem, ModifierKeys.HasFlag(Keys.Control));
prevItem = prevItem.PrevVisibleNode as TreeNodeLocalItem;
}
}
else
{
if (!ModifierKeys.HasFlag(Keys.Control))
{
ClearExistingNodeSelection(new string[] { treeNodeServerFolder.LocalItem });
}
SetExistingNodeSelection(treeNodeServerFolder, ModifierKeys.HasFlag(Keys.Control));
}
treeView.EndUpdate();
e.Cancel = true;
this.m_lastSelectedPath = treeNodeServerFolder.LocalItem;
if (LastSelectedServerItemChanged != null)
{
LastSelectedServerItemChanged(this, new EventArgs());
}
}
}
private void Reset()
{
backgroundWorker.CancelAsync();
m_toExpand.Clear();
treeView.BeginUpdate();
treeView.Nodes.Clear();
TreeNodeLocalItem root = AttachTreeNode(null, m_workspace != null ? m_workspace.Name : "wat?", new TempItemSet.TempItem());
treeView.SelectedNode = root;
if (m_workspace != null)
{
var roots = WorkingFolder.GetWorkspaceRoots(m_workspace.Folders);
List <ItemSpec> specs = new List <ItemSpec>();
foreach (string s in roots)
{
specs.Add(new ItemSpec(s, RecursionType.None));
}
var items = m_workspace.GetExtendedItems(specs.ToArray(), DeletedState.Any, ItemType.Folder);
foreach (var i in items)
{
foreach (var j in i)
{
AttachTreeNode(root, j.LocalItem, new TempItemSet.TempItem {
LocalPath = j.LocalItem, ServerItem = j
});
}
}
}
treeView.EndUpdate();
}
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();
TreeNodeLocalItem treeNodeServerFolder = null;
foreach (TempItemSet itemSet in itemSets)
{
if (itemSet.QueryPath != null)
{
if (treeNodeServerFolder != null && !FileSpec.IsSubItem(itemSet.QueryPath, treeNodeServerFolder.LocalItem))
{
treeNodeServerFolder = null;
}
TreeNodeLocalItem treeNodeServerFolder2;
if (TryFindNodeByServerItem(itemSet.QueryPath, treeNodeServerFolder, out treeNodeServerFolder2) && NodeNeedsExpansion(treeNodeServerFolder2))
{
treeNodeServerFolder2.Nodes.Clear();
foreach (TempItemSet.TempItem i in itemSet.Items)
{
AttachTreeNode(treeNodeServerFolder2, Path.GetFileName(i.LocalPath), i);
}
if (!treeNodeServerFolder2.IsExpanded && m_navigateToWhenLoaded == null)
{
treeNodeServerFolder2.Expand();
}
treeNodeServerFolder = treeNodeServerFolder2;
}
}
}
if (m_navigateToWhenLoaded != null)
{
TreeNodeLocalItem treeNodeServerFolder3;
TryFindNodeByServerItem(m_navigateToWhenLoaded, null, out treeNodeServerFolder3);
if (treeNodeServerFolder3 != null)
{
treeNodeServerFolder3.EnsureVisible();
treeView.SelectedNode = treeNodeServerFolder3;
}
m_navigateToWhenLoaded = null;
}
treeView.EndUpdate();
}
}
private TreeNodeLocalItem AttachTreeNode(TreeNode parent, string name, TempItemSet.TempItem item)
{
TreeNodeLocalItem node;
if (parent == null)
{
//the root
node = new TreeNodeLocalItem("", name);
}
else
{
if (item.ServerItem != null)
{
if (item.ServerItem.ItemType == ItemType.Folder)
{
node = new TreeNodeLocalItem(item.ServerItem, name);
node.Nodes.Add(new TreeNodeWorking());
}
else if (item.ServerItem.ItemType == ItemType.File)
{
node = new TreeNodeLocalItem(item.ServerItem, name);
}
else
{
return(null);
}
}
else
{
node = new TreeNodeLocalItem(item.LocalPath, name);
if (Directory.Exists(item.LocalPath))
{
node.Nodes.Add(new TreeNodeWorking());
}
}
if (m_selectedItems.ContainsKey(node.LocalItem))
{
node.ColorSelected();
m_selectedItems[node.LocalItem] = node;
}
}
if (parent != null)
{
parent.Nodes.Add(node);
}
else
{
treeView.Nodes.Add(node);
}
return(node);
}
private void treeView_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
if (e.Node is TreeNodeLocalItem)
{
TreeNodeLocalItem treeNodeServerFolder = (TreeNodeLocalItem)e.Node;
if (NodeNeedsExpansion(e.Node))
{
m_toExpand.Add(treeNodeServerFolder.LocalItem);
StartBackgroundWorkerIfNeeded();
e.Cancel = true;
}
}
}
void PurgeSelectionReferences(TreeNodeLocalItem root)
{
if (root.IsMultiSelect)
{
m_selectedItems[root.LocalItem] = null;
}
foreach (TreeNode n in root.Nodes)
{
if (n is TreeNodeLocalItem)
{
PurgeSelectionReferences((TreeNodeLocalItem)n);
}
}
}
private void SetExistingNodeSelection(TreeNodeLocalItem treeNodeServerFolder, bool toggle)
{
if (m_selectedItems.ContainsKey(treeNodeServerFolder.LocalItem))
{
if (toggle)
{
treeNodeServerFolder.ColorUnselected();
m_selectedItems.Remove(treeNodeServerFolder.LocalItem);
}
}
else
{
treeNodeServerFolder.ColorSelected();
m_selectedItems.Add(treeNodeServerFolder.LocalItem, treeNodeServerFolder);
}
}
public void Navigate(string initialPath)
{
if (initialPath != null && initialPath.Trim().Length > 0)
{
initialPath = FileSpec.GetFullPath(initialPath);
TreeNodeLocalItem foundItem = null;
if (TryFindNodeByServerItem(initialPath, null, out foundItem))
{
foundItem.EnsureVisible();
m_navigateToWhenLoaded = null;
return;
}
var roots = WorkingFolder.GetWorkspaceRoots(m_workspace.Folders);
foreach (String root in roots)
{
if (FileSpec.IsSubItem(initialPath, root))
{
string[] folders = initialPath.Substring(root.Length + 1).Split('\\');
string curPath = root;
string prevPath = root;
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();
break;
}
}
}
}
private int BinarySearchForNextNode(TreeNodeLocalItem node, string serverItem)
{
int num = node.LocalItem.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);
TreeNodeLocalItem treeNodeServerFolder = (TreeNodeLocalItem)node.Nodes[num5];
int num6 = treeNodeServerFolder.LocalItem.IndexOf('\\', num);
int num7 = ((num6 < 0) ? treeNodeServerFolder.LocalItem.Length : num6) - num;
int num8 = string.Compare(treeNodeServerFolder.LocalItem, 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);
}
private bool TryFindNodeByServerItem(string serverItem, TreeNodeLocalItem startNode, out TreeNodeLocalItem foundNode)
{
foundNode = null;
if (treeView.Nodes.Count == 0 || !(treeView.Nodes[0] is TreeNodeLocalItem))
{
return(false);
}
if (startNode == null)
{
TreeNodeLocalItem rootNode = (TreeNodeLocalItem)treeView.Nodes[0];
foreach (TreeNode node in rootNode.Nodes)
{
if (TryFindNodeByServerItem(serverItem, (TreeNodeLocalItem)node, out foundNode))
{
return(true);
}
}
return(false);
}
else
{
foundNode = startNode;
}
while (foundNode.LocalItem.Length < serverItem.Length)
{
if (this.NodeNeedsExpansion(foundNode))
{
return(false);
}
int num = BinarySearchForNextNode(foundNode, serverItem);
if (num < 0)
{
return(false);
}
foundNode = (TreeNodeLocalItem)foundNode.Nodes[num];
}
return(true);
}
private void treeView_DrawNode(object sender, DrawTreeNodeEventArgs e)
{
TreeNodeLocalItem titem = e.Node as TreeNodeLocalItem;
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;
var imageSize = treeView.ImageList.ImageSize;
drawLoc.X -= imageSize.Width;
using (SolidBrush b = new SolidBrush(titem.BackColor))
{
e.Graphics.FillRectangle(b, drawLoc.X, drawLoc.Y, titem.Bounds.Width + 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);
ExtendedItem item = titem.ExItem;
if (string.IsNullOrEmpty(titem.LocalItem))
{
e.Graphics.DrawIcon(TFV.Properties.Resources.TFSServer, new Rectangle(drawLoc, imageSize));
}
else
{
bool isFolder = false;
if (item != null)
{
isFolder = item.ItemType == ItemType.Folder;
}
else
{
isFolder = Directory.Exists(titem.LocalItem);
}
if (isFolder)
{
e.Graphics.DrawIcon(titem.IsExpanded ? m_folderOpen : m_folderClosed, new Rectangle(drawLoc, imageSize));
}
else
{
e.Graphics.DrawIcon((item != null) ? m_addedFileIcon : m_fileIcon, new Rectangle(drawLoc, imageSize));
}
}
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);
}
}
}
}
