def __init__(self, number=1):
QApplication.__init__(self, sys.argv)
self.setApplicationName("SphereTest")
self.mainWindow = QMainWindow()
self.gl_widget = proPixx480_1440test()
self.mainWindow.setCentralWidget(self.gl_widget)
self.mainWindow.setGeometry(
QtGui.QDesktopWidget().availableGeometry(1))
self.mainWindow.showFullScreen()
self.curr_time = time.time()
self.timer = QTimer()
self.timer.setInterval(0)
self.timer.timeout.connect(self.gl_widget.update)
self.timer.start()
self.timer2 = QTimer()
self.timer2.setInterval(3000)
self.timer2.timeout.connect(self.printFrames)
self.timer2.start()
self.gl_widget.mode = number
self.gl_widget.mouseDoubleClickEvent = lambda x: self.mainWindow.close(
)
self.previous_time = 0
self.previous_total = 0
my_device = PROPixx()
if number is 0: # 480 Hz
my_device.setDlpSequencerProgram('QUAD4X')
else: # 1440 Hz
my_device.setDlpSequencerProgram('QUAD12X')
my_device.updateRegisterCache()
sys.exit(self.exec_()) # Start Qt main loop
def setUpClass(cls):
super(TestEditOrderPartsDocManager, cls).setUpClass()
app = QApplication.instance()
if app is None:
app = QApplication(sys.argv)
# Fix issues with combo box that gets cleared too fast
app.setEffectEnabled(Qt.UI_AnimateCombo, False)
cls.app = app
operation_definition_cache.refresh()
cls.mw = QMainWindow()
cls.mw.setMinimumSize(1024, 768)
cls.widget = EditOrderPartsWidget(None, None, False,
cls.remote_documents_service)
cls.order_overview_widget = OrderOverviewWidget(None, None, None, True)
cls.temp_dir = tempfile.TemporaryDirectory("horse_doc_mgr")
configuration.set("DocumentsDatabase", "documents_root",
cls.temp_dir.name)
cls.mw.setCentralWidget(cls.widget)
cls.mw.show()
QTest.qWaitForWindowShown(cls.mw)
cls.app.processEvents()
def setUpClass(cls):
super(TestCopyPaste, cls).setUpClass()
# operation_definition_cache.refresh()
app = QApplication.instance()
if app is None:
app = QApplication(sys.argv)
# Fix issues with combo box that gets cleared too fast
app.setEffectEnabled(Qt.UI_AnimateCombo, False)
cls.app = app
cls.mw = QMainWindow()
cls.mw.setMinimumSize(1024, 768)
cls.edit_order_widget = EditOrderPartsWidget(
None, None, True, cls.remote_documents_service)
cls.edit_order_widget._show_blank_order(cls.customer.customer_id)
# -TRACE-
cls.order_overview_widget = OrderOverviewWidget(None, None, None, True)
cls.stack = QTabWidget(None)
cls.stack.addTab(cls.edit_order_widget, "Edit order")
# -TRACE-
cls.stack.addTab(cls.order_overview_widget, "Orders overview")
cls.mw.setCentralWidget(cls.stack)
cls.mw.show()
QTest.qWaitForWindowShown(cls.mw)
cls.app.processEvents()
def __init__(self, args, continuous):
self.continuous = continuous
gobject.GObject.__init__(self)
#start by making our app
self.app = QApplication(args)
#make a window
self.window = QMainWindow()
#give the window a name
self.window.setWindowTitle("BlatherQt")
self.window.setMaximumSize(400, 200)
center = QWidget()
self.window.setCentralWidget(center)
layout = QVBoxLayout()
center.setLayout(layout)
#make a listen/stop button
self.lsbutton = QPushButton("Listen")
layout.addWidget(self.lsbutton)
#make a continuous button
self.ccheckbox = QCheckBox("Continuous Listen")
layout.addWidget(self.ccheckbox)
#connect the buttons
self.lsbutton.clicked.connect(self.lsbutton_clicked)
self.ccheckbox.clicked.connect(self.ccheckbox_clicked)
#add a label to the UI to display the last command
self.label = QLabel()
layout.addWidget(self.label)
#add the actions for quiting
quit_action = QAction(self.window)
quit_action.setShortcut('Ctrl+Q')
quit_action.triggered.connect(self.accel_quit)
self.window.addAction(quit_action)
def _init_widgets(self):
main = QMainWindow()
main.setWindowFlags(Qt.Widget)
# main.setCorner(Qt.TopLeftCorner, Qt.TopDockWidgetArea)
# main.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
pathtree = QPathTree(self, self.workspace, parent=main)
pathtree_dock = QDockWidget('PathTree', pathtree)
main.setCentralWidget(pathtree_dock)
# main.addDockWidget(Qt.BottomDockWidgetArea, pathtree_dock)
pathtree_dock.setWidget(pathtree)
simgrs_logic = self.workspace.instance.simgrs if self.workspace.instance is not None else None
simgrs = QSimulationManagers(simgrs_logic, main)
pathgroups_dock = QDockWidget('SimulationManagers', simgrs)
main.addDockWidget(Qt.RightDockWidgetArea, pathgroups_dock)
pathgroups_dock.setWidget(simgrs)
state_viewer = StateInspector(self.workspace, parent=self)
state_viewer_dock = QDockWidget('Selected State', state_viewer)
main.addDockWidget(Qt.RightDockWidgetArea, state_viewer_dock)
state_viewer_dock.setWidget(state_viewer)
self._pathtree = pathtree
self._simgrs = simgrs
self._state_viewer = state_viewer
main_layout = QHBoxLayout()
main_layout.addWidget(main)
main_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(main_layout)
def __init__(self):
self.mainwindow = QMainWindow()
settings.get_settings()
self.access = tuple(settings.access.items())
self.progress = QProgressDialog("Setting up modules...", "cancel", 0,
7, self.mainwindow)
self.progress.setWindowTitle(
QApplication.translate("MainWindow", str(settings.company), None,
QApplication.UnicodeUTF8))
def testWidget(testedWidget):
testLayout = QHBoxLayout()
testLayout.addWidget(testedWidget)
mainWidget = QWidget()
mainWidget.setLayout(testLayout)
testMainWindow = QMainWindow()
testMainWindow.setCentralWidget(mainWidget)
testMainWindow.show()
return testMainWindow
class Window_global:
mayaWin = shiboken.wrapInstance( long( maya.OpenMayaUI.MQtUtil.mainWindow() ), QWidget )
objectName = "sg_ui_setAttr"
title = "UI - Set attr"
width = 300
height = 10
infoPath = cmds.about(pd=True) + "/sg/ui_setAttrInfo.txt"
makeFile( infoPath )
mainGui = QMainWindow()
def __init__(self, renderer, title):
QApplication.__init__(self, sys.argv)
self.window = QMainWindow()
self.window.setWindowTitle(title)
self.window.resize(800, 600)
# Get OpenGL 4.1 context
glformat = QGLFormat()
glformat.setVersion(4, 1)
glformat.setProfile(QGLFormat.CoreProfile)
glformat.setDoubleBuffer(False)
self.glwidget = MyGlWidget(renderer, glformat, self)
self.window.setCentralWidget(self.glwidget)
self.window.show()
class Window_global:
mayaWin = shiboken.wrapInstance(long(maya.OpenMayaUI.MQtUtil.mainWindow()),
QWidget)
objectName = "sg_Tool_createAnimCurve"
title = "SG Tool Create AnimCurve"
width = 300
height = 10
infoPath = cmds.about(pd=True) + "/sg/sg_toolInfo/createAnimCurve.txt"
makeFile(infoPath)
mainGui = QMainWindow()
class Window_global:
mayaWin = shiboken.wrapInstance(long(maya.OpenMayaUI.MQtUtil.mainWindow()),
QWidget)
objectName = "sg_ui_enumVisibilityConnect"
title = "UI - Enum Visibility Connect"
width = 300
height = 10
infoPath = cmds.about(pd=True) + "/sg/sg_ui_enumVisibilityConnect.txt"
makeFile(infoPath)
mainGui = QMainWindow()
def doOperation():
operation = operatorStack.pop()
try:
setB = docStack.pop()
if not isinstance(setB, set):
setB = setB.documentSet
setA = docStack.pop()
if not isinstance(setA, set):
setA = setA.documentSet
docStack.push(logicFunctions[operation](setA, setB))
except StackError:
QMessageBox.information(QMainWindow(), "No items found",
"There was an error parsing your request",
QMessageBox.Ok)
def _init_widgets(self):
main = QMainWindow()
main.setWindowFlags(Qt.Widget)
# main.setCorner(Qt.TopLeftCorner, Qt.TopDockWidgetArea)
# main.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
pathtree = QPathTree(self, self.workspace, parent=main)
pathtree_dock = QDockWidget('PathTree', pathtree)
main.setCentralWidget(pathtree_dock)
# main.addDockWidget(Qt.BottomDockWidgetArea, pathtree_dock)
pathtree_dock.setWidget(pathtree)
simgrs_logic = self.workspace.instance.simgrs if self.workspace.instance is not None else None
simgrs = QSimulationManagers(simgrs_logic, main)
pathgroups_dock = QDockWidget('SimulationManagers', simgrs)
main.addDockWidget(Qt.RightDockWidgetArea, pathgroups_dock)
pathgroups_dock.setWidget(simgrs)
reg_viewer = QRegisterViewer(self)
reg_viewer_dock = QDockWidget('Register Viewer', reg_viewer)
main.addDockWidget(Qt.RightDockWidgetArea, reg_viewer_dock)
reg_viewer_dock.setWidget(reg_viewer)
mem_viewer = QMemoryViewer(self)
mem_viewer_dock = QDockWidget('Memory Viewer', mem_viewer)
main.addDockWidget(Qt.RightDockWidgetArea, mem_viewer_dock)
mem_viewer_dock.setWidget(mem_viewer)
vextemps_viewer = QVEXTempsViewer(self)
vextemps_viewer_dock = QDockWidget('VEX Temps Viewer', vextemps_viewer)
main.addDockWidget(Qt.RightDockWidgetArea, vextemps_viewer_dock)
vextemps_viewer_dock.setWidget(vextemps_viewer)
main.tabifyDockWidget(reg_viewer_dock, mem_viewer_dock)
main.tabifyDockWidget(mem_viewer_dock, vextemps_viewer_dock)
reg_viewer_dock.raise_()
self._pathtree = pathtree
self._simgrs = simgrs
self._register_viewer = reg_viewer
self._memory_viewer = mem_viewer
self._vextemps_viewer = vextemps_viewer
main_layout = QHBoxLayout()
main_layout.addWidget(main)
main_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(main_layout)
def main():
app = QApplication(sys.argv)
mainwindow = QMainWindow()
group = QGroupBox('Some options', mainwindow)
group.setLayout(QVBoxLayout(group))
mainwindow.setCentralWidget(group)
boxes = FoldableCheckBoxes(group)
for group_name, title, items in GROUPS:
boxes.addGroup(group_name, title)
for name, title in items:
boxes.addOption(group_name, name, title)
group.layout().addWidget(boxes)
mainwindow.show()
app.exec_()
def _init_workspace(self):
self.central_widget = QMainWindow()
self.setCentralWidget(self.central_widget)
wk = Workspace(self)
self.workspace = wk
right_dockable_views = [ dock for dock in self.workspace.dockable_views
if dock.widget().default_docking_position == 'right' ]
for d0, d1 in zip(right_dockable_views, right_dockable_views[1:]):
self.central_widget.tabifyDockWidget(d0, d1)
right_dockable_views[0].raise_()
self.central_widget.setTabPosition(Qt.RightDockWidgetArea, QTabWidget.North)
def main():
app = QApplication(sys.argv)
window = QMainWindow()
view = QListView(window)
window.setCentralWidget(view)
view.setViewMode(QListView.IconMode)
view.setMovement(QListView.Static)
view.setIconSize(QSize(64, 64))
view.setModel(
IconModel(
[('System', QIcon.fromTheme('preferences-system')),
('Desktop', QIcon.fromTheme('preferences-desktop-personal'))],
view))
window.show()
app.exec_()
def setUpClass(cls):
super(TestEditOrderPartsComputations, cls).setUpClass()
app = QApplication.instance()
if app is None:
app = QApplication(sys.argv)
app.setEffectEnabled(Qt.UI_AnimateCombo, False)
cls.app = app
cls.mw = QMainWindow()
cls.mw.setMinimumSize(1024, 768)
cls.widget = EditOrderPartsWidget(None, None, True,
cls.remote_documents_service)
cls.mw.setCentralWidget(cls.widget)
cls.mw.show()
QTest.qWaitForWindowShown(cls.mw)
cls.app.processEvents()
def promptDialog(self, evt=0):
mainPos = self.pos()
objectName = Window_global.objectName + "_dialog"
if cmds.window(objectName, ex=1):
cmds.deleteUI(objectName)
dialog = QMainWindow(self)
dialog.setWindowFlags(QtCore.Qt.Dialog)
dialog.setObjectName(objectName)
dialog.resize(200, 100)
dialog.move(self.addTabButton.clickedX + mainPos.x() + 10,
self.addTabButton.clickedY + mainPos.y() + 40)
dialog.show()
vWidget = QWidget(dialog)
vLayout = QVBoxLayout(vWidget)
dialog.setCentralWidget(vWidget)
hEditLayout = QHBoxLayout()
hButtonLayout = QHBoxLayout()
vLayout.addLayout(hEditLayout)
vLayout.addLayout(hButtonLayout)
textWidget = QLabel("Tab Name : ")
editWidget = QLineEdit()
hEditLayout.addWidget(textWidget)
hEditLayout.addWidget(editWidget)
okButtonWidget = QPushButton("OK")
cancelButtonWidget = QPushButton("Cancel")
hButtonLayout.addWidget(okButtonWidget)
hButtonLayout.addWidget(cancelButtonWidget)
def addTabFunc(evt=0):
self.tabWidget.addTab(editWidget.text())
dialog.deleteLater()
cancelButtonWidget.clicked.connect(dialog.deleteLater)
okButtonWidget.clicked.connect(addTabFunc)
editWidget.returnPressed.connect(addTabFunc)
def _view_server(kwargs, queue):
from PySide.QtGui import QApplication, QMainWindow, QFrame, QGridLayout
from RubikView import RubikView
# Grab the partition to view from the queue.
app = QApplication(sys.argv)
frame = QFrame()
layout = QGridLayout()
frame.setLayout(layout)
mainwindow = QMainWindow()
mainwindow.setCentralWidget(frame)
mainwindow.resize(1024, 768)
mainwindow.move(30, 30)
# Find next highest square number and fill within that shape
partitions = queue.get()
side = math.ceil(math.sqrt(len(partitions)))
aspect = (side, side)
views = []
for i, partition in enumerate(partitions):
rview = RubikView(mainwindow)
if "renderer" in kwargs:
rview.set_face_renderer(kwargs["renderer"])
else:
rview.set_face_renderer(colored_face_renderer(**kwargs))
rview.set_partition(partition)
r, c = np.unravel_index(i, aspect)
layout.addWidget(rview, r, c)
views.append(rview)
mainwindow.show()
mainwindow.raise_()
rotation = kwargs.get("rotation", (45, 3, 3, 1))
for rview in views:
rview.set_rotation_quaternion(*rotation)
app.exec_()
def _init_widgets(self):
main = QMainWindow()
main.setWindowFlags(Qt.Widget)
# main.setCorner(Qt.TopLeftCorner, Qt.TopDockWidgetArea)
# main.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
pathtree = QPathTree(self, main)
pathtree_dock = QDockWidget('PathTree', pathtree)
main.setCentralWidget(pathtree_dock)
# main.addDockWidget(Qt.BottomDockWidgetArea, pathtree_dock)
pathtree_dock.setWidget(pathtree)
pathgroups_logic = self.workspace.instance.path_groups if self.workspace.instance is not None else None
pathgroups = QPathGroups(pathgroups_logic, main)
pathgroups_dock = QDockWidget('PathGroups', pathgroups)
main.addDockWidget(Qt.RightDockWidgetArea, pathgroups_dock)
pathgroups_dock.setWidget(pathgroups)
reg_viewer = QRegisterViewer(self)
reg_viewer_dock = QDockWidget('Register Viewer', reg_viewer)
main.addDockWidget(Qt.RightDockWidgetArea, reg_viewer_dock)
reg_viewer_dock.setWidget(reg_viewer)
mem_viewer = QMemoryViewer(self)
mem_viewer_dock = QDockWidget('Memory Viewer', mem_viewer)
main.addDockWidget(Qt.RightDockWidgetArea, mem_viewer_dock)
mem_viewer_dock.setWidget(mem_viewer)
main.tabifyDockWidget(reg_viewer_dock, mem_viewer_dock)
self._pathtree = pathtree
self._pathgroups = pathgroups
self._register_viewer = reg_viewer
self._memory_viewer = mem_viewer
main_layout = QHBoxLayout()
main_layout.addWidget(main)
main_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(main_layout)
def setUpClass(cls):
super(TestEditOrderParts, cls).setUpClass()
app = QApplication.instance()
if app is None:
app = QApplication(sys.argv)
# Fix issues with combo box that gets cleared too fast
app.setEffectEnabled(Qt.UI_AnimateCombo, False)
cls.app = app
operation_definition_cache.refresh()
cls.mw = QMainWindow()
cls.mw.setMinimumSize(1024, 768)
cls.widget = EditOrderPartsWidget(None, None, True,
cls.remote_documents_service)
cls.order_overview_widget = OrderOverviewWidget(None, None, None, True)
cls.mw.setCentralWidget(cls.widget)
cls.mw.show()
QTest.qWaitForWindowShown(cls.mw)
cls.app.processEvents()
def setUpClass(cls):
super(TestOrderOverview, cls).setUpClass()
app = QApplication.instance()
if app is None:
app = QApplication(sys.argv)
# Fix issues with combo box that gets cleared too fast
app.setEffectEnabled(Qt.UI_AnimateCombo, False)
cls.app = app
cls.mw = QMainWindow()
cls.mw.setMinimumSize(1024, 768)
cls.order_overview_widget = OrderOverviewWidget(None, None, None, True)
cls.mw.setCentralWidget(cls.order_overview_widget)
cls.mw.show()
# This is a big hack to select the "in production" order parts filter
# on the overview. Without that, the "completed" order parts filter
# is applied and no order parts gets shown :-(
cls.order_overview_widget.persistent_filter.get_filters_combo(
).setCurrentIndex(1)
QTest.qWaitForWindowShown(cls.mw)
cls.app.processEvents()
def create_main_window(self, version):
"""
Creates the main application window and returns it.
:param version: The application's version number, found in the project root-level __init__.py
:return:
"""
window = QMainWindow()
window.setMinimumSize(800, 600)
window.setWindowTitle("dataNexus v" + version)
# Create the menu for main window.
menu = window.menuBar()
sub_menus = Menu(menu, window)
sub_menus.create_file_menu()
sub_menus.create_edit_menu()
sub_menus.create_about_menu()
window.show()
self.app.exec_()
class Window_global:
mayaWin = shiboken.wrapInstance(long(maya.OpenMayaUI.MQtUtil.mainWindow()),
QWidget)
title = "Put Object On Ground"
width = 300
height = 300
infoPath = cmds.about(pd=True) + "/sg/putObjectOnGround/uiInfo.txt"
makeFile(infoPath)
mainGui = QMainWindow()
listItems = []
objectName = 'sgui_putObjectOnGround'
listWidgetPutName = objectName + "_listPut"
listWidgetGroundName = objectName + "_listGround"
randomOptionRotName = objectName + "_randomRot"
randomOptionScaleName = objectName + "_randomScale"
randomOptionRotAName = objectName + "_randomRotAll"
randomOptionScaleAName = objectName + "_randomScaleAll"
offsetByObjectName = objectName + '_offsetObject'
offsetByGroundName = objectName + '_offsetGround'
checkNormalOrientName = objectName + '_checkNormalOrient'
orientEditModeName = objectName + '_orientEditMode'
duGroupListName = objectName + '_duGroupList'
componentCheckName = objectName + '_componentCheck'
@staticmethod
def saveInfo2(filePath=None):
if not filePath:
filePath = Window_global.infoPath2
rotateChecked = ''
'''
f = open( filePath, "w" )
json.dump( , f, True, False, False )
f.close()
'''
@staticmethod
def loadInfo2(filePath=None):
if not filePath:
filePath = Window_global.infoPath2
f = open(filePath, 'r')
try:
data = json.load(f)
except:
f.close()
return None
f.close()
@staticmethod
def saveInfo(filePath=None):
if not filePath:
filePath = Window_global.infoPath
posX = Window_global.mainGui.pos().x()
posY = Window_global.mainGui.pos().y()
width = Window_global.mainGui.width()
height = Window_global.mainGui.height()
f = open(filePath, "w")
json.dump([posX, posY, width, height], f, True, False, False)
f.close()
@staticmethod
def loadInfo(filePath=None):
if not filePath:
filePath = Window_global.infoPath
f = open(filePath, 'r')
try:
data = json.load(f)
except:
f.close()
return None
f.close()
if not data: return None
try:
posX = data[0]
posY = data[1]
width = data[2]
height = data[3]
Window_global.mainGui.resize(width, height)
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0: posX = 0
if posY < 0: posY = 0
Window_global.mainGui.move(posX, posY)
except:
pass
#@pyqtSlot() # PySide use another name "QtCore.Slot()"
def insertRow(self):
nRows = self.tableWidget.rowCount()
self.tableWidget.insertRow(nRows) # inset one row at the end
kitem = QTableWidgetItem("") # also set flags and state, type
vitem = QTableWidgetItem("")
self.tableWidget.setItem(nRows, 0, kitem)
#print(nRows, self.tableWidget.item(nRows, 0))
self.tableWidget.setItem(nRows, 1, vitem)
def clearDict(self):
self.tableWidget.clearContents() # keep the header, clear all items
def printDict(self):
print(self.dict())
def loadDefault(self):
pass
#############################################
_test_bc = {'U': {"key": "value"}, 'p': {"key": "value"}}
if __name__ == '__main__':
app = QApplication(sys.argv)
#ex = App()
mw = QMainWindow()
mw.setWindowTitle('PyQt FoamBoundaryWidget test')
mw.setCentralWidget(FoamBoundaryWidget(_test_bc))
mw.show()
sys.exit(app.exec_())
def main():
"""Execute QDarkStyle example."""
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
'--qt_from',
default='qtpy',
choices=['pyqt', 'pyqt5', 'pyside', 'pyside2', '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.")
parser.add_argument('--reset',
action='store_true',
help="Reset GUI settings (position, size).")
parser.add_argument('--screenshots',
action='store_true',
help="Generate screenshots.")
# parsing arguments from command line
args = parser.parse_args()
# set log for debug
logging.basicConfig(level=logging.DEBUG)
# to avoid problems when testing without screen
if args.test:
os.environ['QT_QPA_PLATFORM'] = 'offscreen'
if args.qt_from == 'pyside':
# using PySide wrapper
from PySide.QtGui import QApplication, QMainWindow, QDockWidget, QStatusBar, QLabel, QPushButton
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_method = qdarkstyle.load_stylesheet_pyside
elif args.qt_from == 'pyqt':
# using PyQt4 wrapper
from PyQt4.QtGui import QApplication, QMainWindow, QDockWidget, QStatusBar, QLabel, QPushButton
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_method = qdarkstyle.load_stylesheet_pyqt
elif args.qt_from == 'pyqt5':
# using PyQt5 wrapper
from PyQt5.QtWidgets import QApplication, QMainWindow, QDockWidget, QStatusBar, QLabel, QPushButton
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_method = qdarkstyle.load_stylesheet_pyqt5
elif args.qt_from == 'pyside2':
# using PyQt5 wrapper
from PySide2.QtWidgets import QApplication, QMainWindow, QDockWidget, QStatusBar, QLabel, QPushButton
from PySide2.QtCore import QTimer, Qt, QSettings, QByteArray, QPoint, QSize
# import examples UI according to wrapper
from ui.mw_menus_pyside2_ui import Ui_MainWindow as ui_main
from ui.dw_buttons_pyside2_ui import Ui_DockWidget as ui_buttons
from ui.dw_displays_pyside2_ui import Ui_DockWidget as ui_displays
from ui.dw_inputs_fields_pyside2_ui import Ui_DockWidget as ui_inputs_fields
from ui.dw_inputs_no_fields_pyside2_ui import Ui_DockWidget as ui_inputs_no_fields
from ui.dw_widgets_pyside2_ui import Ui_DockWidget as ui_widgets
from ui.dw_views_pyside2_ui import Ui_DockWidget as ui_views
from ui.dw_containers_tabs_pyside2_ui import Ui_DockWidget as ui_containers_tabs
from ui.dw_containers_no_tabs_pyside2_ui import Ui_DockWidget as ui_containers_no_tabs
# Getting style
style_method = qdarkstyle.load_stylesheet_pyside2
elif args.qt_from == 'qtpy':
# using QtPy API
from qtpy.QtWidgets import QApplication, QMainWindow, QDockWidget, QStatusBar, QLabel, QPushButton
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_method = qdarkstyle.load_stylesheet_from_environment
elif args.qt_from == 'pyqtgraph':
# using PyQtGraph API
from pyqtgraph.Qt.QtGui import QApplication, QMainWindow, QDockWidget, QStatusBar, QLabel, QPushButton
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_method = lambda: qdarkstyle.load_stylesheet_from_environment(
is_pyqtgraph=True)
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, reset=False):
"""Read and set window settings from a file."""
settings = QSettings('QDarkStyle', 'QDarkStyle Example')
try:
pos = settings.value('pos', window.pos())
size = settings.value('size', window.size())
state = settings.value('state', window.saveState())
except Exception:
pos = settings.value('pos', window.pos(), type='QPoint')
size = settings.value('size', window.size(), type='QSize')
state = settings.value('state',
window.saveState(),
type='QByteArray')
if not reset:
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
style = ''
if args.no_dark is False:
style = style_method()
app.setStyleSheet(style)
# create main window
window = QMainWindow()
window.setObjectName('mainwindow')
ui = ui_main()
ui.setupUi(window)
window.setWindowTitle("QDarkStyle v." + qdarkstyle.__version__)
# 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 - 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 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 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 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)
# 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)
# 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)
# tabify right docks
window.tabifyDockWidget(dw_containers_no_tabs, dw_containers_tabs)
window.tabifyDockWidget(dw_containers_tabs, dw_widgets)
window.tabifyDockWidget(dw_widgets, dw_views)
# issues #9120, #9121 on Spyder
qstatusbar = QStatusBar()
qstatusbar.addWidget(
QLabel('Issue Spyder #9120, #9121 - background not matching.'))
qstatusbar.addWidget(QPushButton('OK'))
window.setStatusBar(qstatusbar)
# auto quit after 2s when testing on travis-ci
if args.test:
QTimer.singleShot(2000, app.exit)
# run
read_settings(window, args.reset)
window.showMaximized()
# Save screenshots for differents displays and quit
if args.screenshots:
window.showFullScreen()
QTimer.singleShot(
1000, lambda: create_screenshots(app, window, not args.no_dark))
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 testBug(self):
app = QApplication(sys.argv)
window = QMainWindow()
l = window.layout()
self.assert_(isinstance(l, QLayout))
def heightForWidth(self, width):
count = len(self.letters)
heightOne = self.fontMetrics().height()
widthAll = self.fontMetrics().width(self.letters) * H_GAP_PC
if widthAll > width: # Needs to be vertical
return heightOne * count
return heightOne * V_GAP_PC # Needs to be horizontal
def onTimeout(self):
self.timer.stop()
if self.word is not None:
self.word = None
self.update()
if __name__ == "__main__":
app = QApplication([])
win = QMainWindow()
def clickedBar(x):
print(("clicked", x))
bar = Bar()
bar.clicked.connect(clickedBar)
tb = win.addToolBar("Tools")
tb.addWidget(bar)
tb.setFloatable(False)
tb.orientationChanged.connect(bar.setOrientation)
win.show()
app.exec_()
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
