WIP: Make application initialization and start up more clear

- Create SingleInstance class to handling single instance stuff.
 - Instead of calling getInstance() everywhere, initialize each object
   explicitly in order when application starts and getInstance()s do not
   create instances any more and they merely return the created
   instances.
 - Only set initial values in construtor functions __init__(). Move the
   initialization of context-aware (i.e. things that depend on other
   things) to separate functions.
 - Split application creation and initialziation into several steps and
   them should be called explicitly in the correct order.

cura/SingleInstance.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+import json
+import os
+from typing import List, Optional
+
+from PyQt5.QtNetwork import QLocalServer, QLocalSocket
+
+from UM.Logger import Logger
+
+
+class SingleInstance:
+
+    def __init__(self, application, files_to_open: Optional[List[str]]):
+        self._application = application
+        self._files_to_open = files_to_open
+
+        self._single_instance_server = None
+
+    # Starts a client that checks for a single instance server and sends the files that need to opened if the server
+    # exists. Returns True if the single instance server is found, otherwise False.
+    def startClient(self) -> bool:
+        Logger.log("i", "Checking for the presence of an ready running Cura instance.")
+        single_instance_socket = QLocalSocket(self._application)
+        Logger.log("d", "Full single instance server name: %s", single_instance_socket.fullServerName())
+        single_instance_socket.connectToServer("ultimaker-cura")
+        single_instance_socket.waitForConnected(msecs = 3000)  # wait for 3 seconds
+
+        if single_instance_socket.state() != QLocalSocket.ConnectedState:
+            return False
+
+        # We only send the files that need to be opened.
+        if not self._files_to_open:
+            Logger.log("i", "No file need to be opened, do nothing.")
+            return True
+
+        if single_instance_socket.state() == QLocalSocket.ConnectedState:
+            Logger.log("i", "Connection has been made to the single-instance Cura socket.")
+
+            # Protocol is one line of JSON terminated with a carriage return.
+            # "command" field is required and holds the name of the command to execute.
+            # Other fields depend on the command.
+
+            payload = {"command": "clear-all"}
+            single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding = "ascii"))
+
+            payload = {"command": "focus"}
+            single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding = "ascii"))
+
+            for filename in self._files_to_open:
+                payload = {"command": "open", "filePath": os.path.abspath(filename)}
+                single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding = "ascii"))
+
+            payload = {"command": "close-connection"}
+            single_instance_socket.write(bytes(json.dumps(payload) + "\n", encoding = "ascii"))
+
+            single_instance_socket.flush()
+            single_instance_socket.waitForDisconnected()
+        return True
+
+    def startServer(self) -> None:
+        self._single_instance_server = QLocalServer()
+        self._single_instance_server.newConnection.connect(self._onClientConnected)
+        self._single_instance_server.listen("ultimaker-cura")
+
+    def _onClientConnected(self):
+        Logger.log("i", "New connection recevied on our single-instance server")
+        connection = self._single_instance_server.nextPendingConnection()
+
+        if connection is not None:
+            connection.readyRead.connect(lambda c = connection: self.__readCommands(c))
+
+    def __readCommands(self, connection):
+        line = connection.readLine()
+        while len(line) != 0:    # There is also a .canReadLine()
+            try:
+                payload = json.loads(str(line, encoding = "ascii").strip())
+                command = payload["command"]
+
+                # Command: Remove all models from the build plate.
+                if command == "clear-all":
+                    self._application.callLater(lambda: self._application.deleteAll())
+
+                # Command: Load a model file
+                elif command == "open":
+                    self._application.callLater(lambda f = payload["filePath"]: self._application._openFile(f))
+
+                # Command: Activate the window and bring it to the top.
+                elif command == "focus":
+                    # Operating systems these days prevent windows from moving around by themselves.
+                    # 'alert' or flashing the icon in the taskbar is the best thing we do now.
+                    self._application.callLater(lambda: self._application.getMainWindow().alert(0))
+
+                # Command: Close the socket connection. We're done.
+                elif command == "close-connection":
+                    connection.close()
+
+                else:
+                    Logger.log("w", "Received an unrecognized command " + str(command))
+            except json.decoder.JSONDecodeError as ex:
+                Logger.log("w", "Unable to parse JSON command '%s': %s", line, repr(ex))
+            line = connection.readLine()