Merge branch 'master' into enhancements/gitcheckout

StanleyGoldman · web-flow · commit e24a878a77cb · 2018-02-20T10:39:06.000-05:00
diff --git a/src/GitHub.Api/UI/TreeBase.cs b/src/GitHub.Api/UI/TreeBase.cs
@@ -17,7 +17,9 @@ public interface ITreeNode
         string Path { get; set; }
         string Label { get; set; }
         int Level { get; set; }
+        bool IsContainer { get; set; }
         bool IsFolder { get; set; }
+        bool IsFolderOrContainer { get; }
         bool IsCollapsed { get; set; }
         bool IsHidden { get; set; }
         bool IsActive { get; set; }
@@ -52,29 +54,45 @@ public void Load(IEnumerable<TData> treeDatas)
             var isCheckable = IsCheckable;
 
             var isSelected = IsSelectable && selectedNodePath != null && Title == selectedNodePath;
-            AddNode(Title, Title, -1 + displayRootLevel, true, false, false, false, isSelected, false, null);
+            AddNode(Title, Title, -1 + displayRootLevel, true, false, false, false, isSelected, false, null, false);
 
             var hideChildren = false;
             var hideChildrenBelowLevel = 0;
 
             var folders = new HashSet<string>();
 
+            TNode lastAddedNode = null;
             foreach (var treeData in treeDatas)
             {
                 var parts = treeData.Path.Split(new[] { pathSeparator }, StringSplitOptions.None);
-                for (var i = 0; i < parts.Length; i++)
+                for (var level = 0; level < parts.Length; level++)
                 {
-                    var label = parts[i];
-                    var level = i + 1;
-                    var nodePath = String.Join(pathSeparator, parts, 0, level);
-                    var isFolder = i < parts.Length - 1;
+                    var label = parts[level];
+                    var nodePath = String.Join(pathSeparator, parts, 0, level + 1);
+                    var isFolder = level < parts.Length - 1;
+                    var parentIsPromoted = false;
+
+                    if (lastAddedNode != null)
+                    {
+                        if (!lastAddedNode.IsFolder)
+                        {
+                            if (PromoteNode(lastAddedNode, label))
+                            {
+                                Logger.Trace("Promoting Node Label:{0}", lastAddedNode.Label);
+
+                                parentIsPromoted = true;
+                                lastAddedNode.IsContainer = true;
+                            }
+                        }
+                    }
+
                     var alreadyExists = folders.Contains(nodePath);
                     if (!alreadyExists)
                     {
                         var nodeIsHidden = false;
                         if (hideChildren)
                         {
-                            if (level <= hideChildrenBelowLevel)
+                            if (level + 1 <= hideChildrenBelowLevel)
                             {
                                 hideChildren = false;
                             }
@@ -100,7 +118,7 @@ public void Load(IEnumerable<TData> treeDatas)
                                 if (!hideChildren)
                                 {
                                     hideChildren = true;
-                                    hideChildrenBelowLevel = level;
+                                    hideChildrenBelowLevel = level + 1;
                                 }
                             }
                         }
@@ -112,8 +130,9 @@ public void Load(IEnumerable<TData> treeDatas)
                         }
 
                         isSelected = selectedNodePath != null && nodePath == selectedNodePath;
-                        AddNode(nodePath, label, i + displayRootLevel, isFolder, isActive, nodeIsHidden,
-                            nodeIsCollapsed, isSelected, isChecked, treeNodeTreeData);
+
+                        lastAddedNode = AddNode(nodePath, label, level + displayRootLevel + (parentIsPromoted ? 1 : 0), isFolder, isActive, nodeIsHidden,
+                            nodeIsCollapsed, isSelected, isChecked, treeNodeTreeData, false);
                     }
                 }
             }
@@ -124,7 +143,7 @@ public void Load(IEnumerable<TData> treeDatas)
                 for (var index = nodes.Count - 1; index >= 0; index--)
                 {
                     var node = nodes[index];
-                    if (node.Level >= 0 && node.IsFolder)
+                    if (node.Level >= 0 && node.IsFolderOrContainer)
                     {
                         bool? anyChecked = null;
                         bool? allChecked = null;
@@ -150,6 +169,27 @@ public void Load(IEnumerable<TData> treeDatas)
             }
         }
 
