rnhmjoj/qutebrowser
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' of ssh://lupin/qutebrowser

Browse Source
This commit is contained in:
Florian Bruhin 2014-02-18 18:00:16 +01:00
commit 133d720de5
21 changed files with 1323 additions and 952 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
TODO
View File

@ -38,7 +38,6 @@ Internationalization
Marks
show infos in statusline, temporary/longer
set settings/colors/bindings via commandline
write default config with comments
more completions (URLs, ...)
SSL handling

300
qutebrowser/app.py
View File

@ -22,8 +22,10 @@ import sys
import logging
import functools
import subprocess
import configparser
from signal import signal, SIGINT
from argparse import ArgumentParser
from base64 import b64encode
# Print a nice traceback on segfault -- only available on Python 3.3+, but if
# it's unavailable, it doesn't matter much.
@ -62,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()
@ -102,9 +108,9 @@ class QuteBrowser(QApplication):
self.lastWindowClosed.connect(self.shutdown)
self.mainwindow.tabs.keypress.connect(self.keyparser.handle)
self.keyparser.set_cmd_text.connect(
self.mainwindow.status.cmd.on_set_cmd_text)
self.mainwindow.status.cmd.set_cmd_text)
self.mainwindow.tabs.set_cmd_text.connect(
self.mainwindow.status.cmd.on_set_cmd_text)
self.mainwindow.status.cmd.set_cmd_text)
self.mainwindow.tabs.quit.connect(self.shutdown)
self.mainwindow.status.cmd.got_cmd.connect(self.commandparser.run)
self.mainwindow.status.cmd.got_search.connect(self.searchparser.search)
@ -123,7 +129,55 @@ 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 _parseopts(self):
"""Parse command line options."""
parser = ArgumentParser("usage: %(prog)s [options]")
parser.add_argument('-l', '--log', dest='loglevel',
help='Set loglevel', default='info')
parser.add_argument('-c', '--confdir', help='Set config directory '
'(empty for no config storage)')
parser.add_argument('-d', '--debug', help='Turn on debugging options.',
action='store_true')
parser.add_argument('command', nargs='*', help='Commands to execute '
'on startup.', metavar=':command')
# URLs will actually be in command
parser.add_argument('url', nargs='*', help='URLs to open on startup.')
return parser.parse_args()
def _initlog(self):
"""Initialisation of the logging output."""
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))
logging.basicConfig(
level=numeric_level,
format='%(asctime)s [%(levelname)s] '
'[%(module)s:%(funcName)s:%(lineno)s] %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
def _initmisc(self):
"""Initialize misc things."""
if self._args.debug:
os.environ['QT_FATAL_WARNINGS'] = '1'
self.setApplicationName("qutebrowser")
self.setApplicationVersion(qutebrowser.__version__)
def _init_cmds(self):
"""Initialisation of the qutebrowser commands.
Registers all commands, connects its signals, and sets up keyparser.
"""
cmdutils.register_all()
for cmd in cmdutils.cmd_dict.values():
cmd.signal.connect(self.cmd_handler)
try:
self.keyparser.from_config_sect(config.config['keybind'])
except KeyError:
pass
def _process_init_args(self):
"""Process initial positional args.
@ -137,7 +191,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(':'))
@ -152,6 +206,20 @@ class QuteBrowser(QApplication):
for url in config.config.get('general', 'startpage').split(','):
self.mainwindow.tabs.tabopen(url)
def _python_hacks(self):
"""Get around some PyQt-oddities by evil hacks.
This sets up the uncaught exception hook, quits with an appropriate
exit status, and handles Ctrl+C properly by passing control to the
Python interpreter once all 500ms.
"""
signal(SIGINT, lambda *args: self.exit(128 + SIGINT))
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
self._timers.append(timer)
def _recover_pages(self):
"""Try to recover all open pages.
@ -173,6 +241,15 @@ class QuteBrowser(QApplication):
pass
return pages
def _save_geometry(self):
"""Save the window geometry to the state config."""
geom = b64encode(bytes(self.mainwindow.saveGeometry())).decode('ASCII')
try:
config.state.add_section('geometry')
except configparser.DuplicateSectionError:
pass
config.state['geometry']['mainwindow'] = geom
def _exception_hook(self, exctype, excvalue, tb):
"""Handle uncaught python exceptions.
@ -237,99 +314,9 @@ class QuteBrowser(QApplication):
logging.debug("maybe_quit called from {}, quit status {}".format(
sender, self._quit_status))
if all(self._quit_status.values()):
logging.debug("maybe_quit quitting.")
self.quit()
def _python_hacks(self):
"""Get around some PyQt-oddities by evil hacks.
This sets up the uncaught exception hook, quits with an appropriate
exit status, and handles Ctrl+C properly by passing control to the
Python interpreter once all 500ms.
"""
signal(SIGINT, lambda *args: self.exit(128 + SIGINT))
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
self.timers.append(timer)
def _parseopts(self):
"""Parse command line options."""
parser = ArgumentParser("usage: %(prog)s [options]")
parser.add_argument('-l', '--log', dest='loglevel',
help='Set loglevel', default='info')
parser.add_argument('-c', '--confdir', help='Set config directory '
'(empty for no config storage)')
parser.add_argument('-d', '--debug', help='Turn on debugging options.',
action='store_true')
parser.add_argument('command', nargs='*', help='Commands to execute '
'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()
def _initlog(self):
"""Initialisation of the logging output."""
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))
logging.basicConfig(
level=numeric_level,
format='%(asctime)s [%(levelname)s] '
'[%(module)s:%(funcName)s:%(lineno)s] %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
def _initmisc(self):
"""Initialize misc things."""
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.
Registers all commands, connects its signals, and sets up keyparser.
"""
cmdutils.register_all()
for cmd in cmdutils.cmd_dict.values():
cmd.signal.connect(self.cmd_handler)
try:
self.keyparser.from_config_sect(config.config['keybind'])
except KeyError:
pass
@pyqtSlot()
def shutdown(self, do_quit=True):
"""Try to shutdown everything cleanly.
For some reason lastWindowClosing sometimes seem to get emitted twice,
so we make sure we only run once here.
quit -- Whether to quit after shutting down.
"""
if self.shutting_down:
return
self.shutting_down = True
logging.debug("Shutting down... (do_quit={})".format(do_quit))
if config.config is not None:
config.config.save()
try:
if do_quit:
self.mainwindow.tabs.shutdown_complete.connect(self.quit)
else:
self.mainwindow.tabs.shutdown_complete.connect(
functools.partial(self._maybe_quit, 'shutdown'))
self.mainwindow.tabs.shutdown()
except AttributeError: # mainwindow or tabs could still be None
logging.debug("No mainwindow/tabs to shut down.")
if do_quit:
self.quit()
@pyqtSlot(tuple)
def cmd_handler(self, tpl):
"""Handle commands and delegate the specific actions.
@ -345,32 +332,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,
}
@ -404,3 +392,49 @@ class QuteBrowser(QApplication):
"""
raise Exception
@pyqtSlot()
def shutdown(self, do_quit=True):
"""Try to shutdown everything cleanly.
For some reason lastWindowClosing sometimes seem to get emitted twice,
so we make sure we only run once here.
quit -- Whether to quit after shutting down.
"""
if self._shutting_down:
return
self._shutting_down = True
logging.debug("Shutting down... (do_quit={})".format(do_quit))
try:
config.config.save()
except AttributeError:
logging.exception("Could not save config.")
try:
self._save_geometry()
config.state.save()
except AttributeError:
logging.exception("Could not save window geometry.")
try:
if do_quit:
self.mainwindow.tabs.shutdown_complete.connect(
self.on_tab_shutdown_complete)
else:
self.mainwindow.tabs.shutdown_complete.connect(
functools.partial(self._maybe_quit, 'shutdown'))
self.mainwindow.tabs.shutdown()
except AttributeError: # mainwindow or tabs could still be None
logging.exception("No mainwindow/tabs to shut down.")
if do_quit:
self.quit()
@pyqtSlot()
def on_tab_shutdown_complete(self):
"""Quit application after a shutdown.
Gets called when all tabs finished shutting down after shutdown().
"""
logging.debug("Shutdown complete, quitting.")
self.quit()

110
qutebrowser/commands/keys.py
View File

@ -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,35 +58,9 @@ class KeyParser(QObject):
def __init__(self, mainwindow):
super().__init__(mainwindow)
self.commandparser = CommandParser()
def from_config_sect(self, sect):
"""Load keybindings from a ConfigParser section.
Config format: key = command, e.g.:
gg = scrollstart
"""
for (key, cmd) in sect.items():
if key.startswith('@') and key.endswith('@'):
# normalize keystring
keystr = self._normalize_keystr(key.strip('@'))
logging.debug('registered mod key: {} -> {}'.format(keystr,
cmd))
self.modifier_bindings[keystr] = cmd
else:
logging.debug('registered key: {} -> {}'.format(key, cmd))
self.bindings[key] = cmd
def handle(self, e):
"""Handle a new keypress and call the respective handlers.
e -- the KeyPressEvent from Qt
"""
handled = self._handle_modifier_key(e)
if not handled:
self._handle_single_key(e)
self.keystring_updated.emit(self.keystring)
self._keystring = ''
self._bindings = {}
self._modifier_bindings = {}
def _handle_modifier_key(self, e):
"""Handle a new keypress with modifiers.
@ -108,7 +89,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 +114,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 +138,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 +159,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)
@ -229,3 +210,32 @@ class KeyParser(QObject):
cmdstr))
self.set_cmd_text.emit(':{} '.format(cmdstr))
return
def from_config_sect(self, sect):
"""Load keybindings from a ConfigParser section.
Config format: key = command, e.g.:
gg = scrollstart
"""
for (key, cmd) in sect.items():
if key.startswith('@') and key.endswith('@'):
# normalize keystring
keystr = self._normalize_keystr(key.strip('@'))
logging.debug('registered mod key: {} -> {}'.format(keystr,
cmd))
self._modifier_bindings[keystr] = cmd
else:
logging.debug('registered key: {} -> {}'.format(key, cmd))
self._bindings[key] = cmd
def handle(self, e):
"""Handle a new keypress and call the respective handlers.
e -- the KeyPressEvent from Qt
"""
handled = self._handle_modifier_key(e)
if not handled:
self._handle_single_key(e)
self.keystring_updated.emit(self._keystring)

4
qutebrowser/commands/template.py
View File

@ -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:

103
qutebrowser/commands/utils.py
View File

@ -49,12 +49,45 @@ 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)
def _search(self, text, rev=False):
"""Search for a text on the current page.
text -- The text to search for.
rev -- Search direction.
"""
if self._text is not None and self._text != text:
self.do_search.emit('', 0)
self._text = text
self._flags = 0
if config.config.getboolean('general', 'ignorecase', fallback=True):
self._flags |= QWebPage.FindCaseSensitively
if config.config.getboolean('general', 'wrapsearch', fallback=True):
self._flags |= QWebPage.FindWrapsAroundDocument
if rev:
self._flags |= QWebPage.FindBackward
self.do_search.emit(self._text, self._flags)
@pyqtSlot(str)
def search(self, text):
"""Search for a text on a website.
@ -73,40 +106,33 @@ class SearchParser(QObject):
"""
self._search(text, rev=True)
def _search(self, text, rev=False):
"""Search for a text on the current page.
text -- The text to search for.
rev -- Search direction.
"""
if self.text != text:
self.do_search.emit('', 0)
self.text = text
self.flags = 0
if config.config.getboolean('general', 'ignorecase', fallback=True):
self.flags |= QWebPage.FindCaseSensitively
if config.config.getboolean('general', 'wrapsearch', fallback=True):
self.flags |= QWebPage.FindWrapsAroundDocument
if rev:
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):
@ -155,13 +180,17 @@ class CommandParser(QObject):
arguments.
"""
if ';;' in text:
for sub in text.split(';;'):
self.run(sub, count, ignore_exc)
return
try:
self._parse(text)
self._check()
except ArgumentCountError:
if ignore_exc:
self.error.emit("{}: invalid argument count".format(
self.cmd.mainname))
self._cmd.mainname))
return False
else:
raise

