Refactor collapsing mechanism

Now instead of having to call "hide_tab" and show_tab, one simply sets
the collapsed attribute on a Node; TreeTabWidget.tree_tab_update() takes
care of the rest.

qutebrowser/browser/commands.py

@@ -1956,12 +1956,7 @@ def tree_tab_toggle_hide(self, count=None):
         tab = self._cntwidget(count)
         if not tab.node.children:
             return
-        collapsed = tab.node.collapsed
-
-        if collapsed:
-            self._tabbed_browser.show_tab(tab)
-        else:
-            self._tabbed_browser.hide_tab(tab)
+        tab.node.collapsed = not tab.node.collapsed
 
         self._tabbed_browser.widget.tree_tab_update()
 

qutebrowser/mainwindow/treetabbedbrowser.py

@@ -270,50 +270,13 @@ def on_current_changed(self, idx):
         super().on_current_changed(idx)
         self._tree_tab_insert_rel_idx = 0
 
-    def show_tab(self, tab):
-        """Shows a tab that was previously collapsed through _tree_tab_hide.
-
-        This puts all the descendants of the tab back at the right index and
-        under the right parent.
-
-        Note: this does NOT update tab positions or titles. You have to do it
-        yourself. This is so cycle_hide_tab doesn't update a bunch of times.
-
-        """
-        cur_idx = self._tab_index(tab)
-        order = notree.TraverseOrder.PRE
-        tab.node.collapsed = False  # must set it before traverse
-        descendents = list(tab.node.traverse(order, False))[1:]
-        for descendent in descendents:
-            cur_tab = descendent.value
-            cur_parent = descendent.parent
-            name = cur_tab.title()
-            icon = cur_tab.icon()
-            self.widget.insertTab(cur_idx + 1, cur_tab, icon, name)
-            cur_tab.node.parent = cur_parent  # insertTab resets node
-            cur_idx += 1
-
-    def hide_tab(self, tab):
-        """Collaps a tab, hide all its children and set tab.node.collapsed.
-
-        Note: this does NOT update tab positions or titles. You have to do it
-        yourself. This is so cycle_hide_tab doesn't update a bunch of times.
-        """
-        order = notree.TraverseOrder.POST
-        descendents = list(tab.node.traverse(order, False))[:-1]
-        for descendent in descendents:
-            cur_tab = descendent.value
-            idx = self.widget.indexOf(cur_tab)
-            self.widget.removeTab(idx)
-        tab.node.collapsed = True
-
     def cycle_hide_tab(self, node):
         """Utility function for tree_tab_cycle_hide command."""
         # height = node.height  # height is always rel_height
         if node.collapsed:
-            self.show_tab(node.value)
-            for d in node.traverse(render_collapsed=True):
-                self.show_tab(d.value)
+            node.collapsed = False
+            for descendent in node.traverse(render_collapsed=True):
+                descendent.collapsed = False
             return
 
         def rel_depth(n):
@@ -335,4 +298,4 @@ def rel_depth(n):
                 break
         for n in levels[target]:
             if not n.collapsed and n.children:
-                self.hide_tab(n.value)
+                n.collapsed = True

qutebrowser/mainwindow/treetabwidget.py

@@ -21,6 +21,7 @@
 
 from qutebrowser.mainwindow.tabwidget import TabWidget
 from qutebrowser.misc.notree import Node
+from qutebrowser.misc import notree
 from qutebrowser.utils import log
 
 
@@ -71,7 +72,32 @@ def update_tree_tab_positions(self):
                 cur_idx = self.indexOf(node.value)
                 self.tabBar().moveTab(cur_idx, idx-1)
 
+
+    def update_tree_tab_visibility(self):
+        for node in self.tree_root.traverse():
+            if node.value is None:
+                continue
+            if any(ancestor.collapsed for ancestor in node.path[:-1]):
+                if self.indexOf(node.value) != -1:
+                    # node should be hidden but is shown
+                    order = notree.TraverseOrder.POST
+                    cur_tab = node.value
+                    idx = self.indexOf(cur_tab)
+                    if idx != -1:
+                        self.removeTab(idx)
+            else:
+                if self.indexOf(node.value) == -1:
+                    # node should be shown but is hidden
+                    parent = node.parent
+                    tab = node.value
+                    name = tab.title()
+                    icon = tab.icon()
+                    parent_idx = self.indexOf(node.parent.value)
+                    self.insertTab(parent_idx + 1, tab, icon, name)
+                    tab.node.parent = parent  # insertTab resets node
+
     def tree_tab_update(self):
         """Update titles and positions."""
+        self.update_tree_tab_visibility()
         self.update_tree_tab_positions()
         self.update_tab_titles()