def __init__(self, id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QtNetwork.QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QtCore.QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QtNetwork.QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def __init__(self):
self.srv = QtNetwork.QLocalServer()
self.receiver = None
self.ses = {}
self.is_connected = self.srv.connect(self.srv,
QtCore.SIGNAL("newConnection()"),
self.connected)
def startNotifier(self):
if self.protocol() == 'unix':
address = tempfile.mktemp(prefix="pmx")
self.notifier = QtNetwork.QLocalServer(self)
self.notifier.listen(address)
else:
self.notifier = QtNetwork.QTcpServer(self)
self.notifier.listen()
address = "%s:%d" % (self.notifier.serverAddress().toString(),
self.notifier.serverPort())
self.notifier.newConnection.connect(self.on_notifier_newConnection)
return address
def start_server(self):
"""
Start the socket server to allow inter app communication
:return:
"""
self.out_socket = None
self.out_stream = None
self.in_socket = None
self.in_stream = None
self.server = QtNetwork.QLocalServer()
self.server.listen(self.id)
self.server.newConnection.connect(self._on_new_connection)
return True
def __init__(self, argv):
QtWidgets.QApplication.__init__(self, argv)
self._key = 'KCC'
self._timeout = 1000
self._locked = False
socket = QtNetwork.QLocalSocket(self)
socket.connectToServer(self._key, QtCore.QIODevice.WriteOnly)
if not socket.waitForConnected(self._timeout):
self._server = QtNetwork.QLocalServer(self)
# noinspection PyUnresolvedReferences
self._server.newConnection.connect(self.handleMessage)
self._server.listen(self._key)
else:
self._locked = True
socket.disconnectFromServer()
def __init__(self, argv, catalog):
QApplication.__init__(self, argv)
self.aboutToQuit.connect(self.cleanup)
self.control = QtNetwork.QLocalServer(self)
self.control.newConnection.connect(self.onControlConnect)
self.mainwindow = None
self.catalog = '%s-pds.socket' % catalog
self._init_translations()
self.readyToRun = self.control.listen(self.catalog)
if not self.readyToRun:
if self.sendToInstance('show-mainwindow'):
sys.exit()
else:
self.control.removeServer(self.catalog)
self.readyToRun = self.control.listen(self.catalog)
def __init__(self, options, argv):
"""
Initialize Eddy.
:type options: Namespace
:type argv: list
"""
super().__init__(argv)
self.server = None
self.socket = QtNetwork.QLocalSocket()
self.socket.connectToServer(APPID)
self.running = self.socket.waitForConnected()
self.sessions = DistinctList()
self.welcome = None
if not self.isRunning() or options.tests:
self.server = QtNetwork.QLocalServer()
self.server.listen(APPID)
self.socket = None
connect(self.sgnCreateSession, self.doCreateSession)
def __init__(self, argv):
"""
Initialize Eddy.
:type argv: list
"""
super().__init__(argv)
self.openFilePath = None
self.server = None
self.sessions = DistinctList()
self.started = False
self.welcome = None
# APPLICATION INFO
self.setDesktopFileName('{}.{}'.format(ORGANIZATION_REVERSE_DOMAIN,
APPNAME))
self.setOrganizationName(ORGANIZATION)
self.setOrganizationDomain(ORGANIZATION_DOMAIN)
self.setApplicationName(APPNAME)
self.setApplicationDisplayName(APPNAME)
self.setApplicationVersion(VERSION)
# PARSE COMMAND LINE ARGUMENTS
self.options = CommandLineParser()
self.options.process(argv)
# CHECK FOR A RUNNING INSTANCE
self.socket = QtNetwork.QLocalSocket()
self.socket.connectToServer(APPID)
self.running = self.socket.waitForConnected()
if not self.isRunning():
QtNetwork.QLocalServer.removeServer(APPID)
self.server = QtNetwork.QLocalServer()
self.server.listen(APPID)
self.socket = None
connect(self.sgnCreateSession, self.doCreateSession)
connect(self.aboutToQuit, self.onAboutToQuit)
def __init__(self, argv, key):
super().__init__(argv)
QtCore.QSharedMemory(key).attach()
self._memory = QtCore.QSharedMemory(self)
self._memory.setKey(key)
if self._memory.attach():
self._running = True
else:
self._running = False
if not self._memory.create(1):
raise RuntimeError(self._memory.errorString())
self._name = key
self._timeout = 1000
if not self.is_running():
self._server = QtNetwork.QLocalServer(self)
self._server.newConnection.connect(self.handle_message)
self._server.setSocketOptions(QtNetwork.QLocalServer.WorldAccessOption)
self._server.listen(self._name)
try:
self.visibility = False if argv[1] == "--run-in-background" else True
except IndexError:
self.visibility = True