7
qutebrowser/models/commandcompletion.py
View File

@ -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)

394
qutebrowser/models/completion.py
View File

@ -15,15 +15,7 @@
# You should have received a copy of the GNU General Public License
# along with qutebrowser. If not, see <http://www.gnu.org/licenses/>.
"""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,26 +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
def removeRows(self, position=0, count=1, parent=QModelIndex()):
"""Remove rows from the model.
Override QAbstractItemModel::removeRows.
"""
node = self._node(parent)
self.beginRemoveRows(parent, position, position + count - 1)
node.children.pop(position)
self.endRemoveRows()
self._id_map = {}
self._root = CompletionItem([""] * 2)
self._id_map[id(self._root)] = self._root
def _node(self, index):
"""Return the interal data representation for index.
@ -63,172 +47,9 @@ class CompletionModel(QAbstractItemModel):
"""
if index.isValid():
return self.id_map[index.internalId()]
return self._id_map[index.internalId()]
else:
return self.root
def columnCount(self, parent=QModelIndex()):
"""Return the column count in the model.
Override QAbstractItemModel::columnCount.
"""
# pylint: disable=unused-argument
return self.root.column_count()
def data(self, index, role=Qt.DisplayRole):
"""Return the data for role/index as QVariant.
Return an invalid QVariant on error.
Override QAbstractItemModel::data.
"""
if not index.isValid():
return QVariant()
try:
item = self.id_map[index.internalId()]
except KeyError:
return QVariant()
try:
return QVariant(item.data(index.column(), role))
except (IndexError, ValueError):
return QVariant()
def flags(self, index):
"""Return the item flags for index.
Return Qt.NoItemFlags on error.
Override QAbstractItemModel::flags.
"""
# FIXME categories are not selectable, but moving via arrow keys still
# tries to select them
if not index.isValid():
return Qt.NoItemFlags
flags = Qt.ItemIsEnabled
if len(self.id_map[index.internalId()].children) > 0:
return flags
else:
return flags | Qt.ItemIsSelectable
def headerData(self, section, orientation, role=Qt.DisplayRole):
"""Return the header data for role/index as QVariant.
Return an invalid QVariant on error.
Override QAbstractItemModel::headerData.
"""
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
return QVariant(self.root.data(section))
return QVariant()
def setData(self, index, value, role=Qt.EditRole):
"""Set the data for role/index to value.
Return True on success, False on failure.
Override QAbstractItemModel::setData.
"""
if not index.isValid():
return False
item = self.id_map[index.internalId()]
try:
item.setdata(index.column(), value, role)
except (IndexError, ValueError):
return False
self.dataChanged.emit(index, index)
return True
def index(self, row, column, parent=QModelIndex()):
"""Return the QModelIndex for row/column/parent.
Return an invalid QModelIndex on failure.
Override QAbstractItemModel::index.
"""
if (0 <= row < self.rowCount(parent) and
0 <= column < self.columnCount(parent)):
pass
else:
return QModelIndex()
if not parent.isValid():
parent_item = self.root
else:
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)
return index
else:
return QModelIndex()
def parent(self, index):
"""Return the QModelIndex of the parent of the object behind index.
Return an invalid QModelIndex on failure.
Override QAbstractItemModel::parent.
"""
if not index.isValid():
return QModelIndex()
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))
def rowCount(self, parent=QModelIndex()):
"""Return the children count of an item.
Use the root frame if parent is invalid.
Override QAbstractItemModel::rowCount.
"""
if parent.column() > 0:
return 0
if not parent.isValid():
pitem = self.root
else:
pitem = self.id_map[parent.internalId()]
return len(pitem.children)
def sort(self, column, order=Qt.AscendingOrder):
"""Sort the data in column according to order.
Raise NotImplementedError, should be overwritten in a superclass.
Override QAbstractItemModel::sort.
"""
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)
for item in items:
newitem = CompletionItem(item, newcat)
self.id_map[id(newitem)] = newitem
newcat.children.append(newitem)
def mark_all_items(self, needle):
"""Mark a string in all items (children of root-children).
needle -- The string to mark.
"""
for i in range(self.rowCount()):
cat = self.index(i, 0)
for k in range(self.rowCount(cat)):
idx = self.index(k, 0, cat)
old = self.data(idx).value()
marks = self._get_marks(needle, old)
self.setData(idx, marks, Qt.UserRole)
return self._root
def _get_marks(self, needle, haystack):
"""Return the marks for needle in haystack."""
@ -244,15 +65,196 @@ class CompletionModel(QAbstractItemModel):
marks.append((pos1, pos2))
return marks
def mark_all_items(self, needle):
"""Mark a string in all items (children of root-children).
needle -- The string to mark.
"""
for i in range(self.rowCount()):
cat = self.index(i, 0)
for k in range(self.rowCount(cat)):
idx = self.index(k, 0, cat)
old = self.data(idx).value()
marks = self._get_marks(needle, old)
self.setData(idx, marks, Qt.UserRole)
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
newcat.children.append(newitem)
def removeRows(self, position=0, count=1, parent=QModelIndex()):
"""Remove rows from the model.
Override QAbstractItemModel::removeRows.
"""
node = self._node(parent)
self.beginRemoveRows(parent, position, position + count - 1)
node.children.pop(position)
self.endRemoveRows()
def columnCount(self, parent=QModelIndex()):
"""Return the column count in the model.
Override QAbstractItemModel::columnCount.
"""
# pylint: disable=unused-argument
return self._root.column_count()
def rowCount(self, parent=QModelIndex()):
"""Return the children count of an item.
Use the root frame if parent is invalid.
Override QAbstractItemModel::rowCount.
"""
if parent.column() > 0:
return 0
if not parent.isValid():
pitem = self._root
else:
pitem = self._id_map[parent.internalId()]
return len(pitem.children)
def data(self, index, role=Qt.DisplayRole):
"""Return the data for role/index as QVariant.
Return an invalid QVariant on error.
Override QAbstractItemModel::data.
"""
if not index.isValid():
return QVariant()
try:
item = self._id_map[index.internalId()]
except KeyError:
return QVariant()
try:
return QVariant(item.data(index.column(), role))
except (IndexError, ValueError):
return QVariant()
def headerData(self, section, orientation, role=Qt.DisplayRole):
"""Return the header data for role/index as QVariant.
Return an invalid QVariant on error.
Override QAbstractItemModel::headerData.
"""
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
return QVariant(self._root.data(section))
return QVariant()
def setData(self, index, value, role=Qt.EditRole):
"""Set the data for role/index to value.
Return True on success, False on failure.
Override QAbstractItemModel::setData.
"""
if not index.isValid():
return False
item = self._id_map[index.internalId()]
try:
item.setdata(index.column(), value, role)
except (IndexError, ValueError):
return False
self.dataChanged.emit(index, index)
return True
def flags(self, index):
"""Return the item flags for index.
Return Qt.NoItemFlags on error.
Override QAbstractItemModel::flags.
"""
# FIXME categories are not selectable, but moving via arrow keys still
# tries to select them
if not index.isValid():
return Qt.NoItemFlags
flags = Qt.ItemIsEnabled
if len(self._id_map[index.internalId()].children) > 0:
return flags
else:
return flags | Qt.ItemIsSelectable
def index(self, row, column, parent=QModelIndex()):
"""Return the QModelIndex for row/column/parent.
Return an invalid QModelIndex on failure.
Override QAbstractItemModel::index.
"""
if (0 <= row < self.rowCount(parent) and
0 <= column < self.columnCount(parent)):
pass
else:
return QModelIndex()
if not parent.isValid():
parent_item = self._root
else:
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)
return index
else:
return QModelIndex()
def parent(self, index):
"""Return the QModelIndex of the parent of the object behind index.
Return an invalid QModelIndex on failure.
Override QAbstractItemModel::parent.
"""
if not index.isValid():
return QModelIndex()
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))
def sort(self, column, order=Qt.AscendingOrder):
"""Sort the data in column according to order.
Raise NotImplementedError, should be overwritten in a superclass.
Override QAbstractItemModel::sort.
"""
raise NotImplementedError
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):

57
qutebrowser/models/completionfilter.py
View File

@ -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, accessed via the srcmodel property.
"""
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,33 @@ class CompletionFilterModel(QSortFilterProxyModel):
self.sort(sortcol)
self.invalidate()
@property
def srcmodel(self):
"""Getter for srcmodel."""
return self._srcmodel
@srcmodel.setter
def srcmodel(self, model):
"""Set a new source model and clear the pattern.
model -- The new source model.
"""
# FIXME change this to a property
self.setSourceModel(model)
self._srcmodel = model
self.pattern = ''
def first_item(self):
"""Return the first item in the model."""
cat = self.index(0, 0)
return self.index(0, 0, cat)
def last_item(self):
"""Return the last item in the model."""
cat = self.index(self.rowCount() - 1, 0)
return self.index(self.rowCount(cat) - 1, 0, cat)
def filterAcceptsRow(self, row, parent):
"""Custom filter implementation.
@ -116,13 +137,3 @@ class CompletionFilterModel(QSortFilterProxyModel):
return False
else:
return left < right
def first_item(self):
"""Return the first item in the model."""
cat = self.index(0, 0)
return self.index(0, 0, cat)
def last_item(self):
"""Return the last item in the model."""
cat = self.index(self.rowCount() - 1, 0)
return self.index(self.rowCount(cat) - 1, 0, cat)

188
qutebrowser/qutebrowser.conf Normal file
View File

@ -0,0 +1,188 @@
# vim: ft=dosini
# Configfile for qutebrowser.
#
# This configfile is parsed by python's configparser in extended interpolation
# mode. The format is very INI-like, so there are categories like [general]
# with "key = value"-pairs.
#
# Comments start with ; or # and may only start at the beginning of a line.
#
# Interpolation looks like ${value} or ${section:value} and will be replaced
# by the respective value.
#
# This is the default config, so if you want to remove anything from here (as
# opposed to change/add), for example a keybinding, set it to an empty value.
[general]
# show_completion: bool, whether to show the autocompletion window or not.
# ignorecase: bool, whether to do case-insensitive searching.
# wrapsearch: bool, whether to wrap search to the top when arriving at the end.
# startpage: The default pages to open at the start, multiple pages can be
# separated with commas.
# auto_search: Whether to start a search automatically when something
# which is not an url is entered.
# true/naive: Use simple/naive check
# dns: Use DNS matching (might be slow)
# false: Never search automatically
show_completion = true
ignorecase = true
wrapsearch = true
startpage = http://www.duckduckgo.com/
auto_search = naive
[tabbar]
# movable: bool, whether tabs should be movable
# closebuttons: bool, whether tabs should have a close button
# scrollbuttons: bool, whether there should be scroll buttons if there are too
# many tabs open.
# position: Position of the tab bar, either north, south, east or west.
# select_on_remove: Which tab to select when the focused tab is removed. Either
# 'previous', 'left' or 'right'.
# last_close; Behavour when the last tab is closed - 'ignore' (don't do
# anything), 'blank' (load about:blank) or 'quit' (quit
# qutebrowser).
movable = true
closebuttons = false
scrollbuttons = false
position = north
select_on_remove = previous
last_close = quit
[searchengines]
# Definitions of search engines which can be used via the address bar.
# The searchengine named DEFAULT is used when general.auto_search is true and
# something else than an URL was entered to be opened.
# Other search engines can be used via the bang-syntax, e.g.
# "qutebrowser !google". The string "{}" will be replaced by the search term,
# use "{{" and "}}" for literal {/} signs.
DEFAULT = ${duckduckgo}
duckduckgo = https://duckduckgo.com/?q={}
ddg = ${duckduckgo}
google = https://encrypted.google.com/search?q={}
g = ${google}
wikipedia = http://en.wikipedia.org/w/index.php?title=Special:Search&search={}
wiki = ${wikipedia}
[keybind]
# Bindings from a key(chain) to a command. For special keys (can't be part of a
# keychain), enclose them in @-signs. For modifiers, you can use either - or +
# as delimiters, and these names:
# Control: Control, Ctrl
# Meta: Meta, Windows, Mod4
# Alt: Alt, Mod1
# Shift: Shift
# For simple keys (no @ signs), a capital letter means the key is pressed with
# Shift. For modifier keys (with @ signs), you need to explicitely add "Shift-"
# to match a key pressed with shift.
# You can bind multiple commands by separating them with ";;".
o = open
go = opencur
O = tabopen
gO = tabopencur
ga = tabopen about:blank
d = tabclose
J = tabnext
K = tabprev
r = reload
H = back
L = forward
h = scroll -50 0
j = scroll 0 50
k = scroll 0 -50
l = scroll 50 0
u = undo
gg = scroll_perc_y 0
G = scroll_perc_y
n = nextsearch
yy = yank
yY = yank sel
yt = yanktitle
yT = yanktitle sel
pp = paste
pP = paste sel
Pp = tabpaste
PP = tabpaste sel
@Ctrl-Q@ = quit
@Ctrl-Shift-T@ = undo
@Ctrl-W@ = tabclose
@Ctrl-T@ = tabopen about:blank
@Ctrl-F@ = scroll_page 0 1
@Ctrl-B@ = scroll_page 0 -1
@Ctrl-D@ = scroll_page 0 0.5
@Ctrl-U@ = scroll_page 0 -0.5
[colors]
# Colors used in the UI. A value can be in one of the following format:
# - #RGB/#RRGGBB/#RRRGGGBBB/#RRRRGGGGBBBB
# - A SVG color name as specified in [1].
# - transparent (no color)
# - rgb(r, g, b) / rgba(r, g, b, a) (values 0-255 or percentages)
# - hsv(h, s, v) / hsva(h, s, v, a) (values 0-255, hue 0-359)
# - A gradient as explained at [2] under "Gradient"
# [1] http://www.w3.org/TR/SVG/types.html#ColorKeywords
# [2] http://qt-project.org/doc/qt-4.8/stylesheet-reference.html#list-of-property-types
#
## Completion widget
# Text color
completion.fg = #333333
# Background of a normal item
completion.item.bg = white
# Background of a category header
completion.category.bg = qlineargradient(x1:0, y1:0, x2:0, y2:1,
stop:0 #e4e4e4, stop:1 #dbdbdb)
# Borders of a category header
completion.category.border.top = #808080
completion.category.border.bottom = #bbbbbb
# Text/background color for the currently selected item
completion.item.selected.fg = #333333
completion.item.selected.bg = #ffec8b
# Borders for the selected item
completion.item.selected.border.top = #f2f2c0
completion.item.selected.border.bottom = #e6e680
# Matched text in a completion
completion.match.fg = red
## Statusbar widget
# Normal colors for the statusbar.
statusbar.bg = black
statusbar.fg = white
# Statusbar colors when there is an error
statusbar.bg.error = red
# Colors of the progress bar
statusbar.progress.bg = white
# Colors of the URL shown in the statusbar
# Unknown/default status
statusbar.url.fg = ${statusbar.fg}
# Page loaded successfully
statusbar.url.fg.success = lime
# Error while loading page
statusbar.url.fg.error = orange
# Warning while loading page
statusbar.url.fg.warn = yellow
# Link under the mouse cursor
statusbar.url.fg.hover = aqua
## Tabbar
# Tabbar colors
tab.fg = white
tab.bg = grey
# Color of the selected tab
tab.bg.selected = black
# Seperator between tabs
tab.seperator = white
[fonts]
# Fonts used for the UI, with optional style/weight/size.
# Style: normal/italic/oblique
# Weight: normal, bold, 100..900
# Size: Number + px/pt
#
# Default monospace fonts
_monospace = Monospace, "DejaVu Sans Mono", Consolas, Monaco,
"Bitstream Vera Sans Mono", "Andale Mono", "Liberation Mono",
"Courier New", Courier, monospace, Fixed, Terminal
# Font used in the completion widget.
completion = 8pt ${_monospace}
# Font used in the tabbar
tabbar = 8pt ${_monospace}
# Font used in the statusbar.
statusbar = 8pt ${_monospace}

195
qutebrowser/utils/config.py
View File

@ -15,131 +15,32 @@
# You should have received a copy of the GNU General Public License
# along with qutebrowser. If not, see <http://www.gnu.org/licenses/>.
"""Configuration storage and config-related utilities.
config -- The main Config object.
colordict -- All configured colors.
default_config -- The default config as dict.
MONOSPACE -- A list of suitable monospace fonts.
"""
"""Configuration storage and config-related utilities."""
import os
import io
import os.path
import logging
from configparser import ConfigParser, ExtendedInterpolation
from configparser import (ConfigParser, ExtendedInterpolation, NoSectionError,
NoOptionError)
from qutebrowser.utils.misc import read_file
config = None
state = None
colordict = {}
fontdict = {}
default_config = """
[general]
show_completion = true
ignorecase = true
wrapsearch = true
startpage = http://www.duckduckgo.com/
addressbar_dns_lookup = false
auto_search = true
[tabbar]
movable = true
closebuttons = false
scrollbuttons = false
# north, south, east, west
position = north
# previous, left, right
select_on_remove = previous
# ignore, blank, quit
last_close = quit
[searchengines]
DEFAULT = ${duckduckgo}
duckduckgo = https://duckduckgo.com/?q={}
ddg = ${duckduckgo}
google = https://encrypted.google.com/search?q={}
g = ${google}
wikipedia = http://en.wikipedia.org/w/index.php?title=Special:Search&search={}
wiki = ${wikipedia}
[keybind]
o = open
go = opencur
O = tabopen
gO = tabopencur
ga = tabopen about:blank
d = tabclose
J = tabnext
K = tabprev
r = reload
H = back
L = forward
h = scroll -50 0
j = scroll 0 50
k = scroll 0 -50
l = scroll 50 0
u = undo
gg = scroll_perc_y 0
G = scroll_perc_y
n = nextsearch
yy = yank
yY = yank sel
yt = yanktitle
yT = yanktitle sel
pp = paste
pP = paste sel
Pp = tabpaste
PP = tabpaste sel
@Ctrl-Q@ = quit
@Ctrl-Shift-T@ = undo
@Ctrl-W@ = tabclose
@Ctrl-T@ = tabopen about:blank
@Ctrl-F@ = scroll_page 0 1
@Ctrl-B@ = scroll_page 0 -1
@Ctrl-D@ = scroll_page 0 0.5
@Ctrl-U@ = scroll_page 0 -0.5
[colors]
completion.fg = #333333
completion.item.bg = white
completion.category.bg = qlineargradient(x1:0, y1:0, x2:0, y2:1,
stop:0 #e4e4e4, stop:1 #dbdbdb)
completion.category.border.top = #808080
completion.category.border.bottom = #bbbbbb
completion.item.selected.fg = #333333
completion.item.selected.bg = #ffec8b
completion.item.selected.border.top = #f2f2c0
completion.item.selected.border.bottom = #e6e680
completion.match.fg = red
statusbar.progress.bg = white
statusbar.bg = black
statusbar.fg = white
statusbar.bg.error = red
statusbar.url.fg = ${statusbar.fg}
statusbar.url.fg.success = lime
statusbar.url.fg.error = orange
statusbar.url.fg.warn = yellow
statusbar.url.fg.hover = aqua
tab.bg = grey
tab.bg.selected = black
tab.fg = white
tab.seperator = white
[fonts]
_monospace = Monospace, "DejaVu Sans Mono", Consolas, Monaco,
"Bitstream Vera Sans Mono", "Andale Mono", "Liberation Mono",
"Courier New", Courier, monospace, Fixed, Terminal
completion = 8pt ${_monospace}
tabbar = 8pt ${_monospace}
statusbar = 8pt ${_monospace}
"""
# Special value for an unset fallback, so None can be passed as fallback.
_UNSET = object()
def init(confdir):
"""Initialize the global objects based on the config in configdir."""
global config, colordict, fontdict
config = Config(confdir)
global config, state, colordict, fontdict
logging.debug("Config init, confdir {}".format(confdir))
config = Config(confdir, 'qutebrowser.conf', read_file('qutebrowser.conf'))
state = Config(confdir, 'state', always_save=True)
try:
colordict = ColorDict(config['colors'])
except KeyError:
@ -229,33 +130,44 @@ class FontDict(dict):
class Config(ConfigParser):
"""Our own ConfigParser subclass."""
"""Our own ConfigParser subclass.
configdir = None
FNAME = 'config'
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):
"""
def __init__(self, configdir, fname, default_config=None,
always_save=False):
"""Config constructor.
configdir -- directory to store the config in.
fname -- Filename of the config file.
default_config -- Default config as string.
always_save -- Whether to always save the config, even when it wasn't
loaded.
"""
super().__init__(interpolation=ExtendedInterpolation())
self.default_cp = ConfigParser(interpolation=ExtendedInterpolation())
self.default_cp.optionxform = lambda opt: opt # be case-insensitive
self.default_cp.read_string(default_config)
if not self.configdir:
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
if default_config is not None:
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, self.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.
@ -266,25 +178,42 @@ class Config(ConfigParser):
try:
return super().__getitem__(key)
except KeyError:
return self.default_cp[key]
return self._default_cp[key]
def get(self, *args, **kwargs):
def get(self, *args, raw=False, vars=None, fallback=_UNSET):
"""Get an item from the configparser or default dict.
Extend ConfigParser's get().
This is a bit of a hack, but it (hopefully) works like this:
- Get value from original configparser.
- If that's not available, try the default_cp configparser
- If that's not available, try the fallback given as kwarg
- If that's not available, we're doomed.
"""
if 'fallback' in kwargs:
del kwargs['fallback']
fallback = self.default_cp.get(*args, **kwargs)
return super().get(*args, fallback=fallback, **kwargs)
# pylint: disable=redefined-builtin
try:
return super().get(*args, raw=raw, vars=vars)
except (NoSectionError, NoOptionError):
pass
try:
return self._default_cp.get(*args, raw=raw, vars=vars)
except (NoSectionError, NoOptionError):
if fallback is _UNSET:
raise
else:
return fallback
def save(self):
"""Save the config file."""
if self.configdir is None or not self.config_loaded:
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))
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)

14
qutebrowser/utils/misc.py
View File

@ -17,6 +17,7 @@
"""Other utilities which don't fit anywhere else."""
import sys
import os.path
from PyQt5.QtCore import pyqtRemoveInputHook
@ -50,3 +51,16 @@ def read_file(filename):
fn = os.path.join(qutebrowser.basedir, filename)
with open(fn, 'r', encoding='UTF-8') as f:
return f.read()
def trace_lines(do_trace):
"""Turn on/off printing each executed line."""
def trace(frame, event, _):
"""Trace function passed to sys.settrace."""
print("{}, {}:{}".format(event, frame.f_code.co_filename,
frame.f_lineno))
return trace
if do_trace:
sys.settrace(trace)
else:
sys.settrace(None)

