def __init__(self, appid, *args, **kwargs):
super().__init__(*args, **kwargs)
self._socketName = 'SingleApplication:' + appid
self._activationWindow = None
self._activateOnMessage = False
self._socketServer = None
self._socketIn = None
self._streamIn = None
self._socketOut = None
self._streamOut = None
self._isRunning = False
# 先尝试连接
self._socketOut = QLocalSocket(self)
self._socketOut.connectToServer(self._socketName)
self._socketOut.error.connect(self.handleError)
self._isRunning = self._socketOut.waitForConnected()
if self._isRunning: # 程序运行
self._streamOut = QTextStream(self._socketOut)
self._streamOut.setCodec('utf-8')
else:
self._socketOut.close()
self._socketOut = None
self._socketServer = QLocalServer(self)
self._socketServer.listen(self._socketName)
self._socketServer.newConnection.connect(self._onNewConnection)
self.aboutToQuit.connect(self.removeServer)
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 reload_dark_style(self):
f = QFile(":/dark_theme.qss")
f.open(QFile.ReadOnly | QFile.Text)
ts = QTextStream(f)
qss = ts.readAll()
# f = open(Config.get_resource_path('dark_theme.qss', 'resources/ui'), 'r')
# qss = f.read()
self.app.setStyleSheet(qss)
def _load_stylesheet(qt_api=''):
"""
Load the stylesheet based on QtPy abstraction layer environment variable.
If the argument is not passed, it uses the current QT_API environment
variable to make the imports of Qt bindings. If passed, it sets this
variable then make the imports.
Args:
qt_api (str): qt binding name to set QT_API environment variable.
Default is ''. Possible values are pyside, pyside2
pyqt4, pyqt5. Not case sensitive.
Note:
- Note that the variable QT_API is read when first imported. So,
pay attention to the import order.
- If you are using another abstraction layer, i.e PyQtGraph to do
imports on Qt things you must set both to use the same Qt
binding (PyQt, PySide).
- OS, binding and binding version number, and application specific
patches are applied in this order.
Returns:
str: stylesheet string (css).
"""
if qt_api:
os.environ['QT_API'] = qt_api
# Import is made after setting QT_API
from qtpy.QtCore import QCoreApplication, QFile, QTextStream
from qtpy.QtGui import QColor, QPalette
# Then we import resources - binary qrc content
from qdarkstyle import style_rc
# Thus, by importing the binary we can access the resources
package_dir = os.path.basename(PACKAGE_PATH)
qss_rc_path = ":" + os.path.join(package_dir, QSS_FILE)
# It gets the qss file from compiled style_rc that was import
# not from the file QSS as we are using resources
qss_file = QFile(qss_rc_path)
if qss_file.exists():
qss_file.open(QFile.ReadOnly | QFile.Text)
text_stream = QTextStream(qss_file)
stylesheet = text_stream.readAll()
else:
stylesheet = ""
# Todo: check this raise type and add to docs
raise FileNotFoundError("Unable to find QSS file '{}' "
"in resources.".format(qss_rc_path))
# 4. Apply palette fix. See issue #139
_apply_application_patches(QCoreApplication, QPalette, QColor)
return stylesheet
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 _onNewConnection(self):
if self._socketIn:
self._socketIn.readyRead.disconnect(self._onReadyRead)
self._socketIn = self._socketServer.nextPendingConnection()
if not self._socketIn:
return
self._streamIn = QTextStream(self._socketIn)
self._streamIn.setCodec('utf-8')
self._socketIn.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def reload_light_style(self):
if CONFIG['light_theme_is_native']:
self.set_style_to_stock()
return
f = QFile(":/light_theme.qss")
f.open(QFile.ReadOnly | QFile.Text)
ts = QTextStream(f)
qss = ts.readAll()
# f = open(Config.get_resource_path('light_theme.qss', 'resources/ui'), 'r')
# qss = f.read()
self.app.setStyleSheet(qss)
def updateFrameSheet(self):
if globals.applied_style == 'light':
f = QFile(':/frameless-light.qss')
elif globals.applied_style == 'dark':
f = QFile(':/frameless-dark.qss')
else:
raise RuntimeError(
'Set the app style theme before instantiating ModernWindow')
f.open(QIODevice.ReadOnly | QIODevice.Text)
text = QTextStream(f)
text.setCodec('UTF-8')
text = text.readAll()
self.setStyleSheet(text)
f.close()
def save(self):
save_file = QFile(self.filename)
result = save_file.open(QFile.WriteOnly)
if result:
save_stream = QTextStream(save_file)
save_stream << self.text()
save_file.close()
def _apply_base_theme(app):
""" Apply base theme to the application.
Args:
app (QApplication): QApplication instance.
"""
if QT_VERSION < (5,):
app.setStyle('plastique')
else:
app.setStyle('Fusion')
f = QFile(':/style.qss')
f.open(QIODevice.ReadOnly | QIODevice.Text)
text = QTextStream(f)
text.setCodec('UTF-8')
app.setStyleSheet(text.readAll())
f.close()
def save(self):
self.filename = str(STATUS.file)
save_file = QFile(self.filename)
result = save_file.open(QFile.WriteOnly)
if result:
save_stream = QTextStream(save_file)
save_stream << self.text()
save_file.close()
else:
print("save error")
def save(self):
save_file = QFile(self.filename)
result = save_file.open(QFile.WriteOnly)
if result:
LOG.debug("---self.text(): {}".format(self.text()))
save_stream = QTextStream(save_file)
save_stream << self.text()
save_file.close()
self.text_before_edit = ''
self.somethingHasChanged.emit(False)
else:
LOG.debug("---save error")
def saveFile(self, save_file_name=None):
if save_file_name == None:
save_file = QFile(str(STATUS.file))
else:
save_file = QFile(str(save_file_name))
result = save_file.open(QFile.WriteOnly)
if result:
LOG.debug(f'---Save file: {save_file.fileName()}')
save_stream = QTextStream(save_file)
save_stream << self.toPlainText()
save_file.close()
else:
LOG.debug("---save error")
def saveAs(self):
file_name = self.save_as_dialog(self.filename)
if file_name is False:
return
original_file = QFileInfo(self.filename)
path = original_file.path()
new_absolute_path = os.path.join(path, file_name)
new_file = QFile(new_absolute_path)
result = new_file.open(QFile.WriteOnly)
if result:
save_stream = QTextStream(new_file)
save_stream << self.text()
new_file.close()
def saveAs(self):
file_name = self.save_as_dialog(self.filename)
if file_name is False:
print("saveAs file name error")
return
self.filename = str(STATUS.file)
original_file = QFileInfo(self.filename)
path = original_file.path()
new_absolute_path = os.path.join(path, file_name)
new_file = QFile(new_absolute_path)
result = new_file.open(QFile.WriteOnly)
if result:
save_stream = QTextStream(new_file)
save_stream << self.text()
new_file.close()
self.text_before_edit = ''
self.somethingHasChanged.emit(False)
def saveAs(self):
#file_name = self.save_as_dialog(self.filename)
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
file_name, _ = QFileDialog.getSaveFileName(self,"Save As","","All Files (*);;NGC Files (*.ngc)", options=options)
if file_name is False:
print("saveAs file name error")
return
self.filename = str(STATUS.file)
original_file = QFileInfo(self.filename)
path = original_file.path()
new_absolute_path = os.path.join(path, file_name)
new_file = QFile(new_absolute_path)
result = new_file.open(QFile.WriteOnly)
if result:
save_stream = QTextStream(new_file)
save_stream << self.text()
new_file.close()
def main():
app = QApplication(sys.argv)
app.setWindowIcon(QIcon(':/icons/app.svg'))
fontDB = QFontDatabase()
fontDB.addApplicationFont(':/fonts/Roboto-Regular.ttf')
app.setFont(QFont('Roboto'))
f = QFile(':/style.qss')
f.open(QFile.ReadOnly | QFile.Text)
app.setStyleSheet(QTextStream(f).readAll())
f.close()
translator = QTranslator()
translator.load(':/translations/' + QLocale.system().name() + '.qm')
app.installTranslator(translator)
mw = MainWindow()
mw.show()
sys.exit(app.exec_())
def save(self):
reload_file = True
self.filename = str(STATUS.file)
# determine of have a file name
if self.filename == '':
reload_file = False
self.filename = '/tmp/gcode_tmp.ngc'
# save out the file
save_file = QFile(self.filename)
result = save_file.open(QFile.WriteOnly)
if result:
save_stream = QTextStream(save_file)
save_stream << self.text()
save_file.close()
# file save worked, now either load fresh or reload
if reload_file:
reLoadProgram()
else:
loadProgram(self.filename)
else:
print("save error")
def _load_stylesheet(qt_api='', style=''):
"""
Load the stylesheet based on QtPy abstraction layer environment variable.
If the argument is not passed, it uses the current QT_API environment
variable to make the imports of Qt bindings. If passed, it sets this
variable then make the imports.
Args:
qt_api (str): qt binding name to set QT_API environment variable.
Default is ''. Possible values are pyside2,
pyqt5. Not case sensitive.
Note:
- Note that the variable QT_API is read when first imported. So,
pay attention to the import order.
- OS, binding and binding version number, and application specific
patches are applied in this order.
Returns:
str: stylesheet string (css).
"""
if qt_api:
os.environ['QT_API'] = qt_api
# Import is made after setting QT_API
from qtpy.QtCore import QCoreApplication, QFile, QTextStream
from qtpy.QtGui import QColor, QPalette
from qtpy import QT_VERSION
# Search for style in styles directory
style_dir = None
available_styles = getAvailableStyles()
_logger.debug(f"Available styles: {available_styles}")
for stl in available_styles:
if style.lower() == stl.lower():
style_dir = stl
break
if style_dir is None:
stylesheet = ""
raise FileNotFoundError("Style " + style + " does not exists")
# check if any style_rc was loaded before
if "style_rc" in sys.modules:
_logger.info("Found already imported style in sys.modules")
# use qCleanupResources to remove all resource files
global style_rc # noqa
style_rc.qCleanupResources()
# remove imported modules
for x in [
module for module in sys.modules
if module.startswith("style_rc")
]:
del sys.modules[x]
del style_rc
# remove path to previously imported style from sys.path
for stylepath in [
path for path in sys.path if any(
style for style in getAvailableStyles() if style in path)
]:
sys.path.remove(stylepath)
_logger.debug("Removed all imported styles")
try:
_logger.debug("Loading style from directory: " + style_dir)
old_working_dir = os.getcwd()
# set style directory
package_dir = os.path.join(STYLES_PATH, style_dir)
os.chdir(package_dir)
# append directory to sys.path and import style_rc
sys.path.append(package_dir)
try:
import style_rc # noqa
# get palette
palette = style_rc.palette
except ModuleNotFoundError:
raise ModuleNotFoundError(
"Failed to import style_rc from directory: {}".format(
package_dir))
finally:
os.chdir(old_working_dir)
except FileExistsError:
raise FileNotFoundError("Missing style_rc.py file")
_logger.info("Style resources imported successfully")
# Thus, by importing the binary we can access the resources
package_dir = os.path.basename(PACKAGE_PATH)
qss_rc_path = ":" + os.path.join(package_dir, QSS_FILE)
_logger.debug("Reading QSS file in: %s", qss_rc_path)
# It gets the qss file from compiled style_rc that was import
# not from the file QSS as we are using resources
qss_file = QFile(qss_rc_path)
if qss_file.exists():
qss_file.open(QFile.ReadOnly | QFile.Text)
text_stream = QTextStream(qss_file)
stylesheet = text_stream.readAll()
_logger.info("QSS file sucessfuly loaded.")
else:
stylesheet = ""
# Todo: check this raise type and add to docs
raise FileNotFoundError("Unable to find QSS file '{}' "
"in resources.".format(qss_rc_path))
_logger.debug("Checking patches for being applied.")
# Todo: check execution order for these functions
# 1. Apply OS specific patches
stylesheet += _apply_os_patches(palette)
# 2. Apply binding specific patches
stylesheet += _apply_binding_patches()
# 3. Apply binding version specific patches
stylesheet += _apply_version_patches(QT_VERSION)
# 4. Apply palette fix. See issue #139
_apply_application_patches(palette, QCoreApplication, QPalette, QColor)
return stylesheet
class QSingleApplication(QApplication):
"""
See https://github.com/PyQt5/PyQt/blob/master/Demo/Lib/Application.py
and https://stackoverflow.com/questions/12712360/qtsingleapplication-for-pyside-or-pyqt
Example:
```
import sys
from PySide.QtGui import *
appid = 'F3FF80BA-BA05-4277-8063-82A6DB9245A2'
app = QSingleApplication(appid, sys.argv)
if app.isRunning():
sys.exit(0)
w = QWidget()
w.show()
app.setActivationWindow(w)
sys.exit(app.exec_())
```
"""
messageReceived = Signal(str)
def __init__(self, appid, *args, **kwargs):
super().__init__(*args, **kwargs)
self._socketName = 'SingleApplication:' + appid
self._activationWindow = None
self._activateOnMessage = False
self._socketServer = None
self._socketIn = None
self._streamIn = None
self._socketOut = None
self._streamOut = None
self._isRunning = False
# 先尝试连接
self._socketOut = QLocalSocket(self)
self._socketOut.connectToServer(self._socketName)
self._socketOut.error.connect(self.handleError)
self._isRunning = self._socketOut.waitForConnected()
if self._isRunning: # 程序运行
self._streamOut = QTextStream(self._socketOut)
self._streamOut.setCodec('utf-8')
else:
self._socketOut.close()
self._socketOut = None
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._isRunning
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._streamOut:
return False
self._streamOut << message << '\n'
self._streamOut.flush()
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._streamIn = QTextStream(self._socketIn)
self._streamIn.setCodec('utf-8')
self._socketIn.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
message = self._streamIn.readLine()
if not message:
break
self.messageReceived.emit(message)
def removeServer(self):
self._socketServer.close()
self._socketServer.removeServer(self._socketName)
def _load_stylesheet(qt_api='', palette=None):
"""
Load the stylesheet based on QtPy abstraction layer environment variable.
If the argument is not passed, it uses the current QT_API environment
variable to make the imports of Qt bindings. If passed, it sets this
variable then make the imports.
Args:
qt_api (str): qt binding name to set QT_API environment variable.
Default is ''. Possible values are pyside, pyside2
pyqt4, pyqt5. Not case sensitive.
palette (Palette): Palette class that inherits from Palette.
Note:
- Note that the variable QT_API is read when first imported. So,
pay attention to the import order.
- If you are using another abstraction layer, i.e PyQtGraph to do
imports on Qt things you must set both to use the same Qt
binding (PyQt, PySide).
- OS, binding and binding version number, and application specific
patches are applied in this order.
Returns:
str: stylesheet string (css).
"""
if qt_api:
os.environ['QT_API'] = qt_api
# Import is made after setting QT_API
from qtpy.QtCore import QCoreApplication, QFile, QTextStream
from qtpy.QtGui import QColor, QPalette
from qtpy import QT_VERSION
# Then we import resources - binary qrc content
if palette is None:
from qdarkstyle.dark import style_rc
palette = DarkPalette
_set_global_paths('dark')
elif palette.ID == 'dark':
from qdarkstyle.dark import style_rc
palette = DarkPalette
_set_global_paths('dark')
elif palette.ID == 'light':
from qdarkstyle.light import style_rc
palette = LightPalette
_set_global_paths('light')
else:
print("Not recognized ID for palette! Exiting!")
sys.exit(1)
# Thus, by importing the binary we can access the resources
package_dir = os.path.basename(PACKAGE_PATH)
qss_rc_path = ":" + os.path.join(package_dir, palette.ID, QSS_FILE)
_logger.debug("Reading QSS file in: %s" % qss_rc_path)
# It gets the qss file from compiled style_rc that was imported,
# not from the file QSS as we are using resources
qss_file = QFile(qss_rc_path)
if qss_file.exists():
qss_file.open(QFile.ReadOnly | QFile.Text)
text_stream = QTextStream(qss_file)
stylesheet = text_stream.readAll()
_logger.info("QSS file sucessfuly loaded.")
else:
stylesheet = ""
# Todo: check this raise type and add to docs
raise FileNotFoundError("Unable to find QSS file '{}' "
"in resources.".format(qss_rc_path))
_logger.debug("Checking patches for being applied.")
# Todo: check execution order for these functions
# 1. Apply OS specific patches
stylesheet += _apply_os_patches(palette)
# 2. Apply binding specific patches
stylesheet += _apply_binding_patches()
# 3. Apply binding version specific patches
stylesheet += _apply_version_patches(QT_VERSION)
# 4. Apply palette fix. See issue #139
_apply_application_patches(QCoreApplication, QPalette, QColor, palette)
return stylesheet
class QtSingleApplication(QApplication):
messageReceived = Signal(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'
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)