def main():
app = QtGui.QApplication(sys.argv)
app.setWindowIcon(
QtGui.QIcon(constants.DIR_ICON + constants.ICON_LOGO_SMALL))
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
main_win = MainWindow()
sys.exit(app.exec_())
def __init__(self, parent=None):
super(opt_dialog, self).__init__(parent)
self.resize(800, 400)
self.myQWidget = QtGui.QWidget()
self.setCentralWidget(self.myQWidget)
self.hly = QtGui.QVBoxLayout()
self.myQWidget.setLayout(self.hly)
self.opt_txt = QtGui.QTextEdit(self)
self.opt_txt.setMinimumSize(QtCore.QSize(350, 600))
self.opt_txt.setLineWrapMode(QtGui.QTextEdit.NoWrap)
self.opt_txt.setOverwriteMode(False)
self.opt_txt.setObjectName("opt_txt")
self.hly.addWidget(self.opt_txt)
self.clbtn = QtGui.QPushButton('clear contents', self)
self.hly.addWidget(self.clbtn)
self.clbtn.clicked.connect(self.opt_txt.clear)
self.setWindowTitle('command output')
self.move(10, 10)
# self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
def main():
# install exception hook: without this, uncaught exception would cause
# application to exit
# sys.excepthook = trap_exc_during_debug
app = QtGui.QApplication(sys.argv)
app.setWindowIcon(
QtGui.QIcon(constants.DIR_ICON + constants.ICON_LOGO_SMALL))
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
main_win = MainWindow()
sys.exit(app.exec_())
def main( info = False, doLocal = True, verify = True ):
app = QApplication([])
app.setStyleSheet( qdarkstyle.load_stylesheet_pyqt( ) )
icn = QIcon( os.path.join( mainDir, 'resources', 'icons', 'plex_tvdb_gui.png' ) )
app.setWindowIcon( icn )
if info: logging.basicConfig( level = logging.INFO )
fullURL, token = plexcore.checkServerCredentials(
doLocal = doLocal, verify = verify )
tvdb_gui = TVDBGUI( token, fullURL, verify = verify )
result = app.exec_( )
return tvdb_gui
def changeDarkTheme(self, newValue=None):
if newValue is None:
newValue = self.darkThemeAction.isChecked()
self.hide()
if newValue:
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
else:
self.setStyleSheet("")
self.show()
def main(info=False):
imgur_credentials = plexcore.get_imgurl_credentials()
clientID = imgur_credentials['clientID']
clientSECRET = imgur_credentials['clientSECRET']
app = QApplication([])
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
logger = logging.getLogger()
if info: logger.setLevel(logging.INFO)
ioauth2dlg = plexcore_gui.ImgurOauth2Dialog(None, clientID, clientSECRET)
ioauth2dlg.show()
app.exec_()
def main():
# create the application and the main window
app = QtWidgets.QApplication(sys.argv)
window =
# setup stylesheet
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
# run
window.show()
window.run()
app.exec_()
def main( info = False, doLocal = True, verify = True ):
app = QApplication([])
app.setStyleSheet( qdarkstyle.load_stylesheet_pyqt( ) )
icn = QIcon( os.path.join(
mainDir, 'resources', 'icons', 'plex_config_gui.png' ) )
app.setWindowIcon( icn )
pcgui = plexcore_gui.PlexConfigGUI( verify = verify )
pcgui.setStyleSheet("""
QWidget {
font-family: Consolas;
font-size: 11;
}""" )
pcgui.show( )
result = pcgui.exec_( )
def main(info = False, doLocal = True, doLarge = False, verify = True):
app = returnQAppWithFonts( )
app.setStyleSheet( qdarkstyle.load_stylesheet_pyqt( ) )
icn = QIcon( os.path.join(
mainDir, 'resources', 'icons', 'plex_tmdb_totgui.png' ) )
app.setWindowIcon( icn )
logger = logging.getLogger( )
if info: logger.setLevel( logging.INFO )
fullurl, token = plexcore.checkServerCredentials(
doLocal = doLocal, verify = verify )
tmdb_mygui = plextmdb_totgui.TMDBTotGUI(
fullurl, token, doLarge = doLarge, verify = verify )
result = app.exec_( )
return tmdb_mygui
def main(info=False, doLocal=True, verify=True):
testDir = os.path.expanduser('~/.config/plexstuff/tests')
app = QApplication([])
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
if info: logging.basicConfig(level=logging.INFO)
fullurl, token = plexcore.checkServerCredentials(doLocal=doLocal,
verify=verify)
movie_data_rows = pickle.load(
gzip.open(os.path.join(testDir, 'movie_data_rows.pkl.gz'), 'rb'))
tmdbgui = plextmdb_gui.TMDBGUI(token,
fullurl,
movie_data_rows,
verify=verify)
result = app.exec_()
def initUI(self):
self.resize(800, 400)
lyt = QtGui.QVBoxLayout()
self.opt = QtGui.QTextEdit()
self.runbt = QtGui.QPushButton('Run')
self.runbt.clicked.connect(self.callProgram)
lyt.addWidget(self.opt)
lyt.addWidget(self.runbt)
centralWidget = QtGui.QWidget()
centralWidget.setLayout(lyt)
self.setCentralWidget(centralWidget)
self.process = QtCore.QProcess(self)
self.process.readyRead.connect(self.dataReady)
# self.process.start.connect()
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
self.move(100, 100)
def main(info=False,
doLocal=True,
doLarge=False,
verify=True,
onlyEmail=False):
app = QApplication([])
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
icn = QIcon(
os.path.join(mainDir, 'resources', 'icons', 'plex_email_gui.png'))
app.setWindowIcon(icn)
logger = logging.getLogger()
if info: logger.setLevel(logging.INFO)
_, token = returnToken(doLocal=doLocal,
verify=verify,
checkWorkingServer=False)
val = returnGoogleAuthentication()
if not opts.do_onlyemail:
pegui = PlexEmailGUI(token, doLocal=doLocal, doLarge=doLarge)
else:
pegui = PlexEmailMyGUI(token, doLarge=doLarge, verify=verify)
result = app.exec_()
def main(info=False, doLocal=True, verify=True, thingToShow='CRED'):
app = QApplication([])
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
if info: logging.basicConfig(level=logging.INFO)
if thingToShow == 'CRED':
widg = plexcore_gui.PlexConfigCredWidget(None, verify=verify)
elif thingToShow == 'LOGIN':
widg = plexcore_gui.PlexConfigLoginWidget(None, verify=verify)
elif thingToShow == 'MUSIC':
widg = plexcore_gui.PlexConfigMusicWidget(None, verify=verify)
elif thingToShow == 'TOTAL':
widg = plexcore_gui.PlexConfigGUI(verify=verify)
else:
raise ValueError("Error: %s needs to be one of %s." %
(thingToShow, scenarios))
widg.setStyleSheet("""
QWidget {
font-family: Consolas;
font-size: 11;
}""")
widg.show()
result = widg.exec_()
def __init__(self):
super(SelfieApplication, self).__init__(['selfieApp'])
self.parser = self.Parser()
self.setWindowIcon(QIcon('logo.png'))
self.lightStyle = self.styleSheet()
self.darkStyle = load_stylesheet_pyqt()
self.gui = self.Gui()
self.parser.parseSignal.connect(self.gui.createCentralWidget)
self.gui.changeModeSignal.connect(self.changeStyleSheet)
self.connection = self.Connection()
self.gui.connectButton.clicked.connect(self.connection.startConnecting)
self.gui.disconnectButton.clicked.connect(
self.connection.startDisconnecting)
self.connection.connected.connect(self.gui.statusBar.setConnected)
self.connection.disconnected.connect(
self.gui.statusBar.setDisconnected)
self.connection.connectionFailure.connect(self.Gui.WarningBox)
self.connection.connected.connect(self.connection.startCommunication)
self.gui.valueChanged.connect(self.connection.transmitSlot)
self.gui.types.connect(self.connection.getTypes)
self.parser.prse()
self.connection.messageReceived.connect(self.gui.sensorSlot)
self.gui.emptyTrigger.connect(self.connection.emptyTransmitSlot)
sys.exit(self.exec_())
deepData=str(sys.exc_info()))
def logClose():
app.quit()
lg.write('Terminating Session...')
lg.close()
import atexit
atexit.register(logClose)
if __name__ == '__main__':
#def begin():
app = QtGui.QApplication(sys.argv)
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
try:
lg = logger.log('yield')
lg.write('Logging session begin...', deepData='begin_')
except:
print('Logger failure...')
sys.exit()
#Create Base Windows
try:
yieldW = YieldWindow()
lg.write('YieldWindow initialized...')
except:
lg.write('YieldWindow error...')
try:
def Main():
app = QtGui.QApplication(sys.argv)
interface = LeapInterface()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
app.exec_()
def __init__(self, args):
super(Application, self).__init__(args)
# Set up paths
chatLogDirectory = ""
if len(sys.argv) > 1:
chatLogDirectory = sys.argv[1]
if not os.path.exists(chatLogDirectory):
if sys.platform.startswith("darwin"):
chatLogDirectory = os.path.join(os.path.expanduser("~"),
"Documents", "EVE", "logs",
"Chatlogs")
if not os.path.exists(chatLogDirectory):
chatLogDirectory = os.path.join(os.path.expanduser("~"),
"Library",
"Application Support",
"Eve Online", "p_drive",
"User", "My Documents",
"EVE", "logs", "Chatlogs")
elif sys.platform.startswith("linux"):
chatLogDirectory = os.path.join(os.path.expanduser("~"), "EVE",
"logs", "Chatlogs")
elif sys.platform.startswith("win32") or sys.platform.startswith(
"cygwin"):
import ctypes.wintypes
buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH)
ctypes.windll.shell32.SHGetFolderPathW(0, 5, 0, 0, buf)
documentsPath = buf.value
chatLogDirectory = os.path.join(documentsPath, "EVE", "logs",
"Chatlogs")
if not os.path.exists(chatLogDirectory):
# None of the paths for logs exist, bailing out
QMessageBox.critical(None, "No path to Logs",
"No logs found at: " + chatLogDirectory,
"Quit")
sys.exit(1)
# Setting local directory for cache and logging
vintelDirectory = os.path.join(
os.path.dirname(os.path.dirname(chatLogDirectory)), "vintel")
if not os.path.exists(vintelDirectory):
os.mkdir(vintelDirectory)
cache.Cache.PATH_TO_CACHE = os.path.join(vintelDirectory,
"cache-2.sqlite3")
vintelLogDirectory = os.path.join(vintelDirectory, "logs")
if not os.path.exists(vintelLogDirectory):
os.mkdir(vintelLogDirectory)
splash = QtGui.QSplashScreen(
QtGui.QPixmap(resourcePath("vi/ui/res/logo.png")))
vintelCache = Cache()
logLevel = vintelCache.getFromCache("logging_level")
if not logLevel:
logLevel = logging.WARN
dark_mode = vintelCache.getFromCache("dark_mode")
if dark_mode:
self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
splash.show()
self.processEvents()
# Setup logging for console and rotated log files
formatter = logging.Formatter('%(asctime)s| %(message)s',
datefmt='%m/%d %I:%M:%S')
rootLogger = logging.getLogger()
rootLogger.setLevel(level=logLevel)
logFilename = vintelLogDirectory + "/output.log"
fileHandler = RotatingFileHandler(maxBytes=(1048576 * 5),
backupCount=7,
filename=logFilename,
mode='a')
fileHandler.setFormatter(formatter)
rootLogger.addHandler(fileHandler)
consoleHandler = StreamHandler()
consoleHandler.setFormatter(formatter)
rootLogger.addHandler(consoleHandler)
logging.critical("")
logging.critical(
"------------------- Vintel %s starting up -------------------",
version.VERSION)
logging.critical("")
logging.debug("Looking for chat logs at: %s", chatLogDirectory)
logging.debug("Cache maintained here: %s", cache.Cache.PATH_TO_CACHE)
logging.debug("Writing logs to: %s", vintelLogDirectory)
trayIcon = systemtray.TrayIcon(self)
trayIcon.show()
self.mainWindow = viui.MainWindow(chatLogDirectory, trayIcon)
self.mainWindow.show()
self.mainWindow.raise_()
splash.finish(self.mainWindow)
self.reset()
elif key == QtCore.Qt.Key_Backspace:
self.backspace_line_edit()
def backspace_line_edit(self):
init = self.ui.lineEdit.text()
self.ui.lineEdit.setText(init[:-1])
def render_answer(self):
input_equation = self.ui.lineEdit.text()
init_output = self.ui.output_window.toPlainText()
try:
answer = eval(input_equation)
self.ui.output_window.setText(input_equation + " = " +
str(answer) + "\n" + init_output)
except Exception:
self.ui.statusbar.showMessage("Math Error!")
self.clear()
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyApp()
dark_style = qdarkstyle.load_stylesheet_pyqt()
myapp.setStyleSheet(dark_style)
myapp.show()
sys.exit(app.exec_())
def plot3d(self):
self.app = QtGui.QApplication(sys.argv)
self.win = QtGui.QMainWindow()
self.area = DockArea()
self.win.setCentralWidget(self.area)
self.win.resize(800, 450)
self.dark_stylesheet = qdarkstyle.load_stylesheet_pyqt()
self.app.setStyleSheet(self.dark_stylesheet)
self.d1 = Dock("Forward Kinematics", size=(200, 200))
self.d2 = Dock("3D Plot", size=(800, 800))
self.d3 = Dock("Inverse Kinematics", size=(200, 200))
self.area.addDock(self.d1, 'left')
self.area.addDock(self.d2, 'right')
self.area.addDock(self.d3, 'bottom', self.d1)
self.newfont = QtGui.QFont("Helvetica", 12, QtGui.QFont.Bold)
self.w1 = pg.LayoutWidget()
self.saveBtn = QtGui.QPushButton('Forward')
self.label_theta1_ = QtGui.QLabel("Theta 1")
self.label_theta1_.setFont(self.newfont)
self.label_theta2_ = QtGui.QLabel("Theta 2")
self.label_theta2_.setFont(self.newfont)
self.label_theta3_ = QtGui.QLabel("Theta 3")
self.label_theta3_.setFont(self.newfont)
self.theta1_ = QLineEdit()
self.theta2_ = QLineEdit()
self.theta3_ = QLineEdit()
self.w1.addWidget(self.label_theta1_, row=0, col=0)
self.w1.addWidget(self.theta1_, row=0, col=1)
self.w1.addWidget(self.label_theta2_, row=1, col=0)
self.w1.addWidget(self.theta2_, row=1, col=1)
self.w1.addWidget(self.label_theta3_, row=2, col=0)
self.w1.addWidget(self.theta3_, row=2, col=1)
self.w1.addWidget(self.saveBtn, row=3, col=1)
self.saveBtn.clicked.connect(self.capture_angles)
self.d1.addWidget(self.w1)
self.w3 = pg.LayoutWidget()
self.saveBtn = QtGui.QPushButton('Inverse')
self.label_x = QtGui.QLabel("X Value")
self.label_x.setFont(self.newfont)
self.label_y = QtGui.QLabel("Y Value")
self.label_y.setFont(self.newfont)
self.label_z = QtGui.QLabel("Z Value")
self.label_z.setFont(self.newfont)
self.x_ = QLineEdit()
self.y_ = QLineEdit()
self.z_ = QLineEdit()
self.w3.addWidget(self.label_x, row=0, col=0)
self.w3.addWidget(self.x_, row=0, col=1)
self.w3.addWidget(self.label_y, row=1, col=0)
self.w3.addWidget(self.y_, row=1, col=1)
self.w3.addWidget(self.label_z, row=2, col=0)
self.w3.addWidget(self.z_, row=2, col=1)
self.w3.addWidget(self.saveBtn, row=3, col=1)
self.saveBtn.clicked.connect(self.IK)
self.d3.addWidget(self.w3)
self.w2 = gl.GLViewWidget()
# self.w2.orbit(-135,0)
self.w2.orbit(45, 0)
self.w2.pan(0, -100, 0)
# create the background grids
# gx = gl.GLGridItem()
# gx.rotate(90, 0, 1, 0)
# self.w2.addItem(gx)
# gy = gl.GLGridItem()
# gy.rotate(90, 1, 0, 0)
# self.w2.addItem(gy)
gz = gl.GLGridItem()
gz.setSize(200, 200, 200)
gz.setSpacing(10, 10, 10)
self.w2.addItem(gz)
self.plt = gl.GLLinePlotItem(pos=np.array(
[self.O[0, :], self.O[1, :], self.O[2, :]]).transpose(),
width=3,
color=pg.glColor('w'))
self.w2.opts['distance'] = 600
for i in range(0, self.size + 1):
self.pltx[i] = gl.GLLinePlotItem(pos=np.array(
[self.O[:, i], self.X[:, i]]),
width=3,
color=pg.glColor('r'))
self.plty[i] = gl.GLLinePlotItem(pos=np.array(
[self.O[:, i], self.Y[:, i]]),
width=3,
color=pg.glColor('g'))
self.pltz[i] = gl.GLLinePlotItem(pos=np.array(
[self.O[:, i], self.Z[:, i]]),
width=3,
color=pg.glColor('b'))
self.w2.addItem(self.pltx[i])
self.w2.addItem(self.plty[i])
self.w2.addItem(self.pltz[i])
self.w2.addItem(self.plt)
self.pos = [self.O[0, -1], self.O[1, -1], self.O[2, -1]]
self.pos_pt = gl.GLScatterPlotItem(pos=np.array(self.pos),
size=0,
color=pg.glColor('y'))
self.w2.addItem(self.pos_pt)
self.d2.addWidget(self.w2)
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(20)
self.win.show()
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
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 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 get_main_window_app(qt_from='pyqt', no_dark=True):
"""Return main window application."""
# set log for debug
logging.basicConfig(level=logging.DEBUG)
style = ''
if qt_from == 'pyside':
# using PySide wrapper
from PySide.QtGui import QApplication, QMainWindow, QDockWidget
from PySide.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# getting style
style = qdarkstyle.load_stylesheet_pyside()
elif qt_from == 'pyqt':
# using PyQt4 wrapper
from PyQt4.QtGui import QApplication, QMainWindow, QDockWidget
from PyQt4.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# getting style
style = qdarkstyle.load_stylesheet_pyqt()
elif qt_from == 'pyqt5':
# using PyQt5 wrapper
from PyQt5.QtWidgets import QApplication, QMainWindow, QDockWidget
from PyQt5.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# getting style
style = qdarkstyle.load_stylesheet_pyqt5()
elif qt_from == 'qtpy':
# using QtPy API
from qtpy.QtWidgets import QApplication, QMainWindow, QDockWidget
from qtpy.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# getting style
style = qdarkstyle.load_stylesheet_from_environment()
elif qt_from == 'pyqtgraph':
# using PyQtGraph API
from pyqtgraph.Qt import QtGui, QtCore
# getting style
style = qdarkstyle.load_stylesheet_from_environment(is_pyqtgraph=True)
if no_dark:
style = ''
# create the application
app = QApplication(sys.argv)
app.setOrganizationName('QDarkStyle')
app.setApplicationName('QDarkStyle Test')
# setup stylesheet
app.setStyleSheet(style)
# create main window
window = QMainWindow()
window.setWindowTitle("QDarkStyle v." + qdarkstyle.__version__ +
" - TEST - Using " + qt_from)
# auto quit after 2s when testing on travis-ci
if "--test" in sys.argv:
QTimer.singleShot(2000, app.exit)
# run
window.showMaximized()
app.exec_()
return window
def get_app():
app = QApplication([])
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
yield app
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 switch_to_dark(self, checked):
if checked:
app = QtGui.QApplication.instance()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
def close_app(self):
print 'Closing application'
for dev in self.Window.Devices:
dev.IsKilled = True
end(2)
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument('--config', '-c', help='Config file', default='keithley.cfg')
parser.add_argument('--restart', '-R', action='store_true', help='restart hv devices (turn all OFF and set voltage to 0)')
parser.add_argument('--start_time', '-s', nargs='?', help='set start time', default='now')
parser.add_argument('--from_logs', '-l', action='store_true', help='read data from logs')
args = parser.parse_args()
config = ConfigParser()
config.read(join(dirname(realpath(__file__)), 'config', args.config))
start_time = None if args.start_time == 'now' else args.start_time
devices = get_devices(config, not args.restart, print_logs=True) if not args.from_logs else get_logging_devices(config, start_time)
# devices = get_dummies(config)
app = QApplication(['5'])
filterwarnings('ignore')
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt())
g = Gui(devices, args.from_logs)
end(app.exec_())
