static void AddClientDiffs(
TreeViewItem parentItem,
ITreeViewNode parentNode,
List <TreeViewItem> rows,
TreeViewItemIds <IDiffCategory, ITreeViewNode> treeViewItemIds)
{
for (int i = 0; i < parentNode.GetChildrenCount(); i++)
{
ITreeViewNode child = parentNode.GetChild(i);
int nodeId;
if (!treeViewItemIds.TryGetInfoItemId(child, out nodeId))
{
nodeId = treeViewItemIds.AddInfoItem(child);
}
TreeViewItem changeTreeViewItem =
new ClientDiffTreeViewItem(
nodeId,
parentItem.depth + 1,
(ClientDiffInfo)child);
parentItem.AddChild(changeTreeViewItem);
rows.Add(changeTreeViewItem);
}
}
static ClientDiffInfo FindClientDiffOfType(
string path,
ChangeCategoryType type,
ITreeViewNode node)
{
if (node is ClientDiffInfo)
{
ClientDiffInfo clientDiffInfo = (ClientDiffInfo)node;
ChangeCategory category = (ChangeCategory)node.GetParent();
if (category.Type == type &&
clientDiffInfo.DiffWithMount.Difference.Path == path)
{
return((ClientDiffInfo)node);
}
}
for (int i = 0; i < node.GetChildrenCount(); i++)
{
ClientDiffInfo result = FindClientDiffOfType(path, type, node.GetChild(i));
if (result != null)
{
return(result);
}
}
return(null);
}
public void AddChildAtLocation(ITreeViewNode item, int index)
{
// TODO: new list type that contains a method for this?
lock (this.Items)
{
this.Items.Insert(index, item);
}
}
public TreeViewNode(ITreeViewNode parent)
{
this.Text = string.Format("ID{0}", num++);
baseText = this.Text;
this.Children = new ObservableCollection<ITreeViewNode>();
this.Parent = parent;
this.IsExpanded = true;
}
public void AddChild(ITreeViewNode item)
{
this.RegisterNodes(item);
// TODO: new list type that contains a method for this?
lock (this.Items)
{
this.Items.Add(item);
}
}
static void AddClientDiffInfos(ITreeViewNode node, List <ClientDiffInfo> result)
{
if (node is ClientDiffInfo)
{
result.Add((ClientDiffInfo)node);
return;
}
for (int i = 0; i < node.GetChildrenCount(); i++)
{
AddClientDiffInfos(node.GetChild(i), result);
}
}
internal static MergeCategory GetMergeCategory(ClientDiffInfo diff)
{
ChangeCategory changeCategory = GetChangeCategory(diff);
ITreeViewNode mergeCategory = changeCategory.GetParent();
if (mergeCategory == null)
{
return(null);
}
return((MergeCategory)mergeCategory);
}
public override void OnBindViewHolder(TreeView.NodeViewHolder viewHolder, int position)
{
ITreeViewNode node = Nodes[position];
var holder = viewHolder as NodeViewHolder;
if (node is TreeViewNode)
{
holder.TreeContainer.Visibility = (node as TreeViewNode).Collapsed ? ViewStates.Gone : ViewStates.Visible;
}
if (holder.TextView != null)
{
holder.TextView.Text = $"{holder.Level}, {position}, {node.Id}";
}
}
public override void OnBindViewHolder(TreeView.LeafViewHolder viewHolder, int position)
{
ITreeViewNode node = Nodes[position];
var holder = viewHolder as LeafViewHolder;
holder.ItemView.SetBackgroundColor(Color.Green);
if (node is TreeViewNode)
{
(node as TreeViewNode).Collapsed = false;
}
if (holder.TextView != null)
{
holder.TextView.Text = $"{holder.Level}, {position}, {node.Id}";
}
}
static void ExtractToMetaCache(
ITreeViewNode node,
int nodeIndex,
Dictionary <string, ClientDiffInfo> cache,
HashSet <string> indexedKeys)
{
if (node is ClientDiffInfo)
{
ClientDiffInfo diff = (ClientDiffInfo)node;
string path = diff.DiffWithMount.Difference.Path;
if (!MetaPath.IsMetaPath(path))
{
return;
}
string realPath = MetaPath.GetPathFromMetaPath(path);
if (!indexedKeys.Contains(BuildKey.BuildCacheKey(
BuildKey.GetMergeCategory(diff),
BuildKey.GetChangeCategory(diff),
realPath)))
{
return;
}
// found foo.c and foo.c.meta
// with the same chage types - move .meta to cache
cache.Add(BuildKey.ForDiff(diff), diff);
((ChangeCategory)node.GetParent()).RemoveDiffAt(nodeIndex);
}
for (int i = node.GetChildrenCount() - 1; i >= 0; i--)
{
ExtractToMetaCache(
node.GetChild(i),
i,
cache,
indexedKeys);
}
}
public TreeViewNode(ITreeViewNode parent, int customNumber)
{
this.Text = string.Format("{0} - ID{1}", parent != null ? parent.Text : "Root", num++);
baseText = this.Text;
this.Children = new ObservableCollection<ITreeViewNode>();
this.Parent = parent;
this.IsExpanded = true;
writable = readonlyy;
readonlyy = false;
for (int i = 0; i < customNumber; ++i)
{
if (this.writable)
{
this.AddChild(new TreeViewNode(this, 1));
}
this.AddChild(new TreeViewNode(this));
// these are not aware of the tree to get the event hookup
}
}
private void CollapseNode(ITreeViewNode item)
{
if (item.Children.Any())
{
// TODO: new list type that contains a method for this?
lock (this.Items)
{
foreach (ITreeViewNode child in item.Children)
{
// TODO: look into a more efficient implementation
this.Items.Remove(child);
}
}
}
}
private void RegisterNodes(ITreeViewNode node)
{
node.ExpansionStateUpdated += this.OnStateUpdated;
node.ChildAdded += this.OnNodeChildAdded;
node.LocationUpdate += this.OnNodeLocationUpdated;
foreach (ITreeViewNode child in node.Children)
{
this.RegisterNodes(child);
}
}
public void UpdateParent(ITreeViewNode parent)
{
this.Text = baseText + " " + this.UpdateTest + " Updating to parent " + (parent == null ? "null" : parent.Text);
this.Parent = parent;
this.OnPropertyChanged("HierarchyLevel");
}
public void AddChild(ITreeViewNode child)
{
this.Children.Add(child);
if (this.ChildAdded != null)
{
this.ChildAdded(this, new TreeNodeEventArgs(child));
}
}
public TreeNodeEventArgs(ITreeViewNode node)
{
this.Node = node;
}
private void ExpandNode(ITreeViewNode item)
{
if (item.Children.Any())
{
int location = Items.IndexOf(item);
// TODO: new list type that contains a method for this?
lock (this.Items)
{
foreach (ITreeViewNode child in item.Children)
{
this.Items.Insert(++location, child);
}
}
}
}
