Clean up signal connections

qutebrowser/app.py

@@ -233,45 +233,67 @@ class QuteBrowser(QApplication):
 
     def _connect_signals(self):
         """Connect all signals to their slots."""
+        # syntactic sugar
+        kp = self._keyparsers
+        status = self.mainwindow.status
+        completion = self.mainwindow.completion
+        tabs = self.mainwindow.tabs
+        cmd = self.mainwindow.status.cmd
+
+        # misc
         self.lastWindowClosed.connect(self.shutdown)
-        self.mainwindow.tabs.keypress.connect(
+        tabs.quit.connect(self.shutdown)
-            self.mainwindow.status.keypress)
+        tabs.set_mode.connect(self.set_mode)
-        self._keyparsers["normal"].set_cmd_text.connect(
+        tabs.currentChanged.connect(self.mainwindow.update_inspector)
-            self.mainwindow.status.cmd.set_cmd_text)
+
-        self.mainwindow.tabs.set_cmd_text.connect(
+        # status bar
-            self.mainwindow.status.cmd.set_cmd_text)
+        tabs.keypress.connect(status.keypress)
-        self.mainwindow.tabs.quit.connect(self.shutdown)
+        for obj in [kp["normal"], tabs]:
-        self.mainwindow.status.cmd.got_cmd.connect(self.commandparser.run)
+            obj.set_cmd_text.connect(cmd.set_cmd_text)
-        self.mainwindow.status.cmd.got_search.connect(self.searchparser.search)
+
-        self.mainwindow.status.cmd.got_search_rev.connect(
+        # commands
-            self.searchparser.search_rev)
+        cmd.got_cmd.connect(self.commandparser.run)
-        self.mainwindow.status.cmd.returnPressed.connect(
+        cmd.got_search.connect(self.searchparser.search)
-            self.mainwindow.tabs.setFocus)
+        cmd.got_search_rev.connect(self.searchparser.search_rev)
-        self.searchparser.do_search.connect(
+        cmd.returnPressed.connect(tabs.setFocus)
-            self.mainwindow.tabs.cur.search)
+        self.searchparser.do_search.connect(tabs.cur.search)
-        self._keyparsers["normal"].keystring_updated.connect(
+        kp["normal"].keystring_updated.connect(status.keystring.setText)
-            self.mainwindow.status.keystring.setText)
+
-        self._keyparsers["hint"].fire_hint.connect(
+        # hints
-            self.mainwindow.tabs.cur.fire_hint)
+        kp["hint"].fire_hint.connect(tabs.cur.fire_hint)
-        self._keyparsers["hint"].abort_hinting.connect(
+        kp["hint"].abort_hinting.connect(tabs.cur.abort_hinting)
-            self.mainwindow.tabs.cur.abort_hinting)
+        kp["hint"].keystring_updated.connect(tabs.cur.handle_hint_key)
-        self._keyparsers["hint"].keystring_updated.connect(
+        tabs.hint_strings_updated.connect(kp["hint"].on_hint_strings_updated)
-            self.mainwindow.tabs.cur.handle_hint_key)
+
-        self.mainwindow.tabs.hint_strings_updated.connect(
+        # messages
-            self._keyparsers["hint"].on_hint_strings_updated)
+        message.bridge.error.connect(status.disp_error)
-        self.mainwindow.tabs.set_mode.connect(self.set_mode)
+        message.bridge.info.connect(status.txt.set_temptext)
-        message.bridge.error.connect(self.mainwindow.status.disp_error)
+        message.bridge.text.connect(status.txt.set_normaltext)
-        message.bridge.info.connect(self.mainwindow.status.txt.set_temptext)
+
-        message.bridge.text.connect(self.mainwindow.status.txt.set_normaltext)
+        # config
         self.config.style_changed.connect(style.invalidate_caches)
