def init(): """Initialize global prompt objects.""" global prompt_queue prompt_queue = PromptQueue() objreg.register('prompt-queue', prompt_queue) # for commands message.global_bridge.ask_question.connect(prompt_queue.ask_question, Qt.DirectConnection)
def status_command_stub(stubs, qtbot, win_registry): """Fixture which provides a fake status-command object.""" cmd = stubs.StatusBarCommandStub() objreg.register('status-command', cmd, scope='window', window=0) qtbot.addWidget(cmd) yield cmd objreg.delete('status-command', scope='window', window=0)
def fake_args(request): ns = types.SimpleNamespace() ns.backend = 'webengine' if request.config.webengine else 'webkit' ns.debug_flags = [] objreg.register('args', ns) yield ns objreg.delete('args')
def web_history(fake_save_manager, tmpdir, init_sql, config_stub, stubs): """Create a web history and register it into objreg.""" config_stub.val.completion.timestamp_format = '%Y-%m-%d' config_stub.val.completion.web_history.max_items = -1 web_history = history.WebHistory(stubs.FakeHistoryProgress()) objreg.register('web-history', web_history) yield web_history objreg.delete('web-history')
def init(): """Set the application wide proxy factory.""" proxy_factory = ProxyFactory() objreg.register('proxy-factory', proxy_factory) QNetworkProxyFactory.setApplicationProxyFactory(proxy_factory) config.instance.changed.connect(_warn_for_pac) _warn_for_pac()
def showEvent(self, e): """Extend showEvent to register us as the last-visible-main-window. Args: e: The QShowEvent """ super().showEvent(e) objreg.register('last-visible-main-window', self, update=True)
def init(): """Initialize Greasemonkey support.""" gm_manager = GreasemonkeyManager() objreg.register('greasemonkey', gm_manager) try: os.mkdir(_scripts_dir()) except FileExistsError: pass
def tabbed_browser_stubs(qapp, stubs, win_registry): """Fixture providing a fake tabbed-browser object on win_id 0 and 1.""" win_registry.add_window(1) stubs = [stubs.TabbedBrowserStub(), stubs.TabbedBrowserStub()] objreg.register('tabbed-browser', stubs[0], scope='window', window=0) objreg.register('tabbed-browser', stubs[1], scope='window', window=1) yield stubs objreg.delete('tabbed-browser', scope='window', window=0) objreg.delete('tabbed-browser', scope='window', window=1)
def init(): """Initialize the LimitLineParser storing the history.""" save_manager = objreg.get('save-manager') command_history = lineparser.LimitLineParser( standarddir.data(), 'cmd-history', limit='completion.cmd_history_max_items') objreg.register('command-history', command_history) save_manager.add_saveable('command-history', command_history.save, command_history.changed)
def _init_command_dispatcher(self): dispatcher = commands.CommandDispatcher(self.win_id, self.tabbed_browser) objreg.register('command-dispatcher', dispatcher, scope='window', window=self.win_id) self.tabbed_browser.widget.destroyed.connect( functools.partial(objreg.delete, 'command-dispatcher', scope='window', window=self.win_id))
def _init_completion(self): self._completion = completionwidget.CompletionView(self.win_id, self) cmd = objreg.get('status-command', scope='window', window=self.win_id) completer_obj = completer.Completer(cmd=cmd, win_id=self.win_id, parent=self._completion) self._completion.selection_changed.connect( completer_obj.on_selection_changed) objreg.register('completion', self._completion, scope='window', window=self.win_id) self._add_overlay(self._completion, self._completion.update_geometry)
def init(parent=None): """Initialize the web history. Args: parent: The parent to use for WebHistory. """ progress = HistoryProgress() history = WebHistory(progress=progress, parent=parent) objreg.register('web-history', history) if objects.backend == usertypes.Backend.QtWebKit: # pragma: no cover from glimpsebrowser.browser.webkit import webkithistory webkithistory.init(history)
def init(parent=None): """Initialize sessions. Args: parent: The parent to use for the SessionManager. """ base_path = os.path.join(standarddir.data(), 'sessions') try: os.mkdir(base_path) except FileExistsError: pass session_manager = SessionManager(base_path, parent) objreg.register('session-manager', session_manager)
def debug_console(): """Show the debugging console.""" try: con_widget = objreg.get('debug-console') except KeyError: log.misc.debug('initializing debug console') con_widget = consolewidget.ConsoleWidget() objreg.register('debug-console', con_widget) if con_widget.isVisible(): log.misc.debug('hiding debug console') con_widget.hide() else: log.misc.debug('showing debug console') con_widget.show()
def on_focus_changed(_old, new): """Register currently focused main window in the object registry.""" if new is None: return if not isinstance(new, QWidget): log.misc.debug( "on_focus_changed called with non-QWidget {!r}".format(new)) return window = new.window() if isinstance(window, mainwindow.MainWindow): objreg.register('last-focused-main-window', window, update=True) # A focused window must also be visible, and in this case we should # consider it as the most recently looked-at window objreg.register('last-visible-main-window', window, update=True)
def _init_downloadmanager(self): log.init.debug("Initializing downloads...") qtnetwork_download_manager = objreg.get('qtnetwork-download-manager') try: webengine_download_manager = objreg.get( 'webengine-download-manager') except KeyError: webengine_download_manager = None download_model = downloads.DownloadModel(qtnetwork_download_manager, webengine_download_manager) objreg.register('download-model', download_model, scope='window', window=self.win_id)
def early_init(args: argparse.Namespace) -> None: """Initialize the part of the config which works without a QApplication.""" configdata.init() yaml_config = configfiles.YamlConfig() config.instance = config.Config(yaml_config=yaml_config) config.val = config.ConfigContainer(config.instance) configapi.val = config.ConfigContainer(config.instance) config.key_instance = config.KeyConfig(config.instance) config.cache = configcache.ConfigCache() yaml_config.setParent(config.instance) for cf in config.change_filters: cf.validate() config_commands = configcommands.ConfigCommands( config.instance, config.key_instance) objreg.register('config-commands', config_commands) config_file = standarddir.config_py() try: if os.path.exists(config_file): configfiles.read_config_py(config_file) else: configfiles.read_autoconfig() except configexc.ConfigFileErrors as e: log.config.exception("Error while loading {}".format(e.basename)) global _init_errors _init_errors = e configfiles.init() for opt, val in args.temp_settings: try: config.instance.set_str(opt, val) except configexc.Error as e: message.error("set: {} - {}".format(e.__class__.__name__, e)) objects.backend = get_backend(args) configtypes.Font.monospace_fonts = config.val.fonts.monospace config.instance.changed.connect(_update_monospace_fonts) _init_envvars()
def __init__(self, *, win_id, private, parent=None): super().__init__(parent) objreg.register('statusbar', self, scope='window', window=win_id) self.setObjectName(self.__class__.__name__) self.setAttribute(Qt.WA_StyledBackground) config.set_register_stylesheet(self) self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed) self._win_id = win_id self._color_flags = ColorFlags() self._color_flags.private = private self._hbox = QHBoxLayout(self) self._set_hbox_padding() self._hbox.setSpacing(5) self._stack = QStackedLayout() self._hbox.addLayout(self._stack) self._stack.setContentsMargins(0, 0, 0, 0) self.cmd = command.Command(private=private, win_id=win_id) self._stack.addWidget(self.cmd) objreg.register('status-command', self.cmd, scope='window', window=win_id) self.txt = textwidget.Text() self._stack.addWidget(self.txt) self.cmd.show_cmd.connect(self._show_cmd_widget) self.cmd.hide_cmd.connect(self._hide_cmd_widget) self._hide_cmd_widget() self.url = url.UrlText() self.percentage = percentage.Percentage() self.backforward = backforward.Backforward() self.tabindex = tabindex.TabIndex() self.keystring = keystring.KeyString() self.prog = progress.Progress(self) self._draw_widgets() config.instance.changed.connect(self._on_config_changed) QTimer.singleShot(0, self.maybe_hide)
def _on_current_changed(self, idx): """Set last-focused-tab and leave hinting mode when focus changed.""" mode_on_change = config.val.tabs.mode_on_change if idx == -1 or self.shutting_down: # closing the last tab (before quitting) or shutting down return tab = self.widget.widget(idx) if tab is None: log.webview.debug("on_current_changed got called with invalid " "index {}".format(idx)) return log.modes.debug("Current tab changed, focusing {!r}".format(tab)) tab.setFocus() modes_to_leave = [usertypes.KeyMode.hint, usertypes.KeyMode.caret] mm_instance = modeman.instance(self._win_id) current_mode = mm_instance.mode log.modes.debug( "Mode before tab change: {} (mode_on_change = {})".format( current_mode.name, mode_on_change)) if mode_on_change == 'normal': modes_to_leave += modeman.INPUT_MODES for mode in modes_to_leave: modeman.leave(self._win_id, mode, 'tab changed', maybe=True) if (mode_on_change == 'restore' and current_mode not in modeman.PROMPT_MODES): modeman.enter(self._win_id, tab.data.input_mode, 'restore') if self._now_focused is not None: objreg.register('last-focused-tab', self._now_focused, update=True, scope='window', window=self._win_id) log.modes.debug( "Mode after tab change: {} (mode_on_change = {})".format( current_mode.name, mode_on_change)) self._now_focused = tab self.current_tab_changed.emit(tab) QTimer.singleShot(0, self._update_window_title) self._tab_insert_idx_left = self.widget.currentIndex() self._tab_insert_idx_right = self.widget.currentIndex() + 1
def fake_history(self, stubs, tabbed_browser_stubs, monkeypatch, webview): """Fixture which provides a window with a fake history.""" win = FakeMainWindow(b'fake-geometry-0', win_id=0) objreg.register('main-window', win, scope='window', window=0) browser = tabbed_browser_stubs[0] qapp = stubs.FakeQApplication(active_window=win) monkeypatch.setattr(sessions, 'QApplication', qapp) def set_data(items): history = browser.widgets()[0].page().history() stream, _data, user_data = tabhistory.serialize(items) qtutils.deserialize_stream(stream, history) for i, data in enumerate(user_data): history.itemAt(i).setUserData(data) yield set_data objreg.delete('main-window', scope='window', window=0) objreg.delete('tabbed-browser', scope='window', window=0)
def init(args, crash_handler): """Initialize everything. Args: args: The argparse namespace. crash_handler: The CrashHandler instance. """ log.init.debug("Starting init...") crash_handler.init_faulthandler() q_app.setQuitOnLastWindowClosed(False) _init_icon() loader.init() loader.load_components() try: _init_modules(args, crash_handler) except (OSError, UnicodeDecodeError, browsertab.WebTabError) as e: error.handle_fatal_exc(e, args, "Error while initializing!", pre_text="Error while initializing") sys.exit(usertypes.Exit.err_init) log.init.debug("Initializing eventfilter...") event_filter = EventFilter(q_app) q_app.installEventFilter(event_filter) objreg.register('event-filter', event_filter) log.init.debug("Connecting signals...") q_app.focusChanged.connect(on_focus_changed) _process_args(args) QDesktopServices.setUrlHandler('http', open_desktopservices_url) QDesktopServices.setUrlHandler('https', open_desktopservices_url) QDesktopServices.setUrlHandler('glimpse', open_desktopservices_url) log.init.debug("Init done!") crash_handler.raise_crashdlg()
def __init__(self, args): """Constructor. Args: Argument namespace from argparse. """ self._last_focus_object = None qt_args = configinit.qt_args(args) log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args)) super().__init__(qt_args) log.init.debug("Initializing application...") self._args = args objreg.register('args', args) objreg.register('app', self) self.launch_time = datetime.datetime.now() self.focusObjectChanged.connect(self.on_focus_object_changed) self.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
def init(win_id, parent): """Initialize the mode manager and the keyparsers for the given win_id.""" KM = usertypes.KeyMode # noqa: N806 modeman = ModeManager(win_id, parent) objreg.register('mode-manager', modeman, scope='window', window=win_id) keyparsers = { KM.normal: modeparsers.NormalKeyParser(win_id, modeman), KM.hint: modeparsers.HintKeyParser(win_id, modeman), KM.insert: modeparsers.PassthroughKeyParser(win_id, 'insert', modeman), KM.passthrough: modeparsers.PassthroughKeyParser(win_id, 'passthrough', modeman), KM.command: modeparsers.PassthroughKeyParser(win_id, 'command', modeman), KM.prompt: modeparsers.PassthroughKeyParser(win_id, 'prompt', modeman), KM.yesno: modeparsers.PromptKeyParser(win_id, modeman), KM.caret: modeparsers.CaretKeyParser(win_id, modeman), KM.set_mark: modeparsers.RegisterKeyParser(win_id, KM.set_mark, modeman), KM.jump_mark: modeparsers.RegisterKeyParser(win_id, KM.jump_mark, modeman), KM.record_macro: modeparsers.RegisterKeyParser(win_id, KM.record_macro, modeman), KM.run_macro: modeparsers.RegisterKeyParser(win_id, KM.run_macro, modeman), } objreg.register('keyparsers', keyparsers, scope='window', window=win_id) modeman.destroyed.connect( functools.partial(objreg.delete, 'keyparsers', scope='window', window=win_id)) for mode, parser in keyparsers.items(): modeman.register(mode, parser) return modeman
def run(args): """Initialize everything and run the application.""" if args.temp_basedir: args.basedir = tempfile.mkdtemp(prefix='glimpsebrowser-basedir-') quitter = Quitter(args) objreg.register('quitter', quitter) log.init.debug("Initializing directories...") standarddir.init(args) utils.preload_resources() log.init.debug("Initializing config...") configinit.early_init(args) global q_app q_app = Application(args) q_app.setOrganizationName("glimpsebrowser") q_app.setApplicationName("glimpsebrowser") q_app.setDesktopFileName("org.glimpsebrowser.glimpsebrowser") q_app.setApplicationVersion(glimpsebrowser.__version__) q_app.lastWindowClosed.connect(quitter.on_last_window_closed) if args.version: print(version.version()) sys.exit(usertypes.Exit.ok) crash_handler = crashsignal.CrashHandler(app=q_app, quitter=quitter, args=args, parent=q_app) crash_handler.activate() objreg.register('crash-handler', crash_handler) signal_handler = crashsignal.SignalHandler(app=q_app, quitter=quitter, parent=q_app) signal_handler.activate() objreg.register('signal-handler', signal_handler) try: server = ipc.send_or_listen(args) except ipc.Error: # ipc.send_or_listen already displays the error message for us. # We didn't really initialize much so far, so we just quit hard. sys.exit(usertypes.Exit.err_ipc) if server is None: if args.backend is not None: log.init.warning("Backend from the running instance will be used") sys.exit(usertypes.Exit.ok) else: server.got_args.connect(lambda args, target_arg, cwd: process_pos_args( args, cwd=cwd, via_ipc=True, target_arg=target_arg)) init(args, crash_handler) ret = qt_mainloop() return ret
def __init__(self, *, win_id: int, private: bool, parent: QWidget = None) -> None: self.is_private = private self.win_id = win_id self.tab_id = next(tab_id_gen) super().__init__(parent) self.registry = objreg.ObjectRegistry() tab_registry = objreg.get('tab-registry', scope='window', window=win_id) tab_registry[self.tab_id] = self objreg.register('tab', self, registry=self.registry) self.data = TabData() self._layout = miscwidgets.WrapperLayout(self) self._widget = None # type: typing.Optional[QWidget] self._progress = 0 self._has_ssl_errors = False self._load_status = usertypes.LoadStatus.none self._tab_event_filter = eventfilter.TabEventFilter(self, parent=self) self.backend = None # FIXME:qtwebengine Should this be public api via self.hints? # Also, should we get it out of objreg? hintmanager = hints.HintManager(win_id, self.tab_id, parent=self) objreg.register('hintmanager', hintmanager, scope='tab', window=self.win_id, tab=self.tab_id) self.before_load_started.connect(self._on_before_load_started)
def cookiejar_and_cache(stubs): """Fixture providing a fake cookie jar and cache.""" jar = QNetworkCookieJar() ram_jar = cookies.RAMCookieJar() cache = stubs.FakeNetworkCache() objreg.register('cookie-jar', jar) objreg.register('ram-cookie-jar', ram_jar) objreg.register('cache', cache) yield objreg.delete('cookie-jar') objreg.delete('ram-cookie-jar') objreg.delete('cache')
def fake_window(tabbed_browser_stubs): """Fixture which provides a fake main windows with a tabbedbrowser.""" win0 = FakeMainWindow(b'fake-geometry-0', win_id=0) objreg.register('main-window', win0, scope='window', window=0) yield objreg.delete('main-window', scope='window', window=0)
def tabbed_browser(stubs, win_registry): tb = stubs.TabbedBrowserStub() objreg.register('tabbed-browser', tb, scope='window', window=0) yield tb objreg.delete('tabbed-browser', scope='window', window=0)
def init(): """Initialize the MacroRecorder.""" macro_recorder = MacroRecorder() objreg.register('macro-recorder', macro_recorder)
def __init__(self, *, private, geometry=None, parent=None): """Create a new main window. Args: geometry: The geometry to load, as a bytes-object (or None). private: Whether the window is in private browsing mode. parent: The parent the window should get. """ super().__init__(parent) # Late import to avoid a circular dependency # - browsertab -> hints -> webelem -> mainwindow -> bar -> browsertab from glimpsebrowser.mainwindow import tabbedbrowser from glimpsebrowser.mainwindow.statusbar import bar self.setAttribute(Qt.WA_DeleteOnClose) self._commandrunner = None self._overlays = [] 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('glimpsebrowser') self._vbox = QVBoxLayout(self) self._vbox.setContentsMargins(0, 0, 0, 0) self._vbox.setSpacing(0) self._init_downloadmanager() self._downloadview = downloadview.DownloadView(self.win_id) if config.val.content.private_browsing: # This setting always trumps what's passed in. private = True else: private = bool(private) self._private = private self.tabbed_browser = tabbedbrowser.TabbedBrowser(win_id=self.win_id, private=private, parent=self) objreg.register('tabbed-browser', self.tabbed_browser, scope='window', window=self.win_id) self._init_command_dispatcher() # 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(win_id=self.win_id, private=private, parent=self) self._add_widgets() self._downloadview.show() self._init_completion() log.init.debug("Initializing modes...") modeman.init(self.win_id, self) self._commandrunner = runners.CommandRunner(self.win_id, partial_match=True) self._keyhint = keyhintwidget.KeyHintView(self.win_id, self) self._add_overlay(self._keyhint, self._keyhint.update_geometry) self._prompt_container = prompt.PromptContainer(self.win_id, self) self._add_overlay(self._prompt_container, self._prompt_container.update_geometry, centered=True, padding=10) objreg.register('prompt-container', self._prompt_container, scope='window', window=self.win_id) self._prompt_container.hide() self._messageview = messageview.MessageView(parent=self) self._add_overlay(self._messageview, self._messageview.update_geometry) self._init_geometry(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_overlay_signals) config.instance.changed.connect(self._on_config_changed) objreg.get("app").new_window.emit(self) self._set_decoration(config.val.window.hide_decoration) self.state_before_fullscreen = self.windowState() config.set_register_stylesheet(self)