33
qutebrowser/utils/signals.py
View File

@ -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,14 @@ 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 _signal_needs_caching(self, signal):
"""Return True if a signal should be cached, false otherwise."""
return not signal_name(signal) in self._uncached
def add(self, sig, args):
"""Add a new signal to the signal cache.
@ -71,21 +78,17 @@ 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

3
qutebrowser/utils/style.py
View File

@ -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):

120
qutebrowser/utils/url.py
View File

@ -27,6 +27,52 @@ from PyQt5.QtCore import QUrl
import qutebrowser.utils.config as config
def _get_search_url(txt):
"""Return a search engine URL (QUrl) for a text."""
logging.debug('Finding search engine for "{}"'.format(txt))
r = re.compile(r'(^|\s+)!(\w+)($|\s+)')
m = r.search(txt)
if m:
engine = m.group(2)
# FIXME why doesn't fallback work?!
template = config.config.get('searchengines', engine, fallback=None)
term = r.sub('', txt)
logging.debug('engine {}, term "{}"'.format(engine, term))
else:
template = config.config.get('searchengines', 'DEFAULT',
fallback=None)
term = txt
logging.debug('engine: default, term "{}"'.format(txt))
if template is None or not term:
raise ValueError
# pylint: disable=maybe-no-member
return QUrl.fromUserInput(template.format(urllib.parse.quote(term)))
def _is_url_naive(url):
"""Naive check if given url (QUrl) is really an url."""
PROTOCOLS = ['http://', 'https://']
u = urlstring(url)
return (any(u.startswith(proto) for proto in PROTOCOLS) or '.' in u or
u == 'localhost')
def _is_url_dns(url):
"""Check if an url (QUrl) is really an url via DNS."""
# FIXME we could probably solve this in a nicer way by attempting to open
# the page in the webview, and then open the search if that fails.
host = url.host()
logging.debug("DNS request for {}".format(host))
if not host:
return False
try:
socket.gethostbyname(host)
except socket.gaierror:
return False
else:
return True
def qurl(url):
"""Get a QUrl from an url string."""
return url if isinstance(url, QUrl) else QUrl(url)
@ -49,7 +95,7 @@ def fuzzy_url(url):
"""
u = qurl(url)
urlstr = urlstring(url)
if (not config.config.getboolean('general', 'auto_search')) or is_url(u):
if is_url(u):
# probably an address
logging.debug("url is a fuzzy address")
newurl = QUrl.fromUserInput(urlstr)
@ -64,27 +110,6 @@ def fuzzy_url(url):
return newurl
def _get_search_url(txt):
"""Return a search engine URL (QUrl) for a text."""
logging.debug('Finding search engine for "{}"'.format(txt))
r = re.compile(r'(^|\s+)!(\w+)($|\s+)')
m = r.search(txt)
if m:
engine = m.group(2)
# FIXME why doesn't fallback work?!
template = config.config.get('searchengines', engine, fallback=None)
term = r.sub('', txt)
logging.debug('engine {}, term "{}"'.format(engine, term))
else:
template = config.config.get('searchengines', 'DEFAULT',
fallback=None)
term = txt
logging.debug('engine: default, term "{}"'.format(txt))
if template is None or not term:
raise ValueError
return QUrl.fromUserInput(template.format(urllib.parse.quote(term)))
def is_about_url(url):
"""Return True if url (QUrl) is an about:... or other special URL."""
return urlstring(url).replace('http://', '').startswith('about:')
@ -93,38 +118,37 @@ def is_about_url(url):
def is_url(url):
"""Return True if url (QUrl) seems to be a valid URL."""
urlstr = urlstring(url)
logging.debug('Checking if "{}" is an URL'.format(urlstr))
try:
autosearch = config.config.getboolean('general', 'auto_search')
except ValueError:
autosearch = config.config.get('general', 'auto_search')
else:
if autosearch:
autosearch = 'naive'
else:
autosearch = None
logging.debug('Checking if "{}" is an URL (autosearch={}).'.format(
urlstr, autosearch))
if autosearch is None:
# no autosearch, so everything is an URL.
return True
if ' ' in urlstr:
# An URL will never contain a space
logging.debug('Contains space -> no url')
return False
elif config.config.getboolean('general', 'addressbar_dns_lookup'):
elif is_about_url(url):
# About URLs are always URLs, even with autosearch=False
logging.debug('Is an about URL.')
return True
elif autosearch == 'dns':
logging.debug('Checking via DNS')
return _is_url_dns(QUrl.fromUserInput(urlstr))
else:
elif autosearch == 'naive':
logging.debug('Checking via naive check')
return _is_url_naive(url)
def _is_url_naive(url):
"""Naive check if given url (QUrl) is really an url."""
PROTOCOLS = ['http://', 'https://']
u = urlstring(url)
return (any(u.startswith(proto) for proto in PROTOCOLS) or '.' in u or
is_about_url(url) or u == 'localhost')
def _is_url_dns(url):
"""Check if an url (QUrl) is really an url via DNS."""
# FIXME we could probably solve this in a nicer way by attempting to open
# the page in the webview, and then open the search if that fails.
host = url.host()
logging.debug("DNS request for {}".format(host))
if not host:
return False
try:
socket.gethostbyname(host)
except socket.gaierror:
return False
else:
return True
raise ValueError("Invalid autosearch value")