-        self.config.changed.connect(self.mainwindow.tabs.on_config_changed)
+        for obj in [tabs, completion, self.mainwindow, config.cmd_history,
-        self.config.changed.connect(
+                    websettings, kp["normal"]]:
-            self.mainwindow.completion.on_config_changed)
+            self.config.changed.connect(obj.on_config_changed)
-        self.config.changed.connect(self.mainwindow.on_config_changed)
+
-        self.config.changed.connect(config.cmd_history.on_config_changed)
+        # statusbar
-        self.config.changed.connect(websettings.on_config_changed)
+        tabs.cur_progress.connect(status.prog.setValue)
-        self.config.changed.connect(
+        tabs.cur_load_finished.connect(status.prog.hide)
-            self._keyparsers["normal"].on_config_changed)
+        tabs.cur_load_finished.connect(status.url.on_loading_finished)
+        tabs.cur_load_started.connect(status.prog.on_load_started)
+        tabs.cur_scroll_perc_changed.connect(status.percentage.set_perc)
+        tabs.cur_statusbar_message.connect(status.txt.on_statusbar_message)
+        tabs.cur_url_changed.connect(status.url.set_url)
+        tabs.cur_link_hovered.connect(status.url.set_hover_url)
+
+        # command input / completion
+        cmd.esc_pressed.connect(tabs.setFocus)
+        cmd.clear_completion_selection.connect(
+            completion.on_clear_completion_selection)
+        cmd.hide_completion.connect(completion.hide)
+        cmd.textChanged.connect(completion.on_cmd_text_changed)
+        cmd.tab_pressed.connect(completion.on_tab_pressed)
+        completion.change_completed_part.connect(cmd.on_change_completed_part)
 
     def _recover_pages(self):
         """Try to recover all open pages.

qutebrowser/widgets/mainwindow.py

@@ -77,28 +77,6 @@ class MainWindow(QWidget):
         self.status = StatusBar()
         self._vbox.addWidget(self.status)
 
-        self.tabs.cur_progress.connect(self.status.prog.setValue)
-        self.tabs.cur_load_finished.connect(self.status.prog.hide)
-        self.tabs.cur_load_finished.connect(
-            self.status.url.on_loading_finished)
-        self.tabs.cur_load_started.connect(self.status.prog.on_load_started)
-        self.tabs.cur_scroll_perc_changed.connect(
-            self.status.percentage.set_perc)
-        self.tabs.cur_statusbar_message.connect(
-            self.status.txt.on_statusbar_message)
-        self.tabs.cur_url_changed.connect(self.status.url.set_url)
-        self.tabs.cur_link_hovered.connect(self.status.url.set_hover_url)
-        self.tabs.currentChanged.connect(self.update_inspector)
-        self.status.cmd.esc_pressed.connect(self.tabs.setFocus)
-        self.status.cmd.clear_completion_selection.connect(
-            self.completion.on_clear_completion_selection)
-        self.status.cmd.hide_completion.connect(self.completion.hide)
-        self.status.cmd.textChanged.connect(
-            self.completion.on_cmd_text_changed)
-        self.status.cmd.tab_pressed.connect(self.completion.on_tab_pressed)
-        self.completion.change_completed_part.connect(
-            self.status.cmd.on_change_completed_part)
-
         #self.retranslateUi(MainWindow)
         #self.tabWidget.setCurrentIndex(0)
         #QtCore.QMetaObject.connectSlotsByName(MainWindow)

qutebrowser/widgets/tabbedbrowser.py

@@ -127,6 +127,28 @@ class TabbedBrowser(TabWidget):
             logging.debug("Tab shutdown complete.")
             self.shutdown_complete.emit()
 
+    def _connect_tab_signals(self, tab):
+        """Set up the needed signals for tab."""
+        # filtered signals
+        tab.linkHovered.connect(self._filter.create(self.cur_link_hovered))
+        tab.loadProgress.connect(self._filter.create(self.cur_progress))
+        tab.loadFinished.connect(self._filter.create(self.cur_load_finished))
+        tab.loadStarted.connect(lambda:  # pylint: disable=unnecessary-lambda
+                                self.sender().signal_cache.clear())
+        tab.loadStarted.connect(self._filter.create(self.cur_load_started))
+        tab.statusBarMessage.connect(
+            self._filter.create(self.cur_statusbar_message))
+        tab.scroll_pos_changed.connect(
+            self._filter.create(self.cur_scroll_perc_changed))
+        tab.urlChanged.connect(self._filter.create(self.cur_url_changed))
+        # hintmanager
+        tab.hintmanager.hint_strings_updated.connect(self.hint_strings_updated)
+        tab.hintmanager.set_mode.connect(self.set_mode)
+        tab.hintmanager.set_cmd_text.connect(self.set_cmd_text)
+        # misc
+        tab.titleChanged.connect(self._titleChanged_handler)
+        tab.open_tab.connect(self.tabopen)
+
     def cntwidget(self, count=None):
         """Return a widget based on a count/idx.
 
@@ -227,26 +249,11 @@ class TabbedBrowser(TabWidget):
         logging.debug("Opening {}".format(url))
         url = urlutils.qurl(url)
         tab = BrowserTab(self)
+        self._connect_tab_signals(tab)
         self._tabs.append(tab)
         self.addTab(tab, urlutils.urlstring(url))
-        tab.linkHovered.connect(self._filter.create(self.cur_link_hovered))
-        tab.loadProgress.connect(self._filter.create(self.cur_progress))
-        tab.loadFinished.connect(self._filter.create(self.cur_load_finished))
-        tab.loadStarted.connect(lambda:  # pylint: disable=unnecessary-lambda
-                                self.sender().signal_cache.clear())
-        tab.loadStarted.connect(self._filter.create(self.cur_load_started))
-        tab.statusBarMessage.connect(
-            self._filter.create(self.cur_statusbar_message))
-        tab.scroll_pos_changed.connect(
-            self._filter.create(self.cur_scroll_perc_changed))
-        tab.urlChanged.connect(self._filter.create(self.cur_url_changed))
-        tab.titleChanged.connect(self._titleChanged_handler)
-        tab.hintmanager.hint_strings_updated.connect(self.hint_strings_updated)
-        tab.hintmanager.set_mode.connect(self.set_mode)
-        tab.hintmanager.set_cmd_text.connect(self.set_cmd_text)
         # FIXME sometimes this doesn't load
         tab.show()
-        tab.open_tab.connect(self.tabopen)
         tab.openurl(url)
         if not background:
             self.setCurrentWidget(tab)