greg/nix-config
1
0
Fork 0
mirror of https://github.com/gburd/nix-config.git synced 2024-11-15 08:46:25 +00:00
Code Issues Projects Releases Packages Wiki Activity
nix-config/overlays/qutebrowser-tree-tabs.diff

2456 lines
93 KiB
Diff
Raw Normal View History

A fork of Misterio77 and his standard template. Many thangs to the hard work and generous availability of: git@github.com:Misterio77/nix-config.git
2023-09-15 14:53:38 +00:00
diff --git a/qutebrowser/browser/browsertab.py b/qutebrowser/browser/browsertab.py
index 47cba592288..5630dc8cf18 100644
--- a/qutebrowser/browser/browsertab.py
+++ b/qutebrowser/browser/browsertab.py
@@ -52,6 +52,8 @@
from qutebrowser.browser import webelem
from qutebrowser.browser.inspector import AbstractWebInspector
+from qutebrowser.mainwindow.treetabwidget import TreeTabWidget
+from qutebrowser.misc.notree import Node
tab_id_gen = itertools.count(0)
_WidgetType = Union["QWebView", "QWebEngineView"]
@@ -1058,6 +1060,11 @@ def __init__(self, *, win_id: int,
self, parent=self)
self.backend: Optional[usertypes.Backend] = None
+ if parent and isinstance(parent, TreeTabWidget):
+ self.node: AbstractTab = Node(self, parent=parent.tree_root)
+ else:
+ self.node: AbstractTab = Node(self, parent=None)
+
# If true, this tab has been requested to be removed (or is removed).
self.pending_removal = False
self.shutting_down.connect(functools.partial(
diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
index 3b38c44c05b..d1a1cf6be69 100644
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -20,6 +20,7 @@
import os.path
import shlex
import functools
+import urllib.parse
from typing import cast, Callable, Dict, Union, Optional
from qutebrowser.qt.widgets import QApplication, QTabBar
@@ -34,7 +35,7 @@
from qutebrowser.utils import (message, usertypes, log, qtutils, urlutils,
objreg, utils, standarddir, debug)
from qutebrowser.utils.usertypes import KeyMode
-from qutebrowser.misc import editor, guiprocess, objects
+from qutebrowser.misc import editor, guiprocess, objects, notree
from qutebrowser.completion.models import urlmodel, miscmodels
from qutebrowser.mainwindow import mainwindow, windowundo
@@ -112,6 +113,7 @@ def _open(
background: bool = False,
window: bool = False,
related: bool = False,
+ sibling: bool = False,
private: Optional[bool] = None,
) -> None:
"""Helper function to open a page.
@@ -123,6 +125,7 @@ def _open(
window: Whether to open in a new window
private: If opening a new window, open it in private browsing mode.
If not given, inherit the current window's mode.
+ sibling: Open tab in a sibling node of the currently focused tab.
"""
urlutils.raise_cmdexc_if_invalid(url)
tabbed_browser = self._tabbed_browser
@@ -135,10 +138,16 @@ def _open(
tabbed_browser = self._new_tabbed_browser(private)
tabbed_browser.tabopen(url)
tabbed_browser.window().show()
- elif tab:
- tabbed_browser.tabopen(url, background=False, related=related)
- elif background:
- tabbed_browser.tabopen(url, background=True, related=related)
+ elif tab or background:
+ if tabbed_browser.is_treetabbedbrowser:
+ tabbed_browser.tabopen(url, background=background,
+ related=related, sibling=sibling)
+ elif sibling:
+ raise cmdutils.CommandError("--sibling flag only works with \
+ tree-tab enabled")
+ else:
+ tabbed_browser.tabopen(url, background=background,
+ related=related)
else:
widget = self._current_widget()
widget.load_url(url)
@@ -220,7 +229,8 @@ def _get_selection_override(self, prev, next_, opposite):
"{!r}!".format(conf_selection))
return None
- def _tab_close(self, tab, prev=False, next_=False, opposite=False):
+ def _tab_close(self, tab, prev=False, next_=False,
+ opposite=False, new_undo=True):
"""Helper function for tab_close be able to handle message.async.
Args:
@@ -236,17 +246,17 @@ def _tab_close(self, tab, prev=False, next_=False, opposite=False):
opposite)
if selection_override is None:
- self._tabbed_browser.close_tab(tab)
+ self._tabbed_browser.close_tab(tab, new_undo=new_undo)
else:
old_selection_behavior = tabbar.selectionBehaviorOnRemove()
tabbar.setSelectionBehaviorOnRemove(selection_override)
- self._tabbed_browser.close_tab(tab)
+ self._tabbed_browser.close_tab(tab, new_undo=new_undo)
tabbar.setSelectionBehaviorOnRemove(old_selection_behavior)
@cmdutils.register(instance='command-dispatcher', scope='window')
@cmdutils.argument('count', value=cmdutils.Value.count)
def tab_close(self, prev=False, next_=False, opposite=False,
- force=False, count=None):
+ force=False, count=None, recursive=False):
"""Close the current/[count]th tab.
Args:
@@ -255,15 +265,37 @@ def tab_close(self, prev=False, next_=False, opposite=False,
opposite: Force selecting the tab in the opposite direction of
what's configured in 'tabs.select_on_remove'.
force: Avoid confirmation for pinned tabs.
+ recursive: Close all descendents (tree-tabs) as well as current tab
count: The tab index to close, or None
"""
tab = self._cntwidget(count)
+ tabbed_browser = self._tabbed_browser
if tab is None:
return
- close = functools.partial(self._tab_close, tab, prev,
- next_, opposite)
-
- self._tabbed_browser.tab_close_prompt_if_pinned(tab, force, close)
+ if (tabbed_browser.is_treetabbedbrowser and recursive and not
+ tab.node.collapsed):
+ # if collapsed, recursive is the same as normal close
+ new_undo = True # only for first one
+ for descendent in tab.node.traverse(notree.TraverseOrder.POST_R,
+ True):
+ if self._tabbed_browser.widget.indexOf(descendent.value) > -1:
+ close = functools.partial(self._tab_close,
+ descendent.value, prev, next_,
+ opposite, new_undo)
+ tabbed_browser.tab_close_prompt_if_pinned(tab, force,
+ close)
+ new_undo = False
+ else:
+ tab = descendent.value
+ tab.private_api.shutdown()
+ tab.deleteLater()
+ tab.layout().unwrap()
+ else:
+ # this also applied to closing collapsed tabs
+ # logic for that is in TreeTabbedBrowser
+ close = functools.partial(self._tab_close, tab, prev,
+ next_, opposite)
+ tabbed_browser.tab_close_prompt_if_pinned(tab, force, close)
@cmdutils.register(instance='command-dispatcher', scope='window',
name='tab-pin')
@@ -288,8 +320,9 @@ def tab_pin(self, count=None):
@cmdutils.register(instance='command-dispatcher', name='open',
maxsplit=0, scope='window')
@cmdutils.argument('url', completion=urlmodel.url)
+ @cmdutils.argument('sibling', flag='S')
@cmdutils.argument('count', value=cmdutils.Value.count)
- def openurl(self, url=None, related=False,
+ def openurl(self, url=None, related=False, sibling=False,
bg=False, tab=False, window=False, count=None, secure=False,
private=False):
"""Open a URL in the current/[count]th tab.
@@ -303,6 +336,8 @@ def openurl(self, url=None, related=False,
window: Open in a new window.
related: If opening a new tab, position the tab as related to the
current one (like clicking on a link).
+ sibling: If opening a new tab, position the as a sibling of the
+ current one.
count: The tab index to open the URL in, or None.
secure: Force HTTPS.
private: Open a new window in private browsing mode.
@@ -321,8 +356,8 @@ def openurl(self, url=None, related=False,
bg = True
if tab or bg or window or private:
- self._open(cur_url, tab, bg, window, related=related,
- private=private)
+ self._open(cur_url, tab, bg, window, private=private,
+ related=related, sibling=sibling)
else:
curtab = self._cntwidget(count)
if curtab is None:
@@ -461,11 +496,40 @@ def tab_take(self, index, keep=False):
if not keep:
tabbed_browser.close_tab(tab, add_undo=False, transfer=True)
+ def _tree_tab_give(self, tabbed_browser, keep):
+ """Helper function to simplify tab-give."""
+ uid_map = {1: 1}
+ traversed = list(self._current_widget().node.traverse())
+ # first pass: open tabs
+ for node in traversed:
+ tab = tabbed_browser.tabopen(node.value.url())
+
+ uid_map[node.uid] = tab.node.uid
+
+ # second pass: copy tree structure over
+ newroot = tabbed_browser.widget.tree_root
+ oldroot = self._tabbed_browser.widget.tree_root
+ for node in traversed:
+ if node.parent is not oldroot:
+ uid = uid_map[node.uid]
+ new_node = newroot.get_descendent_by_uid(uid)
+ parent_uid = uid_map[node.parent.uid]
+ new_parent = newroot.get_descendent_by_uid(parent_uid)
+ new_node.parent = new_parent
+
+ # third pass: remove tabs from old window
+ if not keep:
+ for _node in traversed:
+ self._tabbed_browser.close_tab(self._current_widget(),
+ add_undo=False,
+ transfer=True)
+
@cmdutils.register(instance='command-dispatcher', scope='window')
@cmdutils.argument('win_id', completion=miscmodels.window)
@cmdutils.argument('count', value=cmdutils.Value.count)
def tab_give(self, win_id: int = None, keep: bool = False,
- count: int = None, private: bool = False) -> None:
+ count: int = None, private: bool = False,
+ recursive: bool = False) -> None:
"""Give the current tab to a new or existing window if win_id given.
If no win_id is given, the tab will get detached into a new window.
@@ -474,6 +538,7 @@ def tab_give(self, win_id: int = None, keep: bool = False,
win_id: The window ID of the window to give the current tab to.
keep: If given, keep the old tab around.
count: Overrides win_id (index starts at 1 for win_id=0).
+ recursive: Whether to move the entire subtree starting at the tab.
private: If the tab should be detached into a private instance.
"""
if config.val.tabs.tabs_are_windows:
@@ -505,13 +570,15 @@ def tab_give(self, win_id: int = None, keep: bool = False,
raise cmdutils.CommandError(
"The window with id {} is not private".format(win_id))
- tabbed_browser.tabopen(self._current_url())
- tabbed_browser.window().show()
-
- if not keep:
- self._tabbed_browser.close_tab(self._current_widget(),
- add_undo=False,
- transfer=True)
+ if recursive and tabbed_browser.is_treetabbedbrowser:
+ self._tree_tab_give(tabbed_browser, keep)
+ else:
+ tabbed_browser.tabopen(self._current_url())
+ tabbed_browser.window().show()
+ if not keep:
+ self._tabbed_browser.close_tab(self._current_widget(),
+ add_undo=False,
+ transfer=True)
def _back_forward(
self, *,
@@ -889,43 +956,79 @@ def undo(self, window: bool = False,
@cmdutils.register(instance='command-dispatcher', scope='window')
@cmdutils.argument('count', value=cmdutils.Value.count)
- def tab_prev(self, count=1):
+ def tab_prev(self, count=1, sibling=False):
"""Switch to the previous tab, or switch [count] tabs back.
Args:
count: How many tabs to switch back.
+ sibling: Whether to focus the previous tree sibling.
"""
if self._count() == 0:
# Running :tab-prev after last tab was closed
# See https://github.com/qutebrowser/qutebrowser/issues/1448
return
- newidx = self._current_index() - count
- if newidx >= 0:
- self._set_current_index(newidx)
- elif config.val.tabs.wrap:
- self._set_current_index(newidx % self._count())
+ if sibling and self._tabbed_browser.is_treetabbedbrowser:
+ cur_node = self._current_widget().node
+ siblings = list(cur_node.parent.children)
+
+ if siblings and len(siblings) > 1:
+ node_idx = siblings.index(cur_node)
+ new_idx = node_idx - count
+ if new_idx >= 0 or config.val.tabs.wrap:
+ target_node = siblings[(node_idx-count) % len(siblings)]
+ idx = self._tabbed_browser.widget.indexOf(
+ target_node.value)
+ self._set_current_index(idx)
+ else:
+ log.webview.debug("First sibling")
+ else:
+ log.webview.debug("No siblings")
else:
- log.webview.debug("First tab")
+ newidx = self._current_index() - count
+ if newidx >= 0:
+ self._set_current_index(newidx)
+ elif config.val.tabs.wrap:
+ self._set_current_index(newidx % self._count())
+ else:
+ log.webview.debug("First tab")
@cmdutils.register(instance='command-dispatcher', scope='window')
@cmdutils.argument('count', value=cmdutils.Value.count)
- def tab_next(self, count=1):
+ def tab_next(self, count=1, sibling=False):
"""Switch to the next tab, or switch [count] tabs forward.
Args:
count: How many tabs to switch forward.
+ sibling: Whether to focus the next tree sibling.
"""
if self._count() == 0:
# Running :tab-next after last tab was closed
# See https://github.com/qutebrowser/qutebrowser/issues/1448
return
- newidx = self._current_index() + count
- if newidx < self._count():
- self._set_current_index(newidx)
- elif config.val.tabs.wrap:
- self._set_current_index(newidx % self._count())
+ if sibling and self._tabbed_browser.is_treetabbedbrowser:
+ cur_node = self._current_widget().node
+ siblings = list(cur_node.parent.children)
+
+ if siblings and len(siblings) > 1:
+ node_idx = siblings.index(cur_node)
+ new_idx = node_idx + count
+ if new_idx < len(siblings) or config.val.tabs.wrap:
+ target_node = siblings[new_idx % len(siblings)]
+ idx = self._tabbed_browser.widget.indexOf(
+ target_node.value)
+ self._set_current_index(idx)
+ else:
+ log.webview.debug("Last sibling")
+ else:
+ log.webview.debug("No siblings")
else:
- log.webview.debug("Last tab")
+ newidx = self._current_index() + count
+ if newidx < self._count():
+ self._set_current_index(newidx)
+ elif config.val.tabs.wrap:
+ self._set_current_index(newidx % self._count())
+ else:
+ log.webview.debug("Last tab")
def _resolve_tab_index(self, index):
"""Resolve a tab index to the tabbedbrowser and tab.
@@ -1005,7 +1108,8 @@ def tab_select(self, index=None, count=None):
tabbed_browser.widget.setCurrentWidget(tab)
@cmdutils.register(instance='command-dispatcher', scope='window')
- @cmdutils.argument('index', choices=['last', 'stack-next', 'stack-prev'],
+ @cmdutils.argument('index', choices=['last', 'parent',
+ 'stack-next', 'stack-prev'],
completion=miscmodels.tab_focus)
@cmdutils.argument('count', value=cmdutils.Value.count)
def tab_focus(self, index: Union[str, int] = None,
@@ -1016,11 +1120,15 @@ def tab_focus(self, index: Union[str, int] = None,
If both are given, use count.
Args:
- index: The tab index to focus, starting with 1. The special value
- `last` focuses the last focused tab (regardless of count),
- and `stack-prev`/`stack-next` traverse a stack of visited
- tabs. Negative indices count from the end, such that -1 is
- the last tab.
+ index: The tab index to focus, starting with 1. Negative indices
+ count from the end, such that -1 is the last tab. Special
+ values are:
+ - `last` focuses the last focused tab (regardless of
+ count).
+ - `parent` focuses the parent tab in the tree hierarchy,
+ if `tabs.tree_tabs` is enabled.
+ - `stack-prev`/`stack-next` traverse a stack of visited
+ tabs.
count: The tab index to focus, starting with 1.
no_last: Whether to avoid focusing last tab if already focused.
"""
@@ -1030,6 +1138,22 @@ def tab_focus(self, index: Union[str, int] = None,
assert isinstance(index, str)
self._tab_focus_stack(index)
return
+ elif index == 'parent' and self._tabbed_browser.is_treetabbedbrowser:
+ node = self._current_widget().node
+ path = node.path
+ if count:
+ if count < len(path):
+ path_idx = 0 - count - 1 # path[-1] is node, so shift by 1
+ else:
+ path_idx = 1 # first non-root node
+ else:
+ path_idx = -2 # immediate parent (path[-1] is node)
+
+ target_node = path[path_idx]
+ if node is target_node or target_node.value is None:
+ raise cmdutils.CommandError("Tab has no parent! ")
+ target_tab = target_node.value
+ index = self._tabbed_browser.widget.indexOf(target_tab) + 1
elif index is None:
message.warning(
"Using :tab-focus without count is deprecated, "
@@ -1069,17 +1193,31 @@ def tab_move(self, index: Union[str, int] = None, count: int = None) -> None:
If moving absolutely: New position (default: 0). This
overrides the index argument, if given.
"""
+ # pylint: disable=invalid-unary-operand-type
+ # https://github.com/PyCQA/pylint/issues/1472
if index in ["+", "-"]:
# relative moving
new_idx = self._current_index()
delta = 1 if count is None else count
- if index == "-":
- new_idx -= delta
- elif index == "+": # pragma: no branch
- new_idx += delta
- if config.val.tabs.wrap:
- new_idx %= self._count()
+ if self._tabbed_browser.is_treetabbedbrowser:
+ node = self._current_widget().node
+ parent = node.parent
+ siblings = list(parent.children)
+
+ if len(siblings) <= 1:
+ return
+ rel_idx = siblings.index(node)
+ rel_idx += delta if index == '+' else - delta
+ rel_idx %= len(siblings)
+ new_idx = self._tabbed_browser.widget.indexOf(
+ siblings[rel_idx].value)
+
+ else:
+ new_idx += delta if index == '+' else - delta
+
+ if config.val.tabs.wrap:
+ new_idx %= self._count()
else:
# pylint: disable=else-if-used
# absolute moving
@@ -1102,7 +1240,34 @@ def tab_move(self, index: Union[str, int] = None, count: int = None) -> None:
cur_idx = self._current_index()
cmdutils.check_overflow(cur_idx, 'int')
cmdutils.check_overflow(new_idx, 'int')
- self._tabbed_browser.widget.tabBar().moveTab(cur_idx, new_idx)
+
+ if self._tabbed_browser.is_treetabbedbrowser:
+ # self._tree_tab_move(new_idx)
+ new_idx += 1 # tree-tabs indexes start at 1 (0 is hidden root tab)
+ tab = self._current_widget()
+
+ # traverse order is the same as display order
+ # so indexing works correctly
+ tree_root = self._tabbed_browser.widget.tree_root
+ tabs = list(tree_root.traverse(render_collapsed=False))
+ target_node = tabs[new_idx]
+ if tab.node in target_node.path:
+ raise cmdutils.CommandError("Can't move tab to a descendent"
+ " of itself")
+
+ new_parent = target_node.parent
+ # we need index relative to parent for correct placement
+ dest_tab = tabs[new_idx]
+ new_idx_relative = new_parent.children.index(dest_tab)
+
+ tab.node.parent = None # avoid duplicate errors
+ siblings = list(new_parent.children)
+ siblings.insert(new_idx_relative, tab.node)
+ new_parent.children = siblings
+
+ self._tabbed_browser.widget.tree_tab_update()
+ else:
+ self._tabbed_browser.widget.tabBar().moveTab(cur_idx, new_idx)
@cmdutils.register(instance='command-dispatcher', scope='window',
maxsplit=0, no_replace_variables=True)
@@ -1899,3 +2064,123 @@ def fullscreen(self, leave=False, enter=False):
log.misc.debug('state before fullscreen: {}'.format(
debug.qflags_key(Qt, window.state_before_fullscreen)))
+
+ @cmdutils.register(instance='command-dispatcher', scope='window',
+ tree_tab=True)
+ @cmdutils.argument('count', value=cmdutils.Value.count)
+ def tree_tab_promote(self, count=1):
+ """Promote a tab so it becomes next sibling of its parent.
+
+ Observes tabs.new_position.tree.promote in positioning the tab among
+ new siblings.
+
+ Args:
+ count: How many levels the tabs should be promoted to
+ """
+ if not self._tabbed_browser.is_treetabbedbrowser:
+ raise cmdutils.CommandError('Tree-tabs are disabled')
+ config_position = config.val.tabs.new_position.tree.promote
+ try:
+ self._current_widget().node.promote(count, config_position)
+ except notree.TreeError:
+ raise cmdutils.CommandError('Tab has no parent!')
+ finally:
+ self._tabbed_browser.widget.tree_tab_update()
+
+ @cmdutils.register(instance='command-dispatcher', scope='window',
+ tree_tab=True)
+ def tree_tab_demote(self):
+ """Demote a tab making it children of its previous adjacent sibling.
+
+ Observes tabs.new_position.tree.demote in positioning the tab among new
+ siblings.
+ """
+ if not self._tabbed_browser.is_treetabbedbrowser:
+ raise cmdutils.CommandError('Tree-tabs are disabled')
+ cur_node = self._current_widget().node
+
+ config_position = config.val.tabs.new_position.tree.demote
+ try:
+ cur_node.demote(config_position)
+ except notree.TreeError:
+ raise cmdutils.CommandError('Tab has no previous sibling!')
+ finally:
+ self._tabbed_browser.widget.tree_tab_update()
+
+ @cmdutils.register(instance='command-dispatcher', scope='window',
+ tree_tab=True)
+ @cmdutils.argument('count', value=cmdutils.Value.count)
+ def tree_tab_toggle_hide(self, count=None):
+ """If the current tab's children are shown hide them, and vice-versa.
+
+ This toggles the current tab's node's `collapsed` attribute.
+
+ Args:
+ count: Which tab to collapse
+ """
+ if not self._tabbed_browser.is_treetabbedbrowser:
+ raise cmdutils.CommandError('Tree-tabs are disabled')
+ tab = self._cntwidget(count)
+ if not tab.node.children:
+ return
+ tab.node.collapsed = not tab.node.collapsed
+
+ self._tabbed_browser.widget.tree_tab_update()
+
+ @cmdutils.register(instance='command-dispatcher', scope='window',
+ tree_tab=True)
+ @cmdutils.argument('count', value=cmdutils.Value.count)
+ def tree_tab_cycle_hide(self, count=1):
+ """Hides levels of descendents: children, grandchildren, and so on.
+
+ Args:
+ count: How many levels to hide.
+ """
+ if not self._tabbed_browser.is_treetabbedbrowser:
+ raise cmdutils.CommandError('Tree-tabs are disabled')
+ while count > 0:
+ tab = self._current_widget()
+ self._tabbed_browser.cycle_hide_tab(tab.node)
+ count -= 1
+
+ self._tabbed_browser.widget.tree_tab_update()
+
+ @cmdutils.register(instance='command-dispatcher', scope='window',
+ tree_tab=True)
+ def tree_tab_create_group(self, *name, related=False,
+ background=False):
+ """Wrapper around :open qute://treegroup/name. Correctly escapes names.
+
+ Example: `:tree-tab-create-group Foo Bar` calls
+ `:open qute://treegroup/Foo%20Bar`
+
+ Args:
+ name: Name of the group to create
+ related: whether to open as a child of current tab or under root
+ background: whether to open in a background tab
+ """
+ title = ' '.join(name)
+ path = urllib.parse.quote(title)
+ if background:
+ self.openurl('qute://treegroup/' + path, related=related, bg=True)
+ else:
+ self.openurl('qute://treegroup/' + path, related=related, tab=True)
+
+ @cmdutils.register(instance='command-dispatcher', scope='window',
+ tree_tab=True)
+ @cmdutils.argument('count', value=cmdutils.Value.count)
+ def tree_tab_suspend_children(self, count=None):
+ """Suspends all descendent of a tab to reduce memory usage.
+
+ Args:
+ count: Target tab.
+ """
+ tab = self._cntwidget(count)
+ for descendent in tab.node.traverse():
+ cur_tab = descendent.value
+ if cur_tab and cur_tab is not tab:
+ cur_url = cur_tab.url().url()
+ if not cur_url.startswith("qute://"):
+ new_url = self._parse_url(
+ "qute://back/#" + cur_tab.title())
+ cur_tab.load_url(new_url)
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 25834670b11..15e4bc769e4 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -588,6 +588,18 @@ def qute_warning(url: QUrl) -> _HandlerRet:
return 'text/html', src
+@add_handler('treegroup')
+def qute_treegroup(url):
+ """Handler for qute://treegroup/x.
+
+ Makes an empty tab with a title, for use with tree-tabs as a grouping
+ feature.
+ """
+ src = jinja.render('tree_group.html',
+ title=url.path()[1:])
+ return 'text/html', src
+
+
@add_handler('resource')
def qute_resource(url: QUrl) -> _HandlerRet:
"""Handler for qute://resource."""
diff --git a/qutebrowser/commands/command.py b/qutebrowser/commands/command.py
index 655a5a336ad..76a44934e97 100644
--- a/qutebrowser/commands/command.py
+++ b/qutebrowser/commands/command.py
@@ -65,6 +65,7 @@ class Command:
both)
no_replace_variables: Don't replace variables like {url}
modes: The modes the command can be executed in.
+ tree_tab: Whether the command is a tree-tabs command
_qute_args: The saved data from @cmdutils.argument
_count: The count set for the command.
_instance: The object to bind 'self' to.
@@ -78,7 +79,7 @@ class Command:
def __init__(self, *, handler, name, instance=None, maxsplit=None,
modes=None, not_modes=None, debug=False, deprecated=False,
no_cmd_split=False, star_args_optional=False, scope='global',
- backend=None, no_replace_variables=False):
+ backend=None, no_replace_variables=False, tree_tab=False):
if modes is not None and not_modes is not None:
raise ValueError("Only modes or not_modes can be given!")
if modes is not None:
@@ -107,6 +108,7 @@ def __init__(self, *, handler, name, instance=None, maxsplit=None,
self.handler = handler
self.no_cmd_split = no_cmd_split
self.backend = backend
+ self.tree_tab = tree_tab
self.no_replace_variables = no_replace_variables
self.docparser = docutils.DocstringParser(handler)
diff --git a/qutebrowser/completion/models/util.py b/qutebrowser/completion/models/util.py
index 69a192f686e..16452d7b571 100644
--- a/qutebrowser/completion/models/util.py
+++ b/qutebrowser/completion/models/util.py
@@ -21,6 +21,7 @@
from qutebrowser.utils import usertypes
from qutebrowser.misc import objects
+from qutebrowser.config import config
DeleteFuncType = Callable[[Sequence[str]], None]
@@ -44,8 +45,9 @@ def get_cmd_completions(info, include_hidden, include_aliases, prefix=''):
hide_debug = obj.debug and not objects.args.debug
hide_mode = (usertypes.KeyMode.normal not in obj.modes and
not include_hidden)
+ hide_tree = obj.tree_tab and not config.cache['tabs.tree_tabs']
hide_ni = obj.name == 'Ni!'
- if not (hide_debug or hide_mode or obj.deprecated or hide_ni):
+ if not (hide_tree or hide_debug or hide_mode or obj.deprecated or hide_ni):
bindings = ', '.join(cmd_to_keys.get(obj.name, []))
cmdlist.append((prefix + obj.name, obj.desc, bindings))
diff --git a/qutebrowser/config/configdata.yml b/qutebrowser/config/configdata.yml
index 0b9d669dceb..05526260e02 100644
--- a/qutebrowser/config/configdata.yml
+++ b/qutebrowser/config/configdata.yml
@@ -2224,6 +2224,40 @@ tabs.new_position.stacking:
Only applies for `next` and `prev` values of `tabs.new_position.related`
and `tabs.new_position.unrelated`.
+tabs.new_position.tree.new_child:
+ default: first
+ type: NewChildPosition
+ desc: >-
+ Position of new children among siblings, e.g. after calling `:open
+ --relative ...` or following a link.
+
+tabs.new_position.tree.new_sibling:
+ default: first
+ type: NewTabPosition
+ desc: >-
+ Position of siblings, e.g. after calling `:open --sibling ...`.
+
+tabs.new_position.tree.new_toplevel:
+ default: last
+ type: NewTabPosition
+ desc: >-
+ Position of new top-level tabs related to the topmost ancestor of current
+ tab, e.g. when calling `:open ...` without `--relative` or `--sibling`.
+
+tabs.new_position.tree.promote:
+ default: next
+ type: NewTabPosition
+ desc: >-
+ Position at which a tab is placed among its new siblings after being
+ promoted with `:tree-tab-promote`
+
+tabs.new_position.tree.demote:
+ default: last
+ type: NewChildPosition
+ desc: >-
+ Position at which a tab is placed among its new siblings after being
+ demoted with `:tree-tab-demote`
+
tabs.padding:
default:
top: 0
@@ -2289,7 +2323,7 @@ tabs.title.elide:
desc: Position of ellipsis in truncated title of tabs.
tabs.title.format:
- default: '{audio}{index}: {current_title}'
+ default: '{tree}{collapsed}{audio}{index}: {current_title}'
type:
name: FormatString
fields:
@@ -2307,12 +2341,16 @@ tabs.title.format:
- current_url
- protocol
- audio
+ - collapsed
+ - tree
none_ok: true
desc: |
Format to use for the tab title.
The following placeholders are defined:
* `{perc}`: Percentage as a string like `[10%]`.
+ * `{collapsed}`: If children tabs are hidden, the string `[...]`, empty otherwise
+ * `{tree}`: The ASCII tree prefix of current tab.
* `{perc_raw}`: Raw percentage, e.g. `10`.
* `{current_title}`: Title of the current web page.
* `{title_sep}`: The string `" - "` if a title is set, empty otherwise.
@@ -2348,6 +2386,8 @@ tabs.title.format_pinned:
- current_url
- protocol
- audio
+ - collapsed
+ - tree
none_ok: true
desc: Format to use for the tab title for pinned tabs. The same placeholders
like for `tabs.title.format` are defined.
@@ -2446,6 +2486,12 @@ tabs.wrap:
type: Bool
desc: Wrap when changing tabs.
+tabs.tree_tabs:
+ default: false
+ type: Bool
+ desc: Enable tree-tabs mode.
+ restart: true
+
tabs.focus_stack_size:
default: 10
type:
@@ -3831,6 +3877,17 @@ bindings.default:
all no-3rdparty never ;; reload
tCu: config-cycle -p -u {url} content.cookies.accept
all no-3rdparty never ;; reload
+ zH: tree-tab-promote
+ zL: tree-tab-demote
+ zJ: tab-next -s
+ zK: tab-prev -s
+ zd: tab-close -r
+ zg: set-cmd-text -s :tree-tab-create-group -r
+ zG: set-cmd-text -s :tree-tab-create-group
+ za: tree-tab-toggle-hide
+ zp: tab-focus parent
+ zo: set-cmd-text --space :open -tr
+ zO: set-cmd-text --space :open -tS
insert:
<Ctrl-E>: edit-text
<Shift-Ins>: insert-text -- {primary}
diff --git a/qutebrowser/config/configtypes.py b/qutebrowser/config/configtypes.py
index b451744c338..a10f4aa3bb5 100644
--- a/qutebrowser/config/configtypes.py
+++ b/qutebrowser/config/configtypes.py
@@ -1955,6 +1955,21 @@ def __init__(
('last', "At the end."))
+class NewChildPosition(String):
+
+ """How new children are positioned."""
+
+ def __init__(
+ self, *,
+ none_ok: bool = False,
+ completions: _Completions = None,
+ ) -> None:
+ super().__init__(none_ok=none_ok, completions=completions)
+ self.valid_values = ValidValues(
+ ('first', "At the beginning."),
+ ('last', "At the end."))
+
+
class LogLevel(String):
"""A logging level."""
diff --git a/qutebrowser/html/tree_group.html b/qutebrowser/html/tree_group.html
new file mode 100644
index 00000000000..b3717e52b6e
--- /dev/null
+++ b/qutebrowser/html/tree_group.html
@@ -0,0 +1,65 @@
+{% extends "base.html" %}
+{% block style %}
+h1, p {
+ margin-left: 3rem;
+}
+
+pre {
+ margin-left: 6em;
+}
+{% endblock %}
+{% block content %}
+<h1>
+ {{ title }}
+</h1>
+<p>
+ <em>Group for tree tabs</em>
+</p>
+<pre>
+{% raw %}
+ _.
+ _~.:'^%^ >@~.
+ ,-~ ? =*=
+ $^_` ` , ' , + -.,
+ (*-^. , * ;' >
+ >. ,> . ' .,.,. %-.,_ ,.-,
+ # ' ` " - " * .,. * .^ `
+ *@! ., * ' ' , ;' ' . %!
+ & " .` :' ` ' . `~,
+ & ' .` ' ' . '": : +.
+ ^ .", , ` ' ` * , ' ` |
+ ] * . , ""] .. ` . , ` , " . . ' ,;,
+ % ' ::, , / , ' , ;
+ .* ,* / *% \ . . *' ` , ' '.
+ ? > . , ::. :;^^. %` ' ` @
+ / ' `/ ` &#@%^^ `&`` ` %;; %
+ ;: :% * * :$%)\ ' `@%$ @%^ ,).
+ . # %&^ (!*^ .\,. ` ^@%^ $#%%^ ` >
+ \ :#$% #^&# : ` * %###$%@! &
+ | ' * %$#@)$*}] ` `#@#%%^ *^
+ : *' * @%&&^:$ ` ' `%%. #$$$^^-, 7
+ &; @#$~~ ' ` @#$%& $,*.-
+ *...*^ .._ %$$#@! @ ., *&&#@
+ :..^ - !%&@}{#& @#$@%
+ --_..%#%%$#&% #&%$#;:
+ $%#^%#@@%%*&;;
+ a%##@%%@% ;:;
+ %####j#:::;
+ &#%Rj;%;;:
+ &#%%#;::;
+ $#%##:%::
+ "#%%#;:;
+ ."$###:::
+ #&$%%#:;:
+ %&#%%#::;
+ %&%###;::
+ &&#%%#:;;
+ *@&#%#};:;
+ $#%#%%^:::
+ *@#$#%#;::;:
+ %%@#$####@$:;:
+ ...%###pinusc@$%%:._____
+{% endraw %}
+
+</pre>
+{% endblock %}
diff --git a/qutebrowser/mainwindow/mainwindow.py b/qutebrowser/mainwindow/mainwindow.py
index 5e34a6649fe..405e9fd285b 100644
--- a/qutebrowser/mainwindow/mainwindow.py
+++ b/qutebrowser/mainwindow/mainwindow.py
@@ -21,7 +21,7 @@
import base64
import itertools
import functools
-from typing import List, MutableSequence, Optional, Tuple, cast
+from typing import List, MutableSequence, Optional, Tuple, cast, Union
from qutebrowser.qt import machinery
from qutebrowser.qt.core import (pyqtBoundSignal, pyqtSlot, QRect, QPoint, QTimer, Qt,
@@ -208,7 +208,7 @@ def __init__(self, *,
super().__init__(parent)
# Late import to avoid a circular dependency
# - browsertab -> hints -> webelem -> mainwindow -> bar -> browsertab
- from qutebrowser.mainwindow import tabbedbrowser
+ from qutebrowser.mainwindow import treetabbedbrowser, tabbedbrowser
from qutebrowser.mainwindow.statusbar import bar
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
@@ -237,8 +237,14 @@ def __init__(self, *,
self.is_private = config.val.content.private_browsing or private
- self.tabbed_browser: tabbedbrowser.TabbedBrowser = tabbedbrowser.TabbedBrowser(
- win_id=self.win_id, private=self.is_private, parent=self)
+ self.tabbed_browser: Union[tabbedbrowser.TabbedBrowser,
+ treetabbedbrowser.TreeTabbedBrowser]
+ if config.val.tabs.tree_tabs:
+ self.tabbed_browser = treetabbedbrowser.TreeTabbedBrowser(
+ win_id=self.win_id, private=self.is_private, parent=self)
+ else:
+ self.tabbed_browser = tabbedbrowser.TabbedBrowser(
+ win_id=self.win_id, private=self.is_private, parent=self)
objreg.register('tabbed-browser', self.tabbed_browser, scope='window',
window=self.win_id)
self._init_command_dispatcher()
@@ -510,8 +516,10 @@ def _connect_signals(self):
mode_manager.keystring_updated.connect(
self.status.keystring.on_keystring_updated)
self.status.cmd.got_cmd[str].connect(self._commandrunner.run_safely)
- self.status.cmd.got_cmd[str, int].connect(self._commandrunner.run_safely)
- self.status.cmd.returnPressed.connect(self.tabbed_browser.on_cmd_return_pressed)
+ self.status.cmd.got_cmd[str, int].connect(
+ self._commandrunner.run_safely)
+ self.status.cmd.returnPressed.connect(
+ self.tabbed_browser.on_cmd_return_pressed)
self.status.cmd.got_search.connect(self._command_dispatcher.search)
# key hint popup
diff --git a/qutebrowser/mainwindow/tabbedbrowser.py b/qutebrowser/mainwindow/tabbedbrowser.py
index da3392a7e81..61f75c2b5a1 100644
--- a/qutebrowser/mainwindow/tabbedbrowser.py
+++ b/qutebrowser/mainwindow/tabbedbrowser.py
@@ -22,8 +22,8 @@
import weakref
import datetime
import dataclasses
-from typing import (
- Any, Deque, List, Mapping, MutableMapping, MutableSequence, Optional, Tuple)
+from typing import (Any, Deque, List, Mapping,
+ MutableMapping, MutableSequence, Optional, Tuple)
from qutebrowser.qt.widgets import QSizePolicy, QWidget, QApplication
from qutebrowser.qt.core import pyqtSignal, pyqtSlot, QTimer, QUrl, QPoint
@@ -207,6 +207,7 @@ class TabbedBrowser(QWidget):
resized = pyqtSignal('QRect')
current_tab_changed = pyqtSignal(browsertab.AbstractTab)
new_tab = pyqtSignal(browsertab.AbstractTab, int)
+ is_treetabbedbrowser = False
shutting_down = pyqtSignal()
def __init__(self, *, win_id, private, parent=None):
@@ -485,6 +486,7 @@ def _remove_tab(self, tab, *, add_undo=True, new_undo=True, crashed=False):
crashed: Whether we're closing a tab with crashed renderer process.
"""
idx = self.widget.indexOf(tab)
+
if idx == -1:
if crashed:
return
@@ -553,17 +555,26 @@ def undo(self, depth=1):
entries = self.undo_stack[-depth]
del self.undo_stack[-depth]
+ # we return the tab list because tree_tabs needs it in post_processing
+ new_tabs = []
for entry in reversed(entries):
if use_current_tab:
newtab = self._tab_by_idx(0)
assert newtab is not None
use_current_tab = False
else:
- newtab = self.tabopen(background=False, idx=entry.index)
+ # FIXME:typing mypy thinks this is None due to @pyqtSlot
+ newtab = self.tabopen(
+ background=False,
+ related=False,
+ idx=entry.index
+ )
newtab.history.private_api.deserialize(entry.history)
newtab.set_pinned(entry.pinned)
+ new_tabs.append(newtab)
newtab.setFocus()
+ return new_tabs
@pyqtSlot('QUrl', bool)
def load_url(self, url, newtab):
@@ -651,7 +662,7 @@ def tabopen(
if idx is None:
idx = self._get_new_tab_idx(related)
- self.widget.insertTab(idx, tab, "")
+ idx = self.widget.insertTab(idx, tab, "")
if url is not None:
tab.load_url(url)
diff --git a/qutebrowser/mainwindow/tabwidget.py b/qutebrowser/mainwindow/tabwidget.py
index fe9ce1e0676..f2cb1765828 100644
--- a/qutebrowser/mainwindow/tabwidget.py
+++ b/qutebrowser/mainwindow/tabwidget.py
@@ -26,7 +26,7 @@
QTimer, QUrl)
from qutebrowser.qt.widgets import (QTabWidget, QTabBar, QSizePolicy, QProxyStyle,
QStyle, QStylePainter, QStyleOptionTab,
- QCommonStyle)
+ QCommonStyle, QWidget)
from qutebrowser.qt.gui import QIcon, QPalette, QColor
from qutebrowser.utils import qtutils, objreg, utils, usertypes, log
@@ -36,7 +36,6 @@
class TabWidget(QTabWidget):
-
"""The tab widget used for TabbedBrowser.
Signals:
@@ -59,14 +58,14 @@ def __init__(self, win_id, parent=None):
self.setStyle(TabBarStyle())
self.setTabBar(bar)
bar.tabCloseRequested.connect(self.tabCloseRequested)
- bar.tabMoved.connect(functools.partial(
- QTimer.singleShot, 0, self.update_tab_titles))
+ bar.tabMoved.connect(self.update_tab_titles)
bar.currentChanged.connect(self._on_current_changed)
bar.new_tab_requested.connect(self._on_new_tab_requested)
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
self.setDocumentMode(True)
self.setUsesScrollButtons(True)
bar.setDrawBase(False)
+
self._init_config()
config.instance.changed.connect(self._init_config)
@@ -92,8 +91,9 @@ def tab_bar(self) -> "TabBar":
assert isinstance(bar, TabBar), bar
return bar
- def _tab_by_idx(self, idx: int) -> Optional[browsertab.AbstractTab]:
+ def _tab_by_idx(self, idx: int) -> Optional[QWidget]:
"""Get the tab at the given index."""
+
tab = self.widget(idx)
if tab is not None:
assert isinstance(tab, browsertab.AbstractTab), tab
@@ -189,6 +189,9 @@ def get_tab_fields(self, idx):
fields['perc_raw'] = tab.progress()
fields['backend'] = objects.backend.name
fields['private'] = ' [Private Mode] ' if tab.is_private else ''
+ fields['tree'] = ''
+ fields['collapsed'] = ''
+
try:
if tab.audio.is_muted():
fields['audio'] = TabWidget.MUTE_STRING
@@ -347,7 +350,7 @@ def tab_url(self, idx):
qtutils.ensure_valid(url)
return url
- def update_tab_favicon(self, tab: browsertab.AbstractTab) -> None:
+ def update_tab_favicon(self, tab: QWidget) -> None:
"""Update favicon of the given tab."""
idx = self.indexOf(tab)
diff --git a/qutebrowser/mainwindow/treetabbedbrowser.py b/qutebrowser/mainwindow/treetabbedbrowser.py
new file mode 100644
index 00000000000..c7e10ab180d
--- /dev/null
+++ b/qutebrowser/mainwindow/treetabbedbrowser.py
@@ -0,0 +1,350 @@
+# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
+
+# Copyright 2014-2018 Giuseppe Stelluto (pinusc) <giuseppe@gstelluto.com>
+#
+# This file is part of qutebrowser.
+#
+# qutebrowser is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# qutebrowser is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with qutebrowser. If not, see <https://www.gnu.org/licenses/>.
+
+"""Subclass of TabbedBrowser to provide tree-tab functionality."""
+
+import collections
+import dataclasses
+import datetime
+from typing import List, Dict
+from qutebrowser.qt.widgets import QSizePolicy
+from qutebrowser.qt.core import pyqtSlot, QUrl
+
+from qutebrowser.config import config
+from qutebrowser.mainwindow.tabbedbrowser import TabbedBrowser
+from qutebrowser.mainwindow.treetabwidget import TreeTabWidget
+from qutebrowser.browser import browsertab
+from qutebrowser.misc import notree
+from qutebrowser.utils import log
+
+
+@dataclasses.dataclass
+class _TreeUndoEntry():
+ """Information needed for :undo."""
+
+ url: QUrl
+ history: bytes
+ index: int
+ pinned: bool
+ uid: int
+ parent_node_uid: int
+ children_node_uids: List[int]
+ local_index: int # index of the tab relative to its siblings
+ created_at: datetime.datetime = dataclasses.field(
+ default_factory=datetime.datetime.now)
+
+ @staticmethod
+ def from_node(node, idx):
+ """Make a TreeUndoEntry from a Node."""
+ url = node.value.url()
+ try:
+ history_data = node.value.history.private_api.serialize()
+ except browsertab.WebTabError:
+ history_data = []
+ pinned = node.value.data.pinned
+ uid = node.uid
+ parent_uid = node.parent.uid
+ children = [n.uid for n in node.children]
+ local_idx = node.index
+ return _TreeUndoEntry(url=url,
+ history=history_data,
+ index=idx,
+ pinned=pinned,
+ uid=uid,
+ parent_node_uid=parent_uid,
+ children_node_uids=children,
+ local_index=local_idx)
+
+
+class TreeTabbedBrowser(TabbedBrowser):
+ """Subclass of TabbedBrowser to provide tree-tab functionality.
+
+ Extends TabbedBrowser methods (mostly tabopen, undo, and _remove_tab) so
+ that the internal tree is updated after every action.
+
+ Provides methods to hide and show subtrees, and to cycle visibility.
+ """
+
+ is_treetabbedbrowser = True
+
+ def __init__(self, *, win_id, private, parent=None):
+ super().__init__(win_id=win_id, private=private, parent=parent)
+ self.is_treetabbedbrowser = True
+ self.widget = TreeTabWidget(win_id, parent=self)
+ self.widget.tabCloseRequested.connect(self.on_tab_close_requested)
+ self.widget.new_tab_requested.connect(self.tabopen)
+ self.widget.currentChanged.connect(self._on_current_changed)
+ self.cur_fullscreen_requested.connect(self.widget.tabBar().maybe_hide)
+ self.widget.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+ self._reset_stack_counters()
+
+ def _remove_tab(self, tab, *, add_undo=True, new_undo=True, crashed=False):
+ """Handle children positioning after a tab is removed."""
+ node = tab.node
+ # FIXME after the fixme in _add_undo_entry is resolved, no need
+ # to save descendents
+ descendents = tuple(node.traverse(render_collapsed=True))
+
+ super()._remove_tab(tab, add_undo=False, new_undo=False,
+ crashed=crashed)
+
+ if not tab.url().isEmpty() and tab.url().isValid() and add_undo:
+ idx = self.widget.indexOf(tab)
+ self._add_undo_entry(tab, idx, new_undo)
+
+ parent = node.parent
+
+ if node.collapsed:
+ # node will already be removed from tree
+ # but we need to manually close the tab processes
+ for descendent in descendents:
+ tab = descendent.value
+ tab.private_api.shutdown()
+ tab.deleteLater()
+ tab.layout().unwrap()
+ elif parent:
+ siblings = list(parent.children)
+ children = node.children
+
+ if children:
+ next_node = children[0]
+
+ for n in children[1:]:
+ n.parent = next_node
+
+ # swap nodes
+ node_idx = siblings.index(node)
+ siblings[node_idx] = next_node
+
+ parent.children = tuple(siblings)
+ node.children = ()
+
+ node.parent = None
+ self.widget.tree_tab_update()
+
+ def _add_undo_entry(self, tab, idx, new_undo):
+ """Save undo entry with tree information.
+
+ This function was removed in tabbedbrowser, but it is still useful here because
+ the mechanism is quite a bit more complex
+ """
+ # TODO see if it's possible to remove duplicate code from
+ # super()._add_undo_entry
+ try:
+ history_data = tab.history.private_api.serialize()
+ except browsertab.WebTabError:
+ pass # special URL
+ else:
+ node = tab.node
+ uid = node.uid
+ parent_uid = node.parent.uid
+ if not node.collapsed:
+ children = [n.uid for n in node.children]
+ local_idx = node.index
+ entry = _TreeUndoEntry(url=tab.url(),
+ history=history_data,
+ index=idx,
+ pinned=tab.data.pinned,
+ uid=uid,
+ parent_node_uid=parent_uid,
+ children_node_uids=children,
+ local_index=local_idx)
+ if new_undo or not self.undo_stack:
+ self.undo_stack.append([entry])
+ else:
+ self.undo_stack[-1].append(entry)
+ else:
+ entries = []
+ for descendent in node.traverse(notree.TraverseOrder.POST_R):
+ entries.append(_TreeUndoEntry.from_node(descendent, 0))
+ # ensure descendent is not later saved as child as well
+ descendent.parent = None # FIXME: Find a way not to change
+ # the tree
+ if new_undo:
+ self.undo_stack.append(entries)
+ else:
+ self.undo_stack[-1] += entries
+
+ def undo(self, depth=1):
+ """Undo removing of a tab or tabs."""
+ # TODO find a way to remove dupe code
+ # probably by getting entries from undo stack, THEN calling super
+ # then post-processing the entries
+
+ # save entries before super().undo() pops them
+ entries = list(self.undo_stack[-depth])
+ new_tabs = super().undo(depth)
+
+ for entry, tab in zip(reversed(entries), new_tabs):
+ if not isinstance(entry, _TreeUndoEntry):
+ continue
+ root = self.widget.tree_root
+ uid = entry.uid
+ parent_uid = entry.parent_node_uid
+ parent_node = root.get_descendent_by_uid(parent_uid)
+ if not parent_node:
+ parent_node = root
+
+ children = []
+ for child_uid in entry.children_node_uids:
+ child_node = root.get_descendent_by_uid(child_uid)
+ children.append(child_node)
+ tab.node.parent = None # Remove the node from the tree
+ tab.node = notree.Node(tab, parent_node,
+ children, uid)
+
+ # correctly reposition the tab
+ local_idx = entry.local_index
+ if tab.node.parent: # should always be true
+ new_siblings = list(tab.node.parent.children)
+ new_siblings.remove(tab.node)
+ new_siblings.insert(local_idx, tab.node)
+ tab.node.parent.children = new_siblings
+
+ self.widget.tree_tab_update()
+
+ @pyqtSlot('QUrl')
+ @pyqtSlot('QUrl', bool)
+ @pyqtSlot('QUrl', bool, bool)
+ def tabopen(
+ self, url: QUrl = None,
+ background: bool = None,
+ related: bool = True,
+ sibling: bool = False,
+ idx: int = None,
+ ) -> browsertab.AbstractTab:
+ """Open a new tab with a given url.
+
+ Args:
+ related: Whether to set the tab as a child of the currently focused
+ tab. Follows `tabs.new_position.tree.related`.
+ sibling: Whether to set the tab as a sibling of the currently
+ focused tab. Follows `tabs.new_position.tree.sibling`.
+
+ """
+ # pylint: disable=arguments-differ
+ # we save this now because super.tabopen also resets the focus
+ cur_tab = self.widget.currentWidget()
+ tab = super().tabopen(url, background, related, idx)
+
+ tab.node.parent = self.widget.tree_root
+ if cur_tab is None or tab is cur_tab:
+ self.widget.tree_tab_update()
+ return tab
+
+ # get pos
+ if related:
+ pos = config.val.tabs.new_position.tree.new_child
+ parent = cur_tab.node
+ # pos can only be first, last
+ elif sibling:
+ pos = config.val.tabs.new_position.tree.new_sibling
+ parent = cur_tab.node.parent
+ # pos can be first, last, prev, next
+ else:
+ pos = config.val.tabs.new_position.tree.new_toplevel
+ parent = self.widget.tree_root
+
+ self._position_tab(cur_tab, tab, pos, parent, sibling, related, background)
+
+ return tab
+
+ def _position_tab(
+ self,
+ cur_tab: browsertab.AbstractTab,
+ tab: browsertab.AbstractTab,
+ pos: str,
+ parent: notree.Node,
+ sibling: bool = False,
+ related: bool = True,
+ background: bool = None,
+ ) -> None:
+ toplevel = not sibling and not related
+ siblings = list(parent.children)
+ if tab.node in siblings: # true if parent is tree_root
+ # remove it and add it later in the right position
+ siblings.remove(tab.node)
+
+ if pos == 'first':
+ rel_idx = 0
+ if config.val.tabs.new_position.stacking and related:
+ rel_idx += self._tree_tab_child_rel_idx
+ self._tree_tab_child_rel_idx += 1
+ siblings.insert(rel_idx, tab.node)
+ elif pos in ['prev', 'next'] and (sibling or toplevel):
+ # pivot is the tab relative to which 'prev' or 'next' apply
+ # it is always a member of 'siblings'
+ pivot = cur_tab.node if sibling else cur_tab.node.path[1]
+ direction = -1 if pos == 'prev' else 1
+ rel_idx = 0 if pos == 'prev' else 1
+ tgt_idx = siblings.index(pivot) + rel_idx
+ if config.val.tabs.new_position.stacking:
+ if sibling:
+ tgt_idx += self._tree_tab_sibling_rel_idx
+ self._tree_tab_sibling_rel_idx += direction
+ elif toplevel:
+ tgt_idx += self._tree_tab_toplevel_rel_idx
+ self._tree_tab_toplevel_rel_idx += direction
+ siblings.insert(tgt_idx, tab.node)
+ else: # position == 'last'
+ siblings.append(tab.node)
+ parent.children = siblings
+ self.widget.tree_tab_update()
+ if not background:
+ self._reset_stack_counters()
+
+ def _reset_stack_counters(self):
+ self._tree_tab_child_rel_idx = 0
+ self._tree_tab_sibling_rel_idx = 0
+ self._tree_tab_toplevel_rel_idx = 0
+
+ @pyqtSlot(int)
+ def _on_current_changed(self, idx):
+ super()._on_current_changed(idx)
+ self._reset_stack_counters()
+
+ 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:
+ node.collapsed = False
+ for descendent in node.traverse(render_collapsed=True):
+ descendent.collapsed = False
+ return
+
+ def rel_depth(n):
+ return n.depth - node.depth
+
+ levels: Dict[int, list] = collections.defaultdict(list)
+ for d in node.traverse(render_collapsed=False):
+ r_depth = rel_depth(d)
+ levels[r_depth].append(d)
+
+ # Remove highest level because it's leaves (or already collapsed)
+ del levels[max(levels.keys())]
+
+ target = 0
+ for level in sorted(levels, reverse=True):
+ nodes = levels[level]
+ if not all(n.collapsed or not n.children for n in nodes):
+ target = level
+ break
+ for n in levels[target]:
+ if not n.collapsed and n.children:
+ n.collapsed = True
diff --git a/qutebrowser/mainwindow/treetabwidget.py b/qutebrowser/mainwindow/treetabwidget.py
new file mode 100644
index 00000000000..12de178c2ec
--- /dev/null
+++ b/qutebrowser/mainwindow/treetabwidget.py
@@ -0,0 +1,105 @@
+# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
+
+# Copyright 2014-2018 Giuseppe Stelluto (pinusc) <giuseppe@gstelluto.com>
+#
+# This file is part of qutebrowser.
+#
+# qutebrowser is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# qutebrowser is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with qutebrowser. If not, see <https://www.gnu.org/licenses/>.
+
+"""Extension of TabWidget for tree-tab functionality."""
+
+from qutebrowser.mainwindow.tabwidget import TabWidget
+from qutebrowser.misc.notree import Node
+from qutebrowser.utils import log
+
+
+class TreeTabWidget(TabWidget):
+ """Tab widget used in TabbedBrowser, with tree-functionality.
+
+ Handles correct rendering of the tree as a tab field, and correct
+ positioning of tabs according to tree structure.
+ """
+
+ def __init__(self, win_id, parent=None):
+ # root of the tab tree, common for all tabs in the window
+ self.tree_root = Node(None)
+ super().__init__(win_id, parent)
+ self.tabBar().tabMoved.disconnect(self.update_tab_titles)
+
+ def _init_config(self):
+ super()._init_config()
+ # For tree-tabs
+ self.update_tab_titles() # Must also be called when deactivating
+ self.tree_tab_update()
+
+ def get_tab_fields(self, idx):
+ """Add tree field data to normal tab field data."""
+ fields = super().get_tab_fields(idx)
+
+ tab = self.widget(idx)
+ fields['collapsed'] = '[...] ' if tab.node.collapsed else ''
+
+ # we remove the first two chars because every tab is child of tree
+ # root and that gets rendered as well
+ rendered_tree = self.tree_root.render()
+ try:
+ pre, _ = rendered_tree[idx+1]
+ tree_prefix = pre[2:]
+ except IndexError: # window or first tab are not initialized yet
+ tree_prefix = ""
+ log.misc.error("tree_prefix is empty!")
+
+ fields['tree'] = tree_prefix
+ return fields
+
+ def update_tree_tab_positions(self):
+ """Update tab positions according to the tree structure."""
+ nodes = self.tree_root.traverse(render_collapsed=False)
+ for idx, node in enumerate(nodes):
+ if idx > 0:
+ cur_idx = self.indexOf(node.value)
+ self.tabBar().moveTab(cur_idx, idx-1)
+
+ def update_tree_tab_visibility(self):
+ """Hide collapsed tabs and show uncollapsed ones.
+
+ Sync the internal tree to the tabs the user can actually see.
+ """
+ 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
+ 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()
+ if node.parent is not None:
+ 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()
diff --git a/qutebrowser/misc/notree.py b/qutebrowser/misc/notree.py
new file mode 100644
index 00000000000..9d180ad4ce7
--- /dev/null
+++ b/qutebrowser/misc/notree.py
@@ -0,0 +1,354 @@
+# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
+
+# Copyright 2019 Giuseppe Stelluto (pinusc) <giuseppe@gstelluto.com>
+#
+# This file is part of qutebrowser.
+#
+# qutebrowser is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# qutebrowser is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with qutebrowser. If not, see <https://www.gnu.org/licenses/>.
+
+"""Tree library for tree-tabs.
+
+The fundamental unit is the Node class.
+
+Create a tree with with Node(value, parent):
+root = Node('foo')
+child = Node('bar', root)
+child2 = Node('baz', root)
+child3 = Node('lorem', child)
+
+You can also assign parent after instantiation, or even reassign it:
+child4 = Node('ipsum')
+child4.parent = root
+
+Assign children:
+child.children = []
+child2.children = [child4, child3]
+child3.parent
+> Node('foo/bar/baz')
+
+Render a tree with render_tree(root_node):
+render_tree(root)
+
+> ('', 'foo')
+> ('├─', 'bar')
+> ('│ ├─', 'lorem')
+> ('│ └─', 'ipsum')
+> ('└─', 'baz')
+"""
+import enum
+from typing import Optional, TypeVar, Sequence, List, Tuple, Iterable, Generic
+import itertools
+
+# For Node.render
+CORNER = '└─'
+INTERSECTION = '├─'
+PIPE = '│'
+
+
+class TreeError(RuntimeError):
+ """Exception used for tree-related errors."""
+
+
+class TraverseOrder(enum.Enum):
+ """To be used as argument to traverse().
+
+ Implemented orders are pre-order and post-order.
+ Attributes:
+ PRE: pre-order (parents before children). Same as in Node.render
+ POST: children of a node are always yield before their parent.
+ POST_R: Like POST, but children are yield in reverse order
+ """
+
+ PRE = 'pre-order'
+ POST = 'post-order'
+ POST_R = 'post-order-reverse'
+
+
+uid_gen = itertools.count(0)
+
+# generic type of value held by Node
+T = TypeVar('T') # pylint: disable=invalid-name
+
+
+class Node(Generic[T]):
+ """Fundamental unit of notree library.
+
+ Attributes:
+ value: The element (ususally a tab) the node represents
+ parent: Node's parent.
+ children: Node's children elements.
+ siblings: Children of parent node that are not self.
+ path: List of nodes from root of tree to self value, parent, and
+ children can all be set by user. Everything else will be updated
+ accordingly, so that if `node.parent = root_node`, then `node in
+ root_node.children` will be True.
+ """
+
+ sep: str = '/'
+ __parent: Optional['Node[T]'] = None
+ # this is a global 'static' class attribute
+
+ def __init__(self,
+ value: T,
+ parent: Optional['Node[T]'] = None,
+ childs: Sequence['Node[T]'] = (),
+ uid: Optional[int] = None) -> None:
+ if uid is not None:
+ self.__uid = uid
+ else:
+ self.__uid = next(uid_gen)
+
+ self.value = value
+ # set initial values so there's no need for AttributeError checks
+ self.__parent: Optional['Node[T]'] = None
+ self.__children: List['Node[T]'] = []
+
+ # For render memoization
+ self.__modified = False
+ self.__set_modified() # not the same as line above
+ self.__rendered: Optional[List[Tuple[str, 'Node[T]']]] = None
+
+ if parent:
+ self.parent = parent # calls setter
+ if childs:
+ self.children = childs # this too
+
+ self.__collapsed = False
+
+ @property
+ def uid(self) -> int:
+ return self.__uid
+
+ @property
+ def parent(self) -> Optional['Node[T]']:
+ return self.__parent
+
+ @parent.setter
+ def parent(self, value: 'Node[T]') -> None:
+ """Set parent property. Also adds self to value.children."""
+ # pylint: disable=protected-access
+ assert(value is None or isinstance(value, Node))
+ if self.__parent:
+ self.__parent.__disown(self)
+ self.__parent = None
+ if value is not None:
+ value.__add_child(self)
+ self.__parent = value
+ self.__set_modified()
+
+ @property
+ def children(self) -> Sequence['Node[T]']:
+ return tuple(self.__children)
+
+ @children.setter
+ def children(self, value: Sequence['Node[T]']) -> None:
+ """Set children property, preserving order.
+
+ Also sets n.parent = self for n in value. Does not allow duplicates.
+ """
+ seen = set(value)
+ if len(seen) != len(value):
+ raise TreeError("A duplicate item is present in in %r" % value)
+ new_children = list(value)
+ for child in new_children:
+ if child.parent is not self:
+ child.parent = self
+ self.__children = new_children
+ self.__set_modified()
+
+ @property
+ def path(self) -> List['Node[T]']:
+ """Get a list of all nodes from the root node to self."""
+ if self.parent is None:
+ return [self]
+ else:
+ return self.parent.path + [self]
+
+ @property
+ def depth(self) -> int:
+ """Get the number of nodes between self and the root node."""
+ return len(self.path) - 1
+
+ @property
+ def index(self) -> int:
+ """Get self's position among its siblings (self.parent.children)."""
+ if self.parent is not None:
+ return self.parent.children.index(self)
+ else:
+ raise TreeError('Node has no parent.')
+
+ @property
+ def collapsed(self) -> bool:
+ return self.__collapsed
+
+ @collapsed.setter
+ def collapsed(self, val: bool) -> None:
+ self.__collapsed = val
+ self.__set_modified()
+
+ def __set_modified(self) -> None:
+ """If self is modified, every ancestor is modified as well."""
+ for node in self.path:
+ node.__modified = True # pylint: disable=protected-access
+
+ def render(self) -> List[Tuple[str, 'Node[T]']]:
+ """Render a tree with ascii symbols.
+
+ Tabs appear in the same order as in traverse() with TraverseOrder.PRE
+ Args:
+ node; the root of the tree to render
+
+ Return: list of tuples where the first item is the symbol,
+ and the second is the node it refers to
+ """
+ if not self.__modified and self.__rendered is not None:
+ return self.__rendered
+
+ result = [('', self)]
+ for child in self.children:
+ if child.children:
+ subtree = child.render()
+ if child is not self.children[-1]:
+ subtree = [(PIPE + ' ' + c, n) for c, n in subtree]
+ char = INTERSECTION
+ else:
+ subtree = [(' ' + c, n) for c, n in subtree]
+ char = CORNER
+ subtree[0] = (char, subtree[0][1])
+ if child.collapsed:
+ result += [subtree[0]]
+ else:
+ result += subtree
+ else:
+ if child is self.children[-1]:
+ result.append((CORNER, child))
+ else:
+ result.append((INTERSECTION, child))
+ self.__modified = False
+ self.__rendered = list(result)
+ return list(result)
+
+ def traverse(self, order: TraverseOrder = TraverseOrder.PRE,
+ render_collapsed: bool = True) -> Iterable['Node']:
+ """Generator for all descendants of `self`.
+
+ Args:
+ order: a TraverseOrder object. See TraverseOrder documentation.
+ render_collapsed: whether to yield children of collapsed nodes
+ Even if render_collapsed is False, collapsed nodes are be rendered.
+ It's their children that won't.
+ """
+ if order == TraverseOrder.PRE:
+ yield self
+
+ if self.collapsed and not render_collapsed:
+ if order != TraverseOrder.PRE:
+ yield self
+ return
+
+ f = reversed if order is TraverseOrder.POST_R else lambda x: x
+ for child in f(self.children):
+ if render_collapsed or not child.collapsed:
+ yield from child.traverse(order, render_collapsed)
+ else:
+ yield child
+ if order in [TraverseOrder.POST, TraverseOrder.POST_R]:
+ yield self
+
+ def __add_child(self, node: 'Node[T]') -> None:
+ if node not in self.__children:
+ self.__children.append(node)
+
+ def __disown(self, value: 'Node[T]') -> None:
+ self.__set_modified()
+ if value in self.__children:
+ self.__children.remove(value)
+
+ def get_descendent_by_uid(self, uid: int) -> Optional['Node[T]']:
+ """Return descendent identified by the provided uid.
+
+ Returns None if there is no such descendent.
+
+ Args:
+ uid: The uid of the node to return
+ """
+ for descendent in self.traverse():
+ if descendent.uid == uid:
+ return descendent
+ return None
+
+ def promote(self, times: int = 1, to: str = 'first') -> None:
+ """Makes self a child of its grandparent, i.e. sibling of its parent.
+
+ Args:
+ times: How many levels to promote the tab to. to: One of 'next',
+ 'prev', 'first', 'last'. Determines the position among siblings
+ after being promoted. 'next' and 'prev' are relative to the current
+ parent.
+
+ """
+ if to not in ['first', 'last', 'next', 'prev']:
+ raise Exception("Invalid value supplied for 'to': " + to)
+ position = {'first': 0, 'last': -1}.get(to, None)
+ diff = {'next': 1, 'prev': 0}.get(to, 1)
+ count = times
+ while count > 0:
+ if self.parent is None or self.parent.parent is None:
+ raise TreeError("Tab has no parent!")
+ grandparent = self.parent.parent
+ if position is not None:
+ idx = position
+ else: # diff is necessarily not none
+ idx = self.parent.index + diff
+ self.parent = None
+
+ siblings = list(grandparent.children)
+ if idx != -1:
+ siblings.insert(idx, self)
+ else:
+ siblings.append(self)
+ grandparent.children = siblings
+ count -= 1
+
+ def demote(self, to: str = 'last') -> None:
+ """Demote a tab making it a child of its previous adjacent sibling."""
+ if self.parent is None or self.parent.children is None:
+ raise TreeError("Tab has no siblings!")
+ siblings = list(self.parent.children)
+
+ # we want previous node in the same subtree as current node
+ rel_idx = siblings.index(self) - 1
+
+ if rel_idx >= 0:
+ parent = siblings[rel_idx]
+ new_siblings = list(parent.children)
+ position = {'first': 0, 'last': -1}.get(to, -1)
+ if position == 0:
+ new_siblings.insert(0, self)
+ else:
+ new_siblings.append(self)
+ parent.children = new_siblings
+ else:
+ raise TreeError("Tab has no previous sibling!")
+
+ def __repr__(self) -> str:
+ try:
+ value = str(self.value.url().url()) # type: ignore
+ except Exception:
+ value = str(self.value)
+ return "<Node -%d- '%s'>" % (self.__uid, value)
+
+ def __str__(self) -> str:
+ # return "<Node '%s'>" % self.value
+ return str(self.value)
diff --git a/qutebrowser/misc/sessions.py b/qutebrowser/misc/sessions.py
index 3608568766c..c8445e4ad4d 100644
--- a/qutebrowser/misc/sessions.py
+++ b/qutebrowser/misc/sessions.py
@@ -243,6 +243,9 @@ def _save_tab(self, tab, active, with_history=True):
active: Whether the tab is currently active.
with_history: Include the tab's history.
"""
+ # FIXME understand why this happens
+ if tab is None:
+ return {}
data: _JsonType = {'history': []}
if active:
data['active'] = True
@@ -287,13 +290,29 @@ def _save_all(self, *, only_window=None, with_private=False, with_history=True):
if getattr(active_window, 'win_id', None) == win_id:
win_data['active'] = True
win_data['geometry'] = bytes(main_window.saveGeometry())
- win_data['tabs'] = []
if tabbed_browser.is_private:
win_data['private'] = True
- for i, tab in enumerate(tabbed_browser.widgets()):
- active = i == tabbed_browser.widget.currentIndex()
- win_data['tabs'].append(self._save_tab(tab, active,
- with_history=with_history))
+
+ if tabbed_browser.is_treetabbedbrowser:
+ # a dict where keys are node UIDs, and values are dicts
+ # with tab data (the result of _save_tab) and a list of
+ # children UIDs
+ tree_data = {}
+ root_node = tabbed_browser.widget.tree_root
+ for i, node in enumerate(root_node.traverse(), -1):
+ node_data = {}
+ active = i == tabbed_browser.widget.currentIndex()
+ node_data['tab'] = self._save_tab(node.value, active)
+ node_data['children'] = [c.uid for c in node.children]
+ node_data['collapsed'] = node.collapsed
+ tree_data[node.uid] = node_data
+ win_data['tree'] = tree_data
+ else:
+ win_data['tabs'] = []
+ for i, tab in enumerate(tabbed_browser.widgets()):
+ active = i == tabbed_browser.widget.currentIndex()
+ win_data['tabs'].append(self._save_tab(tab, active,
+ with_history=with_history))
data['windows'].append(win_data)
return data
@@ -461,6 +480,45 @@ def _load_tab(self, new_tab, data): # noqa: C901
except ValueError as e:
raise SessionError(e)
+ def _load_tree(self, tabbed_browser, tree_data):
+ tree_keys = list(tree_data.keys())
+ if not tree_keys:
+ return None
+
+ root_data = tree_data.get(tree_keys[0])
+ if root_data is None:
+ return None
+
+ root_node = tabbed_browser.widget.tree_root
+ tab_to_focus = None
+ index = -1
+
+ def recursive_load_node(uid):
+ nonlocal tab_to_focus
+ nonlocal index
+ index += 1
+ node_data = tree_data[uid]
+ children_uids = node_data['children']
+
+ if tree_data[uid]['tab'].get('active'):
+ tab_to_focus = index
+
+ tab_data = node_data['tab']
+ new_tab = tabbed_browser.tabopen(background=False)
+ self._load_tab(new_tab, tab_data)
+
+ new_tab.node.parent = root_node
+ children = [recursive_load_node(uid) for uid in children_uids]
+ new_tab.node.children = children
+ new_tab.node.collapsed = node_data['collapsed']
+ return new_tab.node
+
+ for child_uid in root_data['children']:
+ child = recursive_load_node(child_uid)
+ child.parent = root_node
+
+ return tab_to_focus
+
def _load_window(self, win):
"""Turn yaml data into windows."""
window = mainwindow.MainWindow(geometry=win['geometry'],
@@ -468,13 +526,29 @@ def _load_window(self, win):
tabbed_browser = objreg.get('tabbed-browser', scope='window',
window=window.win_id)
tab_to_focus = None
- for i, tab in enumerate(win['tabs']):
- new_tab = tabbed_browser.tabopen(background=False)
- self._load_tab(new_tab, tab)
- if tab.get('active', False):
- tab_to_focus = i
- if new_tab.data.pinned:
- new_tab.set_pinned(True)
+
+ # plain_tabs is used in case the saved session contains a tree and
+ # tree-tabs is not enabled, or if the saved session contains normal
+ # tabs
+ plain_tabs = win.get('tabs', None)
+ if win.get('tree'):
+ if tabbed_browser.is_treetabbedbrowser:
+ tree_data = win.get('tree')
+ tab_to_focus = self._load_tree(tabbed_browser, tree_data)
+ tabbed_browser.widget.tree_tab_update()
+ else:
+ tree = win.get('tree')
+ plain_tabs = [tree[i]['tab'] for i in tree if
+ tree[i]['tab']]
+ if plain_tabs:
+ for i, tab in enumerate(plain_tabs):
+ new_tab = tabbed_browser.tabopen(background=False)
+ self._load_tab(new_tab, tab)
+ if tab.get('active', False):
+ tab_to_focus = i
+ if new_tab.data.pinned:
+ new_tab.set_pinned(True)
+
if tab_to_focus is not None:
tabbed_browser.widget.setCurrentIndex(tab_to_focus)
diff --git a/tests/end2end/features/conftest.py b/tests/end2end/features/conftest.py
index 8ce8ba699a1..75bddfa0f8f 100644
--- a/tests/end2end/features/conftest.py
+++ b/tests/end2end/features/conftest.py
@@ -214,12 +214,15 @@ def open_path(quteproc, server, path):
path = path.replace('(port)', str(server.port))
new_tab = False
+ related_tab = False
new_bg_tab = False
new_window = False
private = False
as_url = False
wait = True
+ related_tab_suffix = ' in a new related tab'
+ related_background_tab_suffix = ' in a new related background tab'
new_tab_suffix = ' in a new tab'
new_bg_tab_suffix = ' in a new background tab'
new_window_suffix = ' in a new window'
@@ -231,6 +234,14 @@ def open_path(quteproc, server, path):
if path.endswith(new_tab_suffix):
path = path[:-len(new_tab_suffix)]
new_tab = True
+ elif path.endswith(related_tab_suffix):
+ path = path[:-len(related_tab_suffix)]
+ new_tab = True
+ related_tab = True
+ elif path.endswith(related_background_tab_suffix):
+ path = path[:-len(related_background_tab_suffix)]
+ new_bg_tab = True
+ related_tab = True
elif path.endswith(new_bg_tab_suffix):
path = path[:-len(new_bg_tab_suffix)]
new_bg_tab = True
@@ -249,9 +260,9 @@ def open_path(quteproc, server, path):
else:
break
- quteproc.open_path(path, new_tab=new_tab, new_bg_tab=new_bg_tab,
- new_window=new_window, private=private, as_url=as_url,
- wait=wait)
+ quteproc.open_path(path, related_tab=related_tab, new_tab=new_tab,
+ new_bg_tab=new_bg_tab, new_window=new_window,
+ private=private, as_url=as_url, wait=wait)
@bdd.when(bdd.parsers.parse("I set {opt} to {value}"))
diff --git a/tests/end2end/fixtures/quteprocess.py b/tests/end2end/fixtures/quteprocess.py
index c3194b8397e..a59a05ec222 100644
--- a/tests/end2end/fixtures/quteprocess.py
+++ b/tests/end2end/fixtures/quteprocess.py
@@ -651,16 +651,17 @@ def temp_setting(self, opt, value):
self.set_setting(opt, old_value)
def open_path(self, path, *, new_tab=False, new_bg_tab=False,
- new_window=False, private=False, as_url=False, port=None,
- https=False, wait=True):
+ related_tab=False, new_window=False, private=False,
+ as_url=False, port=None, https=False, wait=True):
"""Open the given path on the local webserver in qutebrowser."""
url = self.path_to_url(path, port=port, https=https)
self.open_url(url, new_tab=new_tab, new_bg_tab=new_bg_tab,
- new_window=new_window, private=private, as_url=as_url,
- wait=wait)
+ related_tab=related_tab, new_window=new_window,
+ private=private, as_url=as_url, wait=wait)
def open_url(self, url, *, new_tab=False, new_bg_tab=False,
- new_window=False, private=False, as_url=False, wait=True):
+ related_tab=False, new_window=False, private=False,
+ as_url=False, wait=True):
"""Open the given url in qutebrowser."""
if sum(1 for opt in [new_tab, new_bg_tab, new_window, private, as_url]
if opt) > 1:
@@ -670,9 +671,15 @@ def open_url(self, url, *, new_tab=False, new_bg_tab=False,
self.send_cmd(url, invalid=True)
line = None
elif new_tab:
- line = self.send_cmd(':open -t ' + url)
+ if related_tab:
+ line = self.send_cmd(':open -t -r ' + url)
+ else:
+ line = self.send_cmd(':open -t ' + url)
elif new_bg_tab:
- line = self.send_cmd(':open -b ' + url)
+ if related_tab:
+ line = self.send_cmd(':open -b -r ' + url)
+ else:
+ line = self.send_cmd(':open -b ' + url)
elif new_window:
line = self.send_cmd(':open -w ' + url)
elif private:
diff --git a/tests/helpers/stubs.py b/tests/helpers/stubs.py
index 341d1de2a61..2dfb15916e9 100644
--- a/tests/helpers/stubs.py
+++ b/tests/helpers/stubs.py
@@ -337,6 +337,7 @@ class FakeCommand:
hide: bool = False
debug: bool = False
deprecated: bool = False
+ tree_tab: bool = False
completion: Any = None
maxsplit: int = None
takes_count: Callable[[], bool] = lambda: False
diff --git a/tests/unit/misc/test_notree.py b/tests/unit/misc/test_notree.py
new file mode 100644
index 00000000000..95f92f1a68f
--- /dev/null
+++ b/tests/unit/misc/test_notree.py
@@ -0,0 +1,308 @@
+# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
+
+# Copyright 2019 Florian Bruhin (The-Compiler) <me@the-compiler.org>
+#
+# This file is part of qutebrowser.
+#
+# qutebrowser is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# qutebrowser is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with qutebrowser. If not, see <https://www.gnu.org/licenses/>.
+"""Tests for misc.notree library."""
+import pytest
+
+from qutebrowser.misc.notree import TreeError, Node, TraverseOrder
+
+
+@pytest.fixture
+def tree():
+ """Return an example tree.
+
+ n1
+ ├─n2
+ │ ├─n4
+ │ └─n5
+ └─n3
+ ├─n6
+ │ ├─n7
+ │ ├─n8
+ │ └─n9
+ │ └─n10
+ └─n11
+ """
+ # these are actually used because they appear in expected strings
+ n1 = Node('n1')
+ n2 = Node('n2', n1)
+ n4 = Node('n4', n2)
+ n5 = Node('n5', n2)
+ n3 = Node('n3', n1)
+ n6 = Node('n6', n3)
+ n7 = Node('n7', n6)
+ n8 = Node('n8', n6)
+ n9 = Node('n9', n6)
+ n10 = Node('n10', n9)
+ n11 = Node('n11', n3)
+ return n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11
+
+
+@pytest.fixture
+def node(tree):
+ return tree[0]
+
+
+def test_creation():
+ node = Node('foo')
+ assert node.value == 'foo'
+
+ child = Node('bar', node)
+ assert child.parent == node
+ assert node.children == (child, )
+
+
+def test_attach_parent():
+ n1 = Node('n1', None, [])
+ print(n1.children)
+ n2 = Node('n2', n1)
+ n3 = Node('n3')
+
+ n2.parent = n3
+ assert n2.parent == n3
+ assert n3.children == (n2, )
+ assert n1.children == ()
+
+
+def test_duplicate_child():
+ p = Node('n1')
+ try:
+ c1 = Node('c1', p)
+ c2 = Node('c2', p)
+ p.children = [c1, c1, c2]
+ raise AssertionError("Can add duplicate child")
+ except TreeError:
+ pass
+ finally:
+ if len(p.children) == 3:
+ raise AssertionError("Can add duplicate child")
+
+
+def test_replace_parent():
+ p1 = Node('foo')
+ p2 = Node('bar')
+ _ = Node('_', p2)
+ c = Node('baz', p1)
+ c.parent = p2
+ assert c.parent is p2
+ assert c not in p1.children
+ assert c in p2.children
+
+
+def test_replace_children(tree):
+ n2 = tree[1]
+ n3 = tree[2]
+ n6 = tree[5]
+ n11 = tree[10]
+ n3.children = [n11]
+ n2.children = (n6, ) + n2.children
+ assert n6.parent is n2
+ assert n6 in n2.children
+ assert n11.parent is n3
+ assert n11 in n3.children
+ assert n6 not in n3.children
+ assert len(n3.children) == 1
+
+
+def test_promote_to_first(tree):
+ n1 = tree[0]
+ n3 = tree[2]
+ n6 = tree[5]
+ assert n6.parent is n3
+ assert n3.parent is n1
+ n6.promote(to='first')
+ assert n6.parent is n1
+ assert n1.children[0] is n6
+
+
+def test_promote_to_last(tree):
+ n1 = tree[0]
+ n3 = tree[2]
+ n6 = tree[5]
+ assert n6.parent is n3
+ assert n3.parent is n1
+ n6.promote(to='last')
+ assert n6.parent is n1
+ assert n1.children[-1] is n6
+
+
+def test_promote_to_prev(tree):
+ n1 = tree[0]
+ n3 = tree[2]
+ n6 = tree[5]
+ assert n6.parent is n3
+ assert n3.parent is n1
+ assert n1.children[1] is n3
+ n6.promote(to='prev')
+ assert n6.parent is n1
+ assert n1.children[1] is n6
+
+
+def test_promote_to_next(tree):
+ n1 = tree[0]
+ n3 = tree[2]
+ n6 = tree[5]
+ assert n6.parent is n3
+ assert n3.parent is n1
+ assert n1.children[1] is n3
+ n6.promote(to='next')
+ assert n6.parent is n1
+ assert n1.children[2] is n6
+
+
+def test_demote_to_first(tree):
+ n11 = tree[10]
+ n6 = tree[5]
+ assert n11.parent is n6.parent
+ parent = n11.parent
+ assert parent.children.index(n11) == parent.children.index(n6) + 1
+ n11.demote(to='first')
+ assert n11.parent is n6
+ assert n6.children[0] is n11
+
+
+def test_demote_to_last(tree):
+ n11 = tree[10]
+ n6 = tree[5]
+ assert n11.parent is n6.parent
+ parent = n11.parent
+ assert parent.children.index(n11) == parent.children.index(n6) + 1
+ n11.demote(to='last')
+ assert n11.parent is n6
+ assert n6.children[-1] is n11
+
+
+def test_traverse(node):
+ len_traverse = len(list(node.traverse()))
+ len_render = len(node.render())
+ assert len_traverse == len_render
+
+
+def test_traverse_postorder(tree):
+ n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11 = tree
+ actual = list(n1.traverse(TraverseOrder.POST))
+ print('\n'.join([str(n) for n in actual]))
+ assert actual == [n4, n5, n2, n7, n8, n10, n9, n6, n11, n3, n1]
+
+
+def test_traverse_postorder_r(tree):
+ n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11 = tree
+ actual = list(n1.traverse(TraverseOrder.POST_R))
+ print('\n'.join([str(n) for n in actual]))
+ assert actual == [n11, n10, n9, n8, n7, n6, n3, n5, n4, n2, n1]
+
+
+def test_render_tree(node):
+ expected = [
+ 'n1',
+ '├─n2',
+ '│ ├─n4',
+ '│ └─n5',
+ '└─n3',
+ ' ├─n6',
+ ' │ ├─n7',
+ ' │ ├─n8',
+ ' │ └─n9',
+ ' │ └─n10',
+ ' └─n11'
+ ]
+ result = [char + str(n) for char, n in node.render()]
+ print('\n'.join(result))
+ assert expected == result
+
+
+def test_uid(node):
+ uids = set()
+ for n in node.traverse():
+ assert n not in uids
+ uids.add(n.uid)
+ # pylint: disable=unused-variable
+ n1 = Node('n1')
+ n2 = Node('n2', n1)
+ n4 = Node('n4', n2) # noqa: F841
+ n5 = Node('n5', n2) # noqa: F841
+ n3 = Node('n3', n1)
+ n6 = Node('n6', n3)
+ n7 = Node('n7', n6) # noqa: F841
+ n8 = Node('n8', n6) # noqa: F841
+ n9 = Node('n9', n6)
+ n10 = Node('n10', n9) # noqa: F841
+ n11 = Node('n11', n3)
+ # pylint: enable=unused-variable
+ for n in n1.traverse():
+ assert n not in uids
+ uids.add(n.uid)
+
+ n11_uid = n11.uid
+ assert n1.get_descendent_by_uid(n11_uid) is n11
+ assert node.get_descendent_by_uid(n11_uid) is None
+
+
+def test_collapsed(node):
+ pre_collapsed_traverse = list(node.traverse())
+ to_collapse = node.children[1]
+
+ # collapse
+ to_collapse.collapsed = True
+ assert to_collapse.collapsed is True
+ for n in node.traverse(render_collapsed=False):
+ assert to_collapse not in n.path[:-1]
+
+ assert list(to_collapse.traverse(render_collapsed=False)) == [to_collapse]
+
+ assert list(node.traverse()) == pre_collapsed_traverse
+
+ expected = [
+ 'n1',
+ '├─n2',
+ '│ ├─n4',
+ '│ └─n5',
+ '└─n3'
+ ]
+ result = [char + str(n) for char, n in node.render()]
+ print('\n'.join(result))
+ assert expected == result
+
+ # uncollapse
+ to_collapse.collapsed = False
+
+ assert any(n for n in node.traverse(render_collapsed=False) if to_collapse
+ in n.path[:-1])
+
+
+def test_memoization(node):
+ assert node._Node__modified is True
+ node.render()
+ assert node._Node__modified is False
+
+ node.children[0].parent = None
+ assert node._Node__modified is True
+ node.render()
+ assert node._Node__modified is False
+
+ n2 = Node('ntest', parent=node)
+ assert node._Node__modified is True
+ assert n2._Node__modified is True
+ node.render()
+ assert node._Node__modified is False
+
+ node.children[0].children[1].parent = None
+ assert node._Node__modified is True
+ assert node.children[0]._Node__modified is True
+ node.render()
+ assert node._Node__modified is False
Reference in a new issue Copy permalink