def send_to_running_instance(cmdlist):
"""Try to send a commandline to a running instance.
Blocks for CONNECT_TIMEOUT ms.
Args:
cmdlist: A list to send (URLs/commands)
Return:
True if connecting was successful, False if no connection was made.
"""
socket = QLocalSocket()
socket.connectToServer(SOCKETNAME)
connected = socket.waitForConnected(100)
if connected:
log.ipc.info("Opening in existing instance")
line = json.dumps(cmdlist) + '\n'
data = line.encode('utf-8')
log.ipc.debug("Writing: {}".format(data))
socket.writeData(data)
socket.waitForBytesWritten(WRITE_TIMEOUT)
if socket.error() != QLocalSocket.UnknownSocketError:
_socket_error("writing to running instance", socket)
else:
return True
else:
if socket.error() not in (QLocalSocket.ConnectionRefusedError,
QLocalSocket.ServerNotFoundError):
_socket_error("connecting to running instance", socket)
else:
log.ipc.debug("No existing instance present (error {})".format(
socket.error()))
return False
def send_to_running_instance(cmdlist):
"""Try to send a commandline to a running instance.
Blocks for CONNECT_TIMEOUT ms.
Args:
cmdlist: A list to send (URLs/commands)
Return:
True if connecting was successful, False if no connection was made.
"""
socket = QLocalSocket()
socket.connectToServer(SOCKETNAME)
connected = socket.waitForConnected(100)
if connected:
log.ipc.info("Opening in existing instance")
line = json.dumps(cmdlist) + '\n'
data = line.encode('utf-8')
log.ipc.debug("Writing: {}".format(data))
socket.writeData(data)
socket.waitForBytesWritten(WRITE_TIMEOUT)
if socket.error() != QLocalSocket.UnknownSocketError:
_socket_error("writing to running instance", socket)
else:
return True
else:
if socket.error() not in (QLocalSocket.ConnectionRefusedError,
QLocalSocket.ServerNotFoundError):
_socket_error("connecting to running instance", socket)
else:
log.ipc.debug("No existing instance present (error {})".format(
socket.error()))
return False
def _send_to_running_instance(self, payload: bytes, pid: int) -> None:
from PyQt5.QtCore import QByteArray
from PyQt5.QtNetwork import QLocalSocket
named_pipe = f"{BUNDLE_IDENTIFIER}.protocol.{pid}"
log.debug(
f"Opening a local socket to the running instance on {named_pipe} "
f"(payload={self.redact_payload(payload)!r})"
)
client = QLocalSocket()
try:
client.connectToServer(named_pipe)
if not client.waitForConnected():
log.error(f"Unable to open client socket: {client.errorString()}")
return
client.write(QByteArray(payload))
client.waitForBytesWritten()
client.disconnectFromServer()
if client.state() == QLocalSocket.ConnectedState:
client.waitForDisconnected()
finally:
del client
log.debug("Successfully closed client socket")
def send_to_running_instance(socketname, command, target_arg, *,
legacy_name=None, socket=None):
"""Try to send a commandline to a running instance.
Blocks for CONNECT_TIMEOUT ms.
Args:
socketname: The name which should be used for the socket.
command: The command to send to the running instance.
target_arg: --target command line argument
socket: The socket to read data from, or None.
legacy_name: The legacy name to first try to connect to.
Return:
True if connecting was successful, False if no connection was made.
"""
if socket is None:
socket = QLocalSocket()
if (legacy_name is not None and
_has_legacy_server(legacy_name)):
name_to_use = legacy_name
else:
name_to_use = socketname
log.ipc.debug("Connecting to {}".format(name_to_use))
socket.connectToServer(name_to_use)
connected = socket.waitForConnected(CONNECT_TIMEOUT)
if connected:
log.ipc.info("Opening in existing instance")
json_data = {'args': command, 'target_arg': target_arg,
'version': qutebrowser.__version__,
'protocol_version': PROTOCOL_VERSION}
try:
cwd = os.getcwd()
except OSError:
pass
else:
json_data['cwd'] = cwd
line = json.dumps(json_data) + '\n'
data = line.encode('utf-8')
log.ipc.debug("Writing: {}".format(data))
socket.writeData(data)
socket.waitForBytesWritten(WRITE_TIMEOUT)
if socket.error() != QLocalSocket.UnknownSocketError:
raise SocketError("writing to running instance", socket)
else:
socket.disconnectFromServer()
if socket.state() != QLocalSocket.UnconnectedState:
socket.waitForDisconnected(CONNECT_TIMEOUT)
return True
else:
if socket.error() not in (QLocalSocket.ConnectionRefusedError,
QLocalSocket.ServerNotFoundError):
raise SocketError("connecting to running instance", socket)
else:
log.ipc.debug("No existing instance present (error {})".format(
socket.error()))
return False
def _send_to_running_instance(self, payload: bytes, pid: int) -> None:
from PyQt5.QtCore import QByteArray
from PyQt5.QtNetwork import QLocalSocket
named_pipe = f"{BUNDLE_IDENTIFIER}.protocol.{pid}"
log.debug(
f"Opening a local socket to the running instance on {named_pipe} "
f"(payload={self.redact_payload(payload)})"
)
client = QLocalSocket()
try:
client.connectToServer(named_pipe)
if not client.waitForConnected():
log.error(f"Unable to open client socket: {client.errorString()}")
return
client.write(QByteArray(payload))
client.waitForBytesWritten()
client.disconnectFromServer()
if client.state() == QLocalSocket.ConnectedState:
client.waitForDisconnected()
finally:
del client
log.debug("Successfully closed client socket")
def initLocalConnection(self):
socket = QLocalSocket()
socket.connectToServer(self.serverName)
if socket.waitForConnected(self.TIME_OUT):
self.isRuning = True
if len(self.args) >= 3:
data = self.args[1] + ',' + self.args[2]
socket.writeData(data.encode())
socket.flush()
socket.waitForBytesWritten()
return
self.newLocalServer()
def __init__(self, serverName, parent=None):
SocketInterface.__init__(self, serverName, parent=parent)
socket = QLocalSocket(parent)
socket.readyRead.connect(self.receiveMessage)
socket.connectToServer(serverName)
if socket.waitForConnected(1000):
socket.write("Hello {0}!".format(serverName).encode("utf-8"))
socket.flush()
socket.waitForBytesWritten(1000)
self.conn = socket
else:
self.log("Could not connect to SocketServer.")
def send_to_running_instance(socketname, command):
"""Try to send a commandline to a running instance.
Blocks for CONNECT_TIMEOUT ms.
Args:
socketname: The name which should be used for the socket.
command: The command to send to the running instance.
Return:
True if connecting was successful, False if no connection was made.
"""
socket = QLocalSocket()
log.ipc.debug("Connecting to {}".format(socketname))
socket.connectToServer(socketname)
connected = socket.waitForConnected(100)
if connected:
log.ipc.info("Opening in existing instance")
json_data = {'args': command}
try:
cwd = os.getcwd()
except OSError:
pass
else:
json_data['cwd'] = cwd
line = json.dumps(json_data) + '\n'
data = line.encode('utf-8')
log.ipc.debug("Writing: {}".format(data))
socket.writeData(data)
socket.waitForBytesWritten(WRITE_TIMEOUT)
if socket.error() != QLocalSocket.UnknownSocketError:
_socket_error("writing to running instance", socket)
else:
socket.disconnectFromServer()
if socket.state() != QLocalSocket.UnconnectedState:
socket.waitForDisconnected(100)
return True
else:
if socket.error() not in (QLocalSocket.ConnectionRefusedError,
QLocalSocket.ServerNotFoundError):
_socket_error("connecting to running instance", socket)
else:
log.ipc.debug("No existing instance present (error {})".format(
socket.error()))
return False
class InstanceHandler(QObject):
""" Makes sure that only one instance of this application can be run. """
received = pyqtSignal(str)
def __init__(self, parent, name):
super(__class__, self).__init__(parent)
self._parent = parent
self._name = name
self._timeout = 1000
self._socket = QLocalSocket(self)
self._socket.connectToServer(self._name)
self._is_already_running = self._socket.waitForConnected(self._timeout)
if not self.isAlreadyRunning():
self._server = QLocalServer(self)
self._server.newConnection.connect(self._receive_data)
self._server.removeServer(self._name)
self._server.listen(self._name)
def _send_data(self, data=None):
""" Sends model to an server-application. """
if not data:
data = ""
self._socket.write(data.encode())
self._socket.waitForBytesWritten(self._timeout)
self._socket.disconnectFromServer()
def _receive_data(self):
""" Receives model from an client-application. """
socket = self._server.nextPendingConnection()
if socket.waitForReadyRead(self._timeout):
# Emit transmitted model.
self.received.emit(socket.readAll().data().decode(
"utf-8", "surrogateescape"))
else:
# When no model was transmitted just emit empty string.
self.received.emit("")
def newTab(self, input):
""" Opens a new tab in an already running instance. """
self._send_data(input)
def isAlreadyRunning(self) -> bool:
""" Returns True when an instance of the application is already running, otherwise False. """
return self._is_already_running
def send_to_running_instance(args):
"""Try to send a commandline to a running instance.
Blocks for CONNECT_TIMEOUT ms.
Args:
args: The argparse namespace.
Return:
True if connecting was successful, False if no connection was made.
"""
socket = QLocalSocket()
socketname = _get_socketname(args)
log.ipc.debug("Connecting to {}".format(socketname))
socket.connectToServer(socketname)
connected = socket.waitForConnected(100)
if connected:
log.ipc.info("Opening in existing instance")
json_data = {'args': args.command}
try:
cwd = os.getcwd()
except OSError:
pass
else:
json_data['cwd'] = cwd
line = json.dumps(json_data) + '\n'
data = line.encode('utf-8')
log.ipc.debug("Writing: {}".format(data))
socket.writeData(data)
socket.waitForBytesWritten(WRITE_TIMEOUT)
if socket.error() != QLocalSocket.UnknownSocketError:
_socket_error("writing to running instance", socket)
else:
return True
else:
if socket.error() not in (QLocalSocket.ConnectionRefusedError,
QLocalSocket.ServerNotFoundError):
_socket_error("connecting to running instance", socket)
else:
log.ipc.debug("No existing instance present (error {})".format(
socket.error()))
return False
def _send_to_running_instance(self, payload: bytes) -> bool:
from PyQt5.QtCore import QByteArray
from PyQt5.QtNetwork import QLocalSocket
log.debug(
f"Opening local socket to send to the running instance (payload={payload})"
)
client = QLocalSocket()
client.connectToServer("com.nuxeo.drive.protocol")
if not client.waitForConnected():
log.error(f"Unable to open client socket: {client.errorString()}")
return 0
client.write(QByteArray(payload))
client.waitForBytesWritten()
client.disconnectFromServer()
client.waitForDisconnected()
del client
log.debug("Successfully closed client socket")
def sendMessage(self, message):
assert (self._isRunning)
if self.isRunning():
socket = QLocalSocket(self)
socket.connectToServer(self._key, QIODevice.WriteOnly)
if not socket.waitForConnected(self._timeout):
return False
socket.write(message.encode('utf-8'))
if not socket.waitForBytesWritten(self._timeout):
return False
socket.disconnectFromServer()
return True
return False
def sendNotification(self, message):
if self.isRunning():
socket = QLocalSocket(self)
socket.connectToServer(self._key, QIODevice.WriteOnly)
if not socket.waitForConnected(self._timeout):
print(socket.errorString())
return False
if not isinstance(message, bytes):
message = message.encode('utf-8')
socket.write(message)
if not socket.waitForBytesWritten(self._timeout):
print(socket.errorString())
return False
socket.disconnectFromServer()
return True
return False
class SingleApplication(QtWidgets.QApplication):
'''
Inheriting from QApplication, executing main App instead.
Watching whether the app is already running.
If so, quit befor execution.
'''
messageReceived = QtCore.pyqtSignal(str)
def __init__(self, id, *argv):
super(SingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Check if another instance is running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
self._outStream = QtCore.QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.removeServer(self._id) # if existing after crash-exit
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~QtCore.Qt.WindowMinimized)
self._activationWindow.show()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QtCore.QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
class QtSingleApplication(QApplication):
messageReceived = pyqtSignal(str)
def __init__(self, _id, _viewer_id, *argv):
if sys.platform.startswith(
"darwin") and mp.current_process().name == "WebLCDs":
import AppKit
info = AppKit.NSBundle.mainBundle().infoDictionary(
) # @UndefinedVariable
info["LSBackgroundOnly"] = "1"
super(QtSingleApplication, self).__init__(*argv)
self._id = _id
self._viewer_id = _viewer_id
self._activationWindow = None
self._activateOnMessage = False
self._outSocket = None
self._isRunning = False
self._server = None
# we exclude the WebLCDs parallel process from participating any Artisan inter-app communication
if mp.current_process().name != "WebLCDs":
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected(-1)
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
# Is there another viewer running?
self._outSocketViewer = QLocalSocket()
self._outSocketViewer.connectToServer(self._viewer_id)
self._isRunningViewer = self._outSocketViewer.waitForConnected(
-1)
if self._isRunningViewer:
self._outStreamViewer = QTextStream(self._outSocketViewer)
self._outStreamViewer.setCodec('UTF-8')
else:
# app is running, we announce us as viewer app
# First we remove existing servers of that name that might not have been properly closed as the server died
QLocalServer.removeServer(self._viewer_id)
self._outSocketViewer = None
self._outStreamViewer = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._viewer_id)
self._server.newConnection.connect(self._onNewConnection)
else:
self._isRunningViewer = False
# No, there isn't.
# First we remove existing servers of that name that might not have been properly closed as the server died
QLocalServer.removeServer(self._id)
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def isRunningViewer(self):
return self._isRunningViewer
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.show()
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
@pyqtSlot()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage and self._isRunning:
self.activateWindow()
@pyqtSlot()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg: break
self.messageReceived.emit(msg)
class QtSingleApplication(QApplication):
messageReceived = pyqtSignal(str)
def __init__(self, _id, _viewer_id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = _id
self._viewer_id = _viewer_id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected(-1)
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
# Is there another viewer runnging?
self._outSocketViewer = QLocalSocket()
self._outSocketViewer.connectToServer(self._viewer_id)
self._isRunningViewer = self._outSocketViewer.waitForConnected(-1)
if self._isRunningViewer:
self._outStreamViewer = QTextStream(self._outSocketViewer)
self._outStreamViewer.setCodec('UTF-8')
else:
# app is running, we announce us as viewer app
# First we remove existing servers of that name that might not have been properly closed as the server died
QLocalServer.removeServer(self._viewer_id)
self._outSocketViewer = None
self._outStreamViewer = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._viewer_id)
self._server.newConnection.connect(self._onNewConnection)
else:
self._isRunningViewer = False
# No, there isn't.
# First we remove existing servers of that name that might not have been properly closed as the server died
QLocalServer.removeServer(self._id)
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def isRunningViewer(self):
return self._isRunningViewer
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.show()
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
@pyqtSlot()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage and self._isRunning:
self.activateWindow()
@pyqtSlot()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg: break
self.messageReceived.emit(msg)
class QSingleApplication(QApplication):
messageReceived = pyqtSignal(str)
def __init__(self, *args, **kwargs):
super(QSingleApplication, self).__init__(*args, **kwargs)
appid = QApplication.applicationFilePath().lower().split("/")[-1]
self._socketName = "qtsingleapp-" + appid
print("socketName", self._socketName)
self._activationWindow = None
self._activateOnMessage = False
self._socketServer = None
self._socketIn = None
self._socketOut = None
self._running = False
# 先尝试连接
self._socketOut = QLocalSocket(self)
self._socketOut.connectToServer(self._socketName)
self._socketOut.error.connect(self.handleError)
self._running = self._socketOut.waitForConnected()
if not self._running: # 程序未运行
self._socketOut.close()
del self._socketOut
self._socketServer = QLocalServer(self)
self._socketServer.listen(self._socketName)
self._socketServer.newConnection.connect(self._onNewConnection)
self.aboutToQuit.connect(self.removeServer)
def handleError(self, message):
print("handleError message: ", message)
def isRunning(self):
return self._running
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, message, msecs=5000):
if not self._socketOut:
return False
if not isinstance(message, bytes):
message = str(message).encode()
self._socketOut.write(message)
if not self._socketOut.waitForBytesWritten(msecs):
raise RuntimeError("Bytes not written within %ss" %
(msecs / 1000.))
return True
def _onNewConnection(self):
if self._socketIn:
self._socketIn.readyRead.disconnect(self._onReadyRead)
self._socketIn = self._socketServer.nextPendingConnection()
if not self._socketIn:
return
self._socketIn.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while 1:
message = self._socketIn.readLine()
if not message:
break
print("Message received: ", message)
self.messageReceived.emit(message.data().decode())
def removeServer(self):
self._socketServer.close()
self._socketServer.removeServer(self._socketName)
class QtSingleApplication(QApplication):
"""
Adapted from https://stackoverflow.com/a/12712362/11038610
Copyright 2013 Johan Råde
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
"""
message_received_event = pyqtSignal(str)
def __init__(self, id, *argv):
super().__init__(*argv)
self._id = id
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = 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 = QLocalServer()
self._server.removeServer(self._id)
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.message_received_event.emit(msg)
class QtSingleApplication(QApplication):
"""
This class makes sure that we can only start one Tribler application.
When a user tries to open a second Tribler instance, the current active one will be brought to front.
"""
messageReceived = pyqtSignal(unicode)
def __init__(self, win_id, *argv):
logfunc = logging.info
logfunc(sys._getframe().f_code.co_name + '()')
QApplication.__init__(self, *argv)
self._id = win_id
self._activation_window = None
self._activate_on_message = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = None
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't, at least not properly.
# Cleanup any past, crashed server.
error = self._outSocket.error()
logfunc(LOGVARSTR % ('self._outSocket.error()', error))
if error == QLocalSocket.ConnectionRefusedError:
logfunc('received QLocalSocket.ConnectionRefusedError; ' + \
'removing server.')
self.close()
QLocalServer.removeServer(self._id)
self._outSocket = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._on_new_connection)
logfunc(sys._getframe().f_code.co_name + '(): returning')
def close(self):
logfunc = logging.info
logfunc(sys._getframe().f_code.co_name + '()')
if self._inSocket:
self._inSocket.disconnectFromServer()
if self._outSocket:
self._outSocket.disconnectFromServer()
if self._server:
self._server.close()
logfunc(sys._getframe().f_code.co_name + '(): returning')
def is_running(self):
return self._isRunning
def get_id(self):
return self._id
def activation_window(self):
return self._activation_window
def set_activation_window(self, activation_window, activate_on_message=True):
self._activation_window = activation_window
self._activate_on_message = activate_on_message
def activate_window(self):
if not self._activation_window:
return
self._activation_window.setWindowState(
self._activation_window.windowState() & ~Qt.WindowMinimized)
self._activation_window.raise_()
def send_message(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _on_new_connection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._on_ready_read)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._on_ready_read)
if self._activate_on_message:
self.activate_window()
def _on_ready_read(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
def __init__(self, pathObjects, parent=None):
"""Initialize the main tree controls
Arguments:
pathObjects -- a list of file objects to open
parent -- the parent QObject if given
"""
super().__init__(parent)
self.localControls = []
self.activeControl = None
self.trayIcon = None
self.isTrayMinimized = False
self.configDialog = None
self.sortDialog = None
self.numberingDialog = None
self.findTextDialog = None
self.findConditionDialog = None
self.findReplaceDialog = None
self.filterTextDialog = None
self.filterConditionDialog = None
self.basicHelpView = None
self.passwords = {}
globalref.mainControl = self
self.allActions = {}
try:
# check for existing TreeLine session
socket = QLocalSocket()
socket.connectToServer('treeline3-session', QIODevice.WriteOnly)
# if found, send files to open and exit TreeLine
if socket.waitForConnected(1000):
socket.write(
bytes(repr([str(path) for path in pathObjects]), 'utf-8'))
if socket.waitForBytesWritten(1000):
socket.close()
sys.exit(0)
# start local server to listen for attempt to start new session
self.serverSocket = QLocalServer()
self.serverSocket.listen('treeline3-session')
self.serverSocket.newConnection.connect(self.getSocket)
except AttributeError:
print(_('Warning: Could not create local socket'))
mainVersion = '.'.join(__version__.split('.')[:2])
globalref.genOptions = options.Options('general', 'TreeLine',
mainVersion, 'bellz')
optiondefaults.setGenOptionDefaults(globalref.genOptions)
globalref.miscOptions = options.Options('misc')
optiondefaults.setMiscOptionDefaults(globalref.miscOptions)
globalref.histOptions = options.Options('history')
optiondefaults.setHistOptionDefaults(globalref.histOptions)
globalref.toolbarOptions = options.Options('toolbar')
optiondefaults.setToolbarOptionDefaults(globalref.toolbarOptions)
globalref.keyboardOptions = options.Options('keyboard')
optiondefaults.setKeyboardOptionDefaults(globalref.keyboardOptions)
try:
globalref.genOptions.readFile()
globalref.miscOptions.readFile()
globalref.histOptions.readFile()
globalref.toolbarOptions.readFile()
globalref.keyboardOptions.readFile()
except IOError:
errorDir = options.Options.basePath
if not errorDir:
errorDir = _('missing directory')
QMessageBox.warning(
None, 'TreeLine',
_('Error - could not write config file to {}').format(
errorDir))
options.Options.basePath = None
iconPathList = self.findResourcePaths('icons', iconPath)
globalref.toolIcons = icondict.IconDict(
[path / 'toolbar' for path in iconPathList],
['', '32x32', '16x16'])
globalref.toolIcons.loadAllIcons()
windowIcon = globalref.toolIcons.getIcon('treelogo')
if windowIcon:
QApplication.setWindowIcon(windowIcon)
globalref.treeIcons = icondict.IconDict(iconPathList, ['', 'tree'])
icon = globalref.treeIcons.getIcon('default')
qApp.setStyle(QStyleFactory.create('Fusion'))
setThemeColors()
self.recentFiles = recentfiles.RecentFileList()
if globalref.genOptions['AutoFileOpen'] and not pathObjects:
recentPath = self.recentFiles.firstPath()
if recentPath:
pathObjects = [recentPath]
self.setupActions()
self.systemFont = QApplication.font()
self.updateAppFont()
if globalref.genOptions['MinToSysTray']:
self.createTrayIcon()
qApp.focusChanged.connect(self.updateActionsAvail)
if pathObjects:
for pathObj in pathObjects:
self.openFile(pathObj, True)
else:
self.createLocalControl()
class QSingleApplication(QApplication):
# https://github.com/PyQt5/PyQt/blob/master/Demo/Lib/Application.py
messageReceived = pyqtSignal(str)
def __init__(self, *args, **kwargs):
# logger.debug("{} init...".format(self.__class__.__name__))
super(QSingleApplication, self).__init__(*args, **kwargs)
# 使用路径作为appid
# appid = QApplication.applicationFilePath().lower().split("/")[-1]
# 使用固定的appid
appid = "SHL_LHX_Wallet"
# logger.debug("{} appid name: {}".format(self.__class__.__name__,appid))
# self._socketName = "qtsingleapp-" + appid
self._socketName = appid
# print("socketName", self._socketName)
self._activationWindow = None
self._activateOnMessage = False
self._socketServer = None
self._socketIn = None
self._socketOut = None
self._running = False
# 先尝试连接
self._socketOut = QLocalSocket(self)
self._socketOut.connectToServer(self._socketName)
self._socketOut.error.connect(self.handleError)
self._running = self._socketOut.waitForConnected()
# logger.debug("local socket connect error: {}".format(self._socketOut.errorString()))
if not self._running: # 程序未运行
# logger.debug("start init QLocalServer.")
self._socketOut.close()
del self._socketOut
self._socketServer = QLocalServer(self)
# 设置连接权限
self._socketServer.setSocketOptions(QLocalServer.UserAccessOption)
self._socketServer.listen(self._socketName)
self._socketServer.newConnection.connect(self._onNewConnection)
self.aboutToQuit.connect(self.removeServer)
# logger.debug("QLocalServer finished init.")
def handleError(self, message):
print("handleError message: ", message)
def isRunning(self):
return self._running
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
# 增加了显示功能。
# self._activationWindow.show()
def sendMessage(self, message, msecs=5000):
if not self._socketOut:
return False
if not isinstance(message, bytes):
message = str(message).encode()
self._socketOut.write(message)
if not self._socketOut.waitForBytesWritten(msecs):
raise RuntimeError("Bytes not written within %ss" %
(msecs / 1000.))
return True
def _onNewConnection(self):
if self._socketIn:
self._socketIn.readyRead.disconnect(self._onReadyRead)
self._socketIn = self._socketServer.nextPendingConnection()
if not self._socketIn:
return
self._socketIn.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while 1:
message = self._socketIn.readLine()
if not message:
break
# print("Message received: ", message)
self.messageReceived.emit(message.data().decode())
def removeServer(self):
if self._socketServer is not None:
self._socketServer.close()
self._socketServer.removeServer(self._socketName)
class QtSingleApplication(QApplication):
"""
This class makes sure that we can only start one Tribler application.
When a user tries to open a second Tribler instance, the current active one will be brought to front.
"""
messageReceived = pyqtSignal(str)
def __init__(self, win_id, *argv):
logfunc = logging.info
logfunc(sys._getframe().f_code.co_name + '()')
QApplication.__init__(self, *argv)
self._id = win_id
self._activation_window = None
self._activate_on_message = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = None
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't, at least not properly.
# Cleanup any past, crashed server.
error = self._outSocket.error()
logfunc(LOGVARSTR % ('self._outSocket.error()', error))
if error == QLocalSocket.ConnectionRefusedError:
logfunc('received QLocalSocket.ConnectionRefusedError; removing server.')
self.close()
QLocalServer.removeServer(self._id)
self._outSocket = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._on_new_connection)
logfunc(sys._getframe().f_code.co_name + '(): returning')
def close(self):
logfunc = logging.info
logfunc(sys._getframe().f_code.co_name + '()')
if self._inSocket:
self._inSocket.disconnectFromServer()
if self._outSocket:
self._outSocket.disconnectFromServer()
if self._server:
self._server.close()
logfunc(sys._getframe().f_code.co_name + '(): returning')
def is_running(self):
return self._isRunning
def get_id(self):
return self._id
def activation_window(self):
return self._activation_window
def set_activation_window(self, activation_window, activate_on_message=True):
self._activation_window = activation_window
self._activate_on_message = activate_on_message
def activate_window(self):
if not self._activation_window:
return
self._activation_window.setWindowState(self._activation_window.windowState() & ~Qt.WindowMinimized)
self._activation_window.raise_()
def send_message(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _on_new_connection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._on_ready_read)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._on_ready_read)
if self._activate_on_message:
self.activate_window()
def _on_ready_read(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
class Eddy(QApplication):
"""
This class implements the main Qt application.
"""
messageReceived = pyqtSignal(str)
def __init__(self, argv):
"""
Initialize Eddy.
:type argv: list
"""
super().__init__(argv)
parser = ArgumentParser()
parser.add_argument('--nosplash', dest='nosplash', action='store_true')
parser.add_argument('--tests', dest='tests', action='store_true')
options, args = parser.parse_known_args(args=argv)
self.inSocket = None
self.inStream = None
self.outSocket = QLocalSocket()
self.outSocket.connectToServer(APPID)
self.outStream = None
self.isRunning = self.outSocket.waitForConnected()
self.mainwindow = None
self.pendingOpen = []
self.server = None
# We do not initialize a new instance of Eddy if there is a process running
# and we are not executing the tests suite: we'll create a socket instead so we can
# exchange messages between the 2 processes (this one and the already running one).
if self.isRunning and not options.tests:
self.outStream = QTextStream(self.outSocket)
self.outStream.setCodec('UTF-8')
else:
self.server = QLocalServer()
self.server.listen(APPID)
self.outSocket = None
self.outStream = None
connect(self.server.newConnection, self.newConnection)
connect(self.messageReceived, self.readMessage)
############################################################################################################
# #
# PERFORM EDDY INITIALIZATION #
# #
############################################################################################################
# Draw the splashscreen.
self.splashscreen = None
if not options.nosplash:
self.splashscreen = SplashScreen(min_splash_time=4)
self.splashscreen.show()
# Setup layout.
self.setStyle(Clean('Fusion'))
with open(expandPath('@eddy/ui/clean.qss')) as sheet:
self.setStyleSheet(sheet.read())
# Create the main window.
self.mainwindow = MainWindow()
# Close the splashscreen.
if self.splashscreen:
self.splashscreen.wait(self.splashscreen.remaining)
self.splashscreen.close()
# Display the mainwindow.
self.mainwindow.show()
if Platform.identify() is Platform.Darwin:
# On MacOS files being opened are handled as a QFileOpenEvent but since we don't
# have a Main Window initialized we store them locally and we open them here.
for filepath in self.pendingOpen:
self.openFile(filepath)
self.pendingOpen = []
else:
# Perform document opening if files have been added to sys.argv. This is not
# executed on Mac OS since this is already handled as a QFileOpenEvent instance.
for filepath in argv:
self.openFile(filepath)
####################################################################################################################
# #
# EVENTS #
# #
####################################################################################################################
def event(self, event):
"""
Executed when an event is received.
:type event: T <= QEvent | QFileOpenEvent
"""
if event.type() == QEvent.FileOpen:
self.pendingOpen = [event.file()]
return True
return super().event(event)
####################################################################################################################
# #
# INTERFACE #
# #
####################################################################################################################
def activate(self):
"""
Activate the application by raising the main window.
"""
if self.mainwindow:
self.mainwindow.setWindowState((self.mainwindow.windowState()
& ~Qt.WindowMinimized)
| Qt.WindowActive)
self.mainwindow.activateWindow()
self.mainwindow.raise_()
def openFile(self, filepath):
"""
Open the given file in the activation window.
:type filepath: str
:rtype: bool
"""
if self.mainwindow:
if not isEmpty(filepath) and os.path.isfile(
filepath) and filepath.endswith(
Filetype.Graphol.extension):
self.mainwindow.openFile(filepath)
return True
return False
def sendMessage(self, message):
"""
Send a message to the other alive Eddy's process.
:type message: str
:rtype: bool
"""
if self.outStream:
self.outStream = self.outStream << message << '\n'
self.outStream.flush()
return self.outSocket.waitForBytesWritten()
return False
####################################################################################################################
# #
# SLOTS #
# #
####################################################################################################################
@pyqtSlot()
def newConnection(self):
"""
Executed whenever a message is received.
"""
if self.inSocket:
# Disconnect previously connected signal slot.
disconnect(self.inSocket.readyRead, self.readyRead)
# Create a new socket.
self.inSocket = self.server.nextPendingConnection()
if self.inSocket:
self.inStream = QTextStream(self.inSocket)
self.inStream.setCodec('UTF-8')
connect(self.inSocket.readyRead, self.readyRead)
self.activate()
@pyqtSlot()
def readyRead(self):
"""
Executed whenever we need to read a message.
"""
while True:
message = self.inStream.readLine()
if isEmpty(message):
break
self.messageReceived.emit(message)
@pyqtSlot(str)
def readMessage(self, message):
"""
Read a received message.
:type message: str
"""
for filepath in message.split(' '):
self.openFile(filepath)
class QtSingleApplication(QApplication):
unhandledExceptionCaught = pyqtSignal(QVariant, QVariant, QVariant, arguments=["except_type", "except_value", "traceback_obj"])
messageReceived = pyqtSignal(str)
def __init__(self, id, *argv):
super().__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = 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 = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage = True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg: break
self.messageReceived.emit(msg)
class Eddy(QApplication):
"""
This class implements the main Qt application.
"""
messageReceived = pyqtSignal(str)
def __init__(self, argv):
"""
Initialize Eddy.
:type argv: list
"""
super().__init__(argv)
parser = ArgumentParser()
parser.add_argument('--nosplash', dest='nosplash', action='store_true')
parser.add_argument('--tests', dest='tests', action='store_true')
options, args = parser.parse_known_args(args=argv)
self.inSocket = None
self.inStream = None
self.outSocket = QLocalSocket()
self.outSocket.connectToServer(APPID)
self.outStream = None
self.isRunning = self.outSocket.waitForConnected()
self.mainwindow = None
self.pendingOpen = []
self.server = None
# We do not initialize a new instance of Eddy if there is a process running
# and we are not executing the tests suite: we'll create a socket instead so we can
# exchange messages between the 2 processes (this one and the already running one).
if self.isRunning and not options.tests:
self.outStream = QTextStream(self.outSocket)
self.outStream.setCodec('UTF-8')
else:
self.server = QLocalServer()
self.server.listen(APPID)
self.outSocket = None
self.outStream = None
connect(self.server.newConnection, self.newConnection)
connect(self.messageReceived, self.readMessage)
############################################################################################################
# #
# PERFORM EDDY INITIALIZATION #
# #
############################################################################################################
# Draw the splashscreen.
self.splashscreen = None
if not options.nosplash:
self.splashscreen = SplashScreen(min_splash_time=4)
self.splashscreen.show()
# Setup layout.
self.setStyle(Clean('Fusion'))
with open(expandPath('@eddy/ui/clean.qss')) as sheet:
self.setStyleSheet(sheet.read())
# Create the main window.
self.mainwindow = MainWindow()
# Close the splashscreen.
if self.splashscreen:
self.splashscreen.wait(self.splashscreen.remaining)
self.splashscreen.close()
# Display the mainwindow.
self.mainwindow.show()
if Platform.identify() is Platform.Darwin:
# On MacOS files being opened are handled as a QFileOpenEvent but since we don't
# have a Main Window initialized we store them locally and we open them here.
for filepath in self.pendingOpen:
self.openFile(filepath)
self.pendingOpen = []
else:
# Perform document opening if files have been added to sys.argv. This is not
# executed on Mac OS since this is already handled as a QFileOpenEvent instance.
for filepath in argv:
self.openFile(filepath)
####################################################################################################################
# #
# EVENTS #
# #
####################################################################################################################
def event(self, event):
"""
Executed when an event is received.
:type event: T <= QEvent | QFileOpenEvent
"""
if event.type() == QEvent.FileOpen:
self.pendingOpen = [event.file()]
return True
return super().event(event)
####################################################################################################################
# #
# INTERFACE #
# #
####################################################################################################################
def activate(self):
"""
Activate the application by raising the main window.
"""
if self.mainwindow:
self.mainwindow.setWindowState((self.mainwindow.windowState() & ~Qt.WindowMinimized) | Qt.WindowActive)
self.mainwindow.activateWindow()
self.mainwindow.raise_()
def openFile(self, filepath):
"""
Open the given file in the activation window.
:type filepath: str
:rtype: bool
"""
if self.mainwindow:
if not isEmpty(filepath) and os.path.isfile(filepath) and filepath.endswith(Filetype.Graphol.extension):
self.mainwindow.openFile(filepath)
return True
return False
def sendMessage(self, message):
"""
Send a message to the other alive Eddy's process.
:type message: str
:rtype: bool
"""
if self.outStream:
self.outStream = self.outStream << message << '\n'
self.outStream.flush()
return self.outSocket.waitForBytesWritten()
return False
####################################################################################################################
# #
# SLOTS #
# #
####################################################################################################################
@pyqtSlot()
def newConnection(self):
"""
Executed whenever a message is received.
"""
if self.inSocket:
# Disconnect previously connected signal slot.
disconnect(self.inSocket.readyRead, self.readyRead)
# Create a new socket.
self.inSocket = self.server.nextPendingConnection()
if self.inSocket:
self.inStream = QTextStream(self.inSocket)
self.inStream.setCodec('UTF-8')
connect(self.inSocket.readyRead, self.readyRead)
self.activate()
@pyqtSlot()
def readyRead(self):
"""
Executed whenever we need to read a message.
"""
while True:
message = self.inStream.readLine()
if isEmpty(message):
break
self.messageReceived.emit(message)
@pyqtSlot(str)
def readMessage(self, message):
"""
Read a received message.
:type message: str
"""
for filepath in message.split(' '):
self.openFile(filepath)
class SingleApplication(QApplication):
messageReceived = pyqtSignal(str)
def __init__(self, appid, *argv):
super(SingleApplication, self).__init__(*argv)
self._appid = appid
self._activationWindow = None
self._activateOnMessage = False
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._appid)
self._isRunning = self._outSocket.waitForConnected()
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = None
self.settings = QSettings(SingleApplication.getSettingsPath(),
QSettings.IniFormat)
self.singleInstance = self.settings.value('singleInstance',
'on',
type=str) in {'on', 'true'}
if self._isRunning and self.singleInstance:
self._outStream = QTextStream(self._outSocket)
for a in argv[0][1:]:
a = os.path.join(os.getcwd(), a)
if os.path.isfile(a):
self.sendMessage(a)
break
sys.exit(0)
else:
error = self._outSocket.error()
if error == QLocalSocket.ConnectionRefusedError:
self.close()
QLocalServer.removeServer(self._appid)
self._outSocket = None
self._server = QLocalServer()
self._server.listen(self._appid)
self._server.newConnection.connect(self._onNewConnection)
def close(self):
if self._inSocket:
self._inSocket.disconnectFromServer()
if self._outSocket:
self._outSocket.disconnectFromServer()
if self._server:
self._server.close()
@staticmethod
def getSettingsPath() -> str:
if sys.platform == 'win32':
settings_path = os.path.join(QDir.homePath(), 'AppData', 'Local',
'vidcutter')
elif sys.platform == 'darwin':
settings_path = os.path.join(QDir.homePath(), 'Library',
'Preferences', 'vidcutter')
else:
if QFileInfo(__file__).absolutePath().startswith('/app/'):
settings_path = QProcessEnvironment.systemEnvironment().value(
'XDG_CONFIG_HOME', '')
if not len(settings_path):
settings_path = os.path.join(QDir.homePath(), '.var',
'app',
vidcutter.__desktopid__,
'config')
else:
settings_path = os.path.join(QDir.homePath(), '.config',
'vidcutter')
return os.path.join(settings_path, 'vidcutter.ini')
def isRunning(self):
return self._isRunning
def appid(self):
return self._appid
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
# noinspection PyUnresolvedReferences
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
class SingleApplication(QtWidgets.QApplication):
'''
Inheriting from QApplication, executing main App instead.
Watching whether the app is already running.
If so, quit befor execution.
'''
messageReceived = QtCore.pyqtSignal(str)
def __init__(self, id, *argv):
super(SingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Check if another instance is running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
self._outStream = QtCore.QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.removeServer(self._id) # if existing after crash-exit
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~QtCore.Qt.WindowMinimized)
self._activationWindow.show()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QtCore.QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
class QSingleApplication(QApplication):
messageReceived = pyqtSignal(str)
def __init__(self, id, *argv):
super(QSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
self._server = None
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._outSocket.error.connect(self.handleError)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = 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 = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
self.aboutToQuit.connect(self.removeServer)
def handleError(self, msg):
print(msg)
def server(self):
return self._server
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
print("No registered ActivationWindow")
return
# Unfortunately this *doesn't* do much of any use, as it won't
# bring the window to the foreground under KDE... sigh.
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.requestActivate()
def sendMessage(self, msg, msecs=5000):
if not self._outStream:
return False
self._outStream << msg << ''
if not self._outSocket.waitForBytesWritten(msecs):
raise RuntimeError("Bytes not written within %ss" %
(msecs / 1000.))
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
print("Message received")
self.messageReceived.emit(msg)
def removeServer(self):
self._server.close()
self._server.removeServer(self._id)
class QtSingleApplication(QApplication):
"""QApplication que permite solo una instancia de la aplicación.
"""
messageReceived = pyqtSignal(str)
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 = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = 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 = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage = True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n' # pylint: disable=W0104
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg: break
self.messageReceived.emit(msg)
class QtSingleApplication(QApplication):
"""
Adapted from https://stackoverflow.com/a/12712362/11038610
Published by Johan Rade under 2-clause BSD license, opensource.org/licenses/BSD-2-Clause
"""
message_received_event = pyqtSignal(str)
def __init__(self, id, *argv):
super().__init__(*argv)
self._id = id
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = 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 = QLocalServer()
self._server.removeServer(self._id)
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.message_received_event.emit(msg)
class LivePlotClient(object):
def __init__(self, timeout=2000, size=2**28):
self.app = QCoreApplication.instance()
if self.app is None:
self.app = QCoreApplication([])
self.sock = QLocalSocket()
self.sock.connectToServer("LivePlot")
if not self.sock.waitForConnected():
raise EnvironmentError("Couldn't find LivePlotter instance")
self.sock.disconnected.connect(self.disconnect_received)
key = str(uuid.uuid4())
self.shared_mem = QSharedMemory(key)
if not self.shared_mem.create(size):
raise Exception("Couldn't create shared memory %s" %
self.shared_mem.errorString())
logging.debug('Memory created with key %s and size %s' %
(key, self.shared_mem.size()))
self.sock.write(key.encode())
self.sock.waitForBytesWritten()
self.is_connected = True
self.timeout = timeout
atexit.register(self.close)
def close(self):
self.shared_mem.detach()
def send_to_plotter(self, meta, arr=None):
if not self.is_connected:
return
if meta["name"] is None:
meta["name"] = "*"
if arr is not None:
arrbytes = bytearray(arr)
arrsize = len(arrbytes)
if arrsize > self.shared_mem.size():
raise ValueError("Array too big %s > %s" %
(arrsize, self.shared_mem.size()))
meta['arrsize'] = arrsize
meta['dtype'] = str(arr.dtype)
meta['shape'] = arr.shape
else:
meta['arrsize'] = 0
meta_bytes = json.dumps(meta).ljust(300)
if len(meta_bytes) > 300:
raise ValueError("meta object is too large (> 300 char)")
if arr is None:
self.sock.write(meta_bytes.encode())
else:
if not self.sock.bytesAvailable():
self.sock.waitForReadyRead()
self.sock.read(2)
self.shared_mem.lock()
self.sock.write(meta_bytes.encode())
region = self.shared_mem.data()
region[:arrsize] = arrbytes
self.shared_mem.unlock()
def plot_y(self, name, arr, extent=None, start_step=(0, 1), label=''):
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError(
'extent and start_step provide the same info and are thus mutually exclusive'
)
if extent is not None:
x0, x1 = extent
nx = len(arr)
start_step = x0, float(x1 - x0) / nx
meta = {
'name': name,
'operation': 'plot_y',
'start_step': start_step,
'rank': 1,
'label': label,
}
self.send_to_plotter(meta, arr.astype('float64'))
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def plot_z(self, name, arr, extent=None, start_step=None, xname='X axis',\
xscale='arb. u.', yname='Y axis', yscale='arb. u.', zname='Y axis', zscale='arb. u.'):
'''
extent is ((initial x, final x), (initial y, final y))
start_step is ((initial x, delta x), (initial_y, final_y))
'''
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError(
'extent and start_step provide the same info and are thus mutually exclusive'
)
if extent is not None:
(x0, x1), (y0, y1) = extent
nx, ny = arr.shape
start_step = (x0, float(x1 - x0) / nx), (y0, float(y1 - y0) / ny)
meta = {
'name': name,
'operation': 'plot_z',
'rank': 2,
'start_step': start_step,
'X': xscale,
'Y': yscale,
'Z': zscale,
'Xname': xname,
'Yname': yname,
'Zname': zname,
}
self.send_to_plotter(meta, arr.astype('float64'))
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def plot_xy(self, name, xs, ys, label='', xname='X axis', xscale='arb. u.',\
yname='Y axis', yscale='arb. u.', scatter='False', timeaxis='False'):
arr = np.array([xs, ys])
meta = {
'name': name,
'operation': 'plot_xy',
'rank': 1,
'label': label,
'X': xscale,
'Y': yscale,
'Xname': xname,
'Yname': yname,
'Scatter': scatter,
'TimeAxis': timeaxis
}
self.send_to_plotter(meta, np.array([xs, ys]).astype('float64'))
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def append_y(self, name, point, start_step=(0, 1), label='', xname='X axis',\
xscale='arb. u.', yname='Y axis', yscale='arb. u.',scatter='False', timeaxis='False'):
self.send_to_plotter({
'name': name,
'operation': 'append_y',
'value': point,
'start_step': start_step,
'rank': 1,
'label': label,
'X': xscale,
'Y': yscale,
'Xname': xname,
'Yname': yname,
'Scatter': scatter,
'TimeAxis': timeaxis
})
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def append_xy(self, name, x, y, label=''):
self.send_to_plotter({
'name': name,
'operation': 'append_xy',
'value': (x, y),
'rank': 1,
'label': label,
})
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def append_z(self, name, arr, start_step=None, xname='X axis',\
xscale='arb. u.', yname='Y axis', yscale='arb. u.', zname='Y axis', zscale='arb. u.'):
arr = np.array(arr)
meta = {
'name': name,
'operation': 'append_z',
'rank': 2,
'start_step': start_step,
'X': xscale,
'Y': yscale,
'Z': zscale,
'Xname': xname,
'Yname': yname,
'Zname': zname,
}
self.send_to_plotter(meta, arr.astype('float64'))
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def label(self, name, text):
self.send_to_plotter({
'name': name,
'operation': 'label',
'value': text
})
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def clear(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'clear'})
def hide(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'close'})
def remove(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'remove'})
self.send_to_plotter({
'name': 'none',
'operation': 'none'
}, np.array([0.]))
def disconnect_received(self):
self.is_connected = False
warnings.warn(
'Disconnected from LivePlotter server, plotting has been disabled')
class QtSingleApplication(QApplication):
messageReceived = pyqtSignal(str)
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 = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = 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 = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.show()
self._activationWindow.setWindowState(self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << "\n"
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec("UTF-8")
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
class QSingleApplication(QApplication):
messageReceived = pyqtSignal(str)
def __init__(self, name, *args, **kwargs):
super(QSingleApplication, self).__init__(*args, **kwargs)
self._socketName = name
self._activationWindow = None
self._socketServer = None
self._socketIn = None
self._socketOut = None
self._running = False
# 先尝试连接
self._socketOut = QLocalSocket(self)
self._socketOut.connectToServer(self._socketName)
self._socketOut.error.connect(self.handleError)
self._running = self._socketOut.waitForConnected()
if not self._running: # 程序未运行
self._socketOut.close()
del self._socketOut
# 创建本地server
self._socketServer = QLocalServer(self)
self._socketServer.listen(self._socketName)
self._socketServer.newConnection.connect(self._onNewConnection)
self.aboutToQuit.connect(self.removeServer)
def handleError(self, message):
print("handleError message: ", message)
def isRunning(self):
return self._running
def setActivationWindow(self, activationWindow):
# 设置当前窗口
self._activationWindow = activationWindow
def activateWindow(self):
# 激活当前窗口
try:
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
#self._activationWindow.raise_() # 提升窗口到最上面
self._activationWindow.showNormal()
self._activationWindow.activateWindow()
except Exception as e:
print(e)
def sendMessage(self, message, msecs=5000):
if not self._socketOut:
return False
if not isinstance(message, bytes):
message = str(message).encode()
self._socketOut.write(message)
if not self._socketOut.waitForBytesWritten(msecs):
raise Exception("Bytes not written within %ss" % (msecs / 1000.))
return True
def _onNewConnection(self):
if self._socketIn:
self._socketIn.readyRead.disconnect(self._onReadyRead)
self._socketIn = self._socketServer.nextPendingConnection()
if not self._socketIn:
return
self._socketIn.readyRead.connect(self._onReadyRead)
def _onReadyRead(self):
while 1:
message = self._socketIn.readLine()
if not message:
break
if message == b'show':
self.activateWindow()
self.messageReceived.emit(message.data().decode())
def removeServer(self):
self._socketServer.close()
self._socketServer.removeServer(self._socketName)