46
qutebrowser/utils/version.py
View File

@ -28,6 +28,29 @@ from PyQt5.QtWebKit import qWebKitVersion
import qutebrowser
def _git_str():
"""Try to find out git version and return a string if possible.
Return None if there was an error or we're not in a git repo.
"""
if hasattr(sys, "frozen"):
return None
try:
gitpath = os.path.join(os.path.dirname(os.path.realpath(__file__)),
os.path.pardir, os.path.pardir)
except NameError:
return None
if not os.path.isdir(os.path.join(gitpath, ".git")):
return None
try:
return subprocess.check_output(
['git', 'describe', '--tags', '--dirty', '--always'],
cwd=gitpath).decode('UTF-8').strip()
except (subprocess.CalledProcessError, FileNotFoundError):
return None
def version():
"""Return a string with various version informations."""
if sys.platform == 'linux':
@ -56,26 +79,3 @@ def version():
lines.append('\nGit commit: {}'.format(gitver))
return ''.join(lines)
def _git_str():
"""Try to find out git version and return a string if possible.
Return None if there was an error or we're not in a git repo.
"""
if hasattr(sys, "frozen"):
return None
try:
gitpath = os.path.join(os.path.dirname(os.path.realpath(__file__)),
os.path.pardir, os.path.pardir)
except NameError:
return None
if not os.path.isdir(os.path.join(gitpath, ".git")):
return None
try:
return subprocess.check_output(
['git', 'describe', '--tags', '--dirty', '--always'],
cwd=gitpath).decode('UTF-8').strip()
except (subprocess.CalledProcessError, FileNotFoundError):
return None