+        protected bool PromoteNode(TNode previouslyAddedNode, string nextLabel)
+        {
+            if (!PromoteMetaFiles)
+            {
+                return false;
+            }
+
+            if (previouslyAddedNode == null)
+            {
+                return false;
+            }
+
+            if (!nextLabel.EndsWith(".meta"))
+            {
+                return false;
+            }
+
+            var substring = nextLabel.Substring(0, nextLabel.Length - 5);
+            return previouslyAddedNode.Label == substring;
+        }
+
         public void SetCheckStateOnAll(bool isChecked)
         {
             var nodeCheckState = isChecked ? CheckState.Checked : CheckState.Empty;
@@ -174,9 +214,9 @@ public void SetCheckStateOnAll(bool isChecked)
 
         protected abstract IEnumerable<string> GetCollapsedFolders();
 
-        protected void AddNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isSelected, bool isChecked, TData? treeData)
+        protected TNode AddNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isSelected, bool isChecked, TData? treeData, bool isContainer)
         {
-            var node = CreateTreeNode(path, label, level, isFolder, isActive, isHidden, isCollapsed, isChecked, treeData);
+            var node = CreateTreeNode(path, label, level, isFolder, isActive, isHidden, isCollapsed, isChecked, treeData, isContainer);
 
             SetNodeIcon(node);
             Nodes.Add(node);
@@ -185,6 +225,8 @@ protected void AddNode(string path, string label, int level, bool isFolder, bool
             {
                 SelectedNode = node;
             }
+
+            return node;
         }
 
         protected void Clear()
@@ -198,7 +240,7 @@ protected void Clear()
 
         protected abstract void AddCheckedNode(TNode node);
 
-        protected abstract TNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, TData? treeData);
+        protected abstract TNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, TData? treeData, bool isContainer);
 
         protected abstract void OnClear();
 
@@ -212,7 +254,7 @@ protected void ToggleNodeVisibility(int idx, TNode node)
             for (; idx < Nodes.Count && Nodes[idx].Level > nodeLevel; idx++)
             {
                 Nodes[idx].IsHidden = node.IsCollapsed;
-                if (Nodes[idx].IsFolder && !node.IsCollapsed && Nodes[idx].IsCollapsed)
+                if (Nodes[idx].IsFolderOrContainer && !node.IsCollapsed && Nodes[idx].IsCollapsed)
                 {
                     var level = Nodes[idx].Level;
                     for (idx++; idx < Nodes.Count && Nodes[idx].Level > level; idx++)
@@ -245,11 +287,7 @@ protected void ToggleNodeChecked(int idx, TNode node)
                     break;
             }
 
-            if (node.IsFolder)
-            {
-                ToggleChildrenChecked(idx, node, isChecked);
-            }
-            else
+            if (!node.IsFolder)
             {
                 if (isChecked)
                 {
@@ -261,6 +299,11 @@ protected void ToggleNodeChecked(int idx, TNode node)
                 }
             }
 
+            if (node.IsFolderOrContainer)
+            {
+                ToggleChildrenChecked(idx, node, isChecked);
+            }
+
             ToggleParentFoldersChecked(idx, node, isChecked);
         }
 
@@ -272,11 +315,7 @@ private void ToggleChildrenChecked(int idx, TNode node, bool isChecked)
                 var wasChecked = childNode.CheckState == CheckState.Checked;
                 childNode.CheckState = isChecked ? CheckState.Checked : CheckState.Empty;
 
-                if (childNode.IsFolder)
-                {
-                    ToggleChildrenChecked(i, childNode, isChecked);
-                }
-                else
+                if (!childNode.IsFolder)
                 {
                     if (isChecked && !wasChecked)
                     {
@@ -287,6 +326,11 @@ private void ToggleChildrenChecked(int idx, TNode node, bool isChecked)
                         RemoveCheckedNode(childNode);
                     }
                 }
+
+                if (childNode.IsFolderOrContainer)
+                {
+                    ToggleChildrenChecked(i, childNode, isChecked);
+                }
             }
         }
 
@@ -394,5 +438,6 @@ private void ToggleParentFoldersChecked(int idx, TNode node, bool isChecked)
         public abstract bool IsSelectable { get; set; }
         public abstract bool IsCheckable { get; set; }
         public abstract string PathSeparator { get; set; }
