diff --git a/qutebrowser/app.py b/qutebrowser/app.py
index f84eafd27..2fc0e88f1 100644
--- a/qutebrowser/app.py
+++ b/qutebrowser/app.py
@@ -64,39 +64,43 @@ class QuteBrowser(QApplication):
>>> app = QuteBrowser()
>>> sys.exit(app.exec_())
- """
+ Attributes:
+ mainwindow: The MainWindow QWidget.
+ commandparser: The main CommandParser instance.
+ keyparser: The main KeyParser instance.
+ searchparser: The main SearchParser instance.
+ _dirs: AppDirs instance for config/cache directories.
+ _args: ArgumentParser instance.
+ _timers: List of used QTimers so they don't get GCed.
+ _shutting_down: True if we're currently shutting down.
+ _quit_status: The current quitting status.
- dirs = None # AppDirs - config/cache directories
- config = None # Config(Parser) object
- mainwindow = None
- commandparser = None
- keyparser = None
- args = None # ArgumentParser
- timers = None
- shutting_down = False
- _quit_status = None
+ """
def __init__(self):
super().__init__(sys.argv)
self._quit_status = {}
+ self._timers = []
+ self._shutting_down = False
+
sys.excepthook = self._exception_hook
- self._parseopts()
+ self._args = self._parseopts()
self._initlog()
self._initmisc()
- self.dirs = AppDirs('qutebrowser')
- if self.args.confdir is None:
- confdir = self.dirs.user_config_dir
- elif self.args.confdir == '':
+ self._dirs = AppDirs('qutebrowser')
+ if self._args.confdir is None:
+ confdir = self._dirs.user_config_dir
+ elif self._args.confdir == '':
confdir = None
else:
- confdir = self.args.confdir
+ confdir = self._args.confdir
config.init(confdir)
self.commandparser = cmdutils.CommandParser()
self.searchparser = cmdutils.SearchParser()
- self.keyparser = KeyParser(self.mainwindow)
+ self.keyparser = KeyParser(self)
self._init_cmds()
self.mainwindow = MainWindow()
@@ -125,7 +129,7 @@ class QuteBrowser(QApplication):
self.mainwindow.show()
self._python_hacks()
timer = QTimer.singleShot(0, self._process_init_args)
- self.timers.append(timer)
+ self._timers.append(timer)
def _process_init_args(self):
"""Process initial positional args.
@@ -139,7 +143,7 @@ class QuteBrowser(QApplication):
QEventLoop.ExcludeSocketNotifiers)
opened_urls = False
- for e in self.args.command:
+ for e in self._args.command:
if e.startswith(':'):
logging.debug('Startup cmd {}'.format(e))
self.commandparser.run(e.lstrip(':'))
@@ -254,7 +258,7 @@ class QuteBrowser(QApplication):
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
- self.timers.append(timer)
+ self._timers.append(timer)
def _parseopts(self):
"""Parse command line options."""
@@ -269,11 +273,11 @@ class QuteBrowser(QApplication):
'on startup.', metavar=':command')
# URLs will actually be in command
parser.add_argument('url', nargs='*', help='URLs to open on startup.')
- self.args = parser.parse_args()
+ return parser.parse_args()
def _initlog(self):
"""Initialisation of the logging output."""
- loglevel = 'debug' if self.args.debug else self.args.loglevel
+ loglevel = 'debug' if self._args.debug else self._args.loglevel
numeric_level = getattr(logging, loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: {}'.format(loglevel))
@@ -285,11 +289,10 @@ class QuteBrowser(QApplication):
def _initmisc(self):
"""Initialize misc things."""
- if self.args.debug:
+ if self._args.debug:
os.environ['QT_FATAL_WARNINGS'] = '1'
self.setApplicationName("qutebrowser")
self.setApplicationVersion(qutebrowser.__version__)
- self.timers = []
def _init_cmds(self):
"""Initialisation of the qutebrowser commands.
@@ -315,9 +318,9 @@ class QuteBrowser(QApplication):
quit -- Whether to quit after shutting down.
"""
- if self.shutting_down:
+ if self._shutting_down:
return
- self.shutting_down = True
+ self._shutting_down = True
logging.debug("Shutting down... (do_quit={})".format(do_quit))
try:
config.config.save()
@@ -331,7 +334,7 @@ class QuteBrowser(QApplication):
try:
if do_quit:
self.mainwindow.tabs.shutdown_complete.connect(
- self._on_tab_shutdown_complete)
+ self.on_tab_shutdown_complete)
else:
self.mainwindow.tabs.shutdown_complete.connect(
functools.partial(self._maybe_quit, 'shutdown'))
@@ -351,7 +354,7 @@ class QuteBrowser(QApplication):
config.state['geometry']['mainwindow'] = geom
@pyqtSlot()
- def _on_tab_shutdown_complete(self):
+ def on_tab_shutdown_complete(self):
"""Quit application after a shutdown.
Gets called when all tabs finished shutting down after shutdown().
@@ -375,32 +378,33 @@ class QuteBrowser(QApplication):
(count, argv) = tpl
cmd = argv[0]
args = argv[1:]
+ browser = self.mainwindow.tabs
handlers = {
- 'open': self.mainwindow.tabs.openurl,
- 'opencur': self.mainwindow.tabs.opencur,
- 'tabopen': self.mainwindow.tabs.tabopen,
- 'tabopencur': self.mainwindow.tabs.tabopencur,
+ 'open': browser.openurl,
+ 'opencur': browser.opencur,
+ 'tabopen': browser.tabopen,
+ 'tabopencur': browser.tabopencur,
'quit': self.shutdown,
- 'tabclose': self.mainwindow.tabs.cur_close,
- 'tabprev': self.mainwindow.tabs.switch_prev,
- 'tabnext': self.mainwindow.tabs.switch_next,
- 'reload': self.mainwindow.tabs.cur_reload,
- 'stop': self.mainwindow.tabs.cur_stop,
- 'back': self.mainwindow.tabs.cur_back,
- 'forward': self.mainwindow.tabs.cur_forward,
- 'print': self.mainwindow.tabs.cur_print,
- 'scroll': self.mainwindow.tabs.cur_scroll,
- 'scroll_page': self.mainwindow.tabs.cur_scroll_page,
- 'scroll_perc_x': self.mainwindow.tabs.cur_scroll_percent_x,
- 'scroll_perc_y': self.mainwindow.tabs.cur_scroll_percent_y,
- 'undo': self.mainwindow.tabs.undo_close,
+ 'tabclose': browser.cur_close,
+ 'tabprev': browser.switch_prev,
+ 'tabnext': browser.switch_next,
+ 'reload': browser.cur_reload,
+ 'stop': browser.cur_stop,
+ 'back': browser.cur_back,
+ 'forward': browser.cur_forward,
+ 'print': browser.cur_print,
+ 'scroll': browser.cur_scroll,
+ 'scroll_page': browser.cur_scroll_page,
+ 'scroll_perc_x': browser.cur_scroll_percent_x,
+ 'scroll_perc_y': browser.cur_scroll_percent_y,
+ 'undo': browser.undo_close,
'pyeval': self.pyeval,
'nextsearch': self.searchparser.nextsearch,
- 'yank': self.mainwindow.tabs.cur_yank,
- 'yanktitle': self.mainwindow.tabs.cur_yank_title,
- 'paste': self.mainwindow.tabs.paste,
- 'tabpaste': self.mainwindow.tabs.tabpaste,
+ 'yank': browser.cur_yank,
+ 'yanktitle': browser.cur_yank_title,
+ 'paste': browser.paste,
+ 'tabpaste': browser.tabpaste,
'crash': self.crash,
}
diff --git a/qutebrowser/commands/keys.py b/qutebrowser/commands/keys.py
index 7ba79c3a5..5fcc18b2e 100644
--- a/qutebrowser/commands/keys.py
+++ b/qutebrowser/commands/keys.py
@@ -32,17 +32,24 @@ startchars = ":/?"
class KeyParser(QObject):
- """Parser for vim-like key sequences."""
+ """Parser for vim-like key sequences.
+
+ Attributes:
+ commandparser: Commandparser instance.
+ _keystring: The currently entered key sequence
+ _bindings: Bound keybindings
+ _modifier_bindings: Bound modifier bindings.
+
+ Signals:
+ set_cmd_text: Emitted when the statusbar should set a partial command.
+ arg: Text to set.
+ keystring_updated: Emitted when the keystring is updated.
+ arg: New keystring.
+
+ """
- keystring = '' # The currently entered key sequence
- # Signal emitted when the statusbar should set a partial command
set_cmd_text = pyqtSignal(str)
- # Signal emitted when the keystring is updated
keystring_updated = pyqtSignal(str)
- # Keybindings
- bindings = {}
- modifier_bindings = {}
- commandparser = None
MATCH_PARTIAL = 0
MATCH_DEFINITIVE = 1
@@ -51,6 +58,9 @@ class KeyParser(QObject):
def __init__(self, mainwindow):
super().__init__(mainwindow)
self.commandparser = CommandParser()
+ self._keystring = ''
+ self._bindings = {}
+ self._modifier_bindings = {}
def from_config_sect(self, sect):
"""Load keybindings from a ConfigParser section.
@@ -65,10 +75,10 @@ class KeyParser(QObject):
keystr = self._normalize_keystr(key.strip('@'))
logging.debug('registered mod key: {} -> {}'.format(keystr,
cmd))
- self.modifier_bindings[keystr] = cmd
+ self._modifier_bindings[keystr] = cmd
else:
logging.debug('registered key: {} -> {}'.format(key, cmd))
- self.bindings[key] = cmd
+ self._bindings[key] = cmd
def handle(self, e):
"""Handle a new keypress and call the respective handlers.
@@ -79,7 +89,7 @@ class KeyParser(QObject):
handled = self._handle_modifier_key(e)
if not handled:
self._handle_single_key(e)
- self.keystring_updated.emit(self.keystring)
+ self.keystring_updated.emit(self._keystring)
def _handle_modifier_key(self, e):
"""Handle a new keypress with modifiers.
@@ -108,7 +118,7 @@ class KeyParser(QObject):
modstr += s + '+'
keystr = QKeySequence(e.key()).toString()
try:
- cmdstr = self.modifier_bindings[modstr + keystr]
+ cmdstr = self._modifier_bindings[modstr + keystr]
except KeyError:
logging.debug('No binding found for {}.'.format(modstr + keystr))
return True
@@ -133,15 +143,15 @@ class KeyParser(QObject):
logging.debug('Ignoring, no text')
return
- self.keystring += txt
+ self._keystring += txt
- if any(self.keystring == c for c in startchars):
- self.set_cmd_text.emit(self.keystring)
- self.keystring = ''
+ if any(self._keystring == c for c in startchars):
+ self.set_cmd_text.emit(self._keystring)
+ self._keystring = ''
return
(countstr, cmdstr_needle) = re.match(r'^(\d*)(.*)',
- self.keystring).groups()
+ self._keystring).groups()
if not cmdstr_needle:
return
@@ -157,16 +167,16 @@ class KeyParser(QObject):
if match == self.MATCH_DEFINITIVE:
pass
elif match == self.MATCH_PARTIAL:
- logging.debug('No match for "{}" (added {})'.format(self.keystring,
- txt))
+ logging.debug('No match for "{}" (added {})'.format(
+ self._keystring, txt))
return
elif match == self.MATCH_NONE:
logging.debug('Giving up with "{}", no matches'.format(
- self.keystring))
- self.keystring = ''
+ self._keystring))
+ self._keystring = ''
return
- self.keystring = ''
+ self._keystring = ''
count = int(countstr) if countstr else None
self._run_or_fill(cmdstr_hay, count=count, ignore_exc=False)
return
@@ -178,11 +188,11 @@ class KeyParser(QObject):
"""
try:
- cmdstr_hay = self.bindings[cmdstr_needle]
+ cmdstr_hay = self._bindings[cmdstr_needle]
return (self.MATCH_DEFINITIVE, cmdstr_hay)
except KeyError:
# No definitive match, check if there's a chance of a partial match
- for hay in self.bindings:
+ for hay in self._bindings:
try:
if cmdstr_needle[-1] == hay[len(cmdstr_needle) - 1]:
return (self.MATCH_PARTIAL, None)
diff --git a/qutebrowser/commands/template.py b/qutebrowser/commands/template.py
index b99c79a9c..7126fe017 100644
--- a/qutebrowser/commands/template.py
+++ b/qutebrowser/commands/template.py
@@ -30,6 +30,10 @@ class Command(QObject):
See the module documentation for qutebrowser.commands.commands for details.
+ Signals:
+ signal: Emitted when the command was executed.
+ arg: A tuple (command, [args])
+
"""
# FIXME:
diff --git a/qutebrowser/commands/utils.py b/qutebrowser/commands/utils.py
index 7de54da6a..4e20bfeec 100644
--- a/qutebrowser/commands/utils.py
+++ b/qutebrowser/commands/utils.py
@@ -49,12 +49,26 @@ def register_all():
class SearchParser(QObject):
- """Parse qutebrowser searches."""
+ """Parse qutebrowser searches.
+
+ Attributes:
+ _text: The text from the last search.
+ _flags: The flags from the last search.
+
+ Signals:
+ do_search: Emitted when a search should be started.
+ arg 1: Search string.
+ arg 2: Flags to use.
+
+ """
- text = None
- flags = 0
do_search = pyqtSignal(str, 'QWebPage::FindFlags')
+ def __init__(self, parent=None):
+ self._text = None
+ self._flags = 0
+ super().__init__(parent)
+
@pyqtSlot(str)
def search(self, text):
"""Search for a text on a website.
@@ -80,33 +94,45 @@ class SearchParser(QObject):
rev -- Search direction.
"""
- if self.text != text:
+ if self._text is not None and self._text != text:
self.do_search.emit('', 0)
- self.text = text
- self.flags = 0
+ self._text = text
+ self._flags = 0
if config.config.getboolean('general', 'ignorecase', fallback=True):
- self.flags |= QWebPage.FindCaseSensitively
+ self._flags |= QWebPage.FindCaseSensitively
if config.config.getboolean('general', 'wrapsearch', fallback=True):
- self.flags |= QWebPage.FindWrapsAroundDocument
+ self._flags |= QWebPage.FindWrapsAroundDocument
if rev:
- self.flags |= QWebPage.FindBackward
- self.do_search.emit(self.text, self.flags)
+ self._flags |= QWebPage.FindBackward
+ self.do_search.emit(self._text, self._flags)
def nextsearch(self, count=1):
"""Continue the search to the ([count]th) next term."""
- if self.text is not None:
+ if self._text is not None:
for i in range(count): # pylint: disable=unused-variable
- self.do_search.emit(self.text, self.flags)
+ self.do_search.emit(self._text, self._flags)
class CommandParser(QObject):
- """Parse qutebrowser commandline commands."""
+ """Parse qutebrowser commandline commands.
- text = ''
- cmd = ''
- args = []
- error = pyqtSignal(str) # Emitted if there's an error
+ Attributes:
+ _cmd: The command which was parsed.
+ _args: The arguments which were parsed.
+
+ Signals:
+ error: Emitted if there was an error.
+ arg: The error message.
+
+ """
+
+ error = pyqtSignal(str)
+
+ def __init__(self, parent=None):
+ super().__init__(parent)
+ self._cmd = None
+ self._args = []
def _parse(self, text):
"""Split the commandline text into command and arguments.
@@ -114,8 +140,7 @@ class CommandParser(QObject):
Raise NoSuchCommandError if a command wasn't found.
"""
- self.text = text
- parts = self.text.strip().split(maxsplit=1)
+ parts = text.strip().split(maxsplit=1)
if not parts:
raise NoSuchCommandError
cmdstr = parts[0]
@@ -130,19 +155,19 @@ class CommandParser(QObject):
args = shlex.split(parts[1])
else:
args = [parts[1]]
- self.cmd = cmd
- self.args = args
+ self._cmd = cmd
+ self._args = args
def _check(self):
"""Check if the argument count for the command is correct."""
- self.cmd.check(self.args)
+ self._cmd.check(self._args)
def _run(self, count=None):
"""Run a command with an optional count."""
if count is not None:
- self.cmd.run(self.args, count=count)
+ self._cmd.run(self._args, count=count)
else:
- self.cmd.run(self.args)
+ self._cmd.run(self._args)
@pyqtSlot(str, int, bool)
def run(self, text, count=None, ignore_exc=True):
@@ -165,7 +190,7 @@ class CommandParser(QObject):
except ArgumentCountError:
if ignore_exc:
self.error.emit("{}: invalid argument count".format(
- self.cmd.mainname))
+ self._cmd.mainname))
return False
else:
raise
diff --git a/qutebrowser/models/commandcompletion.py b/qutebrowser/models/commandcompletion.py
index 25bb6e819..d8e4f7d72 100644
--- a/qutebrowser/models/commandcompletion.py
+++ b/qutebrowser/models/commandcompletion.py
@@ -17,6 +17,8 @@
"""A CompletionModel filled with all commands and descriptions."""
+from collections import OrderedDict
+
from qutebrowser.commands.utils import cmd_dict
from qutebrowser.models.completion import CompletionModel
@@ -35,5 +37,6 @@ class CommandCompletionModel(CompletionModel):
if not obj.hide:
doc = obj.__doc__.splitlines()[0].strip().rstrip('.')
cmdlist.append([obj.mainname, doc])
- self._data['Commands'] = sorted(cmdlist)
- self.init_data()
+ data = OrderedDict()
+ data['Commands'] = sorted(cmdlist)
+ self.init_data(data)
diff --git a/qutebrowser/models/completion.py b/qutebrowser/models/completion.py
index 1e4ed488b..7d2ab64a4 100644
--- a/qutebrowser/models/completion.py
+++ b/qutebrowser/models/completion.py
@@ -15,15 +15,7 @@
# You should have received a copy of the GNU General Public License
# along with qutebrowser. If not, see .
-"""The base completion model for completion in the command line.
-
-Contains:
- CompletionModel -- A simple tree model based on Python data.
- CompletionItem -- One item in the CompletionModel.
-
-"""
-
-from collections import OrderedDict
+"""The base completion model for completion in the command line."""
from PyQt5.QtCore import Qt, QVariant, QAbstractItemModel, QModelIndex
@@ -34,15 +26,18 @@ class CompletionModel(QAbstractItemModel):
Used for showing completions later in the CompletionView.
+ Attributes:
+ _id_map: A mapping from Python object IDs (from id()) to objects, to be
+ used as internalIndex for the model.
+ _root: The root item.
+
"""
def __init__(self, parent=None):
super().__init__(parent)
- self._data = OrderedDict()
- self.parents = []
- self.id_map = {}
- self.root = CompletionItem([""] * 2)
- self.id_map[id(self.root)] = self.root
+ self._id_map = {}
+ self._root = CompletionItem([""] * 2)
+ self._id_map[id(self._root)] = self._root
def removeRows(self, position=0, count=1, parent=QModelIndex()):
"""Remove rows from the model.
@@ -63,9 +58,9 @@ class CompletionModel(QAbstractItemModel):
"""
if index.isValid():
- return self.id_map[index.internalId()]
+ return self._id_map[index.internalId()]
else:
- return self.root
+ return self._root
def columnCount(self, parent=QModelIndex()):
"""Return the column count in the model.
@@ -74,7 +69,7 @@ class CompletionModel(QAbstractItemModel):
"""
# pylint: disable=unused-argument
- return self.root.column_count()
+ return self._root.column_count()
def data(self, index, role=Qt.DisplayRole):
"""Return the data for role/index as QVariant.
@@ -86,7 +81,7 @@ class CompletionModel(QAbstractItemModel):
if not index.isValid():
return QVariant()
try:
- item = self.id_map[index.internalId()]
+ item = self._id_map[index.internalId()]
except KeyError:
return QVariant()
try:
@@ -106,7 +101,7 @@ class CompletionModel(QAbstractItemModel):
if not index.isValid():
return Qt.NoItemFlags
flags = Qt.ItemIsEnabled
- if len(self.id_map[index.internalId()].children) > 0:
+ if len(self._id_map[index.internalId()].children) > 0:
return flags
else:
return flags | Qt.ItemIsSelectable
@@ -119,7 +114,7 @@ class CompletionModel(QAbstractItemModel):
"""
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
- return QVariant(self.root.data(section))
+ return QVariant(self._root.data(section))
return QVariant()
def setData(self, index, value, role=Qt.EditRole):
@@ -131,7 +126,7 @@ class CompletionModel(QAbstractItemModel):
"""
if not index.isValid():
return False
- item = self.id_map[index.internalId()]
+ item = self._id_map[index.internalId()]
try:
item.setdata(index.column(), value, role)
except (IndexError, ValueError):
@@ -153,14 +148,14 @@ class CompletionModel(QAbstractItemModel):
return QModelIndex()
if not parent.isValid():
- parent_item = self.root
+ parent_item = self._root
else:
- parent_item = self.id_map[parent.internalId()]
+ parent_item = self._id_map[parent.internalId()]
child_item = parent_item.children[row]
if child_item:
index = self.createIndex(row, column, id(child_item))
- self.id_map.setdefault(index.internalId(), child_item)
+ self._id_map.setdefault(index.internalId(), child_item)
return index
else:
return QModelIndex()
@@ -174,8 +169,8 @@ class CompletionModel(QAbstractItemModel):
"""
if not index.isValid():
return QModelIndex()
- item = self.id_map[index.internalId()].parent
- if item == self.root or item is None:
+ item = self._id_map[index.internalId()].parent
+ if item == self._root or item is None:
return QModelIndex()
return self.createIndex(item.row(), 0, id(item))
@@ -190,9 +185,9 @@ class CompletionModel(QAbstractItemModel):
return 0
if not parent.isValid():
- pitem = self.root
+ pitem = self._root
else:
- pitem = self.id_map[parent.internalId()]
+ pitem = self._id_map[parent.internalId()]
return len(pitem.children)
@@ -205,15 +200,19 @@ class CompletionModel(QAbstractItemModel):
"""
raise NotImplementedError
- def init_data(self):
- """Initialize the Qt model based on the data in self._data."""
- for (cat, items) in self._data.items():
- newcat = CompletionItem([cat], self.root)
- self.id_map[id(newcat)] = newcat
- self.root.children.append(newcat)
+ def init_data(self, data):
+ """Initialize the Qt model based on the data given.
+
+ data -- dict of data to process.
+
+ """
+ for (cat, items) in data.items():
+ newcat = CompletionItem([cat], self._root)
+ self._id_map[id(newcat)] = newcat
+ self._root.children.append(newcat)
for item in items:
newitem = CompletionItem(item, newcat)
- self.id_map[id(newitem)] = newitem
+ self._id_map[id(newitem)] = newitem
newcat.children.append(newitem)
def mark_all_items(self, needle):
@@ -247,12 +246,15 @@ class CompletionModel(QAbstractItemModel):
class CompletionItem():
- """An item (row) in a CompletionModel."""
+ """An item (row) in a CompletionModel.
- parent = None
- children = None
- _data = None
- _marks = None
+ Attributes:
+ parent: The parent of this item.
+ children: The children of this item.
+ _data: The data of this item.
+ _marks: The marks of this item.
+
+ """
def __init__(self, data, parent=None):
"""Constructor for CompletionItem.
@@ -262,8 +264,8 @@ class CompletionItem():
"""
self.parent = parent
- self._data = data
self.children = []
+ self._data = data
self._marks = []
def data(self, column, role=Qt.DisplayRole):
diff --git a/qutebrowser/models/completionfilter.py b/qutebrowser/models/completionfilter.py
index 8d2c50bb8..371784e68 100644
--- a/qutebrowser/models/completionfilter.py
+++ b/qutebrowser/models/completionfilter.py
@@ -27,13 +27,17 @@ from PyQt5.QtCore import QSortFilterProxyModel, QModelIndex
class CompletionFilterModel(QSortFilterProxyModel):
- """Subclass of QSortFilterProxyModel with custom sorting/filtering."""
+ """Subclass of QSortFilterProxyModel with custom sorting/filtering.
- _pattern = None
- srcmodel = None
+ Attributes:
+ _pattern: The pattern to filter with, used in pattern property.
+ srcmodel: The source model.
+
+ """
def __init__(self, parent=None):
super().__init__(parent)
+ self.srcmodel = None
self._pattern = ''
@property
@@ -41,16 +45,6 @@ class CompletionFilterModel(QSortFilterProxyModel):
"""Getter for pattern."""
return self._pattern
- def setsrc(self, model):
- """Set a new source model and clear the pattern.
-
- model -- The new source model.
-
- """
- self.setSourceModel(model)
- self.srcmodel = model
- self.pattern = ''
-
@pattern.setter
def pattern(self, val):
"""Setter for pattern.
@@ -71,6 +65,16 @@ class CompletionFilterModel(QSortFilterProxyModel):
self.sort(sortcol)
self.invalidate()
+ def setsrc(self, model):
+ """Set a new source model and clear the pattern.
+
+ model -- The new source model.
+
+ """
+ self.setSourceModel(model)
+ self.srcmodel = model
+ self.pattern = ''
+
def filterAcceptsRow(self, row, parent):
"""Custom filter implementation.
diff --git a/qutebrowser/utils/config.py b/qutebrowser/utils/config.py
index d96cfb189..c286e56b4 100644
--- a/qutebrowser/utils/config.py
+++ b/qutebrowser/utils/config.py
@@ -130,11 +130,14 @@ class FontDict(dict):
class Config(ConfigParser):
- """Our own ConfigParser subclass."""
+ """Our own ConfigParser subclass.
- configdir = None
- default_cp = None
- config_loaded = False
+ Attributes:
+ _configdir: The dictionary to save the config in.
+ _default_cp: The ConfigParser instance supplying the default values.
+ _config_loaded: Whether the config was loaded successfully.
+
+ """
def __init__(self, configdir, fname, default_config=None,
always_save=False):
@@ -148,22 +151,23 @@ class Config(ConfigParser):
"""
super().__init__(interpolation=ExtendedInterpolation())
+ self._config_loaded = False
self.always_save = always_save
- self.configdir = configdir
- self.default_cp = ConfigParser(interpolation=ExtendedInterpolation())
- self.default_cp.optionxform = lambda opt: opt # be case-insensitive
+ self._configdir = configdir
+ self._default_cp = ConfigParser(interpolation=ExtendedInterpolation())
+ self._default_cp.optionxform = lambda opt: opt # be case-insensitive
if default_config is not None:
- self.default_cp.read_string(default_config)
- if not self.configdir:
+ self._default_cp.read_string(default_config)
+ if not self._configdir:
return
self.optionxform = lambda opt: opt # be case-insensitive
- self.configdir = configdir
- self.configfile = os.path.join(self.configdir, fname)
+ self._configdir = configdir
+ self.configfile = os.path.join(self._configdir, fname)
if not os.path.isfile(self.configfile):
return
logging.debug("Reading config from {}".format(self.configfile))
self.read(self.configfile)
- self.config_loaded = True
+ self._config_loaded = True
def __getitem__(self, key):
"""Get an item from the configparser or default dict.
@@ -174,7 +178,7 @@ class Config(ConfigParser):
try:
return super().__getitem__(key)
except KeyError:
- return self.default_cp[key]
+ return self._default_cp[key]
def get(self, *args, raw=False, vars=None, fallback=_UNSET):
"""Get an item from the configparser or default dict.
@@ -194,7 +198,7 @@ class Config(ConfigParser):
except (NoSectionError, NoOptionError):
pass
try:
- return self.default_cp.get(*args, raw=raw, vars=vars)
+ return self._default_cp.get(*args, raw=raw, vars=vars)
except (NoSectionError, NoOptionError):
if fallback is _UNSET:
raise
@@ -203,13 +207,13 @@ class Config(ConfigParser):
def save(self):
"""Save the config file."""
- if self.configdir is None or (not self.config_loaded and
- not self.always_save):
+ if self._configdir is None or (not self._config_loaded and
+ not self.always_save):
logging.error("Not saving config (dir {}, loaded {})".format(
- self.configdir, self.config_loaded))
+ self._configdir, self._config_loaded))
return
- if not os.path.exists(self.configdir):
- os.makedirs(self.configdir, 0o755)
+ if not os.path.exists(self._configdir):
+ os.makedirs(self._configdir, 0o755)
logging.debug("Saving config to {}".format(self.configfile))
with open(self.configfile, 'w') as f:
self.write(f)
diff --git a/qutebrowser/utils/signals.py b/qutebrowser/utils/signals.py
index a124f3cae..b933c57ad 100644
--- a/qutebrowser/utils/signals.py
+++ b/qutebrowser/utils/signals.py
@@ -42,10 +42,13 @@ def dbg_signal(sig, args):
class SignalCache(QObject):
- """Cache signals emitted by an object, and re-emit them later."""
+ """Cache signals emitted by an object, and re-emit them later.
- uncached = None
- signal_dict = None
+ Attributes:
+ _uncached: A list of signals which should not be cached.
+ _signal_dict: The internal mapping of signals we got.
+
+ """
def __init__(self, uncached=None):
"""Create a new SignalCache.
@@ -56,10 +59,10 @@ class SignalCache(QObject):
"""
super().__init__()
if uncached is None:
- self.uncached = []
+ self._uncached = []
else:
- self.uncached = uncached
- self.signal_dict = OrderedDict()
+ self._uncached = uncached
+ self._signal_dict = OrderedDict()
def add(self, sig, args):
"""Add a new signal to the signal cache.
@@ -71,21 +74,21 @@ class SignalCache(QObject):
"""
if not self._signal_needs_caching(sig):
return
- had_signal = sig.signal in self.signal_dict
- self.signal_dict[sig.signal] = (sig, args)
+ had_signal = sig.signal in self._signal_dict
+ self._signal_dict[sig.signal] = (sig, args)
if had_signal:
- self.signal_dict.move_to_end(sig.signal)
+ self._signal_dict.move_to_end(sig.signal)
def clear(self):
"""Clear/purge the signal cache."""
- self.signal_dict.clear()
+ self._signal_dict.clear()
def replay(self):
"""Replay all cached signals."""
- for (signal, args) in self.signal_dict.values():
+ for (signal, args) in self._signal_dict.values():
logging.debug('emitting {}'.format(dbg_signal(signal, args)))
signal.emit(*args)
def _signal_needs_caching(self, signal):
"""Return True if a signal should be cached, false otherwise."""
- return not signal_name(signal) in self.uncached
+ return not signal_name(signal) in self._uncached
diff --git a/qutebrowser/utils/style.py b/qutebrowser/utils/style.py
index 344ab959c..4b7a654b4 100644
--- a/qutebrowser/utils/style.py
+++ b/qutebrowser/utils/style.py
@@ -38,6 +38,9 @@ class Style(QCommonStyle):
http://stackoverflow.com/a/17294081
https://code.google.com/p/makehuman/source/browse/trunk/makehuman/lib/qtgui.py # noqa # pylint: disable=line-too-long
+ Attributes:
+ _style: The base/"parent" style.
+
"""
def __init__(self, style):
diff --git a/qutebrowser/widgets/browser.py b/qutebrowser/widgets/browser.py
index 14d2e9d9f..491346b0b 100644
--- a/qutebrowser/widgets/browser.py
+++ b/qutebrowser/widgets/browser.py
@@ -56,23 +56,40 @@ class TabbedBrowser(TabWidget):
- the signal gets filtered with _filter_signals and self.cur_* gets
emitted if the signal occured in the current tab.
+ Attributes:
+ _url_stack: Stack of URLs of closed tabs.
+ _space: Space QShortcut to avoid garbage collection
+ _tabs: A list of open tabs.
+
+ Signals:
+ cur_progress: Progress of the current tab changed (loadProgress).
+ cur_load_started: Current tab started loading (loadStarted)
+ cur_load_finished: Current tab finished loading (loadFinished)
+ cur_statusbar_message: Current tab got a statusbar message
+ (statusBarMessage)
+ cur_url_changed: Current URL changed (urlChanged)
+ cur_link_hovered: Link hovered in current tab (linkHovered)
+ cur_scroll_perc_changed: Scroll percentage of current tab changed.
+ arg 1: x-position in %.
+ arg 2: y-position in %.
+ keypress: A key was pressed.
+ arg: The QKeyEvent leading to the keypress.
+ shutdown_complete: The shuttdown is completed.
+ quit: The last tab was closed, quit application.
+
"""
- cur_progress = pyqtSignal(int) # Progress of the current tab changed
- cur_load_started = pyqtSignal() # Current tab started loading
- cur_load_finished = pyqtSignal(bool) # Current tab finished loading
- cur_statusbar_message = pyqtSignal(str) # Status bar message
- cur_url_changed = pyqtSignal('QUrl') # Current URL changed
- cur_link_hovered = pyqtSignal(str, str, str) # Link hovered in cur tab
- # Current tab changed scroll position
+ cur_progress = pyqtSignal(int)
+ cur_load_started = pyqtSignal()
+ cur_load_finished = pyqtSignal(bool)
+ cur_statusbar_message = pyqtSignal(str)
+ cur_url_changed = pyqtSignal('QUrl')
+ cur_link_hovered = pyqtSignal(str, str, str)
cur_scroll_perc_changed = pyqtSignal(int, int)
- set_cmd_text = pyqtSignal(str) # Set commandline to a given text
+ set_cmd_text = pyqtSignal(str)
keypress = pyqtSignal('QKeyEvent')
- shutdown_complete = pyqtSignal() # All tabs have been shut down.
- quit = pyqtSignal() # Last tab closed, quit application.
- _url_stack = [] # Stack of URLs of closed tabs
- _space = None # Space QShortcut
- _tabs = None
+ shutdown_complete = pyqtSignal()
+ quit = pyqtSignal()
def __init__(self, parent=None):
super().__init__(parent)
@@ -469,27 +486,37 @@ class BrowserTab(QWebView):
Our own subclass of a QWebView with some added bells and whistles.
+ Attributes:
+ page_: The QWebPage behind the view
+ signal_cache: The signal cache associated with the view.
+ _scroll_pos: The old scroll position.
+ _shutdown_callback: Callback to be called after shutdown.
+ _open_new_tab: Whether to open a new tab for the next action.
+ _shutdown_callback: The callback to call after shutting down.
+ _destroyed: Dict of all items to be destroyed on shtudown.
+ Signals:
+ scroll_pos_changed: Scroll percentage of current tab changed.
+ arg 1: x-position in %.
+ arg 2: y-position in %.
+ open_tab: A new tab should be opened.
+ arg: The address to open
+ linkHovered: QWebPages linkHovered signal exposed.
+
"""
- progress = 0
scroll_pos_changed = pyqtSignal(int, int)
open_tab = pyqtSignal('QUrl')
linkHovered = pyqtSignal(str, str, str)
- _scroll_pos = (-1, -1)
- _shutdown_callback = None # callback to be called after shutdown
- _open_new_tab = False # open new tab for the next action
- _destroyed = None # Dict of all items to be destroyed.
- page_ = None # QWebPage
- # dict of tab specific signals, and the values we last got from them.
- signal_cache = None
def __init__(self, parent=None):
super().__init__(parent)
+ self._scroll_pos = (-1, -1)
+ self._shutdown_callback = None
+ self._open_new_tab = False
self._destroyed = {}
self.page_ = BrowserPage(self)
self.setPage(self.page_)
self.signal_cache = SignalCache(uncached=['linkHovered'])
- self.loadProgress.connect(self.on_load_progress)
self.page_.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.page_.linkHovered.connect(self.linkHovered)
self.installEventFilter(self)
@@ -532,17 +559,6 @@ class BrowserTab(QWebView):
else:
self.openurl(url)
- @pyqtSlot(int)
- def on_load_progress(self, prog):
- """Update the progress property if the loading progress changed.
-
- Slot for the loadProgress signal.
-
- prog -- New progress.
-
- """
- self.progress = prog
-
def shutdown(self, callback=None):
"""Shut down the tab cleanly and remove it.
@@ -562,22 +578,22 @@ class BrowserTab(QWebView):
self.settings().setAttribute(QWebSettings.JavascriptEnabled, False)
self._destroyed[self.page_] = False
- self.page_.destroyed.connect(functools.partial(self.on_destroyed,
+ self.page_.destroyed.connect(functools.partial(self._on_destroyed,
self.page_))
self.page_.deleteLater()
self._destroyed[self] = False
- self.destroyed.connect(functools.partial(self.on_destroyed, self))
+ self.destroyed.connect(functools.partial(self._on_destroyed, self))
self.deleteLater()
netman = self.page_.network_access_manager
self._destroyed[netman] = False
netman.abort_requests()
- netman.destroyed.connect(functools.partial(self.on_destroyed, netman))
+ netman.destroyed.connect(functools.partial(self._on_destroyed, netman))
netman.deleteLater()
logging.debug("Tab shutdown scheduled")
- def on_destroyed(self, sender):
+ def _on_destroyed(self, sender):
"""Called when a subsystem has been destroyed during shutdown."""
self._destroyed[sender] = True
dbgout = '\n'.join(['{}: {}'.format(k.__class__.__name__, v)
@@ -636,10 +652,13 @@ class BrowserTab(QWebView):
class BrowserPage(QWebPage):
- """Our own QWebPage with advanced features."""
+ """Our own QWebPage with advanced features.
- _extension_handlers = None
- network_access_manager = None
+ Attributes:
+ _extension_handlers: Mapping of QWebPage extensions to their handlers.
+ network_access_manager: The QNetworkAccessManager used.
+
+ """
def __init__(self, parent=None):
super().__init__(parent)
@@ -683,9 +702,12 @@ class BrowserPage(QWebPage):
class NetworkManager(QNetworkAccessManager):
- """Our own QNetworkAccessManager."""
+ """Our own QNetworkAccessManager.
- _requests = None
+ Attributes:
+ _requests: Pending requests.
+
+ """
def __init__(self, parent=None):
self._requests = {}
diff --git a/qutebrowser/widgets/completion.py b/qutebrowser/widgets/completion.py
index 35799a9a1..e0cd87c58 100644
--- a/qutebrowser/widgets/completion.py
+++ b/qutebrowser/widgets/completion.py
@@ -45,9 +45,22 @@ class CompletionView(QTreeView):
Highlights completions based on marks in the UserRole.
+ Attributes:
+ _STYLESHEET: The stylesheet template for the CompletionView.
+ _completion_models: dict of available completion models.
+ _ignore_next: Whether to ignore the next cmd_text_changed signal.
+ _enabled: Whether showing the CompletionView is enabled.
+ _completing: Whether we're currently completing something.
+ _height: The height to use for the CompletionView.
+ _delegate: The item delegate used.
+
+ Signals:
+ append_cmd_text: Command text which should be appended to the
+ statusbar.
+
"""
- _stylesheet = """
+ _STYLESHEET = """
QTreeView {{
{font[completion]}
{color[completion.fg]}
@@ -77,25 +90,24 @@ class CompletionView(QTreeView):
# like one anymore
# FIXME somehow only the first column is yellow, even with
# setAllColumnsShowFocus
- completion_models = {}
append_cmd_text = pyqtSignal(str)
- ignore_next = False
- enabled = True
- completing = False
- height = QPoint(0, 200)
- _delegate = None
def __init__(self, parent=None):
super().__init__(parent)
- self.enabled = config.config.getboolean('general', 'show_completion')
- self.completion_models[''] = None
- self.completion_models['command'] = CommandCompletionModel()
+ self._height = QPoint(0, 200) # FIXME make that configurable
+ self._enabled = config.config.getboolean('general', 'show_completion')
+ self._completion_models = {}
+ self._completion_models[''] = None
+ self._completion_models['command'] = CommandCompletionModel()
+ self._ignore_next = False
+ self._completing = False
+
self.model = CompletionFilterModel()
self.setModel(self.model)
self.setmodel('command')
- self._delegate = CompletionItemDelegate(self)
+ self._delegate = _CompletionItemDelegate(self)
self.setItemDelegate(self._delegate)
- self.setStyleSheet(config.get_stylesheet(self._stylesheet))
+ self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Minimum)
self.setHeaderHidden(True)
self.setIndentation(0)
@@ -117,7 +129,7 @@ class CompletionView(QTreeView):
model -- A QAbstractItemModel with available completions.
"""
- self.model.setsrc(self.completion_models[model])
+ self.model.setsrc(self._completion_models[model])
self.expandAll()
self.resizeColumnToContents(0)
@@ -131,7 +143,7 @@ class CompletionView(QTreeView):
"""
bottomleft = geom.topLeft()
bottomright = geom.topRight()
- topleft = bottomleft - self.height
+ topleft = bottomleft - self._height
assert topleft.x() < bottomright.x()
assert topleft.y() < bottomright.y()
self.setGeometry(QRect(topleft, bottomright))
@@ -144,7 +156,7 @@ class CompletionView(QTreeView):
pos -- A QPoint containing the statusbar position.
"""
- self.move(pos - self.height)
+ self.move(pos - self._height)
@pyqtSlot(str)
def on_cmd_text_changed(self, text):
@@ -154,22 +166,22 @@ class CompletionView(QTreeView):
text -- The new text
"""
- if self.ignore_next:
+ if self._ignore_next:
# Text changed by a completion, so we don't have to complete again.
- self.ignore_next = False
+ self._ignore_next = False
return
# FIXME more sophisticated completions
if ' ' in text or not text.startswith(':'):
self.hide()
- self.completing = False
+ self._completing = False
return
- self.completing = True
+ self._completing = True
self.setmodel('command')
text = text.lstrip(':')
self.model.pattern = text
self.model.srcmodel.mark_all_items(text)
- if self.enabled:
+ if self._enabled:
self.show()
@pyqtSlot(bool)
@@ -182,7 +194,7 @@ class CompletionView(QTreeView):
shift -- Whether shift is pressed or not.
"""
- if not self.completing:
+ if not self._completing:
# No completion running at the moment, ignore keypress
return
idx = self._next_idx(shift)
@@ -190,7 +202,7 @@ class CompletionView(QTreeView):
idx, QItemSelectionModel.ClearAndSelect)
data = self.model.data(idx)
if data is not None:
- self.ignore_next = True
+ self._ignore_next = True
self.append_cmd_text.emit(self.model.data(idx) + ' ')
def _next_idx(self, upwards):
@@ -217,7 +229,7 @@ class CompletionView(QTreeView):
return idx
-class CompletionItemDelegate(QStyledItemDelegate):
+class _CompletionItemDelegate(QStyledItemDelegate):
"""Delegate used by CompletionView to draw individual items.
@@ -227,12 +239,20 @@ class CompletionItemDelegate(QStyledItemDelegate):
Original implementation:
qt/src/gui/styles/qcommonstyle.cpp:drawControl:2153
+ Attributes:
+ _opt: The QStyleOptionViewItem which is used.
+ _style: The style to be used.
+ _painter: The QPainter to be used.
+ _doc: The QTextDocument to be used.
+
"""
- opt = None
- style = None
- painter = None
- doc = None
+ def __init__(self, parent=None):
+ self._painter = None
+ self._opt = None
+ self._doc = None
+ self._style = None
+ super().__init__(parent)
def sizeHint(self, option, index):
"""Override sizeHint of QStyledItemDelegate.
@@ -244,49 +264,48 @@ class CompletionItemDelegate(QStyledItemDelegate):
value = index.data(Qt.SizeHintRole)
if value is not None:
return value
- self.opt = QStyleOptionViewItem(option)
- self.initStyleOption(self.opt, index)
- self.style = self.opt.widget.style()
+ self._opt = QStyleOptionViewItem(option)
+ self.initStyleOption(self._opt, index)
+ self._style = self._opt.widget.style()
self._get_textdoc(index)
- docsize = self.doc.size().toSize()
- size = self.style.sizeFromContents(QStyle.CT_ItemViewItem, self.opt,
- docsize, self.opt.widget)
+ docsize = self._doc.size().toSize()
+ size = self._style.sizeFromContents(QStyle.CT_ItemViewItem, self._opt,
+ docsize, self._opt.widget)
return size + QSize(10, 1)
def paint(self, painter, option, index):
"""Override the QStyledItemDelegate paint function."""
- painter.save()
-
- self.painter = painter
- self.opt = QStyleOptionViewItem(option)
- self.initStyleOption(self.opt, index)
- self.style = self.opt.widget.style()
+ self._painter = painter
+ self._painter.save()
+ self._opt = QStyleOptionViewItem(option)
+ self.initStyleOption(self._opt, index)
+ self._style = self._opt.widget.style()
self._draw_background()
self._draw_icon()
self._draw_text(index)
self._draw_focus_rect()
- painter.restore()
+ self._painter.restore()
def _draw_background(self):
"""Draw the background of an ItemViewItem."""
- self.style.drawPrimitive(self.style.PE_PanelItemViewItem, self.opt,
- self.painter, self.opt.widget)
+ self._style.drawPrimitive(self._style.PE_PanelItemViewItem, self._opt,
+ self._painter, self._opt.widget)
def _draw_icon(self):
"""Draw the icon of an ItemViewItem."""
- icon_rect = self.style.subElementRect(
- self.style.SE_ItemViewItemDecoration, self.opt, self.opt.widget)
+ icon_rect = self._style.subElementRect(
+ self._style.SE_ItemViewItemDecoration, self._opt, self._opt.widget)
mode = QIcon.Normal
- if not self.opt.state & QStyle.State_Enabled:
+ if not self._opt.state & QStyle.State_Enabled:
mode = QIcon.Disabled
- elif self.opt.state & QStyle.State_Selected:
+ elif self._opt.state & QStyle.State_Selected:
mode = QIcon.Selected
- state = QIcon.On if self.opt.state & QStyle.State_Open else QIcon.Off
- self.opt.icon.paint(self.painter, icon_rect,
- self.opt.decorationAlignment, mode, state)
+ state = QIcon.On if self._opt.state & QStyle.State_Open else QIcon.Off
+ self._opt.icon.paint(self._painter, icon_rect,
+ self._opt.decorationAlignment, mode, state)
def _draw_text(self, index):
"""Draw the text of an ItemViewItem.
@@ -297,13 +316,13 @@ class CompletionItemDelegate(QStyledItemDelegate):
index of the item of the item -- The QModelIndex of the item to draw.
"""
- if not self.opt.text:
+ if not self._opt.text:
return
- text_rect_ = self.style.subElementRect(self.style.SE_ItemViewItemText,
- self.opt, self.opt.widget)
- margin = self.style.pixelMetric(QStyle.PM_FocusFrameHMargin, self.opt,
- self.opt.widget) + 1
+ text_rect_ = self._style.subElementRect(
+ self._style.SE_ItemViewItemText, self._opt, self._opt.widget)
+ margin = self._style.pixelMetric(QStyle.PM_FocusFrameHMargin,
+ self._opt, self._opt.widget) + 1
# remove width padding
text_rect = text_rect_.adjusted(margin, 0, -margin, 0)
# move text upwards a bit
@@ -311,8 +330,8 @@ class CompletionItemDelegate(QStyledItemDelegate):
text_rect.adjust(0, -1, 0, -1)
else:
text_rect.adjust(0, -2, 0, -2)
- self.painter.save()
- state = self.opt.state
+ self._painter.save()
+ state = self._opt.state
if state & QStyle.State_Enabled and state & QStyle.State_Active:
cg = QPalette.Normal
elif state & QStyle.State_Enabled:
@@ -321,22 +340,22 @@ class CompletionItemDelegate(QStyledItemDelegate):
cg = QPalette.Disabled
if state & QStyle.State_Selected:
- self.painter.setPen(self.opt.palette.color(
+ self._painter.setPen(self._opt.palette.color(
cg, QPalette.HighlightedText))
# FIXME this is a dirty fix for the text jumping by one pixel...
# we really should do this properly somehow
text_rect.adjust(0, -1, 0, 0)
else:
- self.painter.setPen(self.opt.palette.color(cg, QPalette.Text))
+ self._painter.setPen(self._opt.palette.color(cg, QPalette.Text))
if state & QStyle.State_Editing:
- self.painter.setPen(self.opt.palette.color(cg, QPalette.Text))
- self.painter.drawRect(text_rect_.adjusted(0, 0, -1, -1))
+ self._painter.setPen(self._opt.palette.color(cg, QPalette.Text))
+ self._painter.drawRect(text_rect_.adjusted(0, 0, -1, -1))
- self.painter.translate(text_rect.left(), text_rect.top())
+ self._painter.translate(text_rect.left(), text_rect.top())
self._get_textdoc(index)
self._draw_textdoc(text_rect)
- self.painter.restore()
+ self._painter.restore()
def _draw_textdoc(self, text_rect):
"""Draw the QTextDocument of an item.
@@ -345,7 +364,7 @@ class CompletionItemDelegate(QStyledItemDelegate):
"""
clip = QRectF(0, 0, text_rect.width(), text_rect.height())
- self.doc.drawContents(self.painter, clip)
+ self._doc.drawContents(self._painter, clip)
def _get_textdoc(self, index):
"""Create the QTextDocument of an item.
@@ -356,32 +375,32 @@ class CompletionItemDelegate(QStyledItemDelegate):
# FIXME we probably should do eliding here. See
# qcommonstyle.cpp:viewItemDrawText
text_option = QTextOption()
- if self.opt.features & QStyleOptionViewItem.WrapText:
+ if self._opt.features & QStyleOptionViewItem.WrapText:
text_option.setWrapMode(QTextOption.WordWrap)
else:
text_option.setWrapMode(QTextOption.ManualWrap)
- text_option.setTextDirection(self.opt.direction)
+ text_option.setTextDirection(self._opt.direction)
text_option.setAlignment(QStyle.visualAlignment(
- self.opt.direction, self.opt.displayAlignment))
+ self._opt.direction, self._opt.displayAlignment))
- self.doc = QTextDocument(self)
+ self._doc = QTextDocument(self)
if index.parent().isValid():
- self.doc.setPlainText(self.opt.text)
+ self._doc.setPlainText(self._opt.text)
else:
- self.doc.setHtml('{}'.format(html.escape(self.opt.text)))
- self.doc.setDefaultFont(self.opt.font)
- self.doc.setDefaultTextOption(text_option)
- self.doc.setDefaultStyleSheet(config.get_stylesheet("""
+ self._doc.setHtml('{}'.format(html.escape(self._opt.text)))
+ self._doc.setDefaultFont(self._opt.font)
+ self._doc.setDefaultTextOption(text_option)
+ self._doc.setDefaultStyleSheet(config.get_stylesheet("""
.highlight {{
{color[completion.match.fg]}
}}
"""))
- self.doc.setDocumentMargin(2)
+ self._doc.setDocumentMargin(2)
if index.column() == 0:
marks = index.data(Qt.UserRole)
for mark in marks:
- cur = QTextCursor(self.doc)
+ cur = QTextCursor(self._doc)
cur.setPosition(mark[0])
cur.setPosition(mark[1], QTextCursor.KeepAnchor)
txt = cur.selectedText()
@@ -391,12 +410,12 @@ class CompletionItemDelegate(QStyledItemDelegate):
def _draw_focus_rect(self):
"""Draw the focus rectangle of an ItemViewItem."""
- state = self.opt.state
+ state = self._opt.state
if not state & QStyle.State_HasFocus:
return
- o = self.opt
- o.rect = self.style.subElementRect(self.style.SE_ItemViewItemFocusRect,
- self.opt, self.opt.widget)
+ o = self._opt
+ o.rect = self._style.subElementRect(
+ self._style.SE_ItemViewItemFocusRect, self._opt, self._opt.widget)
o.state |= QStyle.State_KeyboardFocusChange | QStyle.State_Item
if state & QStyle.State_Enabled:
cg = QPalette.Normal
@@ -406,6 +425,6 @@ class CompletionItemDelegate(QStyledItemDelegate):
role = QPalette.Highlight
else:
role = QPalette.Window
- o.backgroundColor = self.opt.palette.color(cg, role)
- self.style.drawPrimitive(QStyle.PE_FrameFocusRect, o, self.painter,
- self.opt.widget)
+ o.backgroundColor = self._opt.palette.color(cg, role)
+ self._style.drawPrimitive(QStyle.PE_FrameFocusRect, o, self._painter,
+ self._opt.widget)
diff --git a/qutebrowser/widgets/crash.py b/qutebrowser/widgets/crash.py
index 43a45c661..b5da98dbf 100644
--- a/qutebrowser/widgets/crash.py
+++ b/qutebrowser/widgets/crash.py
@@ -29,14 +29,18 @@ from qutebrowser.utils.version import version
class CrashDialog(QDialog):
- """Dialog which gets shown after there was a crash."""
+ """Dialog which gets shown after there was a crash.
- vbox = None
- lbl = None
- txt = None
- hbox = None
- btn_quit = None
- btn_restore = None
+ Attributes:
+ These are just here to have a static reference to avoid GCing.
+ _vbox: The main QVBoxLayout
+ _lbl: The QLabel with the static text
+ _txt: The QTextEdit with the crash information
+ _hbox: The QHboxLayout containing the buttons
+ _btn_quit: The quit button
+ _btn_restore: the restore button
+
+ """
def __init__(self, pages, cmdhist, exc):
super().__init__()
@@ -44,8 +48,8 @@ class CrashDialog(QDialog):
self.setWindowTitle('Whoops!')
self.setModal(True)
- self.vbox = QVBoxLayout(self)
- self.lbl = QLabel()
+ self._vbox = QVBoxLayout(self)
+ self._lbl = QLabel()
text = ('Argh! qutebrowser crashed unexpectedly.
'
'Please review the info below to remove sensitive data and '
'then submit it to '
@@ -53,29 +57,29 @@ class CrashDialog(QDialog):
if pages:
text += ('You can click "Restore tabs" to attempt to reopen your '
'open tabs.')
- self.lbl.setText(text)
- self.lbl.setWordWrap(True)
- self.vbox.addWidget(self.lbl)
+ self._lbl.setText(text)
+ self._lbl.setWordWrap(True)
+ self._vbox.addWidget(self._lbl)
- self.txt = QTextEdit()
- self.txt.setReadOnly(True)
- self.txt.setText(self._crash_info(pages, cmdhist, exc))
- self.vbox.addWidget(self.txt)
+ self._txt = QTextEdit()
+ self._txt.setReadOnly(True)
+ self._txt.setText(self._crash_info(pages, cmdhist, exc))
+ self._vbox.addWidget(self._txt)
- self.hbox = QHBoxLayout()
- self.hbox.addStretch()
- self.btn_quit = QPushButton()
- self.btn_quit.setText('Quit')
- self.btn_quit.clicked.connect(self.reject)
- self.hbox.addWidget(self.btn_quit)
+ self._hbox = QHBoxLayout()
+ self._hbox.addStretch()
+ self._btn_quit = QPushButton()
+ self._btn_quit.setText('Quit')
+ self._btn_quit.clicked.connect(self.reject)
+ self._hbox.addWidget(self._btn_quit)
if pages:
- self.btn_restore = QPushButton()
- self.btn_restore.setText('Restore tabs')
- self.btn_restore.clicked.connect(self.accept)
- self.btn_restore.setDefault(True)
- self.hbox.addWidget(self.btn_restore)
+ self._btn_restore = QPushButton()
+ self._btn_restore.setText('Restore tabs')
+ self._btn_restore.clicked.connect(self.accept)
+ self._btn_restore.setDefault(True)
+ self._hbox.addWidget(self._btn_restore)
- self.vbox.addLayout(self.hbox)
+ self._vbox.addLayout(self._hbox)
def _crash_info(self, pages, cmdhist, exc):
"""Gather crash information to display."""
diff --git a/qutebrowser/widgets/mainwindow.py b/qutebrowser/widgets/mainwindow.py
index a465209ce..72da4f74e 100644
--- a/qutebrowser/widgets/mainwindow.py
+++ b/qutebrowser/widgets/mainwindow.py
@@ -36,11 +36,12 @@ class MainWindow(QWidget):
Adds all needed components to a vbox, initializes subwidgets and connects
signals.
- """
+ Attributes:
+ tabs: The TabbedBrowser widget.
+ status: The StatusBar widget.
+ _vbox: The main QVBoxLayout.
- vbox = None
- tabs = None
- status = None
+ """
def __init__(self):
super().__init__()
@@ -59,17 +60,17 @@ class MainWindow(QWidget):
if not ok:
self._set_default_geometry()
- self.vbox = QVBoxLayout(self)
- self.vbox.setContentsMargins(0, 0, 0, 0)
- self.vbox.setSpacing(0)
+ self._vbox = QVBoxLayout(self)
+ self._vbox.setContentsMargins(0, 0, 0, 0)
+ self._vbox.setSpacing(0)
self.tabs = TabbedBrowser()
- self.vbox.addWidget(self.tabs)
+ self._vbox.addWidget(self.tabs)
self.completion = CompletionView(self)
self.status = StatusBar()
- self.vbox.addWidget(self.status)
+ self._vbox.addWidget(self.status)
self.status.resized.connect(self.completion.resize_to_bar)
self.status.moved.connect(self.completion.move_to_bar)
diff --git a/qutebrowser/widgets/statusbar.py b/qutebrowser/widgets/statusbar.py
index 16862eb71..0a5fd59f2 100644
--- a/qutebrowser/widgets/statusbar.py
+++ b/qutebrowser/widgets/statusbar.py
@@ -32,20 +32,33 @@ from qutebrowser.utils.url import urlstring
class StatusBar(QWidget):
- """The statusbar at the bottom of the mainwindow."""
+ """The statusbar at the bottom of the mainwindow.
+
+ Attributes:
+ cmd: The Command widget in the statusbar.
+ txt: The Text widget in the statusbar.
+ keystring: The KeyString widget in the statusbar.
+ percentage: The Percentage widget in the statusbar.
+ url: The Url widget in the statusbar.
+ prog: The Progress widget in the statusbar.
+ _hbox: The main QHBoxLayout.
+ _error: If there currently is an error, accessed through the error
+ property.
+ _STYLESHEET: The stylesheet template.
+
+ Signals:
+ resized: Emitted when the statusbar has resized, so the completion
+ widget can adjust its size to it.
+ arg: The new size.
+ moved: Emitted when the statusbar has moved, so the completion widget
+ can move the the right position.
+ arg: The new position.
+
+ """
- hbox = None
- cmd = None
- txt = None
- keystring = None
- percentage = None
- url = None
- prog = None
resized = pyqtSignal('QRect')
moved = pyqtSignal('QPoint')
- _error = False
- _option = None
- _stylesheet = """
+ _STYLESHEET = """
QWidget#StatusBar[error="false"] {{
{color[statusbar.bg]}
}}
@@ -60,36 +73,38 @@ class StatusBar(QWidget):
}}
"""
- # TODO: the statusbar should be a bit smaller
def __init__(self, parent=None):
super().__init__(parent)
self.setObjectName(self.__class__.__name__)
- self.setStyleSheet(config.get_stylesheet(self._stylesheet))
+ self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
- self.hbox = QHBoxLayout(self)
- self.hbox.setContentsMargins(0, 0, 0, 0)
- self.hbox.setSpacing(5)
+ self._error = False
+ self._option = None
- self.cmd = Command(self)
- self.hbox.addWidget(self.cmd)
+ self._hbox = QHBoxLayout(self)
+ self._hbox.setContentsMargins(0, 0, 0, 0)
+ self._hbox.setSpacing(5)
- self.txt = Text(self)
- self.hbox.addWidget(self.txt)
- self.hbox.addStretch()
+ self.cmd = _Command(self)
+ self._hbox.addWidget(self.cmd)
- self.keystring = KeyString(self)
- self.hbox.addWidget(self.keystring)
+ self.txt = _Text(self)
+ self._hbox.addWidget(self.txt)
+ self._hbox.addStretch()
- self.url = Url(self)
- self.hbox.addWidget(self.url)
+ self.keystring = _KeyString(self)
+ self._hbox.addWidget(self.keystring)
- self.percentage = Percentage(self)
- self.hbox.addWidget(self.percentage)
+ self.url = _Url(self)
+ self._hbox.addWidget(self.url)
- self.prog = Progress(self)
- self.hbox.addWidget(self.prog)
+ self.percentage = _Percentage(self)
+ self._hbox.addWidget(self.percentage)
+
+ self.prog = _Progress(self)
+ self._hbox.addWidget(self.prog)
@pyqtProperty(bool)
def error(self):
@@ -106,20 +121,19 @@ class StatusBar(QWidget):
"""
self._error = val
- self.setStyleSheet(config.get_stylesheet(self._stylesheet))
+ self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
def paintEvent(self, e):
"""Override QWIidget.paintEvent to handle stylesheets."""
# pylint: disable=unused-argument
- self._option = QStyleOption()
- self._option.initFrom(self)
+ option = QStyleOption()
+ option.initFrom(self)
painter = QPainter(self)
- self.style().drawPrimitive(QStyle.PE_Widget, self._option,
- painter, self)
+ self.style().drawPrimitive(QStyle.PE_Widget, option, painter, self)
@pyqtSlot(str)
def disp_error(self, text):
- """Displaysan error in the statusbar."""
+ """Display an error in the statusbar."""
self.error = True
self.txt.set_error(text)
@@ -147,24 +161,40 @@ class StatusBar(QWidget):
self.moved.emit(e.pos())
-class Command(QLineEdit):
+class _Command(QLineEdit):
- """The commandline part of the statusbar."""
+ """The commandline part of the statusbar.
+
+ Attributes:
+ history: The command history, with newer commands at the bottom.
+ _statusbar: The statusbar (parent) QWidget.
+ _shortcuts: Defined QShortcuts to prevent GCing.
+ _tmphist: The temporary history for history browsing
+ _histpos: The current position inside _tmphist
+ _validator: The current command validator.
+
+ Signals:
+ got_cmd: Emitted when a command is triggered by the user.
+ arg: The command string.
+ got_search: Emitted when the user started a new search.
+ arg: The search term.
+ got_rev_search: Emitted when the user started a new reverse search.
+ arg: The search term.
+ esc_pressed: Emitted when the escape key was pressed.
+ tab_pressed: Emitted when the tab key was pressed.
+ arg: Whether shift has been pressed.
+ hide_completion: Emitted when the completion widget should be hidden.
+
+ """
+
+ # FIXME we should probably use a proper model for the command history.
- # Emitted when a command is triggered by the user
got_cmd = pyqtSignal(str)
- # Emitted for searches triggered by the user
got_search = pyqtSignal(str)
got_search_rev = pyqtSignal(str)
- statusbar = None # The status bar object
- esc_pressed = pyqtSignal() # Emitted when escape is pressed
- tab_pressed = pyqtSignal(bool) # Emitted when tab is pressed (arg: shift)
- hide_completion = pyqtSignal() # Hide completion window
- history = [] # The command history, with newer commands at the bottom
- _shortcuts = []
- _tmphist = []
- _histpos = None
- _validator = None # CommandValidator
+ esc_pressed = pyqtSignal()
+ tab_pressed = pyqtSignal(bool)
+ hide_completion = pyqtSignal()
# FIXME won't the tab key switch to the next widget?
# See [0] for a possible fix.
@@ -173,7 +203,9 @@ class Command(QLineEdit):
def __init__(self, statusbar):
super().__init__(statusbar)
# FIXME
- self.statusbar = statusbar
+ self._statusbar = statusbar
+ self._histpos = None
+ self._tmphist = []
self.setStyleSheet("""
QLineEdit {
border: 0px;
@@ -181,16 +213,18 @@ class Command(QLineEdit):
background-color: transparent;
}
""")
- self._validator = CommandValidator(self)
+ self._validator = _CommandValidator(self)
self.setValidator(self._validator)
- self.returnPressed.connect(self.on_return_pressed)
+ self.returnPressed.connect(self._on_return_pressed)
self.textEdited.connect(self._histbrowse_stop)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Ignored)
+ self.history = []
+ self._shortcuts = []
for (key, handler) in [
(Qt.Key_Escape, self.esc_pressed),
- (Qt.Key_Up, self.on_key_up_pressed),
- (Qt.Key_Down, self.on_key_down_pressed),
+ (Qt.Key_Up, self._on_key_up_pressed),
+ (Qt.Key_Down, self._on_key_down_pressed),
(Qt.Key_Tab | Qt.SHIFT, lambda: self.tab_pressed.emit(True)),
(Qt.Key_Tab, lambda: self.tab_pressed.emit(False))
]:
@@ -201,7 +235,7 @@ class Command(QLineEdit):
self._shortcuts.append(sc)
@pyqtSlot()
- def on_return_pressed(self):
+ def _on_return_pressed(self):
"""Handle the command in the status bar."""
signals = {
':': self.got_cmd,
@@ -240,7 +274,7 @@ class Command(QLineEdit):
def focusInEvent(self, e):
"""Clear error message when the statusbar is focused."""
- self.statusbar.clear_error()
+ self._statusbar.clear_error()
super().focusInEvent(e)
def _histbrowse_start(self):
@@ -264,7 +298,7 @@ class Command(QLineEdit):
self._histpos = None
@pyqtSlot()
- def on_key_up_pressed(self):
+ def _on_key_up_pressed(self):
"""Handle Up presses (go back in history)."""
logging.debug("history up [pre]: pos {}".format(self._histpos))
if self._histpos is None:
@@ -280,7 +314,7 @@ class Command(QLineEdit):
self.set_cmd_text(self._tmphist[self._histpos])
@pyqtSlot()
- def on_key_down_pressed(self):
+ def _on_key_down_pressed(self):
"""Handle Down presses (go forward in history)."""
logging.debug("history up [pre]: pos {}".format(self._histpos,
self._tmphist, len(self._tmphist), self._histpos))
@@ -294,7 +328,7 @@ class Command(QLineEdit):
self.set_cmd_text(self._tmphist[self._histpos])
-class CommandValidator(QValidator):
+class _CommandValidator(QValidator):
"""Validator to prevent the : from getting deleted."""
@@ -313,13 +347,17 @@ class CommandValidator(QValidator):
return (QValidator.Invalid, string, pos)
-class Progress(QProgressBar):
+class _Progress(QProgressBar):
- """The progress bar part of the status bar."""
+ """The progress bar part of the status bar.
+
+ Attributes:
+ _STYLESHEET: The stylesheet template.
+
+ """
- statusbar = None
# FIXME for some reason, margin-left is not shown
- _stylesheet = """
+ _STYLESHEET = """
QProgressBar {{
border-radius: 0px;
border: 2px solid transparent;
@@ -332,10 +370,9 @@ class Progress(QProgressBar):
}}
"""
- def __init__(self, statusbar):
- super().__init__(statusbar)
- self.statusbar = statusbar
- self.setStyleSheet(config.get_stylesheet(self._stylesheet))
+ def __init__(self, parent):
+ super().__init__(parent)
+ self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Ignored)
self.setTextVisible(False)
self.hide()
@@ -356,15 +393,17 @@ class TextBase(QLabel):
Eliding is loosly based on
http://gedgedev.blogspot.ch/2010/12/elided-labels-in-qt.html
- """
+ Attributes:
+ _elidemode: Where to elide the text.
+ _elided_text: The current elided text.
- elidemode = None
- _elided_text = None
+ """
def __init__(self, bar, elidemode=Qt.ElideRight):
super().__init__(bar)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
- self.elidemode = elidemode
+ self._elidemode = elidemode
+ self._elided_text = ''
def setText(self, txt):
"""Extend QLabel::setText to update the elided text afterwards."""
@@ -383,11 +422,11 @@ class TextBase(QLabel):
"""
self._elided_text = self.fontMetrics().elidedText(
- self.text(), self.elidemode, width, Qt.TextShowMnemonic)
+ self.text(), self._elidemode, width, Qt.TextShowMnemonic)
def paintEvent(self, e):
"""Override QLabel::paintEvent to draw elided text."""
- if self.elidemode == Qt.ElideNone:
+ if self._elidemode == Qt.ElideNone:
super().paintEvent(e)
else:
painter = QPainter(self)
@@ -396,30 +435,37 @@ class TextBase(QLabel):
self._elided_text)
-class Text(TextBase):
+class _Text(TextBase):
- """Text displayed in the statusbar."""
+ """Text displayed in the statusbar.
- old_text = ''
+ Attributes:
+ _old_text: The text displayed before the temporary error message.
+
+ """
+
+ def __init__(self, parent=None):
+ super().__init__(parent)
+ self._old_text = ''
def set_error(self, text):
"""Display an error message and save current text in old_text."""
- self.old_text = self.text()
+ self._old_text = self.text()
self.setText(text)
def clear_error(self):
"""Clear a displayed error message."""
- self.setText(self.old_text)
+ self.setText(self._old_text)
-class KeyString(TextBase):
+class _KeyString(TextBase):
"""Keychain string displayed in the statusbar."""
pass
-class Percentage(TextBase):
+class _Percentage(TextBase):
"""Reading percentage displayed in the statusbar."""
@@ -434,15 +480,20 @@ class Percentage(TextBase):
self.setText('[{:2}%]'.format(y))
-class Url(TextBase):
+class _Url(TextBase):
- """URL displayed in the statusbar."""
+ """URL displayed in the statusbar.
- _old_url = None
- _old_urltype = None
- _urltype = None # 'normal', 'ok', 'error', 'warn, 'hover'
+ Attributes:
+ _old_url: The URL displayed before the hover URL.
+ _old_urltype: The type of the URL displayed before the hover URL.
+ _urltype: The current URL type. One of normal/ok/error/warn/hover.
+ Accessed via the urltype property.
+ _STYLESHEET: The stylesheet template.
- _stylesheet = """
+ """
+
+ _STYLESHEET = """
QLabel#Url[urltype="normal"] {{
{color[statusbar.url.fg]}
}}
@@ -468,7 +519,10 @@ class Url(TextBase):
"""Override TextBase::__init__ to elide in the middle by default."""
super().__init__(bar, elidemode)
self.setObjectName(self.__class__.__name__)
- self.setStyleSheet(config.get_stylesheet(self._stylesheet))
+ self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
+ self._urltype = None
+ self._old_urltype = None
+ self._old_url = None
@pyqtProperty(str)
def urltype(self):
@@ -480,7 +534,7 @@ class Url(TextBase):
def urltype(self, val):
"""Setter for self.urltype, so it can be used as Qt property."""
self._urltype = val
- self.setStyleSheet(config.get_stylesheet(self._stylesheet))
+ self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
@pyqtSlot(bool)
def on_loading_finished(self, ok):
diff --git a/qutebrowser/widgets/tabbar.py b/qutebrowser/widgets/tabbar.py
index 9a5c75a62..3aa50c1b0 100644
--- a/qutebrowser/widgets/tabbar.py
+++ b/qutebrowser/widgets/tabbar.py
@@ -26,12 +26,17 @@ from qutebrowser.utils.style import Style
class TabWidget(QTabWidget):
- """The tabwidget used for TabbedBrowser."""
+ """The tabwidget used for TabbedBrowser.
+
+ Attributes:
+ _STYLESHEET: The stylesheet template to be used.
+
+ """
# FIXME there is still some ugly 1px white stripe from somewhere if we do
# background-color: grey for QTabBar...
- _stylesheet = """
+ _STYLESHEET = """
QTabWidget::pane {{
position: absolute;
top: 0px;
@@ -63,7 +68,7 @@ class TabWidget(QTabWidget):
super().__init__(parent)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.setStyle(Style(self.style()))
- self.setStyleSheet(config.get_stylesheet(self._stylesheet))
+ self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
self.setDocumentMode(True)
self.setElideMode(Qt.ElideRight)
self._init_config()