166
qutebrowser/widgets/browser.py
View File

@ -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)
@ -171,9 +188,10 @@ class TabbedBrowser(TabWidget):
try:
self._tabs.remove(tab)
except ValueError:
logging.error("tab {} could not be removed from tabs {}.".format(
tab, self._tabs))
logging.exception("tab {} could not be removed".format(tab))
logging.debug("Tabs after removing: {}".format(self._tabs))
if not self._tabs: # all tabs shut down
logging.debug("Tab shutdown complete.")
self.shutdown_complete.emit()
def cur_reload(self, count=None):
@ -205,7 +223,7 @@ class TabbedBrowser(TabWidget):
# FIXME that does not what I expect
tab = self._widget(count)
if tab is not None:
preview = QPrintPreviewDialog()
preview = QPrintPreviewDialog(self)
preview.paintRequested.connect(tab.print)
preview.exec_()
@ -451,12 +469,12 @@ class TabbedBrowser(TabWidget):
except TypeError:
pass
tabcount = self.count()
logging.debug("Shutting down {} tabs...".format(tabcount))
if tabcount == 0:
logging.debug("No tabs -> shutdown complete")
self.shutdown_complete.emit()
return
for tabidx in range(tabcount):
logging.debug("shutdown {}".format(tabidx))
logging.debug("Shutting down tab {}/{}".format(tabidx, tabcount))
tab = self.widget(tabidx)
tab.shutdown(callback=functools.partial(self._cb_tab_shutdown,
tab))
@ -468,30 +486,39 @@ 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)
self.linkClicked.connect(self.on_link_clicked)
# FIXME find some way to hide scrollbars without setScrollBarPolicy
@ -531,17 +558,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.
@ -561,55 +577,57 @@ 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("Shutdown scheduled")
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)
for (k, v) in self._destroyed.items()])
logging.debug("{} has been destroyed, new status:\n{}".format(
sender.__class__.__name__, dbgout))
if all(self._destroyed.values()):
if self._shutdown_callback is not None:
logging.debug("Everything destroyed, calling callback")
self._shutdown_callback()
def eventFilter(self, watched, e):
"""Dirty hack to emit a signal if the scroll position changed.
def paintEvent(self, e):
"""Extend paintEvent to emit a signal if the scroll position changed.
We listen to repaint requests here, in the hope a repaint will always
be requested when scrolling, and if the scroll position actually
changed, we emit a signal.
This is a bit of a hack: We listen to repaint requests here, in the
hope a repaint will always be requested when scrolling, and if the
scroll position actually changed, we emit a signal.
watched -- The watched Qt object.
e -- The new event.
e -- The QPaintEvent.
"""
if watched == self and e.type() == QEvent.Paint:
frame = self.page_.mainFrame()
new_pos = (frame.scrollBarValue(Qt.Horizontal),
frame.scrollBarValue(Qt.Vertical))
if self._scroll_pos != new_pos:
self._scroll_pos = new_pos
logging.debug("Updating scroll position")
frame = self.page_.mainFrame()
new_pos = (frame.scrollBarValue(Qt.Horizontal),
frame.scrollBarValue(Qt.Vertical))
if self._scroll_pos != new_pos:
self._scroll_pos = new_pos
logging.debug("Updating scroll position")
frame = self.page_.mainFrame()
m = (frame.scrollBarMaximum(Qt.Horizontal),
frame.scrollBarMaximum(Qt.Vertical))
perc = (round(100 * new_pos[0] / m[0]) if m[0] != 0 else 0,
round(100 * new_pos[1] / m[1]) if m[1] != 0 else 0)
self.scroll_pos_changed.emit(*perc)
# we're not actually filtering something, let superclass handle the
# event
return super().eventFilter(watched, e)
m = (frame.scrollBarMaximum(Qt.Horizontal),
frame.scrollBarMaximum(Qt.Vertical))
perc = (round(100 * new_pos[0] / m[0]) if m[0] != 0 else 0,
round(100 * new_pos[1] / m[1]) if m[1] != 0 else 0)
self.scroll_pos_changed.emit(*perc)
# Let superclass handle the event
return super().paintEvent(e)
def event(self, e):
"""Check if a link was clicked with the middle button or Ctrl.
@ -630,10 +648,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)
@ -677,9 +698,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 = {}

