def applySettings(self):
if Settings().globalStyle == 'white':
QtWidgets.QApplication.instance().setStyleSheet("")
self.frameRecents.setStyleSheet(home.frame_recent_white)
self.labelRecents.setStyleSheet(home.label_recent_white)
self.listWidgetRecents.setStyleSheet(home.list_recent_white)
else:
self.frameRecents.setStyleSheet(home.frame_recent_dark)
self.labelRecents.setStyleSheet(home.label_recent_dark)
self.listWidgetRecents.setStyleSheet(home.list_recent_dark)
if '5' in os.environ['QT_API']:
QtWidgets.QApplication.instance().setStyleSheet(
qdarkstyle.load_stylesheet_pyqt5())
else:
QtWidgets.QApplication.instance().setStyleSheet(
qdarkstyle.load_stylesheet(pyside=False))
self.statusbar.setVisible(Settings().displayStatusBar)
for i in range(self.tabWidgetEditors.count()):
self.tabWidgetEditors.widget(i).updateSettings()
self.setupIcons()
self.menuBar.setVisible(Settings().displayMenuBar)
if self.stackedWidget.currentIndex():
self.toolBarCode.setVisible(Settings().displayToolBar)
self.toolBarFile.setVisible(Settings().displayToolBar)
self.lblFormat.setText('Free format' if Settings().free_format else 'Fixed format')
def main():
"""
Application entry point
"""
logging.basicConfig(level=logging.DEBUG)
# create the application and the main window
app = QtWidgets.QApplication(sys.argv)
window = QtWidgets.QMainWindow()
# setup ui
ui = example_ui.Ui_MainWindow()
ui.setupUi(window)
window.setWindowTitle("QDarkStyle example")
# tabify dock widgets to show bug #6
window.tabifyDockWidget(ui.dockWidget1, ui.dockWidget2)
# setup stylesheet
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# auto quit after 2s when testing on travis-ci
if "--travis" in sys.argv:
QtCore.QTimer.singleShot(2000, app.exit)
# run
window.show()
app.exec_()
def createQApp():
"""创建PyQt应用对象"""
# 创建Qt应用对象
qApp = QtWidgets.QApplication([])
# 设置Qt的皮肤
if globalSetting['darkStyle']:
try:
import qdarkstyle
qApp.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
except :
print("Unexpected error when import darkStyle:", sys.exc_info()[0])
# 设置Windows底部任务栏图标
if 'Windows' in platform.uname():
import ctypes
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID('vn.trader')
# 设置Qt字体
qApp.setFont(BASIC_FONT)
# 设置Qt图标
qApp.setWindowIcon(QtGui.QIcon(loadIconPath('vnpy.ico')))
# 返回创建好的QApp对象
return qApp
def set_dark_theme_if_needed(self):
use_dark_theme = self.config.get('qt_gui_color_theme', 'default') == 'dark'
if use_dark_theme:
try:
import qdarkstyle
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
except BaseException as e:
use_dark_theme = False
self.print_error('Error setting dark theme: {}'.format(repr(e)))
# Even if we ourselves don't set the dark theme,
# the OS/window manager/etc might set *a dark theme*.
# Hence, try to choose colors accordingly:
ColorScheme.update_from_widget(QWidget(), force_dark=use_dark_theme)
def set_dark_theme_if_needed(self):
use_dark_theme = self.config.get('qt_gui_color_theme', 'default') == 'dark'
if use_dark_theme:
try:
import qdarkstyle
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
except BaseException as e:
use_dark_theme = False
self.logger.warning(f'Error setting dark theme: {repr(e)}')
# Apply any necessary stylesheet patches
patch_qt_stylesheet(use_dark_theme=use_dark_theme)
# Even if we ourselves don't set the dark theme,
# the OS/window manager/etc might set *a dark theme*.
# Hence, try to choose colors accordingly:
ColorScheme.update_from_widget(QWidget(), force_dark=use_dark_theme)
def update_app_style(self):
if Settings().dark_style:
try:
import qdarkstyle
except ImportError:
Settings().dark_style = False
else:
qt_api = os.environ[QT_API]
if qt_api in PYQT5_API:
qss = qdarkstyle.load_stylesheet_pyqt5()
else:
qss = qdarkstyle.load_stylesheet(qt_api in PYSIDE_API)
self.app.setStyleSheet(qss)
return
self.app.setStyleSheet('')
def gui_mode():
"""
Start NEFI2 GUI
"""
myappid = 'nefi2.0' # arbitrary string
if sys.platform == 'win32' or sys.platform == 'win64':
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
extloader = ExtensionLoader()
pipeline = Pipeline(extloader.cats_container)
app = QApplication(sys.argv)
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
app.setQuitOnLastWindowClosed(True)
app.setWindowIcon(QtGui.QIcon(os.path.join('icons', 'nefi2.ico')))
wnd = MainView(pipeline)
wnd.load_dark_theme(app)
wnd.show()
sys.exit(app.exec_())
def update_app_style(self):
if Settings().dark_style:
try:
import qdarkstyle
except ImportError:
Settings().dark_style = False
else:
qt_api = os.environ[QT_API]
if qt_api in PYQT5_API:
qss = qdarkstyle.load_stylesheet_pyqt5()
else:
qss = qdarkstyle.load_stylesheet(qt_api in PYSIDE_API)
self.app.setStyleSheet(qss)
return
elif system.windows and QtCore.QSysInfo.windowsVersion() == QtCore.QSysInfo.WV_WINDOWS10:
self.app.setStyleSheet('QToolBar { background-color: white;};')
else:
self.app.setStyleSheet('')
def main():
config_server = None
try:
path = os.path.abspath(os.path.dirname(__file__))
config_file = os.path.join(path, 'config_server.yaml')
with open(os.path.expanduser(config_file), encoding='utf8') as fd:
config_server = yaml.load(fd)
except IOError:
print("config_server.yaml is missing")
config_client = None
try:
path = os.path.abspath(os.path.dirname(__file__))
config_file = os.path.join(path, 'config_client.yaml')
with open(os.path.expanduser(config_file), encoding='utf8') as fd:
config_client = yaml.load(fd)
except IOError:
print("config_client.yaml is missing")
lang_dict = None
font = None
try:
path = os.path.abspath(os.path.dirname(__file__))
config_file = os.path.join(path, 'language/en/live_text.yaml')
font = QtGui.QFont('Microsoft Sans Serif', 10)
if config_client['language'] == 'cn':
config_file = os.path.join(path, 'language/cn/live_text.yaml')
font = QtGui.QFont(u'微软雅黑', 10)
with open(os.path.expanduser(config_file), encoding='utf8') as fd:
lang_dict = yaml.load(fd)
lang_dict['font'] = font
except IOError:
print("live_text.yaml is missing")
app = QtWidgets.QApplication(sys.argv)
mainWindow = MainWindow(config_server, config_client, lang_dict)
if config_client['theme'] == 'dark':
import qdarkstyle
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
mainWindow.showMaximized()
sys.exit(app.exec_())
def main():
"""
Application entry point
"""
logging.basicConfig(level=logging.DEBUG)
# create the application and the main window
app = QtWidgets.QApplication(sys.argv)
window = QtWidgets.QMainWindow()
# setup ui
ui = example_ui.Ui_MainWindow()
ui.setupUi(window)
ui.bt_delay_popup.addActions([
ui.actionAction,
ui.actionAction_C
])
ui.bt_instant_popup.addActions([
ui.actionAction,
ui.actionAction_C
])
ui.bt_menu_button_popup.addActions([
ui.actionAction,
ui.actionAction_C
])
item = QtWidgets.QTableWidgetItem("Test")
item.setCheckState(QtCore.Qt.Checked)
ui.tableWidget.setItem(0, 0, item)
window.setWindowTitle("QDarkStyle example")
# tabify dock widgets to show bug #6
window.tabifyDockWidget(ui.dockWidget1, ui.dockWidget2)
# setup stylesheet
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# auto quit after 2s when testing on travis-ci
if "--travis" in sys.argv:
QtCore.QTimer.singleShot(2000, app.exit)
# run
window.show()
app.exec_()
def main(args=sys.argv):
make_logger("unicodemoticon", emoji=True)
lock = set_single_instance("unicodemoticon")
check_encoding()
set_process_name("unicodemoticon")
set_process_priority()
app = QApplication(args)
app.setApplicationName("unicodemoticon")
app.setOrganizationName("unicodemoticon")
app.setOrganizationDomain("unicodemoticon")
app.instance().setQuitOnLastWindowClosed(False) # no quit on dialog quit
if qdarkstyle:
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
icon = QIcon(app.style().standardPixmap(QStyle.SP_FileIcon))
app.setWindowIcon(icon)
mainwindow = MainWidget()
mainwindow.show()
mainwindow.hide()
make_post_exec_msg(start_time)
sys.exit(app.exec())
def apply_preferences(self):
"""
Apply preferences on all open windows
"""
if settings.dark_theme():
self._qapp.setStyleSheet(load_stylesheet_pyqt5())
else:
self._qapp.setStyleSheet('')
if self._args.dev:
self._qapp.setStyleSheet(
self._qapp.styleSheet() +
'\nQToolBar{background-color: #80AA80;color: white;}')
self.tray_icon.setVisible(settings.show_tray_icon())
mime_types.load()
icons.init()
FileSystemContextMenu.set_file_explorer_command(
settings.file_manager_cmd())
for w in self.editor_windows:
w.apply_preferences()
self.flg_force_indexing = False
def create_qapp(app_name: str = "VN Trader"):
"""
Create Qt Application.
"""
sys.excepthook = excepthook
qapp = QtWidgets.QApplication([])
qapp.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
font = QtGui.QFont(SETTINGS["font.family"], SETTINGS["font.size"])
qapp.setFont(font)
icon = QtGui.QIcon(get_icon_path(__file__, "vnpy.ico"))
qapp.setWindowIcon(icon)
if "Windows" in platform.uname():
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
app_name
)
return qapp
def __init__(self, parent=None):
"""Initialize MainWindow."""
super(MainWindow, self).__init__(parent)
self.ram_info, self.ram_timer = QLabel(self), QTimer(self)
self.menubar, self.view = QMenu(self), WebView(self)
self.ram_timer.timeout.connect(self.update_statusbar)
self.ram_timer.start(60000) # Every 60 seconds
self.statusBar().insertPermanentWidget(0, self.ram_info)
self.setMinimumSize(640, 480)
self.setMaximumSize(QDesktopWidget().screenGeometry().width() * 2,
QDesktopWidget().screenGeometry().height() * 2)
self.palette().setBrush(QPalette.Base, Qt.transparent)
self.setPalette(self.palette()) # Transparent palette
self.setAttribute(Qt.WA_OpaquePaintEvent, False) # no opaque paint
self.setAttribute(Qt.WA_TranslucentBackground, True) # translucent
QShortcut("Ctrl+q", self, activated=self.close)
self.make_toolbar()
self.make_menubar()
self.update_statusbar()
self.setCentralWidget(self.view)
if qdarkstyle:
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
def _on_change_color_theme(self, theme):
import pyqtgraph as pg
if theme == 'default':
self._app.setStyleSheet(None)
pg.setConfigOptions(background='w', foreground='k')
for sub_window in self.mdi_area.subWindowList():
sub_window.plot_widget.setBackground('w')
sub_window.plot_widget.getAxis('bottom').setPen('k')
sub_window.plot_widget.getAxis('left').setPen('k')
elif theme == 'dark':
try:
import qdarkstyle
except ImportError:
logging.error("No dark style installed.")
else:
self._app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
pg.setConfigOptions(background='#232629', foreground='w')
for sub_window in self.mdi_area.subWindowList():
sub_window.plot_widget.setBackground('#232629')
sub_window.plot_widget.getAxis('bottom').setPen('w')
sub_window.plot_widget.getAxis('left').setPen('w')
t = date2num(t)
x = self.DataFrame['cost']
y = self.DataFrame['budget']
# plot data
p1 = ax.bar(t, x,width=0.2,color='b',align='center')
p2 = ax.bar(t, y,width=0.2,color='g',align='center')
ax.xaxis_date()
ax.set_xlabel('Date')
ax.set_ylabel('Cash (RM)')
ax.legend((p1[0], p2[0]), ('Cost', 'Budget'))
self.figure.autofmt_xdate(bottom=0.2, rotation=30, ha='right', which=None)
ax.autoscale(tight=True)
# refresh canvas
self.canvas.draw()
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
Felda = QtWidgets.QMainWindow()
dark_stylesheet = qdarkstyle.load_stylesheet_pyqt5()
app.setStyleSheet(dark_stylesheet)
ui = Ui_Felda()
ui.__init__(Felda)
Felda.show()
sys.exit(app.exec_())
def __init__(self, parent=None):
# 调用父类构造函数
super(QMainWindow, self).__init__(parent)
self.setupUi(self)
# 经典暗黑主题
qApp.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# 窗口置顶
self.setWindowFlags(Qt.WindowStaysOnTopHint)
# 图标，QIcon作为参数(相对/绝对路径)
self.setWindowIcon(QIcon(':/yu/yu.ico'))
# 标题
self.setWindowTitle('余时锐文件重命名v4.0')
# 大小
self.resize(600, 800)
# 位置
self.move(0, 0)
# 表格0行
self.tableWidget.setRowCount(0)
# 表格3列
self.tableWidget.setColumnCount(3)
# 水平列名([列表])
self.tableWidget.setHorizontalHeaderLabels(['原文件名', '新文件名', '状态'])
# 表头自适应伸缩
self.tableWidget.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
# 自动调整列宽
self.tableWidget.resizeColumnsToContents()
# 调用Drops方法
self.setAcceptDrops(True)
# 文件路径空列表
self.old_file_xpath_list = []
self.new_file_xpath_list = []
# 文件名空列表
self.old_file_name_list = []
self.new_file_name_list = []
# 文件后缀空列表
self.old_file_houzhui_list = []
self.new_file_houzhui_list = []
# 清空槽函数
self.btn_qingkong.clicked.connect(self.qingkong)
# 预览槽函数
self.btn_rename.clicked.connect(lambda: self.yulan(self.btn_rename))
self.btn_tihuan.clicked.connect(lambda: self.yulan(self.btn_tihuan))
self.btn_charu.clicked.connect(lambda: self.yulan(self.btn_charu))
self.btn_daxiaoxie.clicked.connect(
lambda: self.yulan(self.btn_daxiaoxie))
self.btn_kuozhanming.clicked.connect(
lambda: self.yulan(self.btn_kuozhanming))
self.btn_baoliuzhongwen.clicked.connect(
lambda: self.yulan(self.btn_baoliuzhongwen))
# 执行槽函数
self.btn_zhixing.clicked.connect(self.zhixing)
def _apply_style(self):
# setup stylesheet
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# -*- coding: utf-8 -*-
"""
Author: Juan Camilo Florez R. <*****@*****.**>
"""
from PyQt5 import QtWidgets
from presentation.GUIAssist import Ui_GUIAssist
import qdarkstyle
if __name__ == "__main__":
"""
Creates an application object based on PyQt5 QApplication widget
and shows the GUI stored in the presentation layer
"""
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
ui = Ui_GUIAssist()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
main_window = MainWindow()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
main_window.show()
sys.exit(app.exec_())
def main():
app = QtWidgets.QApplication(argv)
window = Resumaker()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5()) # темная тема
window.show()
app.exec_()
def setDark():
QApplication.instance().setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
def main():
app=QApplication(sys.argv)
window=SignApp()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
window.show()
app.exec_()
def __init__(self):
super(Window, self).__init__()
self.setWindowOpacity(0.95) # 设置窗口透明度
# 美化风格
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.setWindowTitle("模式识别大作业--人脸识别—PCA_SVM--葛健男")
self.resize(500, 900)
layout = QVBoxLayout(self)
layout_imgs = QHBoxLayout(self)
# self.imageLabel = QLabel(self)
# self.imageLabel.setAlignment(Qt.AlignCenter)
# self.imageLabel.setFixedSize(400, 559)
# layout_imgs.addWidget(self.imageLabel)
# self.imageLabel_result = QLabel(self)
# self.imageLabel_result.setAlignment(Qt.AlignCenter)
# self.imageLabel_result.setFixedSize(348, 559)
self.image_test_1 = QLabel(self)
self.image_test_1.setAlignment(Qt.AlignCenter)
self.image_test_1.setFixedSize(200, 280)
self.image_test_2 = QLabel(self)
self.image_test_2.setAlignment(Qt.AlignCenter)
self.image_test_2.setFixedSize(200, 280)
self.image_test_3 = QLabel(self)
self.image_test_3.setAlignment(Qt.AlignCenter)
self.image_test_3.setFixedSize(200, 280)
self.image_test_4 = QLabel(self)
self.image_test_4.setAlignment(Qt.AlignCenter)
self.image_test_4.setFixedSize(200, 280)
self.imageLabel = QLabel(self)
self.imageLabel.setAlignment(Qt.AlignCenter)
self.imageLabel.setFixedSize(400, 559)
test_1 = QHBoxLayout(self)
test_1.addWidget(self.image_test_1)
test_1.addWidget(self.image_test_2)
test_1.setSpacing(2)
test_2 = QHBoxLayout(self)
test_2.addWidget(self.image_test_3)
test_2.addWidget(self.image_test_4)
test_2.setSpacing(2)
test_show = QVBoxLayout(self)
test_show.addLayout(test_1)
test_show.addLayout(test_2)
source_show = QVBoxLayout(self)
source_show.addWidget(self.imageLabel)
layout_imgs.addLayout(source_show)
layout_imgs.addLayout(test_show)
layout_imgs.setSpacing(3)
# layout_imgs.addWidget(self.imageLabel_result)
# layout_imgs.setSpacing(10)
layout.addItem(layout_imgs)
clayout = QHBoxLayout()
layout.addItem(clayout)
self.button1 = QPushButton('开始训练', self, clicked=self.train_svm)
self.button2 = QPushButton('测试图片', self, clicked=self.select_pic)
self.button3 = QPushButton('显示结果', self, clicked=self.test_svm)
self.button4 = QPushButton('关于我们', self, clicked=self.about_us)
self.button1.setStyleSheet(
"QPushButton{color:black}"
"QPushButton:hover{color:red}"
"QPushButton{background-color:rgb(255,128,128)}"
"QPushButton{border:2px}"
"QPushButton{border-radius:10px}"
"QPushButton{padding:2px 4px}")
self.button1.setMinimumHeight(30)
self.button2.setStyleSheet(
"QPushButton{color:black}"
"QPushButton:hover{color:red}"
"QPushButton{background-color:rgb(255,128,128)}"
"QPushButton{border:2px}"
"QPushButton{border-radius:10px}"
"QPushButton{padding:2px 4px}")
self.button2.setMinimumHeight(30)
self.button3.setStyleSheet(
"QPushButton{color:black}"
"QPushButton:hover{color:red}"
"QPushButton{background-color:rgb(255,128,128)}"
"QPushButton{border:2px}"
"QPushButton{border-radius:10px}"
"QPushButton{padding:2px 4px}")
self.button3.setMinimumHeight(30)
self.button4.setStyleSheet(
"QPushButton{color:black}"
"QPushButton:hover{color:red}"
"QPushButton{background-color:rgb(255,128,128)}"
"QPushButton{border:2px}"
"QPushButton{border-radius:10px}"
"QPushButton{padding:2px 4px}")
self.button4.setMinimumHeight(30)
clayout.addWidget(self.button1)
clayout.addWidget(self.button2)
clayout.addWidget(self.button3)
clayout.addWidget(self.button4)
clayout.setSpacing(10)
# 设置文本显示框
text = QHBoxLayout(self)
self.tx = QTextEdit(self)
text.addWidget(self.tx)
layout.addItem(text)
self.tx.setFontPointSize(15)
self.tx.setPlainText("算法运行结果显示")
def __init__(self, motLat='',motorTypeName0='', motVert='',motorTypeName1='',nomWin='',nomTilt='',unit=1,jogValue=1,background='gray',parent=None):
super(TILTMOTORGUI, self).__init__()
p = pathlib.Path(__file__)
sepa=os.sep
self.icon=str(p.parent) + sepa + 'icons' +sepa
self.motor=[str(motLat),str(motVert)]
self.motorTypeName=[motorTypeName0,motorTypeName1]
self.motorType=[0,0]
self.MOT=[0,0]
self.configMotName=[0,0]
self.conf=[0,0]
self.configPath="./fichiersConfig/"
self.isWinOpen=False
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.indexUnit=unit
self.jogValue=jogValue
self.nomTilt=nomTilt
self.setStyleSheet("background-color:"+background)
self.setWindowIcon(QIcon(self.icon+'LOA.png'))
self.version=__version__
for zi in range (0,2): #• creation list configuration et type de moteurs
if self.motorTypeName[zi]=='RSAI':
self.configMotName[zi]=self.configPath+'configMoteurRSAI.ini'
import moteurRSAI as RSAI
self.motorType[zi]=RSAI
self.MOT[zi]=self.motorType[zi].MOTORRSAI(self.motor[zi])
elif self.motorTypeName[zi]=='SmartAct':
self.configMotName[zi]=self.configPath+'configMoteurSmartAct.ini'
import smartactmot as SmartAct
self.motorType[zi]=SmartAct
self.MOT[zi]=self.motorType[zi].MOTORSMART(self.motor[zi])
elif self.motorTypeName[zi]=='A2V':
self.configMotName[zi]=self.configPath+'configMoteurA2V.ini'
import moteurA2V as A2V
self.motorType[zi]=A2V
self.MOT[zi]=self.motorType[zi].MOTORA2V(self.motor[zi])
elif self.motorTypeName[zi]=='NewFocus':
self.configMotName[zi]=self.configPath+'configMoteurNewFocus.ini'
import moteurNewFocus as NewFoc
self.motorType[zi]=NewFoc
self.MOT[zi]=self.motorType[zi].MOTORNEWFOCUS(self.motor[zi])
elif self.motorTypeName[zi]=='newport':
self.configMotName[zi]=self.configPath+'confNewport.ini'
import newportMotors as Newport
self.motorType[zi]=Newport
self.MOT[zi]=self.motorType[zi].MOTORNEWPORT(self.motor[zi])
elif self.motorTypeName[zi]=='Servo':
self.configMotName[zi]=self.configPath+'configMoteurServo.ini'
import servo as servo
self.motorType[zi]=servo
self.MOT[zi]=self.motorType[zi].MOTORSERVO(self.motor[zi])
else:
print('Error config motor Type name')
self.configMotName[zi]=self.configPath+'configMoteurTest.ini'
import moteurtest as test
self.motorType[zi]=test
self.MOT[zi]=self.motorType[zi].MOTORTEST(self.motor[zi])
self.conf[zi]=QtCore.QSettings(self.configMotName[zi], QtCore.QSettings.IniFormat) # fichier config motor fichier .ini
self.stepmotor=[0,0]
self.butePos=[0,0]
self.buteNeg=[0,0]
self.name=[0,0,0]
for zzi in range(0,2):
self.stepmotor[zzi]=float(self.conf[zzi].value(self.motor[zzi]+"/stepmotor")) #list of stepmotor values for unit conversion
self.butePos[zzi]=float(self.conf[zzi].value(self.motor[zzi]+"/buteePos")) # list
self.buteNeg[zzi]=float(self.conf[zzi].value(self.motor[zzi]+"/buteeneg"))
self.name[zzi]=str(self.conf[zzi].value(self.motor[zzi]+"/Name"))
self.unitChangeLat=self.indexUnit
self.unitChangeVert=self.indexUnit
self.setWindowTitle(nomWin+' : '+' V.'+str(self.version))
self.threadLat=PositionThread(mot=self.MOT[0],motorType=self.motorType[0]) # thread pour afficher position Lat
self.threadLat.POS.connect(self.PositionLat)
time.sleep(0.1)
self.threadVert=PositionThread(mot=self.MOT[1],motorType=self.motorType[1]) # thread pour afficher position Vert
self.threadVert.POS.connect(self.PositionVert)
self.setup()
if self.indexUnit==0: # step
self.unitChangeLat=1
self.unitName='step'
if self.indexUnit==1: # micron
self.unitChangeLat=float((1*self.stepmotor[0]))
self.unitName='um'
if self.indexUnit==2: # mm
self.unitChangeLat=float((1000*self.stepmotor[0]))
self.unitName='mm'
if self.indexUnit==3: # ps double passage : 1 microns=6fs
self.unitChangeLat=float(1*self.stepmotor[0]/0.0066666666)
self.unitName='ps'
if self.indexUnit==4: # en degres
self.unitChangeLat=1 *self.stepmotor[0]
self.unitName='°'
self.unitTrans()
def __init__(self, app, uuid, parent=None):
super(MainDialog, self).__init__(parent)
layouts_helper.configure_default_params(self)
self.app = app
self.uuid = uuid
self.settings: Settings = Settings(
constants.ORGANIZATION_NAME, constants.APPLICATION_NAME)
self.appSettings = QSettings()
self.ffmpeg_config = FfmpegConfig()
processes.add(self.ffmpeg_config)
self.fileOpenDialogDirectory = os.path.expanduser('~')
self.bindLicenseActions()
self.source_time_button.clicked.connect(self.getSourceTime)
self.sound_track_button.clicked.connect(self.getSoundTrack)
self.font_button.clicked.connect(self.getParamFont)
self.font_size_tb.valueChanged.connect(self.setFontSize)
self.red_spin_box_2.valueChanged.connect(self.changeFontPickerRed)
self.green_spin_box.valueChanged.connect(self.changeFontPickerGreen)
self.blue_spin_box.valueChanged.connect(self.changeFontPickerBlue)
self.red_spin_box_text_box.valueChanged.connect(self.changeBackgroundPickerRed)
self.green_spin_box_text_box.valueChanged.connect(self.changeBackgroundPickerGreen)
self.blue_spin_box_text_box.valueChanged.connect(
self.changeBackgroundPickerBlue)
self.show_bounding_box.clicked.connect(self.toggleBoundingBox)
self.background_button.clicked.connect(self.getBackgroundImage)
self.generate_video_button.clicked.connect(self._generateVideo)
self.refresh_button.clicked.connect(self.refreshVideo)
self.video_location_button.clicked.connect(self.getVideoOutputLocation)
self.frame_next_button.clicked.connect(self.showNextFrame)
self.frame_previous_button.clicked.connect(self.showPreviousFrame)
self.source_time_tb.textChanged.connect(self.updateSourceTimeTextBox)
self.sound_track_tb.textChanged.connect(self.updateSoundTrackTextBox)
self.font_tb.textChanged.connect(self.updateFontTextBox)
self.video_location_tb.textChanged.connect(
self.updateVideoLocationTextBox)
self.theme_actions = {}
self.themes = (list(map(theme_set, QtWidgets.QStyleFactory.keys())) +
[layouts_helper.Theme("Dark Style", qdarkstyle.load_stylesheet_pyqt5(), True)])
self.videoThread: QThread = GenerateVideo()
self.videoThread.update.connect(self.updateProgress)
self.videoThread.text.connect(self.updateVideoGenerationStatusText)
self.videoThread.image.connect(self.updatePreviewWindowVG)
self.videoThread.success.connect(self.generationSuccessCheck)
self.videoThread.finished.connect(self.cleanupVideoGeneration)
self.actionOpen.triggered.connect(self.openConfig)
self.actionOpen.setIcon(
self.style().standardIcon(QStyle.SP_DialogOpenButton))
self.actionSave_As.triggered.connect(self.saveAsConfig)
self.actionSave.triggered.connect(self.saveConfig)
self.actionSave.setIcon(
self.style().standardIcon(QStyle.SP_DialogSaveButton))
self.actionNew.triggered.connect(self.newWindow)
self.actionNew.setIcon(self.style().standardIcon(QStyle.SP_FileIcon))
self.recently_opened = RecentlyOpened(self)
self.recently_opened.buildRecentlyOpenedDict()
self.recently_opened.build_dropdown()
self.actionExit.triggered.connect(self.close)
self.align_text_top_radial.toggled.connect(self.setTextPosition)
self.align_text_center_radial.toggled.connect(self.setTextPosition)
self.align_text_bottom_radial.toggled.connect(self.setTextPosition)
self.reset_preview_button.setIcon(
self.style().standardIcon(QStyle.SP_MediaSkipBackward))
self.reset_preview_button.clicked.connect(self.resetPreview)
self.skip_to_end_button.setIcon(
self.style().standardIcon(QStyle.SP_MediaSkipForward))
self.skip_to_end_button.clicked.connect(self.skipToEnd)
self.player = QMediaPlayer()
self.isMuted = False
self.mute_preview_button.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolume))
self.mute_preview_button.clicked.connect(self.checkPreviewMute)
self.isPlayingPreview = False
self.play_preview_button.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
self.play_preview_button.clicked.connect(self.playPreview)
self.background_preview.setRenderHint(
QtGui.QPainter.SmoothPixmapTransform)
self.preview_graphic.setRenderHint(
QtGui.QPainter.SmoothPixmapTransform)
self.actionClear_all_settings.triggered.connect(self.appSettings.clear)
self.text_align_left.setDisabled(True)
self.text_align_center.setDisabled(True)
self.text_align_right.setDisabled(True)
self.text_x_pos.valueChanged.connect(self.update_text_x_pos)
self.text_y_pos.valueChanged.connect(self.update_text_y_pos)
self.currentFrame = 0
self.actionConfigure_FFMPEG_location.triggered.connect(
self.showFFMPEGConfigureDialog)
self.checkFFMPEGVersion(onStart=True)
self.setThemeOptions()
self.setTheme()
# self.actionTheme.triggered.connect(self.changeTheme)
self.updateColors()
self.preview_dialog = ImageViewer(self)
processes.add(self.preview_dialog)
self.previewClicked.connect(self.bindLargePreviewActions)
self.checkFramePosition()
self.preview_frame_buffer = list()
timer100ms = QtCore.QTimer(self)
timer100ms.timeout.connect(self.runUpdateEvents100ms)
timer100ms.start(100) # 100 ms refesh rate
self.file_not_found = FileNotFound(self)
processes.add(self.file_not_found)
def main():
"""Execute QDarkStyle example."""
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
'--qt_from',
default='pyqt',
choices=['pyqt', 'pyqt5', 'pyside', 'qtpy', 'pyqtgraph'],
help="Choose which wrapper/framework is to be used to run the example.",
type=str)
parser.add_argument(
'--no_dark',
action='store_true',
help="Exihibts the original window (without qdarkstyle).")
parser.add_argument('--test',
action='store_true',
help="Auto close window after 2s.")
# parsing arguments from command line
args = parser.parse_args()
# set log for debug
logging.basicConfig(level=logging.DEBUG)
if args.qt_from == 'pyside':
# using PySide wrapper
from PySide.QtGui import QApplication, QMainWindow, QDockWidget
from PySide.QtCore import QTimer, Qt
# import examples UI according to wrapper
from ui.mw_views_widgets_containers_pyside_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyside_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyside_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyside_ui import Ui_DockWidget as ui_inputs
from ui.dw_inputs_no_fields_pyside_ui import Ui_DockWidget as ui_inputs_no_fields
# getting style
style = qdarkstyle.load_stylesheet_pyside()
elif args.qt_from == 'pyqt':
# using PyQt4 wrapper
from PyQt4.QtGui import QApplication, QMainWindow, QDockWidget
from PyQt4.QtCore import QTimer, Qt
# import examples UI according to wrapper
from ui.mw_views_widgets_containers_pyqt_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyqt_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyqt_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyqt_ui import Ui_DockWidget as ui_inputs
from ui.dw_inputs_no_fields_pyqt_ui import Ui_DockWidget as ui_inputs_no_fields
# getting style
style = qdarkstyle.load_stylesheet_pyqt()
elif args.qt_from == 'pyqt5':
# using PyQt5 wrapper
from PyQt5.QtWidgets import QApplication, QMainWindow, QDockWidget
from PyQt5.QtCore import QTimer, Qt
# import examples UI according to wrapper
from ui.mw_views_widgets_containers_pyqt5_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyqt5_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyqt5_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyqt5_ui import Ui_DockWidget as ui_inputs
from ui.dw_inputs_no_fields_pyqt5_ui import Ui_DockWidget as ui_inputs_no_fields
# getting style
style = qdarkstyle.load_stylesheet_pyqt5()
elif args.qt_from == 'qtpy':
# using QtPy API
from qtpy.QtWidgets import QApplication, QMainWindow, QDockWidget
from qtpy.QtCore import QTimer, Qt
# import examples UI according to wrapper
from ui.mw_views_widgets_containers_qtpy_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_qtpy_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_qtpy_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_qtpy_ui import Ui_DockWidget as ui_inputs
from ui.dw_inputs_no_fields_qtpy_ui import Ui_DockWidget as ui_inputs_no_fields
# getting style
style = qdarkstyle.load_stylesheet_from_environment()
elif args.qt_from == 'pyqtgraph':
# using PyQtGraph API
from pyqtgraph.Qt import QtGui, QtCore
# import examples UI according to wrapper
from ui.mw_views_widgets_containers_pyqtgraph_ui import Ui_MainWindow as ui_main
from ui.mw_dw_buttons_pyqtgraph_ui import Ui_DockWidget as ui_buttons
from ui.mw_dw_displays_pyqtgraph_ui import Ui_DockWidget as ui_displays
from ui.mw_dw_inputs_fields_pyqtgraph_ui import Ui_DockWidget as ui_inputs
from ui.mw_dw_inputs_no_fields_pyqtgraph_ui import Ui_DockWidget as ui_inputs_no_fields
# getting style
style = qdarkstyle.load_stylesheet_from_environment(is_pyqtgraph=True)
if args.no_dark:
style = ''
# create the application
app = QApplication(sys.argv)
# setup stylesheet
app.setStyleSheet(style)
# create main window
window = QMainWindow()
ui = ui_main()
ui.setupUi(window)
window.setWindowTitle("QDarkStyle v." + qdarkstyle.__version__ +
" - Example - Using " + args.qt_from)
# create docks for buttons
dw_buttons = QDockWidget()
ui_buttons = ui_buttons()
ui_buttons.setupUi(dw_buttons)
window.addDockWidget(Qt.RightDockWidgetArea, dw_buttons)
# create docks for buttons
dw_displays = QDockWidget()
ui_displays = ui_displays()
ui_displays.setupUi(dw_displays)
window.addDockWidget(Qt.RightDockWidgetArea, dw_displays)
# create docks for inputs - fields
dw_inputs = QDockWidget()
ui_inputs = ui_inputs()
ui_inputs.setupUi(dw_inputs)
window.addDockWidget(Qt.RightDockWidgetArea, dw_inputs)
# create docks for inputs - no fields
dw_inputs_no_field = QDockWidget()
ui_inputs_no_field = ui_inputs_no_fields()
ui_inputs_no_field.setupUi(dw_inputs_no_field)
window.addDockWidget(Qt.RightDockWidgetArea, dw_inputs_no_field)
# tabify docks
window.tabifyDockWidget(dw_buttons, dw_displays)
window.tabifyDockWidget(dw_displays, dw_inputs)
window.tabifyDockWidget(dw_inputs, dw_inputs_no_field)
# connect some actions, signals and functions
# auto quit after 2s when testing on travis-ci
if "--test" in sys.argv:
QTimer.singleShot(2000, app.exit)
# run
window.showMaximized()
app.exec_()
def setup_additional(self):
self.parent_window.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.centralwidget.layout().addWidget(self.directoryListWidget, 1, 0)
self.directoryListWidget.setAcceptDrops(True)
def __init__(self, exec=True, app=None, **kwargs):
# Check if exist a default config file in the home (user) directory:
mp.set_start_method("spawn", force=True)
inum = kwargs.get("instance_number", -1)
if inum >= 0:
default_config_file = Path.home(
) / "stytra_setup_config_{}.json".format(inum)
else:
default_config_file = Path.home() / "stytra_setup_config.json"
if default_config_file.is_file():
config = json.load(open(str(default_config_file)))
else:
config = dict()
# Get rest of configuration parameters from the protocol:
try:
extra_config = kwargs["protocol"].stytra_config
recursive_update(config, extra_config)
except AttributeError:
pass
recursive_update(config, kwargs) # Use also keyword arguments
if config.get("scope_triggering", None) == "zmq":
# Automatically use zmqTrigger if zmq is specified
from stytra.triggering import ZmqTrigger
config["scope_triggering"] = ZmqTrigger(port="5555")
if app is None:
app = QApplication([])
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
if app.devicePixelRatio() > 1:
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
class_kwargs = dict(app=app)
class_kwargs.update(config)
base = VisualExperiment
if "camera" in class_kwargs.keys():
base = CameraVisualExperiment
if "tracking" in class_kwargs.keys():
base = TrackingExperiment
if not class_kwargs["tracking"].get("embedded", True):
class_kwargs["calibrator"] = CircleCalibrator()
# Stytra logo
app_icon = QIcon()
for size in [32, 64, 128, 256]:
app_icon.addFile(
pkg_resources.resource_filename(__name__,
"/icons/{}.png".format(size)),
QSize(size, size),
)
app.setWindowIcon(app_icon)
pg.setConfigOptions(imageAxisOrder="row-major")
self.exp = base(**class_kwargs)
self.exp.start_experiment()
if exec:
app.exec_()
def __init__(self, pulse_lib, digitizer, scan_type = 'Virtual', cust_defaults = None,
iq_mode=None, channel_map=None):
'''
init of the class
Args:
pulse_lib (pulselib) : provide the pulse library object. This is used to generate the sequences.
digitizer (QCodes Instrument) : provide the digitizer driver of the card. In this case the one put in V2 software.
scan_type (str) : type of the scan, will point towards a certain driver for getting the data (e.g. 'Virtual', 'Keysight')
cust_defaults (dict of dicts): Dictionary to supply custom starting defaults. Any parameters/dicts that are not defined will resort to defaults.
Format is {'1D': dict, '2D': dict, 'gen': dict}
1D = {'gate_name': str,
'V_swing': float,
'npt': int,
't_meas': float,
'biasT_corr': bool,
'average': int,
'diff': bool}
2D = {'gate1_name': str,
'gate2_name': str,
'V1_swing': float,
'V2_swing': float,
'npt': int,
't_meas': float,
'biasT_corr': bool,
'average': int,
'gradient': str} # 'Off', 'Magnitude', or 'Mag & angle'
gen = {'ch1': bool,
'ch2': bool,
'ch3': bool,
'ch4': bool,
'sample_rate': float, # (currently only 100 or 500 allowed)
'dig_vmax: float, # allowed: 4.0, 2.0, 1.0, 0.5, 0.25, 0.125
'enabled_markers': list[str],
'n_columns': int,
'line_margin': int,
'bias_T_RC': float,
'acquisition_delay_ns': float, # Time in ns between AWG output change and digitizer acquisition start.
}
iq_mode (str or dict): when digitizer is in MODE.IQ_DEMODULATION then this parameter specifies how the
complex I/Q value should be plotted: 'I', 'Q', 'abs', 'angle', 'angle_deg'. A string applies to
all channels. A dict can be used to specify selection per channel, e.g. {1:'abs', 2:'angle'}
channel_map (Dict[str, Tuple(int, Callable[[np.ndarray], np.ndarray])]):
defines new list of derived channels to display. Dictionary entries name: (channel_number, func).
E.g. {(ch1-I':(1, np.real), 'ch1-Q':(1, np.imag), 'ch3-Amp':(3, np.abs), 'ch3-Phase':(3, np.angle)}
The default channel_map is:
{'ch1':(1, np.real), 'ch2':(2, np.real), 'ch3':(3, np.real), 'ch4':(4, np.real)}
'''
logging.info('initialising vm')
self.pulse_lib = pulse_lib
self.digitizer = digitizer
if scan_type == 'Virtual':
self.construct_1D_scan_fast = scan_generator_Virtual.construct_1D_scan_fast
self.construct_2D_scan_fast = scan_generator_Virtual.construct_2D_scan_fast
elif scan_type == "Keysight":
from core_tools.GUI.keysight_videomaps.data_getter import scan_generator_Keysight
self.construct_1D_scan_fast = scan_generator_Keysight.construct_1D_scan_fast
self.construct_2D_scan_fast = scan_generator_Keysight.construct_2D_scan_fast
elif scan_type == "Tektronix":
from core_tools.GUI.keysight_videomaps.data_getter import scan_generator_Tektronix
self.construct_1D_scan_fast = scan_generator_Tektronix.construct_1D_scan_fast
self.construct_2D_scan_fast = scan_generator_Tektronix.construct_2D_scan_fast
else:
raise ValueError("Unsupported agrument for scan type.")
self.current_plot = plot_content(None, None)
self.current_param_getter = param_getter(None, None)
instance_ready = True
# set graphical user interface
self.app = QtCore.QCoreApplication.instance()
if self.app is None:
instance_ready = False
self.app = QtWidgets.QApplication([])
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
super(QtWidgets.QMainWindow, self).__init__()
self.setupUi(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
self._init_channels(channel_map, iq_mode)
self._init_markers(pulse_lib)
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
self.start_1D.clicked.connect(self._1D_start_stop)
self.start_2D.clicked.connect(self._2D_start_stop)
self._1D_update_plot.clicked.connect(self.update_plot_settings_1D)
self._2D_update_plot.clicked.connect(self.update_plot_settings_2D)
self._flip_axes.clicked.connect(self.do_flip_axes)
self.tabWidget.currentChanged.connect(self.tab_changed)
self.init_defaults(pulse_lib.channels, cust_defaults)
self._1D_save_data.clicked.connect(self.save_data)
self._2D_save_data.clicked.connect(self.save_data)
self._1D_ppt_save.clicked.connect(self.copy_ppt)
self._2D_ppt_save.clicked.connect(self.copy_ppt)
self.show()
if instance_ready == False:
self.app.exec()
def main():
myApp = QApplication(sys.argv)
myApp.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
myWindow = MainWindow()
myWindow.show()
return myApp.exec()
def __init__(self,
motLat='',
motorTypeName0='',
motVert='',
motorTypeName1='',
nomWin='',
nomTilt='',
parent=None):
super(TiltMOTORGUI, self).__init__()
self.motor = [str(motLat), str(motVert)]
self.motorTypeName = [motorTypeName0, motorTypeName1]
self.motorType = [0, 0]
self.MOT = [0, 0]
self.configMotName = [0, 0]
self.conf = [0, 0]
self.configPath = "./fichiersConfig/"
self.isWinOpen = False
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.setup()
self.actionButton()
for zi in range(0,
2): #• creation list configuration et type de moteurs
if self.motorTypeName[zi] == 'RSAI':
self.configMotName[
zi] = self.configPath + 'configMoteurRSAI.ini'
import moteurRSAI as RSAI
self.motorType[zi] = RSAI
self.MOT[zi] = self.motorType[zi].MOTORRSAI(self.motor[zi])
elif self.motorTypeName == 'SmartAct':
self.configMotName[
zi] = self.configPath + 'configMoteurSmartAct.ini'
import smartactmot as SmartAct
self.motorType[zi] = SmartAct
self.MOT[zi] = self.motorType[zi].MOTORSMART(self.motor[zi])
elif self.motorTypeName[zi] == 'A2V':
self.configMotName[
zi] = self.configPath + 'configMoteurA2V.ini'
import moteurA2V as A2V
self.motorType[zi] = A2V
self.MOT[zi] = self.motorType[zi].MOTORA2V(self.motor[zi])
elif self.motorTypeName[zi] == 'NewFocus':
self.configMotName[
zi] = self.configPath + 'configMoteurNewFocus.ini'
import moteurNewFocus as NewFoc
self.motorType[zi] = NewFoc
self.MOT[zi] = self.motorType[zi].MOTORNEWFOCUS(self.motor[zi])
print('NewFocus')
elif self.motorTypeName[zi] == 'newport':
self.configMotName[zi] = self.configPath + 'confNewport.ini'
import newportMotors as Newport
self.motorType[zi] = Newport
self.MOT[zi] = self.motorType[zi].MOTORNEWPORT(self.motor[zi])
elif self.motorTypeName[zi] == 'Servo':
self.configMotName[
zi] = self.configPath + 'configMoteurServo.ini'
import servo as servo
self.motorType[zi] = servo
self.MOT[zi] = self.motorType[zi].MOTORSERVO(self.motor[zi])
else:
print('Error config motor Type name')
self.conf[zi] = QtCore.QSettings(
self.configMotName[zi], QtCore.QSettings.IniFormat
) # fichier config motor fichier .ini
self.setWindowTitle(
nomWin) # affichage nom du moteur sur la barre de la fenetre
# affichage nom du moteur
#self.show()
self.stepmotor = [0, 0]
self.butePos = [0, 0]
self.buteNeg = [0, 0]
for zzi in range(0, 2):
self.stepmotor[zzi] = float(self.conf[zzi].value(
self.motor[zzi] +
"/stepmotor")) #list of stepmotor values for unit conversion
self.butePos[zzi] = float(
self.conf[zzi].value(self.motor[zzi] + "/buteePos")) # list
self.buteNeg[zzi] = float(self.conf[zzi].value(self.motor[zzi] +
"/buteeneg"))
self.unitChangeLat = 1
self.unitChangeVert = 1
self.threadLat = PositionThread(
mot=self.MOT[0],
motorType=self.motorType[0]) # thread pour afficher position Lat
self.threadLat.POS.connect(self.PositionLat)
time.sleep(0.1)
self.threadVert = PositionThread(
mot=self.MOT[1],
motorType=self.motorType[1]) # thread pour afficher position Vert
self.threadVert.POS.connect(self.PositionVert)
def __init__(self,
shoot=True,
title='Motors Control',
configFile='configMoteurA2V.ini'):
super(MainWin, self).__init__()
p = pathlib.Path(__file__)
sepa = os.sep
self.icon = str(p.parent) + sepa + 'icons' + sepa
self.shoot = shoot
self.configPath = str(p.parent / "fichiersConfig") + sepa
self.configMotName = self.configPath + configFile
self.conf = QtCore.QSettings(self.configMotName,
QtCore.QSettings.IniFormat)
self.groups = self.conf.childGroups() # lecture de tous les moteurs
print('motor in file : ', self.configMotName)
print(self.groups)
self.motorListButton = list()
self.motorListGui = list()
self.setWindowTitle(title)
self.setWindowIcon(QIcon(self.icon + 'LOA.png'))
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
grid = QGridLayout()
vbox1 = QVBoxLayout()
print('Please wait ...')
for vi in self.groups:
#print(vi)
# creation des boutons avec le nom
self.motorListButton.append(
QPushButton(self.conf.value(vi + "/Name"), self))
# creation de widget oneMotorGui pour chaque moteurs
self.motorListGui.append(
oneMotorGuiNew.ONEMOTORGUI(mot=str(vi), motorTypeName='A2V'))
#creation des d'une matrice de point pour creer une grille
z = 0
self.nbOfMotor = len(self.motorListButton)
for i in range(0, int(self.nbOfMotor / 2)):
for j in range(0, int(self.nbOfMotor / 2)):
if z < self.nbOfMotor:
grid.addWidget(self.motorListButton[z], j, i)
z += 1
j = 0
for mm in self.motorListButton:
# #ajout de chaque boutton dans la grille
# grid.addWidget(self.motorListButton[j], gridPos[j][0], gridPos[j][1])
#action de chaque bouton : open a new widget for onemotor control
mm.clicked.connect(
lambda checked, j=j: self.open_widget(self.motorListGui[j]))
j += 1
# ajout de la grille de bouton au widget proncipal
vbox1.addLayout(grid)
# if self.shoot==True: # to add shoot button in salle Jaune
# self.tirWidget=TIRGUI()
# vbox1.addWidget(self.tirWidget)
self.setLayout(vbox1)
self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
error.setIcon(QMessageBox.Warning)
error.setStandardButtons(QMessageBox.Reset
| QMessageBox.Ok) # QMessageBox.Close
# error.setStandardButtons(QMessageBox.Ok|QMessageBox.Cancel) # QMessageBox.Close
# error.setDefaultButton(QMessageBox.Cancel) # подсветка указанной кнопки в вспылвающем окне
error.setInformativeText("Два раза действие не выполнить")
error.setDetailedText("Введите верное выражение для вычисления ")
error.buttonClicked.connect(self.popup_action)
error.exec_()
def popup_action(self, btn_name):
if btn_name.text() == "Ok":
print("ok")
elif btn_name.text() == "Reset":
self.label_result.setText("0")
self.is_res = False
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
app.setStyleSheet(
qdarkstyle.load_stylesheet_pyqt5()) # set dark style sheet
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
def darkstyle(self):
"""change the theme of ui into dark style"""
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.ui.actiondarkstyle.setDisabled(True)
self.ui.append_text('进入暗色主题')
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(1012, 705)
dark_stylesheet = qdarkstyle.load_stylesheet_pyqt5()
MainWindow.setStyleSheet(dark_stylesheet)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.tabWidget = QtWidgets.QTabWidget(self.centralwidget)
self.tabWidget.setGeometry(QtCore.QRect(10, 10, 991, 641))
self.tabWidget.setObjectName("tabWidget")
self.tab = QtWidgets.QWidget()
self.tab.setObjectName("tab")
self.widget = QtWidgets.QWidget(self.tab)
self.widget.setGeometry(QtCore.QRect(10, 10, 961, 591))
self.widget.setObjectName("widget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.widget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setObjectName("verticalLayout")
#self.graphicsView = QtWidgets.QGraphicsView(self.widget)
self.graphicsView = pg.PlotWidget(self.widget)
self.graphicsView.setObjectName("graphicsView")
self.verticalLayout.addWidget(self.graphicsView)
self.btnRecords = QtWidgets.QPushButton(self.widget)
font = QtGui.QFont()
font.setPointSize(14)
self.btnRecords.setFont(font)
self.btnRecords.setObjectName("btnRecords")
self.verticalLayout.addWidget(self.btnRecords)
self.tabWidget.addTab(self.tab, "")
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
self.groupBox = QtWidgets.QGroupBox(self.tab_2)
self.groupBox.setGeometry(QtCore.QRect(30, 20, 921, 571))
font = QtGui.QFont()
font.setPointSize(18)
self.groupBox.setFont(font)
self.groupBox.setObjectName("groupBox")
self.widget1 = QtWidgets.QWidget(self.groupBox)
self.widget1.setGeometry(QtCore.QRect(20, 30, 371, 311))
self.widget1.setObjectName("widget1")
self.gridLayout = QtWidgets.QGridLayout(self.widget1)
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.gridLayout.setObjectName("gridLayout")
self.label = QtWidgets.QLabel(self.widget1)
font = QtGui.QFont()
font.setPointSize(16)
self.label.setFont(font)
self.label.setObjectName("label")
self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
self.lcdNumber = QtWidgets.QLCDNumber(self.widget1)
self.lcdNumber.setDigitCount(3)
self.lcdNumber.setObjectName("lcdNumber")
self.gridLayout.addWidget(self.lcdNumber, 0, 1, 1, 1)
self.label_2 = QtWidgets.QLabel(self.widget1)
font = QtGui.QFont()
font.setPointSize(16)
self.label_2.setFont(font)
self.label_2.setObjectName("label_2")
self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
self.lcdNumber_2 = QtWidgets.QLCDNumber(self.widget1)
self.lcdNumber_2.setDigitCount(3)
self.lcdNumber_2.setObjectName("lcdNumber_2")
self.gridLayout.addWidget(self.lcdNumber_2, 1, 1, 1, 1)
self.label_3 = QtWidgets.QLabel(self.widget1)
font = QtGui.QFont()
font.setPointSize(16)
self.label_3.setFont(font)
self.label_3.setObjectName("label_3")
self.gridLayout.addWidget(self.label_3, 2, 0, 1, 1)
self.lcdNumber_3 = QtWidgets.QLCDNumber(self.widget1)
self.lcdNumber_3.setDigitCount(3)
self.lcdNumber_3.setObjectName("lcdNumber_3")
self.gridLayout.addWidget(self.lcdNumber_3, 2, 1, 1, 1)
self.pushButton = QtWidgets.QPushButton(self.widget1)
self.pushButton.setObjectName("pushButton")
self.gridLayout.addWidget(self.pushButton, 3, 0, 1, 2)
self.tabWidget.addTab(self.tab_2, "")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1012, 22))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
#self.graphicsView.setBackground((163,248,236))
self.graphicsView.setBackground('k')
self.btnRecords.clicked.connect(self.btn_clk)
self.pushButton.clicked.connect(self.btnLastRecord)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __init__(self, app, main_window):
self.app = app
self.gui = main_window
super(syncPlotWindow, self).__init__()
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.window_closed = False
# Set look and feel
uic.loadUi(self.gui.resourcePath('Sync_Plot_GUI.ui'), self)
#Connect signals
self.status_emit = self.status_signal.emit #Function instance saved so it can later be disconnected explicitly
self.update_emit = self.sync_update_signal.emit #Function instance saved so it can later be disconnected explicitly
self.gui.sync_update_signal.connect(self.update_emit)
self.sync_update_signal.connect(
self.updateWindow
) # Update status when new status signal is received
self.gui.status_signal.connect(
self.status_emit
) # Connect mainWindow status signal to dialog status signal
self.status_signal.connect(
self.updateStatus
) #Update status when new status signal is received
self.plot_timeline = guiMapper.TimeLine(
loopCount=0, interval=STARTING_PLOT_RATE
) # Animation object for animating plots
# Set dark skin if in dark mode since skin is reverted when window is opened.
if self.gui.menu_view_skins_dark.isChecked():
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
else:
self.app.setStyleSheet("")
self.app.setFont(QFont("MS Shell Dlg 2", 12))
#Initialize lists for storing plot data
self.y_ref = [
OrderedDict([("PWM", []), ("Current", []), ("Channel", [])]),
OrderedDict([("PWM", []), ("Current", []), ("Channel", [])])
] #Y values of reference sequence line
self.x_ref = [[], []] #X values of reference sequence line
self.y_values = copy.deepcopy(self.y_ref)
self.x_values = copy.deepcopy(
self.x_ref) # X values of reference sequence line
self.status_dict = copy.deepcopy(self.gui.status_dict)
self.resetStatus()
self.seq_list = guiMapper.initializeSeqList(self.gui)
self.seq_dict = self.gui.seq_dict
self.mode = None #Save active sync mode string
#Plot widget data
self.plots = [
OrderedDict([("PWM", self.graph_intensity_pwm0),
("Current", self.graph_intensity_current0),
("Channel", self.graph_channel0)]),
OrderedDict([("PWM", self.graph_intensity_pwm1),
("Current", self.graph_intensity_current1),
("Channel", self.graph_channel1)])
]
self.state_dict = OrderedDict([("Digital", ["LOW", "HIGH"]),
("Analog", ["Active", "Active"]),
("Confocal", ["Standby", "Scanning"]),
("Serial", ["Active", "Active"]),
("Custom", ["Active", "Active"])])
self.hold_label = [self.hold_label0, self.hold_label1]
#Timers for x-axis
self.plot_interval = STARTING_PLOT_RATE #Time between plot updates in milliseconds
self.plot_start_time = timer(
) # Timer for tracking time points for x_axis
self.hold_start_time = timer(
) # Timer for tracking duration of hold at end of sequence
self.hold_status = [
None, None
] # State of plot hold (None = no hold, False = hold not yet reached, True = in hold)
for plot_dict in self.plots:
for key, value in plot_dict.items():
self.initializePlot(value, key)
self.updateWindow()
self.serialHelper = SerialHelper(port=port)
self.parent.serialHelper = self.serialHelper
# print(port)
# print(self.serialHelper.alive, self.serialHelper.serial_port.isOpen())
if not self.serialHelper.alive:
self.serialHelper.start()
print(self.serialHelper.alive, self.serialHelper.serial_port.isOpen())
# TODO disable close button if not serial port is open
def close_port(self):
print('close button clicked')
if self.serialHelper is not None:
if self.serialHelper.serial_port.isOpen():
self.serialHelper.stop()
else:
print("No open port")
if __name__ == '__main__':
print(PYQT_VERSION_STR)
app = QApplication(sys.argv)
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
mainWindow = QMainWindow()
mainWindow.setCentralWidget(QWidget())
controlPadDockWidget = SerialPortDockWidget()
mainWindow.addDockWidget(Qt.LeftDockWidgetArea, controlPadDockWidget)
mainWindow.setFixedSize(1024, 768)
mainWindow.show()
sys.exit(app.exec_())
def setDark():
QApplication.instance().setStyleSheet(qdarkstyle.load_stylesheet_pyqt5() +
pyqtgraph_parametertree_fixes)
def __init__(self, parent=None, live=False, cfg=None, dark=True):
super().__init__(parent=parent)
ui = self.ui
#Change the stylesheet
if dark:
try:
import qdarkstyle
except ImportError:
logger.error("Can not use dark theme, "
"qdarkstyle package not available")
else:
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# Configure debug file after all the qt logs
logging.basicConfig(level=logging.DEBUG,
format=('%(asctime)s '
'%(name)-12s '
'%(levelname)-8s '
'%(message)s'),
datefmt='%m-%d %H:%M:%S',
filename='./skywalker_debug.log',
filemode='a')
# Set self.sim, self.loader, self.nominal_config
self.sim = not live
self.config_folder = cfg
self.init_config()
# Load things
self.config_cache = {}
self.cache_config()
# Load system and alignments into the combo box objects
ui.image_title_combo.clear()
ui.procedure_combo.clear()
ui.procedure_combo.addItem('None')
self.all_imager_names = [
entry['imager'] for entry in self.loader.live_systems.values()
]
for imager_name in self.all_imager_names:
ui.image_title_combo.addItem(imager_name)
for align in self.alignments.keys():
ui.procedure_combo.addItem(align)
# Pick out some initial parameters from system and alignment dicts
first_system_key = list(self.alignments.values())[0][0][0]
first_set = self.loader.get_subsystem(first_system_key)
first_imager = first_set.get('imager', None)
first_slit = first_set.get('slits', None)
first_rotation = first_set.get('rotation', 0)
# self.procedure and self.image_obj keep track of the gui state
self.procedure = 'None'
self.image_obj = first_imager
# Initialize slit readback
self.slit_group = ObjWidgetGroup([
ui.slit_x_width, ui.slit_y_width, ui.slit_x_setpoint,
ui.slit_y_setpoint, ui.slit_circle
], [
'xwidth.readback', 'ywidth.readback', 'xwidth.setpoint',
'ywidth.setpoint', 'xwidth.done'
],
first_slit,
label=ui.readback_slits_title)
# Initialize mirror control
self.mirror_groups = []
mirror_labels = self.get_widget_set('mirror_name')
mirror_rbvs = self.get_widget_set('mirror_readback')
mirror_vals = self.get_widget_set('mirror_setpos')
mirror_circles = self.get_widget_set('mirror_circle')
mirror_nominals = self.get_widget_set('move_nominal')
for label, rbv, val, circle, nom, mirror in zip(
mirror_labels, mirror_rbvs, mirror_vals, mirror_circles,
mirror_nominals, self.mirrors_padded()):
mirror_group = ObjWidgetGroup([rbv, val, circle, nom], [
'pitch.user_readback', 'pitch.user_setpoint',
'pitch.motor_done_move'
],
mirror,
label=label)
if mirror is None:
mirror_group.hide()
self.mirror_groups.append(mirror_group)
# Initialize the goal entry fields
self.goals_groups = []
goal_labels = self.get_widget_set('goal_name')
goal_edits = self.get_widget_set('goal_value')
slit_checks = self.get_widget_set('slit_check')
for label, edit, check, img, slit in zip(goal_labels, goal_edits,
slit_checks,
self.imagers_padded(),
self.slits_padded()):
if img is None:
name = None
else:
name = img.name
validator = QDoubleValidator(0, 5000, 3)
goal_group = ValueWidgetGroup(edit,
label,
checkbox=check,
name=name,
cache=self.config_cache,
validator=validator)
if img is None:
goal_group.hide()
elif slit is None:
goal_group.checkbox.setEnabled(False)
self.goals_groups.append(goal_group)
# Initialize image and centroids. Needs goals defined first.
self.image_group = ImgObjWidget(ui.image, first_imager,
ui.beam_x_value, ui.beam_y_value,
ui.beam_x_delta, ui.beam_y_delta,
ui.image_state, ui.image_state_select,
ui.readback_imager_title, self,
first_rotation)
ui.image.setColorMapToPreset('jet')
# Initialize the settings window.
first_step = Setting('first_step', 6.0)
tolerance = Setting('tolerance', 5.0)
averages = Setting('averages', 100)
timeout = Setting('timeout', 600.0)
tol_scaling = Setting('tol_scaling', 8.0)
min_beam = Setting('min_beam', 1.0, required=False)
min_rate = Setting('min_rate', 1.0, required=False)
slit_width = Setting('slit_width', 0.2)
samples = Setting('samples', 100)
close_fee_att = Setting('close_fee_att', True)
self.settings = SettingsGroup(
parent=self,
collumns=[['alignment'], ['slits', 'suspenders', 'setup']],
alignment=[first_step, tolerance, averages, timeout, tol_scaling],
suspenders=[min_beam, min_rate],
slits=[slit_width, samples],
setup=[close_fee_att])
self.settings_cache = {}
self.load_settings()
self.restore_settings()
self.cache_settings() # Required in case nothing is loaded
# Create the RunEngine that will be used in the alignments.
# This gives us the ability to pause, etc.
self.RE = RunEngine({})
install_qt_kicker()
# Some hax to keep the state string updated
# There is probably a better way to do this
# This might break on some package update
self.RE.state # Yes this matters
old_set = RunEngine.state._memory[self.RE].set_
def new_set(state): # NOQA
old_set(state)
txt = " Status: " + state.capitalize()
self.ui.status_label.setText(txt)
RunEngine.state._memory[self.RE].set_ = new_set
# Connect relevant signals and slots
procedure_changed = ui.procedure_combo.currentIndexChanged[str]
procedure_changed.connect(self.on_procedure_combo_changed)
imager_changed = ui.image_title_combo.currentIndexChanged[str]
imager_changed.connect(self.on_image_combo_changed)
for goal_value in self.get_widget_set('goal_value'):
goal_changed = goal_value.editingFinished
goal_changed.connect(self.on_goal_changed)
start_pressed = ui.start_button.clicked
start_pressed.connect(self.on_start_button)
pause_pressed = ui.pause_button.clicked
pause_pressed.connect(self.on_pause_button)
abort_pressed = ui.abort_button.clicked
abort_pressed.connect(self.on_abort_button)
slits_pressed = ui.slit_run_button.clicked
slits_pressed.connect(self.on_slits_button)
save_mirrors_pressed = ui.save_mirrors_button.clicked
save_mirrors_pressed.connect(self.on_save_mirrors_button)
save_goals_pressed = ui.save_goals_button.clicked
save_goals_pressed.connect(self.on_save_goals_button)
settings_pressed = ui.settings_button.clicked
settings_pressed.connect(self.on_settings_button)
for i, nominal_button in enumerate(mirror_nominals):
nominal_pressed = nominal_button.clicked
nominal_pressed.connect(partial(self.on_move_nominal_button, i))
self.cam_lock = RLock()
# Store some info about our screen size.
QApp = QCoreApplication.instance()
desktop = QApp.desktop()
geometry = desktop.screenGeometry()
self.screen_size = (geometry.width(), geometry.height())
window_qsize = self.window().size()
self.preferred_size = (window_qsize.width(), window_qsize.height())
# Setup the post-init hook
post_init = PostInit(self)
self.installEventFilter(post_init)
post_init.post_init.connect(self.on_post_init)
# Setup the on-screen logger
console = self.setup_gui_logger()
# Stop the run if we get closed
close_dict = dict(RE=self.RE, console=console)
self.destroyed.connect(partial(SkywalkerGui.on_close, close_dict))
# Put out the initialization message.
init_base = 'Skywalker GUI initialized in '
if self.sim:
init_str = init_base + 'sim mode.'
else:
init_str = init_base + 'live mode.'
logger.info(init_str)
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle(title + ' ' + version)
self.setWindowFlags(Qt.X11BypassWindowManagerHint)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create new action
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open movie')
openAction.triggered.connect(self.openFile)
# Create new action
downloadAction = QAction('&Download Youtube Video', self)
downloadAction.setStatusTip('Download youtube video')
downloadAction.triggered.connect(self.youtubeDownloadPopup)
# Create exit action
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
# Create menu bar and add action
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
#fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(downloadAction)
fileMenu.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
# app.setStyleSheet(qdarkgraystyle.load_stylesheet())
# Force the style to be the same on all OSs:
# app.setStyle("Fusion")
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
def main():
"""Execute QDarkStyle example."""
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--qt_from', default='pyqt',
choices=['pyqt', 'pyqt5', 'pyside', 'qtpy', 'pyqtgraph'],
help="Choose which wrapper/framework is to be used to run the example.", type=str)
parser.add_argument('--no_dark', action='store_true',
help="Exihibts the original window (without qdarkstyle).")
parser.add_argument('--test', action='store_true',
help="Auto close window after 2s.")
# parsing arguments from command line
args = parser.parse_args()
# set log for debug
logging.basicConfig(level=logging.DEBUG)
if args.qt_from == 'pyside':
# using PySide wrapper
from PySide.QtGui import QApplication, QMainWindow, QDockWidget
from PySide.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# import examples UI according to wrapper
from ui.mw_menus_pyside_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyside_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyside_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyside_ui import Ui_DockWidget as ui_inputs_fields
from ui.dw_inputs_no_fields_pyside_ui import Ui_DockWidget as ui_inputs_no_fields
from ui.dw_widgets_pyside_ui import Ui_DockWidget as ui_widgets
from ui.dw_views_pyside_ui import Ui_DockWidget as ui_views
from ui.dw_containers_tabs_pyside_ui import Ui_DockWidget as ui_containers_tabs
from ui.dw_containers_no_tabs_pyside_ui import Ui_DockWidget as ui_containers_no_tabs
# getting style
style = qdarkstyle.load_stylesheet_pyside()
elif args.qt_from == 'pyqt':
# using PyQt4 wrapper
from PyQt4.QtGui import QApplication, QMainWindow, QDockWidget
from PyQt4.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# import examples UI according to wrapper
from ui.mw_menus_pyqt_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyqt_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyqt_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyqt_ui import Ui_DockWidget as ui_inputs_fields
from ui.dw_inputs_no_fields_pyqt_ui import Ui_DockWidget as ui_inputs_no_fields
from ui.dw_widgets_pyqt_ui import Ui_DockWidget as ui_widgets
from ui.dw_views_pyqt_ui import Ui_DockWidget as ui_views
from ui.dw_containers_tabs_pyqt_ui import Ui_DockWidget as ui_containers_tabs
from ui.dw_containers_no_tabs_pyqt_ui import Ui_DockWidget as ui_containers_no_tabs
# getting style
style = qdarkstyle.load_stylesheet_pyqt()
elif args.qt_from == 'pyqt5':
# using PyQt5 wrapper
from PyQt5.QtWidgets import QApplication, QMainWindow, QDockWidget
from PyQt5.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# import examples UI according to wrapper
from ui.mw_menus_pyqt5_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyqt5_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyqt5_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyqt5_ui import Ui_DockWidget as ui_inputs_fields
from ui.dw_inputs_no_fields_pyqt5_ui import Ui_DockWidget as ui_inputs_no_fields
from ui.dw_widgets_pyqt5_ui import Ui_DockWidget as ui_widgets
from ui.dw_views_pyqt5_ui import Ui_DockWidget as ui_views
from ui.dw_containers_tabs_pyqt5_ui import Ui_DockWidget as ui_containers_tabs
from ui.dw_containers_no_tabs_pyqt5_ui import Ui_DockWidget as ui_containers_no_tabs
# getting style
style = qdarkstyle.load_stylesheet_pyqt5()
elif args.qt_from == 'qtpy':
# using QtPy API
from qtpy.QtWidgets import QApplication, QMainWindow, QDockWidget
from qtpy.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# import examples UI according to wrapper
from ui.mw_menus_qtpy_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_qtpy_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_qtpy_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_qtpy_ui import Ui_DockWidget as ui_inputs_fields
from ui.dw_inputs_no_fields_qtpy_ui import Ui_DockWidget as ui_inputs_no_fields
from ui.dw_widgets_qtpy_ui import Ui_DockWidget as ui_widgets
from ui.dw_views_qtpy_ui import Ui_DockWidget as ui_views
from ui.dw_containers_tabs_qtpy_ui import Ui_DockWidget as ui_containers_tabs
from ui.dw_containers_no_tabs_qtpy_ui import Ui_DockWidget as ui_containers_no_tabs
# getting style
style = qdarkstyle.load_stylesheet_from_environment()
elif args.qt_from == 'pyqtgraph':
# using PyQtGraph API
from pyqtgraph.Qt.QtGui import QApplication, QMainWindow, QDockWidget
from pyqtgraph.Qt.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
#from pyqtgraph.Qt import QtGui, QtCore
# import examples UI according to wrapper
from ui.mw_menus_pyqtgraph_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyqtgraph_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyqtgraph_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyqtgraph_ui import Ui_DockWidget as ui_inputs_fields
from ui.dw_inputs_no_fields_pyqtgraph_ui import Ui_DockWidget as ui_inputs_no_fields
from ui.dw_widgets_pyqtgraph_ui import Ui_DockWidget as ui_widgets
from ui.dw_views_pyqtgraph_ui import Ui_DockWidget as ui_views
from ui.dw_containers_tabs_pyqtgraph_ui import Ui_DockWidget as ui_containers_tabs
from ui.dw_containers_no_tabs_pyqtgraph_ui import Ui_DockWidget as ui_containers_no_tabs
# getting style
style = qdarkstyle.load_stylesheet_from_environment(is_pyqtgraph=True)
if args.no_dark:
style = ''
def write_settings(window):
"""Get window settings and write it into a file."""
settings = QSettings('QDarkStyle', 'QDarkStyle Example')
settings.setValue('pos', window.pos())
settings.setValue('size', window.size())
settings.setValue('state', window.saveState())
def read_settings(window):
"""Read and set window settings from a file."""
settings = QSettings('QDarkStyle', 'QDarkStyle Example')
if args.qt_from == 'pyside':
pos = settings.value('pos', window.pos())
size = settings.value('size', window.size())
state = settings.value('state', window.saveState())
else:
pos = settings.value('pos', window.pos(), type='QPoint')
size = settings.value('size', window.size(), type='QSize')
state = settings.value('state', window.saveState(), type='QByteArray')
window.restoreState(state)
window.resize(size)
window.move(pos)
# create the application
app = QApplication(sys.argv)
app.setOrganizationName('QDarkStyle')
app.setApplicationName('QDarkStyle Example')
# setup stylesheet
app.setStyleSheet(style)
# create main window
window = QMainWindow()
window.setObjectName('mainwindow')
ui = ui_main()
ui.setupUi(window)
window.setWindowTitle("QDarkStyle v." + qdarkstyle.__version__ +
" - Example - Using " + args.qt_from)
# create docks for buttons
dw_buttons = QDockWidget()
dw_buttons.setObjectName('buttons')
ui_buttons = ui_buttons()
ui_buttons.setupUi(dw_buttons)
window.addDockWidget(Qt.RightDockWidgetArea, dw_buttons)
# create docks for buttons
dw_displays = QDockWidget()
dw_displays.setObjectName('displays')
ui_displays = ui_displays()
ui_displays.setupUi(dw_displays)
window.addDockWidget(Qt.RightDockWidgetArea, dw_displays)
# create docks for inputs - fields
dw_inputs_fields = QDockWidget()
dw_inputs_fields.setObjectName('_fields')
ui_inputs_fields = ui_inputs_fields()
ui_inputs_fields.setupUi(dw_inputs_fields)
window.addDockWidget(Qt.RightDockWidgetArea, dw_inputs_fields)
# create docks for inputs - no fields
dw_inputs_no_fields = QDockWidget()
dw_inputs_no_fields.setObjectName('inputs_no_fields')
ui_inputs_no_fields = ui_inputs_no_fields()
ui_inputs_no_fields.setupUi(dw_inputs_no_fields)
window.addDockWidget(Qt.RightDockWidgetArea, dw_inputs_no_fields)
# create docks for widgets
dw_widgets = QDockWidget()
dw_widgets.setObjectName('widgets')
ui_widgets = ui_widgets()
ui_widgets.setupUi(dw_widgets)
window.addDockWidget(Qt.LeftDockWidgetArea, dw_widgets)
# create docks for views
dw_views = QDockWidget()
dw_views.setObjectName('views')
ui_views = ui_views()
ui_views.setupUi(dw_views)
window.addDockWidget(Qt.LeftDockWidgetArea, dw_views)
# create docks for containters - tabs
dw_containers_tabs = QDockWidget()
dw_containers_tabs.setObjectName('containers')
ui_containers_tabs = ui_containers_tabs()
ui_containers_tabs.setupUi(dw_containers_tabs)
window.addDockWidget(Qt.LeftDockWidgetArea, dw_containers_tabs)
# create docks for containers - no tabs
dw_containers_no_tabs = QDockWidget()
dw_containers_no_tabs.setObjectName('containers_no_tabs')
ui_containers_no_tabs = ui_containers_no_tabs()
ui_containers_no_tabs.setupUi(dw_containers_no_tabs)
window.addDockWidget(Qt.LeftDockWidgetArea, dw_containers_no_tabs)
# tabify right docks
window.tabifyDockWidget(dw_buttons, dw_displays)
window.tabifyDockWidget(dw_displays, dw_inputs_fields)
window.tabifyDockWidget(dw_inputs_fields, dw_inputs_no_fields)
# auto quit after 2s when testing on travis-ci
if "--test" in sys.argv:
QTimer.singleShot(2000, app.exit)
# run
read_settings(window)
window.showMaximized()
app.exec_()
write_settings(window)
def __init__(self):
super().__init__()
# Determine where module is located (needed for finding ICO & PNG files)
try:
test = sys.frozen
self.rootDir = os.path.dirname(sys.executable)
except:
self.rootDir = __file__.replace("library.zip", "")
if os.path.islink(self.rootDir):
self.rootDir = os.path.realpath(self.rootDir)
self.rootDir = os.path.dirname(os.path.abspath(self.rootDir))
uifile = resource_filename(__name__, 'ui' + os.sep + 'winMain.ui')
# Create the main window and set all text so that translations are handled via gettext
Ui_winMain, base_class = uic.loadUiType(uifile)
self.winMain = QtWidgets.QMainWindow(self)
self.setWindowFlags(QtCore.Qt.Dialog)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.uiMain = Ui_winMain()
self.uiMain.setupUi(self)
# Set window style
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# Centre window on screen
self.center()
self.dragPos = self.pos()
# Sets some widgets to WA_NoMousePropagation to avoid window dragging issues
mouse_ignore_list = [self.uiMain.btnAbout, self.uiMain.btnExit, self.uiMain.btnLogin,
self.uiMain.btnMinimize, self.uiMain.btnOptions,
self.uiMain.btnSwitchGame,
self.uiMain.cboRealm, self.uiMain.chkSaveSettings]
for widget in mouse_ignore_list:
widget.setAttribute(QtCore.Qt.WA_NoMousePropagation)
# Connect signals to functions
self.uiMain.btnLogin.clicked.connect(self.btnLoginClicked)
self.uiMain.txtAccount.returnPressed.connect(self.txtAccountEnter)
self.uiMain.txtPassword.returnPressed.connect(self.txtPasswordEnter)
self.uiMain.btnExit.clicked.connect(self.close)
self.uiMain.btnMinimize.clicked.connect(self.showMinimized)
self.uiMain.btnAbout.clicked.connect(self.btnAboutSelected)
self.uiMain.btnLoginMenu = QtWidgets.QMenu()
self.uiMain.btnLoginMenu.addAction(self.uiMain.actionPatch)
self.uiMain.actionPatch.triggered.connect(self.actionPatchSelected)
self.uiMain.btnLogin.setMenu(self.uiMain.btnLoginMenu)
self.uiMain.btnOptions.setIcon(QtGui.QIcon(resource_filename(__name__,
"images" + os.sep + "SettingsGear.png")))
self.uiMain.btnOptions.clicked.connect(self.btnOptionsSelected)
self.uiMain.btnSwitchGame.clicked.connect(self.btnSwitchGameClicked)
self.uiMain.btnSwitchGameMenu = QtWidgets.QMenu()
self.uiMain.btnSwitchGameMenu.addAction(self.uiMain.actionLOTROTest)
self.uiMain.actionLOTROTest.triggered.connect(self.SwitchToLOTROTest)
self.uiMain.btnSwitchGameMenu.addAction(self.uiMain.actionDDOTest)
self.uiMain.actionDDOTest.triggered.connect(self.SwitchToDDOTest)
self.uiMain.btnSwitchGameMenu.addAction(self.uiMain.actionLOTRO)
self.uiMain.actionLOTRO.triggered.connect(self.SwitchToLOTRO)
self.uiMain.btnSwitchGameMenu.addAction(self.uiMain.actionDDO)
self.uiMain.actionDDO.triggered.connect(self.SwitchToDDO)
self.uiMain.btnSwitchGame.setMenu(self.uiMain.btnSwitchGameMenu)
#self.uiMain.actionHideWinMain.triggered.connect(self.actionHideWinMainSelected)
self.ReturnLog = self.ReturnLog
self.ReturnLog.connect(self.AddLog)
self.ReturnBaseConfig = self.ReturnBaseConfig
self.ReturnBaseConfig.connect(self.GetBaseConfig)
self.ReturnGLSDataCentre = self.ReturnGLSDataCentre
self.ReturnGLSDataCentre.connect(self.GetGLSDataCentre)
self.ReturnWorldQueueConfig = self.ReturnWorldQueueConfig
self.ReturnWorldQueueConfig.connect(self.GetWorldQueueConfig)
self.ReturnNews = self.ReturnNews
self.ReturnNews.connect(self.GetNews)
# Disable login and save settings buttons
self.uiMain.btnLogin.setEnabled(False)
self.uiMain.chkSaveSettings.setEnabled(False)
# Initialise variables
self.settings = None
self.osType = DetermineOS()
self.gameType = DetermineGame()
self.configFile = ""
self.currentGame = None
self.InitialSetup()
def test_ui(self):
app = QtWidgets.QApplication(sys.argv)
win = Ui_MainWindow_Setting()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
win.show()
sys.exit(app.exec_())
def set_stylesheet(app):
"""
sets a dark theme for all GUI elements (qdarkstyle)
"""
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
app_window.showFullScreen() # Shows the window in full screen mode
return app_window
#####################################
# Main Definition
#####################################
if __name__ == "__main__":
signal.signal(signal.SIGINT, signal.SIG_DFL
) # This allows the keyboard interrupt kill to work properly
# ########## Start the QApplication Framework ##########
application = QtWidgets.QApplication(
sys.argv) # Create the ase qt gui application
application.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# ########## Set Organization Details for QSettings ##########
QtCore.QCoreApplication.setOrganizationName("OSURC")
QtCore.QCoreApplication.setOrganizationDomain("http://osurobotics.club/")
QtCore.QCoreApplication.setApplicationName("groundstation")
# ########## Check ROS Master Status ##########
master_checker = ROSMasterChecker.ROSMasterChecker()
if not master_checker.master_present(5):
message_box = QtWidgets.QMessageBox()
message_box.setWindowTitle("Rover Ground Station")
message_box.setText(
"Connection to ROS Master Failed!!!\n" +
"Ensure ROS master is running or check for network issues.")
def init_UI(self):
self.setFixedSize(1000, 700)
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
self.vbox_left = QtWidgets.QVBoxLayout()
self.vbox_right = QtWidgets.QVBoxLayout()
self.function_features = QtWidgets.QHBoxLayout()
self.optim_features = QtWidgets.QHBoxLayout()
self.t_label = QtWidgets.QLabel("Choose a function:")
self.m_label = QtWidgets.QLabel("Choose optimisation method:")
self.c_label = QtWidgets.QLabel("Optimisation process:")
self.tol_label = QtWidgets.QLabel("Set method tolerance:")
self.stp_label = QtWidgets.QLabel("Choose starting point (comma separated):")
self.changing_panel = QtWidgets.QVBoxLayout()
self.d_label = QtWidgets.QLabel("Choose step length (Default: 1):")
self.int_label = QtWidgets.QLabel("Choose helper function interval (Default: [-5,5]):")
self.d_field = QtWidgets.QLineEdit()
self.int_field = QtWidgets.QLineEdit()
self.changing_panel.addWidget(self.d_label)
self.changing_panel.addWidget(self.d_field)
self.changing_panel.addWidget(self.int_label)
self.changing_panel.addWidget(self.int_field)
self.start_btn = QtWidgets.QPushButton("START")
self.plot_btn = QtWidgets.QPushButton("PLOT")
self.info1 = QtWidgets.QTextEdit()
self.info1.setReadOnly(True)
self.tol = QtWidgets.QLineEdit()
self.stp = QtWidgets.QLineEdit()
self.info2 = QtWidgets.QTextEdit()
self.info2.setReadOnly(True)
self.result_console = QtWidgets.QTextEdit()
self.result_console.setReadOnly(True)
self.screen_layout = QtWidgets.QHBoxLayout()
self.fun_box = QtWidgets.QComboBox()
for name in get_function_names():
self.fun_box.addItem(name)
self.get_fun_info()
self.fun_box.currentIndexChanged.connect(self.get_fun_info)
self.met_box = QtWidgets.QComboBox()
for name in get_method_names():
self.met_box.addItem(name)
self.get_met_info()
self.met_box.currentIndexChanged.connect(self.get_met_info)
self.function_features.addWidget(self.fun_box)
self.function_features.addWidget(self.plot_btn)
self.optim_features.addWidget(self.met_box)
self.optim_features.addWidget(self.start_btn)
self.vbox_left.addWidget(self.t_label)
self.vbox_left.addLayout(self.function_features)
self.vbox_left.addWidget(self.info1)
self.vbox_left.addSpacing(20)
self.vbox_left.addWidget(self.m_label)
self.vbox_left.addLayout(self.optim_features)
self.vbox_left.addWidget(self.info2)
self.vbox_left.addWidget(self.tol_label)
self.vbox_left.addWidget(self.tol)
self.vbox_left.addWidget(self.stp_label)
self.vbox_left.addWidget(self.stp)
self.vbox_left.addLayout(self.changing_panel)
self.vbox_right.addWidget(self.c_label)
self.vbox_right.addWidget(self.result_console)
self.screen_layout.addLayout(self.vbox_left)
self.screen_layout.addLayout(self.vbox_right)
self.setLayout(self.screen_layout)
self.plot_btn.clicked.connect(self.plot_function)
self.start_btn.clicked.connect(self.start_optim_process)
self.show()