+        protected abstract bool PromoteMetaFiles { get; }
     }
 }
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ChangesTreeControl.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ChangesTreeControl.cs
@@ -82,6 +82,11 @@ public override string PathSeparator
             set { pathSeparator = value; }
         }
 
+        protected override bool PromoteMetaFiles
+        {
+            get { return true; }
+        }
+
         public override ChangesTreeNode SelectedNode
         {
             get
@@ -186,7 +191,7 @@ protected Texture GetNodeIconBadge(ChangesTreeNode node)
             return Styles.GetFileStatusIcon(gitFileStatus, node.IsLocked);
         }
 
-        protected override ChangesTreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitStatusEntryTreeData? treeData)
+        protected override ChangesTreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitStatusEntryTreeData? treeData, bool isContainer)
         {
             var gitStatusEntry = GitStatusEntry.Default;
             var isLocked = false;
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/TreeControl.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/TreeControl.cs
@@ -240,7 +240,7 @@ private bool HandleInput(Rect rect, TNode currentNode, int index, Action<TNode>
                     }
                     else if (directionX > 0)
                     {
-                        if (currentNode.IsFolder && currentNode.IsCollapsed)
+                        if (currentNode.IsFolderOrContainer && currentNode.IsCollapsed)
                         {
                             ToggleNodeVisibility(index, currentNode);
                         }
@@ -251,7 +251,7 @@ private bool HandleInput(Rect rect, TNode currentNode, int index, Action<TNode>
                     }
                     else if (directionX < 0)
                     {
-                        if (currentNode.IsFolder && !currentNode.IsCollapsed)
+                        if (currentNode.IsFolderOrContainer && !currentNode.IsCollapsed)
                         {
                             ToggleNodeVisibility(index, currentNode);
                         }
@@ -274,13 +274,13 @@ private bool HandleInput(Rect rect, TNode currentNode, int index, Action<TNode>
             return requiresRepaint;
         }
 
-        private int SelectNext(int index, bool foldersOnly)
+        private int SelectNext(int index, bool foldersOrContainersOnly)
         {
             for (index++; index < Nodes.Count; index++)
             {
                 if (Nodes[index].IsHidden)
                     continue;
-                if (!Nodes[index].IsFolder && foldersOnly)
+                if (!Nodes[index].IsFolderOrContainer && foldersOrContainersOnly)
                     continue;
                 break;
             }
@@ -296,13 +296,13 @@ private int SelectNext(int index, bool foldersOnly)
             return index;
         }
 
-        private int SelectPrevious(int index, bool foldersOnly)
+        private int SelectPrevious(int index, bool foldersOrContainersOnly)
         {
             for (index--; index >= 0; index--)
             {
                 if (Nodes[index].IsHidden)
                     continue;
-                if (!Nodes[index].IsFolder && foldersOnly)
+                if (!Nodes[index].IsFolderOrContainer && foldersOrContainersOnly)
                     continue;
                 break;
             }
@@ -344,6 +344,7 @@ public class TreeNode : ITreeNode
         public string label;
         public int level;
         public bool isFolder;
+        public bool isContainer;
         public bool isCollapsed;
         public bool isHidden;
         public bool isActive;
@@ -372,12 +373,23 @@ public int Level
             set { level = value; }
         }
 
+        public bool IsContainer
+        {
+            get { return isContainer; }
+            set { isContainer = value; }
+        }
+
         public bool IsFolder
         {
             get { return isFolder; }
             set { isFolder = value; }
         }
 
+        public bool IsFolderOrContainer
+        {
+            get { return IsFolder || IsContainer; }
+        }
+
         public bool IsCollapsed
         {
             get { return isCollapsed; }
@@ -459,7 +471,7 @@ public TreeNodeRenderResult Render(Rect rect, float indentation, bool isSelected
             }
 
             var styleOn = false;
-            if (IsFolder)
+            if (IsFolderOrContainer)
             {
                 styleOn = !IsCollapsed;
 
@@ -577,6 +589,11 @@ public override string PathSeparator
             set { pathSeparator = value; }
         }
 
+        protected override bool PromoteMetaFiles
+        {
+            get { return false; }
+        }
+
         public override TreeNode SelectedNode
         {
             get
@@ -643,13 +660,14 @@ protected Texture GetNodeIcon(TreeNode node)
             return nodeIcon;
         }
 
-        protected override TreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitBranchTreeData? treeData)
+        protected override TreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitBranchTreeData? treeData, bool isContainer)
         {
             var node = new TreeNode {
                 Path = path,
                 Label = label,
                 Level = level,
                 IsFolder = isFolder,
+                IsContainer = isContainer,
                 IsActive = isActive,
                 IsHidden = isHidden,
                 IsCollapsed = isCollapsed,
diff --git a/src/tests/UnitTests/SetUpFixture.cs b/src/tests/UnitTests/SetUpFixture.cs
@@ -14,8 +14,8 @@ public void SetUp()
             LogHelper.TracingEnabled = true;
 
             LogHelper.LogAdapter = new MultipleLogAdapter(
-                new FileLogAdapter($"..\\{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}-unit-tests.log")
-                //, new ConsoleLogAdapter()
+                new FileLogAdapter($"..\\{DateTime.UtcNow:yyyyMMddHHmmss}-unit-tests.log")
+                , new ConsoleLogAdapter()
             );
         }
     }
diff --git a/src/tests/UnitTests/UI/TreeBaseTests.cs b/src/tests/UnitTests/UI/TreeBaseTests.cs

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,9 @@ public interface ITreeNode`
`17`	`17`	`string Path { get; set; }`
`18`	`18`	`string Label { get; set; }`
`19`	`19`	`int Level { get; set; }`
	`20`	`+ bool IsContainer { get; set; }`
`20`	`21`	`bool IsFolder { get; set; }`
	`22`	`+ bool IsFolderOrContainer { get; }`
`21`	`23`	`bool IsCollapsed { get; set; }`
`22`	`24`	`bool IsHidden { get; set; }`
`23`	`25`	`bool IsActive { get; set; }`
`@@ -52,29 +54,45 @@ public void Load(IEnumerable<TData> treeDatas)`
`52`	`54`	`var isCheckable = IsCheckable;`
`53`	`55`
`54`	`56`	`var isSelected = IsSelectable && selectedNodePath != null && Title == selectedNodePath;`
`55`		`- AddNode(Title, Title, -1 + displayRootLevel, true, false, false, false, isSelected, false, null);`
	`57`	`+ AddNode(Title, Title, -1 + displayRootLevel, true, false, false, false, isSelected, false, null, false);`
`56`	`58`
`57`	`59`	`var hideChildren = false;`
`58`	`60`	`var hideChildrenBelowLevel = 0;`
`59`	`61`
`60`	`62`	`var folders = new HashSet<string>();`
`61`	`63`
	`64`	`+ TNode lastAddedNode = null;`
`62`	`65`	`foreach (var treeData in treeDatas)`
`63`	`66`	`{`
`64`	`67`	`var parts = treeData.Path.Split(new[] { pathSeparator }, StringSplitOptions.None);`
`65`		`- for (var i = 0; i < parts.Length; i++)`
	`68`	`+ for (var level = 0; level < parts.Length; level++)`
`66`	`69`	`{`
`67`		`- var label = parts[i];`
`68`		`- var level = i + 1;`
`69`		`- var nodePath = String.Join(pathSeparator, parts, 0, level);`
`70`		`- var isFolder = i < parts.Length - 1;`
	`70`	`+ var label = parts[level];`
	`71`	`+ var nodePath = String.Join(pathSeparator, parts, 0, level + 1);`
	`72`	`+ var isFolder = level < parts.Length - 1;`
	`73`	`+ var parentIsPromoted = false;`
	`74`	`+`
	`75`	`+ if (lastAddedNode != null)`
	`76`	`+ {`
	`77`	`+ if (!lastAddedNode.IsFolder)`
	`78`	`+ {`
	`79`	`+ if (PromoteNode(lastAddedNode, label))`
	`80`	`+ {`
	`81`	`+ Logger.Trace("Promoting Node Label:{0}", lastAddedNode.Label);`
	`82`	`+`
	`83`	`+ parentIsPromoted = true;`
	`84`	`+ lastAddedNode.IsContainer = true;`
	`85`	`+ }`
	`86`	`+ }`
	`87`	`+ }`
	`88`	`+`
`71`	`89`	`var alreadyExists = folders.Contains(nodePath);`
`72`	`90`	`if (!alreadyExists)`
`73`	`91`	`{`
`74`	`92`	`var nodeIsHidden = false;`
`75`	`93`	`if (hideChildren)`
`76`	`94`	`{`
`77`		`- if (level <= hideChildrenBelowLevel)`
	`95`	`+ if (level + 1 <= hideChildrenBelowLevel)`
`78`	`96`	`{`
`79`	`97`	`hideChildren = false;`
`80`	`98`	`}`
`@@ -100,7 +118,7 @@ public void Load(IEnumerable<TData> treeDatas)`
`100`	`118`	`if (!hideChildren)`
`101`	`119`	`{`
`102`	`120`	`hideChildren = true;`
`103`		`- hideChildrenBelowLevel = level;`
	`121`	`+ hideChildrenBelowLevel = level + 1;`
`104`	`122`	`}`
`105`	`123`	`}`
`106`	`124`	`}`
`@@ -112,8 +130,9 @@ public void Load(IEnumerable<TData> treeDatas)`
`112`	`130`	`}`
`113`	`131`
`114`	`132`	`isSelected = selectedNodePath != null && nodePath == selectedNodePath;`
`115`		`- AddNode(nodePath, label, i + displayRootLevel, isFolder, isActive, nodeIsHidden,`
`116`		`- nodeIsCollapsed, isSelected, isChecked, treeNodeTreeData);`
	`133`	`+`
	`134`	`+ lastAddedNode = AddNode(nodePath, label, level + displayRootLevel + (parentIsPromoted ? 1 : 0), isFolder, isActive, nodeIsHidden,`
	`135`	`+ nodeIsCollapsed, isSelected, isChecked, treeNodeTreeData, false);`
`117`	`136`	`}`
`118`	`137`	`}`
`119`	`138`	`}`
`@@ -124,7 +143,7 @@ public void Load(IEnumerable<TData> treeDatas)`
`124`	`143`	`for (var index = nodes.Count - 1; index >= 0; index--)`
`125`	`144`	`{`
`126`	`145`	`var node = nodes[index];`
`127`		`- if (node.Level >= 0 && node.IsFolder)`
	`146`	`+ if (node.Level >= 0 && node.IsFolderOrContainer)`
`128`	`147`	`{`
`129`	`148`	`bool? anyChecked = null;`
`130`	`149`	`bool? allChecked = null;`
`@@ -150,6 +169,27 @@ public void Load(IEnumerable<TData> treeDatas)`
`150`	`169`	`}`
`151`	`170`	`}`
`152`	`171`
	`172`	`+ protected bool PromoteNode(TNode previouslyAddedNode, string nextLabel)`
	`173`	`+ {`
	`174`	`+ if (!PromoteMetaFiles)`
	`175`	`+ {`
	`176`	`+ return false;`
	`177`	`+ }`
	`178`	`+`
	`179`	`+ if (previouslyAddedNode == null)`
	`180`	`+ {`
	`181`	`+ return false;`
	`182`	`+ }`
	`183`	`+`
	`184`	`+ if (!nextLabel.EndsWith(".meta"))`
	`185`	`+ {`
	`186`	`+ return false;`
	`187`	`+ }`
	`188`	`+`
	`189`	`+ var substring = nextLabel.Substring(0, nextLabel.Length - 5);`
	`190`	`+ return previouslyAddedNode.Label == substring;`
	`191`	`+ }`
	`192`	`+`
`153`	`193`	`public void SetCheckStateOnAll(bool isChecked)`
`154`	`194`	`{`
`155`	`195`	`var nodeCheckState = isChecked ? CheckState.Checked : CheckState.Empty;`
`@@ -174,9 +214,9 @@ public void SetCheckStateOnAll(bool isChecked)`
`174`	`214`
`175`	`215`	`protected abstract IEnumerable<string> GetCollapsedFolders();`
`176`	`216`
`177`		`- protected void AddNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isSelected, bool isChecked, TData? treeData)`
	`217`	`+ protected TNode AddNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isSelected, bool isChecked, TData? treeData, bool isContainer)`
`178`	`218`	`{`
`179`		`- var node = CreateTreeNode(path, label, level, isFolder, isActive, isHidden, isCollapsed, isChecked, treeData);`
	`219`	`+ var node = CreateTreeNode(path, label, level, isFolder, isActive, isHidden, isCollapsed, isChecked, treeData, isContainer);`
`180`	`220`
`181`	`221`	`SetNodeIcon(node);`
`182`	`222`	`Nodes.Add(node);`
`@@ -185,6 +225,8 @@ protected void AddNode(string path, string label, int level, bool isFolder, bool`
`185`	`225`	`{`
`186`	`226`	`SelectedNode = node;`
`187`	`227`	`}`
	`228`	`+`
	`229`	`+ return node;`
`188`	`230`	`}`
`189`	`231`
`190`	`232`	`protected void Clear()`
`@@ -198,7 +240,7 @@ protected void Clear()`
`198`	`240`
`199`	`241`	`protected abstract void AddCheckedNode(TNode node);`
`200`	`242`
`201`		`- protected abstract TNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, TData? treeData);`
	`243`	`+ protected abstract TNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, TData? treeData, bool isContainer);`
`202`	`244`
`203`	`245`	`protected abstract void OnClear();`
`204`	`246`
`@@ -212,7 +254,7 @@ protected void ToggleNodeVisibility(int idx, TNode node)`
`212`	`254`	`for (; idx < Nodes.Count && Nodes[idx].Level > nodeLevel; idx++)`
`213`	`255`	`{`
`214`	`256`	`Nodes[idx].IsHidden = node.IsCollapsed;`
`215`		`- if (Nodes[idx].IsFolder && !node.IsCollapsed && Nodes[idx].IsCollapsed)`
	`257`	`+ if (Nodes[idx].IsFolderOrContainer && !node.IsCollapsed && Nodes[idx].IsCollapsed)`
`216`	`258`	`{`
`217`	`259`	`var level = Nodes[idx].Level;`
`218`	`260`	`for (idx++; idx < Nodes.Count && Nodes[idx].Level > level; idx++)`
`@@ -245,11 +287,7 @@ protected void ToggleNodeChecked(int idx, TNode node)`
`245`	`287`	`break;`
`246`	`288`	`}`
`247`	`289`
`248`		`- if (node.IsFolder)`
`249`		`- {`
`250`		`- ToggleChildrenChecked(idx, node, isChecked);`
`251`		`- }`
`252`		`- else`
	`290`	`+ if (!node.IsFolder)`
`253`	`291`	`{`
`254`	`292`	`if (isChecked)`
`255`	`293`	`{`
`@@ -261,6 +299,11 @@ protected void ToggleNodeChecked(int idx, TNode node)`
`261`	`299`	`}`
`262`	`300`	`}`
`263`	`301`
	`302`	`+ if (node.IsFolderOrContainer)`
	`303`	`+ {`
	`304`	`+ ToggleChildrenChecked(idx, node, isChecked);`
	`305`	`+ }`
	`306`	`+`
`264`	`307`	`ToggleParentFoldersChecked(idx, node, isChecked);`
`265`	`308`	`}`
`266`	`309`
`@@ -272,11 +315,7 @@ private void ToggleChildrenChecked(int idx, TNode node, bool isChecked)`
`272`	`315`	`var wasChecked = childNode.CheckState == CheckState.Checked;`
`273`	`316`	`childNode.CheckState = isChecked ? CheckState.Checked : CheckState.Empty;`
`274`	`317`
`275`		`- if (childNode.IsFolder)`
`276`		`- {`
`277`		`- ToggleChildrenChecked(i, childNode, isChecked);`
`278`		`- }`
`279`		`- else`
	`318`	`+ if (!childNode.IsFolder)`
`280`	`319`	`{`
`281`	`320`	`if (isChecked && !wasChecked)`
`282`	`321`	`{`
`@@ -287,6 +326,11 @@ private void ToggleChildrenChecked(int idx, TNode node, bool isChecked)`
`287`	`326`	`RemoveCheckedNode(childNode);`
`288`	`327`	`}`
`289`	`328`	`}`
	`329`	`+`
	`330`	`+ if (childNode.IsFolderOrContainer)`
	`331`	`+ {`
	`332`	`+ ToggleChildrenChecked(i, childNode, isChecked);`
	`333`	`+ }`
`290`	`334`	`}`
`291`	`335`	`}`
`292`	`336`
`@@ -394,5 +438,6 @@ private void ToggleParentFoldersChecked(int idx, TNode node, bool isChecked)`
`394`	`438`	`public abstract bool IsSelectable { get; set; }`
`395`	`439`	`public abstract bool IsCheckable { get; set; }`
`396`	`440`	`public abstract string PathSeparator { get; set; }`
	`441`	`+ protected abstract bool PromoteMetaFiles { get; }`
`397`	`442`	`}`
`398`	`443`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,11 @@ public override string PathSeparator`
`82`	`82`	`set { pathSeparator = value; }`
`83`	`83`	`}`
`84`	`84`
	`85`	`+ protected override bool PromoteMetaFiles`
	`86`	`+ {`
	`87`	`+ get { return true; }`
	`88`	`+ }`
	`89`	`+`