181
qutebrowser/widgets/completion.py
View File

@ -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.srcmodel = 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._doc = QTextDocument(self)
if index.parent().isValid():
self.doc.setPlainText(self.opt.text)
self._doc.setPlainText(self._opt.text)
else:
self.doc.setHtml('<b>{}</b>'.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('<b>{}</b>'.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)

60
qutebrowser/widgets/crash.py
View File

@ -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.lbl = QLabel(self)
self._vbox = QVBoxLayout(self)
self._lbl = QLabel()
text = ('Argh! qutebrowser crashed unexpectedly.<br/>'
'Please review the info below to remove sensitive data and '
'then submit it to <a href="mailto:crash@qutebrowser.org">'
@ -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)
self.txt.setReadOnly(True)
self.txt.setText(self._crash_info(pages, cmdhist, exc))
self.vbox.addWidget(self.txt)
self.setLayout(self.vbox)
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.btn_quit = QPushButton(self)
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)
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."""

42
qutebrowser/widgets/mainwindow.py
View File

@ -17,11 +17,16 @@
"""The main window of QuteBrowser."""
import binascii
from base64 import b64decode
from PyQt5.QtCore import QRect
from PyQt5.QtWidgets import QWidget, QVBoxLayout
from qutebrowser.widgets.statusbar import StatusBar
from qutebrowser.widgets.browser import TabbedBrowser
from qutebrowser.widgets.completion import CompletionView
import qutebrowser.utils.config as config
class MainWindow(QWidget):
@ -31,30 +36,41 @@ 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__()
self.setWindowTitle('qutebrowser')
# FIXME maybe store window position/size on exit
self.resize(800, 600)
try:
geom = b64decode(config.state['geometry']['mainwindow'],
validate=True)
except binascii.Error:
self._set_default_geometry()
else:
try:
ok = self.restoreGeometry(geom)
except KeyError:
self._set_default_geometry()
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)
@ -80,3 +96,7 @@ class MainWindow(QWidget):
#self.retranslateUi(MainWindow)
#self.tabWidget.setCurrentIndex(0)
#QtCore.QMetaObject.connectSlotsByName(MainWindow)
def _set_default_geometry(self):
"""Set some sensible default geometry."""
self.setGeometry(QRect(50, 50, 800, 600))

240
qutebrowser/widgets/statusbar.py
View File

@ -21,8 +21,7 @@ import logging
from PyQt5.QtCore import pyqtSignal, pyqtSlot, pyqtProperty, Qt
from PyQt5.QtWidgets import (QWidget, QLineEdit, QProgressBar, QLabel,
QHBoxLayout, QSizePolicy, QShortcut, QStyle,
QStyleOption)
QHBoxLayout, QSizePolicy, QShortcut)
from PyQt5.QtGui import QPainter, QKeySequence, QValidator
import qutebrowser.utils.config as config
@ -32,20 +31,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 +72,39 @@ 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.setAttribute(Qt.WA_StyledBackground)
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,11 @@ class StatusBar(QWidget):
"""
self._error = val
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)
painter = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, self._option,
painter, self)
self.setStyleSheet(config.get_stylesheet(self._STYLESHEET))
@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 +153,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 +195,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 +205,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 +227,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,
@ -217,7 +243,7 @@ class Command(QLineEdit):
signals[text[0]].emit(text.lstrip(text[0]))
@pyqtSlot(str)
def on_set_cmd_text(self, text):
def set_cmd_text(self, text):
"""Preset the statusbar to some text."""
self.setText(text)
self.setFocus()
@ -240,7 +266,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 +290,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:
@ -277,10 +303,10 @@ class Command(QLineEdit):
return
logging.debug("history up: {} / len {} / pos {}".format(
self._tmphist, len(self._tmphist), self._histpos))
self.set_cmd(self._tmphist[self._histpos])
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))
@ -291,10 +317,10 @@ class Command(QLineEdit):
self._histpos += 1
logging.debug("history up: {} / len {} / pos {}".format(
self._tmphist, len(self._tmphist), self._histpos))
self.set_cmd(self._tmphist[self._histpos])
self.set_cmd_text(self._tmphist[self._histpos])
class CommandValidator(QValidator):
class _CommandValidator(QValidator):
"""Validator to prevent the : from getting deleted."""
@ -313,13 +339,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 +362,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 +385,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 +414,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 +427,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 +472,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 +511,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 +526,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):

11
qutebrowser/widgets/tabbar.py
View File

@ -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()