Selectively queue messages rather than unqueueing.

qutebrowser/app.py

@@ -326,7 +326,7 @@ class QuteBrowser(QApplication):
         for e in self._args.command:
             if e.startswith(':'):
                 logging.debug("Startup cmd {}".format(e))
-                self.commandmanager.run_safely(e.lstrip(':'))
+                self.commandmanager.run_safely_init(e.lstrip(':'))
             else:
                 logging.debug("Startup URL {}".format(e))
                 self._opened_urls.append(e)

qutebrowser/commands/managers.py

@@ -230,3 +230,14 @@ class CommandManager:
             self.run(text, count)
         except (CommandMetaError, CommandError) as e:
             message.error(e)
+
+    @pyqtSlot(str, int)
+    def run_safely_init(self, text, count=None):
+        """Run a command and display exceptions in the statusbar.
+
+        Contrary to run_safely, error messages are queued so this is more
+        suitable to use while initializing."""
+        try:
+            self.run(text, count)
+        except (CommandMetaError, CommandError) as e:
+            message.error(e, queue=True)

qutebrowser/network/networkmanager.py

@@ -64,7 +64,8 @@ class NetworkManager(QNetworkAccessManager):
             return
         for err in errors:
             # FIXME we might want to use warn here (non-fatal error)
-            message.error('SSL error: {}'.format(err.errorString()))
+            message.error('SSL error: {}'.format(err.errorString()),
+                          queue=True)
         reply.ignoreSslErrors()
 
     def createRequest(self, op, req, outgoing_data):

qutebrowser/utils/message.py

@@ -27,30 +27,30 @@ def instance():
     return QCoreApplication.instance().messagebridge
 
 
-def error(message, immediate=False):
+def error(message, queue=False):
     """Display an error message in the statusbar.
 
     Args:
         message: The message to display.
-        immediate: If set, message gets displayed immediately rather than
-                   getting queued.
+        queue: If set, message gets queued rather than being displayed
+               immediately.
     """
     message = str(message)
     logging.error(message)
-    instance().error.emit(message, immediate)
+    instance().error.emit(message, queue)
 
 
-def info(message, immediate=False):
+def info(message, queue=False):
     """Display a temporary info message in the statusbar.
 
     Args:
         message: The message to display.
-        immediate: If set, message gets displayed immediately rather than
-                   getting queued.
+        queue: If set, message gets queued rather than being displayed
+               immediately.
     """
     message = str(message)
     logging.info(message)
-    instance().info.emit(message, immediate)
+    instance().info.emit(message, queue)
 
 
 def text(message):

qutebrowser/widgets/statusbar/bar.py

@@ -181,14 +181,14 @@ class StatusBar(QWidget):
             self._text_pop_timer.start()
         self._stack.setCurrentWidget(self.txt)
 
-    def _disp_text(self, text, error, immediate=False):
+    def _disp_text(self, text, error, queue=False):
         """Inner logic for disp_error and disp_temp_text.
 
         Args:
             text: The message to display.
             error: Whether it's an error message (True) or normal text (False)
-            immediate: If set, message gets displayed immediately rather than
-                       getting queued.
+            queue: If set, message gets queued rather than being displayed
+                   immediately.
         """
         logging.debug("Displaying text: {} (error={})".format(text, error))
         now = datetime.now()
@@ -197,7 +197,7 @@ class StatusBar(QWidget):
                  else now - self._last_text_time)
         self._last_text_time = now
         logging.debug("queue: {} / delta: {}".format(self._text_queue, delta))
-        if immediate or (not self._text_queue and (
+        if (not queue) or (not self._text_queue and (
                 delta is None or delta.total_seconds() * 1000.0 > mindelta)):
             # If the queue is empty and we didn't print messages for long
             # enough, we can take the short route and display the message
@@ -219,26 +219,26 @@ class StatusBar(QWidget):
         self._text_pop_timer.start()
 
     @pyqtSlot(str, bool)
-    def disp_error(self, text, immediate=False):
+    def disp_error(self, text, queue=False):
         """Display an error in the statusbar.
 
         Args:
             text: The message to display.
-            immediate: If set, message gets displayed immediately rather than
-                       getting queued.
+            queue: If set, message gets queued rather than being displayed
+                   immediately.
         """
-        self._disp_text(text, True, immediate)
+        self._disp_text(text, True, queue)
 
     @pyqtSlot(str, bool)
-    def disp_temp_text(self, text, immediate):
+    def disp_temp_text(self, text, queue):
         """Display a temporary text in the statusbar.
 
         Args:
             text: The message to display.
-            immediate: If set, message gets displayed immediately rather than
-                       getting queued.
+            queue: If set, message gets queued rather than being displayed
+                   immediately.
         """
-        self._disp_text(text, False, immediate)
+        self._disp_text(text, False, queue)
 
     @pyqtSlot(str)
     def set_text(self, val):

qutebrowser/widgets/webview.py

@@ -308,7 +308,7 @@ class WebView(QWebView):
         if perc < 0:
             raise CommandError("Can't zoom {}%!".format(perc))
         self.setZoomFactor(float(perc) / 100)
-        message.info("Zoom level: {}%".format(perc), immediate=True)
+        message.info("Zoom level: {}%".format(perc))
 
     def zoom(self, offset):
         """Increase/Decrease the zoom level.