`85`	`90`	`public override ChangesTreeNode SelectedNode`
`86`	`91`	`{`
`87`	`92`	`get`
`@@ -186,7 +191,7 @@ protected Texture GetNodeIconBadge(ChangesTreeNode node)`
`186`	`191`	`return Styles.GetFileStatusIcon(gitFileStatus, node.IsLocked);`
`187`	`192`	`}`
`188`	`193`
`189`		`- protected override ChangesTreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitStatusEntryTreeData? treeData)`
	`194`	`+ protected override ChangesTreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitStatusEntryTreeData? treeData, bool isContainer)`
`190`	`195`	`{`
`191`	`196`	`var gitStatusEntry = GitStatusEntry.Default;`
`192`	`197`	`var isLocked = false;`
Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ private bool HandleInput(Rect rect, TNode currentNode, int index, Action<TNode>`
`240`	`240`	`}`
`241`	`241`	`else if (directionX > 0)`
`242`	`242`	`{`
`243`		`- if (currentNode.IsFolder && currentNode.IsCollapsed)`
	`243`	`+ if (currentNode.IsFolderOrContainer && currentNode.IsCollapsed)`
`244`	`244`	`{`
`245`	`245`	`ToggleNodeVisibility(index, currentNode);`
`246`	`246`	`}`
`@@ -251,7 +251,7 @@ private bool HandleInput(Rect rect, TNode currentNode, int index, Action<TNode>`
`251`	`251`	`}`
`252`	`252`	`else if (directionX < 0)`
`253`	`253`	`{`
`254`		`- if (currentNode.IsFolder && !currentNode.IsCollapsed)`
	`254`	`+ if (currentNode.IsFolderOrContainer && !currentNode.IsCollapsed)`
`255`	`255`	`{`
`256`	`256`	`ToggleNodeVisibility(index, currentNode);`
`257`	`257`	`}`
`@@ -274,13 +274,13 @@ private bool HandleInput(Rect rect, TNode currentNode, int index, Action<TNode>`
`274`	`274`	`return requiresRepaint;`
`275`	`275`	`}`
`276`	`276`
`277`		`- private int SelectNext(int index, bool foldersOnly)`
	`277`	`+ private int SelectNext(int index, bool foldersOrContainersOnly)`
`278`	`278`	`{`
`279`	`279`	`for (index++; index < Nodes.Count; index++)`
`280`	`280`	`{`
`281`	`281`	`if (Nodes[index].IsHidden)`
`282`	`282`	`continue;`
`283`		`- if (!Nodes[index].IsFolder && foldersOnly)`
	`283`	`+ if (!Nodes[index].IsFolderOrContainer && foldersOrContainersOnly)`
`284`	`284`	`continue;`
`285`	`285`	`break;`
`286`	`286`	`}`
`@@ -296,13 +296,13 @@ private int SelectNext(int index, bool foldersOnly)`
`296`	`296`	`return index;`
`297`	`297`	`}`
`298`	`298`
`299`		`- private int SelectPrevious(int index, bool foldersOnly)`
	`299`	`+ private int SelectPrevious(int index, bool foldersOrContainersOnly)`
`300`	`300`	`{`
`301`	`301`	`for (index--; index >= 0; index--)`
`302`	`302`	`{`
`303`	`303`	`if (Nodes[index].IsHidden)`
`304`	`304`	`continue;`
`305`		`- if (!Nodes[index].IsFolder && foldersOnly)`
	`305`	`+ if (!Nodes[index].IsFolderOrContainer && foldersOrContainersOnly)`
`306`	`306`	`continue;`
`307`	`307`	`break;`
`308`	`308`	`}`
`@@ -344,6 +344,7 @@ public class TreeNode : ITreeNode`
`344`	`344`	`public string label;`
`345`	`345`	`public int level;`
`346`	`346`	`public bool isFolder;`
	`347`	`+ public bool isContainer;`
`347`	`348`	`public bool isCollapsed;`
`348`	`349`	`public bool isHidden;`
`349`	`350`	`public bool isActive;`
`@@ -372,12 +373,23 @@ public int Level`
`372`	`373`	`set { level = value; }`
`373`	`374`	`}`
`374`	`375`
	`376`	`+ public bool IsContainer`
	`377`	`+ {`
	`378`	`+ get { return isContainer; }`
	`379`	`+ set { isContainer = value; }`
	`380`	`+ }`
	`381`	`+`
`375`	`382`	`public bool IsFolder`
`376`	`383`	`{`
`377`	`384`	`get { return isFolder; }`
`378`	`385`	`set { isFolder = value; }`
`379`	`386`	`}`
`380`	`387`
	`388`	`+ public bool IsFolderOrContainer`
	`389`	`+ {`
	`390`	`+ get { return IsFolder \|\| IsContainer; }`
	`391`	`+ }`
	`392`	`+`
`381`	`393`	`public bool IsCollapsed`
`382`	`394`	`{`
`383`	`395`	`get { return isCollapsed; }`
`@@ -459,7 +471,7 @@ public TreeNodeRenderResult Render(Rect rect, float indentation, bool isSelected`
`459`	`471`	`}`
`460`	`472`
`461`	`473`	`var styleOn = false;`
`462`		`- if (IsFolder)`
	`474`	`+ if (IsFolderOrContainer)`
`463`	`475`	`{`
`464`	`476`	`styleOn = !IsCollapsed;`
`465`	`477`
`@@ -577,6 +589,11 @@ public override string PathSeparator`
`577`	`589`	`set { pathSeparator = value; }`
`578`	`590`	`}`
`579`	`591`
	`592`	`+ protected override bool PromoteMetaFiles`
	`593`	`+ {`
	`594`	`+ get { return false; }`
	`595`	`+ }`
	`596`	`+`
`580`	`597`	`public override TreeNode SelectedNode`
`581`	`598`	`{`
`582`	`599`	`get`
`@@ -643,13 +660,14 @@ protected Texture GetNodeIcon(TreeNode node)`
`643`	`660`	`return nodeIcon;`
`644`	`661`	`}`
`645`	`662`
`646`		`- protected override TreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitBranchTreeData? treeData)`
	`663`	`+ protected override TreeNode CreateTreeNode(string path, string label, int level, bool isFolder, bool isActive, bool isHidden, bool isCollapsed, bool isChecked, GitBranchTreeData? treeData, bool isContainer)`
`647`	`664`	`{`
`648`	`665`	`var node = new TreeNode {`
`649`	`666`	`Path = path,`
`650`	`667`	`Label = label,`
`651`	`668`	`Level = level,`
`652`	`669`	`IsFolder = isFolder,`
	`670`	`+ IsContainer = isContainer,`
`653`	`671`	`IsActive = isActive,`
`654`	`672`	`IsHidden = isHidden,`
`655`	`673`	`IsCollapsed = isCollapsed,`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ public void SetUp()`
`14`	`14`	`LogHelper.TracingEnabled = true;`
`15`	`15`
`16`	`16`	`LogHelper.LogAdapter = new MultipleLogAdapter(`
`17`		`- new FileLogAdapter($"..\\{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}-unit-tests.log")`
`18`		`- //, new ConsoleLogAdapter()`
	`17`	`+ new FileLogAdapter($"..\\{DateTime.UtcNow:yyyyMMddHHmmss}-unit-tests.log")`
	`18`	`+ , new ConsoleLogAdapter()`
`19`	`19`	`);`
`20`	`20`	`}`
`21`	`21`	`}`