1c10a1aecf
`buffer` takes either a tab index or a string and focuses the specified tab. The index can be of the form [0-9]+ which will switch to the relevant tab in the current window or [0-9]+/[0-9]+ (that is win_id/index) which will focus the specified window before switching tabs. If a string is passed the list of open tabs across all windows is sorted based on title and url (just like in the completion widget) and the top result is selected.
445 lines
17 KiB
Python
445 lines
17 KiB
Python
# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
|
|
|
|
# Copyright 2014-2016 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
|
|
#
|
|
# This file is part of qutebrowser.
|
|
#
|
|
# qutebrowser is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# qutebrowser is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with qutebrowser. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
"""The main window of qutebrowser."""
|
|
|
|
import binascii
|
|
import base64
|
|
import itertools
|
|
import functools
|
|
|
|
from PyQt5.QtCore import pyqtSlot, QRect, QPoint, QTimer, Qt
|
|
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QApplication
|
|
|
|
from qutebrowser.commands import runners, cmdutils
|
|
from qutebrowser.config import config
|
|
from qutebrowser.utils import message, log, usertypes, qtutils, objreg, utils
|
|
from qutebrowser.mainwindow import tabbedbrowser
|
|
from qutebrowser.mainwindow.statusbar import bar
|
|
from qutebrowser.completion import completionwidget
|
|
from qutebrowser.keyinput import modeman
|
|
from qutebrowser.browser import hints, downloads, downloadview, commands
|
|
from qutebrowser.misc import crashsignal
|
|
|
|
|
|
win_id_gen = itertools.count(0)
|
|
|
|
|
|
def get_window(via_ipc, force_window=False, force_tab=False,
|
|
force_target=None):
|
|
"""Helper function for app.py to get a window id.
|
|
|
|
Args:
|
|
via_ipc: Whether the request was made via IPC.
|
|
force_window: Whether to force opening in a window.
|
|
force_tab: Whether to force opening in a tab.
|
|
force_target: Override the new-instance-open-target config
|
|
"""
|
|
if force_window and force_tab:
|
|
raise ValueError("force_window and force_tab are mutually exclusive!")
|
|
if not via_ipc:
|
|
# Initial main window
|
|
return 0
|
|
window_to_raise = None
|
|
if force_target is not None:
|
|
open_target = force_target
|
|
else:
|
|
open_target = config.get('general', 'new-instance-open-target')
|
|
if (open_target == 'window' or force_window) and not force_tab:
|
|
window = MainWindow()
|
|
window.show()
|
|
win_id = window.win_id
|
|
window_to_raise = window
|
|
else:
|
|
try:
|
|
window = objreg.last_window()
|
|
except objreg.NoWindow:
|
|
# There is no window left, so we open a new one
|
|
window = MainWindow()
|
|
window.show()
|
|
win_id = window.win_id
|
|
window_to_raise = window
|
|
win_id = window.win_id
|
|
if open_target not in ('tab-silent', 'tab-bg-silent'):
|
|
window_to_raise = window
|
|
if window_to_raise is not None:
|
|
window_to_raise.setWindowState(
|
|
window.windowState() & ~Qt.WindowMinimized | Qt.WindowActive)
|
|
window_to_raise.raise_()
|
|
window_to_raise.activateWindow()
|
|
QApplication.instance().alert(window_to_raise)
|
|
return win_id
|
|
|
|
|
|
class MainWindow(QWidget):
|
|
|
|
"""The main window of qutebrowser.
|
|
|
|
Adds all needed components to a vbox, initializes sub-widgets and connects
|
|
signals.
|
|
|
|
Attributes:
|
|
status: The StatusBar widget.
|
|
tabbed_browser: The TabbedBrowser widget.
|
|
_downloadview: The DownloadView widget.
|
|
_vbox: The main QVBoxLayout.
|
|
_commandrunner: The main CommandRunner instance.
|
|
"""
|
|
|
|
def __init__(self, geometry=None, parent=None):
|
|
"""Create a new main window.
|
|
|
|
Args:
|
|
geometry: The geometry to load, as a bytes-object (or None).
|
|
parent: The parent the window should get.
|
|
"""
|
|
super().__init__(parent)
|
|
self.setAttribute(Qt.WA_DeleteOnClose)
|
|
self._commandrunner = None
|
|
self.win_id = next(win_id_gen)
|
|
self.registry = objreg.ObjectRegistry()
|
|
objreg.window_registry[self.win_id] = self
|
|
objreg.register('main-window', self, scope='window',
|
|
window=self.win_id)
|
|
tab_registry = objreg.ObjectRegistry()
|
|
objreg.register('tab-registry', tab_registry, scope='window',
|
|
window=self.win_id)
|
|
|
|
message_bridge = message.MessageBridge(self)
|
|
objreg.register('message-bridge', message_bridge, scope='window',
|
|
window=self.win_id)
|
|
|
|
self.setWindowTitle('qutebrowser')
|
|
self._vbox = QVBoxLayout(self)
|
|
self._vbox.setContentsMargins(0, 0, 0, 0)
|
|
self._vbox.setSpacing(0)
|
|
|
|
log.init.debug("Initializing downloads...")
|
|
download_manager = downloads.DownloadManager(self.win_id, self)
|
|
objreg.register('download-manager', download_manager, scope='window',
|
|
window=self.win_id)
|
|
|
|
self._downloadview = downloadview.DownloadView(self.win_id)
|
|
|
|
self.tabbed_browser = tabbedbrowser.TabbedBrowser(self.win_id)
|
|
objreg.register('tabbed-browser', self.tabbed_browser, scope='window',
|
|
window=self.win_id)
|
|
dispatcher = commands.CommandDispatcher(self.win_id,
|
|
self.tabbed_browser)
|
|
objreg.register('command-dispatcher', dispatcher, scope='window',
|
|
window=self.win_id)
|
|
self.tabbed_browser.destroyed.connect(
|
|
functools.partial(objreg.delete, 'command-dispatcher',
|
|
scope='window', window=self.win_id))
|
|
|
|
# We need to set an explicit parent for StatusBar because it does some
|
|
# show/hide magic immediately which would mean it'd show up as a
|
|
# window.
|
|
self.status = bar.StatusBar(self.win_id, parent=self)
|
|
|
|
self._add_widgets()
|
|
self._downloadview.show()
|
|
|
|
self._completion = completionwidget.CompletionView(self.win_id, self)
|
|
|
|
self._commandrunner = runners.CommandRunner(self.win_id)
|
|
|
|
log.init.debug("Initializing modes...")
|
|
modeman.init(self.win_id, self)
|
|
|
|
if geometry is not None:
|
|
self._load_geometry(geometry)
|
|
elif self.win_id == 0:
|
|
self._load_state_geometry()
|
|
else:
|
|
self._set_default_geometry()
|
|
log.init.debug("Initial main window geometry: {}".format(
|
|
self.geometry()))
|
|
|
|
self._connect_signals()
|
|
|
|
# When we're here the statusbar might not even really exist yet, so
|
|
# resizing will fail. Therefore, we use singleShot QTimers to make sure
|
|
# we defer this until everything else is initialized.
|
|
QTimer.singleShot(0, self._connect_resize_completion)
|
|
objreg.get('config').changed.connect(self.on_config_changed)
|
|
|
|
if config.get('ui', 'hide-mouse-cursor'):
|
|
self.setCursor(Qt.BlankCursor)
|
|
|
|
#self.retranslateUi(MainWindow)
|
|
#self.tabWidget.setCurrentIndex(0)
|
|
#QtCore.QMetaObject.connectSlotsByName(MainWindow)
|
|
|
|
objreg.get("app").new_window.emit(self)
|
|
|
|
def __repr__(self):
|
|
return utils.get_repr(self)
|
|
|
|
@pyqtSlot(str, str)
|
|
def on_config_changed(self, section, option):
|
|
"""Resize the completion if related config options changed."""
|
|
if section == 'completion' and option in ('height', 'shrink'):
|
|
self.resize_completion()
|
|
elif section == 'ui' and option == 'statusbar-padding':
|
|
self.resize_completion()
|
|
elif section == 'ui' and option == 'downloads-position':
|
|
self._add_widgets()
|
|
|
|
def _add_widgets(self):
|
|
"""Add or readd all widgets to the VBox."""
|
|
self._vbox.removeWidget(self.tabbed_browser)
|
|
self._vbox.removeWidget(self._downloadview)
|
|
self._vbox.removeWidget(self.status)
|
|
position = config.get('ui', 'downloads-position')
|
|
if position == 'top':
|
|
self._vbox.addWidget(self._downloadview)
|
|
self._vbox.addWidget(self.tabbed_browser)
|
|
elif position == 'bottom':
|
|
self._vbox.addWidget(self.tabbed_browser)
|
|
self._vbox.addWidget(self._downloadview)
|
|
else:
|
|
raise ValueError("Invalid position {}!".format(position))
|
|
self._vbox.addWidget(self.status)
|
|
|
|
def _load_state_geometry(self):
|
|
"""Load the geometry from the state file."""
|
|
state_config = objreg.get('state-config')
|
|
try:
|
|
data = state_config['geometry']['mainwindow']
|
|
geom = base64.b64decode(data, validate=True)
|
|
except KeyError:
|
|
# First start
|
|
self._set_default_geometry()
|
|
except binascii.Error:
|
|
log.init.exception("Error while reading geometry")
|
|
self._set_default_geometry()
|
|
else:
|
|
self._load_geometry(geom)
|
|
|
|
def _save_geometry(self):
|
|
"""Save the window geometry to the state config."""
|
|
state_config = objreg.get('state-config')
|
|
data = bytes(self.saveGeometry())
|
|
geom = base64.b64encode(data).decode('ASCII')
|
|
state_config['geometry']['mainwindow'] = geom
|
|
|
|
def _load_geometry(self, geom):
|
|
"""Load geometry from a bytes object.
|
|
|
|
If loading fails, loads default geometry.
|
|
"""
|
|
log.init.debug("Loading mainwindow from {}".format(geom))
|
|
ok = self.restoreGeometry(geom)
|
|
if not ok:
|
|
log.init.warning("Error while loading geometry.")
|
|
self._set_default_geometry()
|
|
|
|
def _connect_resize_completion(self):
|
|
"""Connect the resize_completion signal and resize it once."""
|
|
self._completion.resize_completion.connect(self.resize_completion)
|
|
self.resize_completion()
|
|
|
|
def _set_default_geometry(self):
|
|
"""Set some sensible default geometry."""
|
|
self.setGeometry(QRect(50, 50, 800, 600))
|
|
|
|
def _get_object(self, name):
|
|
"""Get an object for this window in the object registry."""
|
|
return objreg.get(name, scope='window', window=self.win_id)
|
|
|
|
def _connect_signals(self):
|
|
"""Connect all mainwindow signals."""
|
|
key_config = objreg.get('key-config')
|
|
|
|
status = self._get_object('statusbar')
|
|
keyparsers = self._get_object('keyparsers')
|
|
completion_obj = self._get_object('completion')
|
|
tabs = self._get_object('tabbed-browser')
|
|
cmd = self._get_object('status-command')
|
|
message_bridge = self._get_object('message-bridge')
|
|
mode_manager = self._get_object('mode-manager')
|
|
prompter = self._get_object('prompter')
|
|
|
|
# misc
|
|
self.tabbed_browser.close_window.connect(self.close)
|
|
mode_manager.entered.connect(hints.on_mode_entered)
|
|
|
|
# status bar
|
|
mode_manager.entered.connect(status.on_mode_entered)
|
|
mode_manager.left.connect(status.on_mode_left)
|
|
mode_manager.left.connect(cmd.on_mode_left)
|
|
mode_manager.left.connect(prompter.on_mode_left)
|
|
|
|
# commands
|
|
keyparsers[usertypes.KeyMode.normal].keystring_updated.connect(
|
|
status.keystring.setText)
|
|
cmd.got_cmd.connect(self._commandrunner.run_safely)
|
|
cmd.returnPressed.connect(tabs.on_cmd_return_pressed)
|
|
tabs.got_cmd.connect(self._commandrunner.run_safely)
|
|
|
|
# config
|
|
for obj in keyparsers.values():
|
|
key_config.changed.connect(obj.on_keyconfig_changed)
|
|
|
|
# messages
|
|
message_bridge.s_error.connect(status.disp_error)
|
|
message_bridge.s_warning.connect(status.disp_warning)
|
|
message_bridge.s_info.connect(status.disp_temp_text)
|
|
message_bridge.s_set_text.connect(status.set_text)
|
|
message_bridge.s_maybe_reset_text.connect(status.txt.maybe_reset_text)
|
|
message_bridge.s_set_cmd_text.connect(cmd.set_cmd_text)
|
|
message_bridge.s_question.connect(prompter.ask_question,
|
|
Qt.DirectConnection)
|
|
|
|
# statusbar
|
|
# FIXME some of these probably only should be triggered on mainframe
|
|
# loadStarted.
|
|
# https://github.com/The-Compiler/qutebrowser/issues/112
|
|
tabs.current_tab_changed.connect(status.prog.on_tab_changed)
|
|
tabs.cur_progress.connect(status.prog.setValue)
|
|
tabs.cur_load_finished.connect(status.prog.hide)
|
|
tabs.cur_load_started.connect(status.prog.on_load_started)
|
|
|
|
tabs.current_tab_changed.connect(status.percentage.on_tab_changed)
|
|
tabs.cur_scroll_perc_changed.connect(status.percentage.set_perc)
|
|
|
|
tabs.tab_index_changed.connect(status.tabindex.on_tab_index_changed)
|
|
|
|
tabs.current_tab_changed.connect(status.txt.on_tab_changed)
|
|
tabs.cur_statusbar_message.connect(status.txt.on_statusbar_message)
|
|
tabs.cur_load_started.connect(status.txt.on_load_started)
|
|
|
|
tabs.current_tab_changed.connect(status.url.on_tab_changed)
|
|
tabs.cur_url_text_changed.connect(status.url.set_url)
|
|
tabs.cur_link_hovered.connect(status.url.set_hover_url)
|
|
tabs.cur_load_status_changed.connect(status.url.on_load_status_changed)
|
|
|
|
# command input / completion
|
|
mode_manager.left.connect(tabs.on_mode_left)
|
|
cmd.clear_completion_selection.connect(
|
|
completion_obj.on_clear_completion_selection)
|
|
cmd.hide_completion.connect(completion_obj.hide)
|
|
|
|
@pyqtSlot()
|
|
def resize_completion(self):
|
|
"""Adjust completion according to config."""
|
|
if not self._completion.isVisible():
|
|
# It doesn't make sense to resize the completion as long as it's
|
|
# not shown anyways.
|
|
return
|
|
# Get the configured height/percentage.
|
|
confheight = str(config.get('completion', 'height'))
|
|
if confheight.endswith('%'):
|
|
perc = int(confheight.rstrip('%'))
|
|
height = self.height() * perc / 100
|
|
else:
|
|
height = int(confheight)
|
|
# Shrink to content size if needed and shrinking is enabled
|
|
if config.get('completion', 'shrink'):
|
|
contents_height = (
|
|
self._completion.viewportSizeHint().height() +
|
|
self._completion.horizontalScrollBar().sizeHint().height())
|
|
if contents_height <= height:
|
|
height = contents_height
|
|
else:
|
|
contents_height = -1
|
|
# hpoint now would be the bottom-left edge of the widget if it was on
|
|
# the top of the main window.
|
|
topleft_y = self.height() - self.status.height() - height
|
|
topleft_y = qtutils.check_overflow(topleft_y, 'int', fatal=False)
|
|
topleft = QPoint(0, topleft_y)
|
|
bottomright = self.status.geometry().topRight()
|
|
rect = QRect(topleft, bottomright)
|
|
log.misc.debug('completion rect: {}'.format(rect))
|
|
if rect.isValid():
|
|
self._completion.setGeometry(rect)
|
|
|
|
@cmdutils.register(instance='main-window', scope='window')
|
|
@pyqtSlot()
|
|
def close(self):
|
|
"""Close the current window.
|
|
|
|
//
|
|
|
|
Extend close() so we can register it as a command.
|
|
"""
|
|
super().close()
|
|
|
|
@cmdutils.register(instance='main-window', scope='window')
|
|
def fullscreen(self):
|
|
"""Toggle fullscreen mode."""
|
|
if self.isFullScreen():
|
|
self.showNormal()
|
|
else:
|
|
self.showFullScreen()
|
|
|
|
def resizeEvent(self, e):
|
|
"""Extend resizewindow's resizeEvent to adjust completion.
|
|
|
|
Args:
|
|
e: The QResizeEvent
|
|
"""
|
|
super().resizeEvent(e)
|
|
self.resize_completion()
|
|
self._downloadview.updateGeometry()
|
|
self.tabbed_browser.tabBar().refresh()
|
|
|
|
def _do_close(self):
|
|
"""Helper function for closeEvent."""
|
|
objreg.get('session-manager').save_last_window_session()
|
|
self._save_geometry()
|
|
log.destroy.debug("Closing window {}".format(self.win_id))
|
|
self.tabbed_browser.shutdown()
|
|
|
|
def closeEvent(self, e):
|
|
"""Override closeEvent to display a confirmation if needed."""
|
|
if crashsignal.is_crashing:
|
|
e.accept()
|
|
return
|
|
confirm_quit = config.get('ui', 'confirm-quit')
|
|
tab_count = self.tabbed_browser.count()
|
|
download_manager = objreg.get('download-manager', scope='window',
|
|
window=self.win_id)
|
|
download_count = download_manager.rowCount()
|
|
quit_texts = []
|
|
# Ask if multiple-tabs are open
|
|
if 'multiple-tabs' in confirm_quit and tab_count > 1:
|
|
quit_texts.append("{} {} open.".format(
|
|
tab_count, "tab is" if tab_count == 1 else "tabs are"))
|
|
# Ask if multiple downloads running
|
|
if 'downloads' in confirm_quit and download_count > 0:
|
|
quit_texts.append("{} {} running.".format(
|
|
tab_count,
|
|
"download is" if tab_count == 1 else "downloads are"))
|
|
# Process all quit messages that user must confirm
|
|
if quit_texts or 'always' in confirm_quit:
|
|
text = '\n'.join(['Really quit?'] + quit_texts)
|
|
confirmed = message.ask(self.win_id, text,
|
|
usertypes.PromptMode.yesno,
|
|
default=True)
|
|
# Stop asking if the user cancels
|
|
if not confirmed:
|
|
log.destroy.debug("Cancelling closing of window {}".format(
|
|
self.win_id))
|
|
e.ignore()
|
|
return
|
|
e.accept()
|
|
self._do_close()
|