def onBindingUI(self):
###init ui default setting and connect the signals with ui
self.auto_save.setChecked(Qt.Checked)
self.auto_save.clicked.connect(self.save)
self.checkBox_1.stateChanged.connect(self.checkbox1_changed)
self.checkBox_2.stateChanged.connect(self.checkbox2_changed)
self.checkBox_3.stateChanged.connect(self.checkbox3_changed)
self.Speed_Slider.valueChanged.connect(self.change_label_speed)
self.Speed_Slider.setMaximum(120)
self.Speed_Slider.setMinimum(50)
self.btn_close.clicked.connect(self.close_the_app)
self.transparent_slider.setTickInterval(100)
self.transparent_slider.setMinimum(50)
self.transparent_slider.setMaximum(100)
self.transparent_slider.valueChanged.connect(self.change_transparent)
#
self.cbb_screen.currentIndexChanged.connect(self.set_screen_current_index)
self.btn_qrcode.clicked.connect(self.qrcode_msg_show)
self.btn_testing.clicked.connect(self.preview)
##美化 ui
self.setWindowOpacity(self.transparent_slider.value() / 100.0)
dark_stylesheet = qdarkstyle.load_stylesheet_pyside2()
self.setStyleSheet(dark_stylesheet)
self.setFixedSize(640, 600)
def main():
app = QApplication(sys.argv)
window = AssetManagerWindow()
app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
window.show()
sys.exit(app.exec_())
def main():
app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
window = BlenderUpdater()
window.setWindowTitle(f"Overmind Studios Blender Updater {appversion}")
window.statusbar.setSizeGripEnabled(False)
window.show()
app.exec_()
def set_theme(self, theme):
if theme == "dark":
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
else:
self.app.setStyleSheet("")
self.settings.set_theme(theme)
def run_cli():
app = QtWidgets.QApplication(sys.argv)
app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
font = QtGui.QFont()
win = DatabasePublisher()
win.show()
sys.exit(app.exec_())
def copy_url(self):
pyperclip.copy(self.link)
self.messagebox = QMessageBox(self)
dark_stylesheet = qdarkstyle.load_stylesheet_pyside2()
self.messagebox.setStyleSheet(dark_stylesheet)
self.messagebox.setText("The link is copyed!!!")
self.messagebox.setStandardButtons(QMessageBox.Ok)
self.messagebox.show()
def launch():
import argparse
parser = argparse.ArgumentParser(description="Visualize ASDF files.")
parser.add_argument(
"filename",
metavar="ASDF-FILE",
type=str,
help="Directly open a file.",
nargs="?",
)
args = parser.parse_args()
if args.filename and not os.path.exists(args.filename):
raise ValueError(f"'{args.filename}' does not exist.")
# Launch and open the window.
app = QtGui.QApplication(sys.argv)
# Set application name for OS - does not work on OSX but seems to work
# on others.
app.setApplicationName("ASDF Sextant")
app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
# Set the application icon
app_icon = QtGui.QIcon()
app_icon.addFile(
os.path.join(os.path.dirname(__file__), "icon.png"),
QtCore.QSize(1024, 1024),
)
app.setWindowIcon(app_icon)
window = Window()
# Move window to center of screen.
window_rect = window.frameGeometry()
window_rect.moveCenter(QDesktopWidget().availableGeometry().center())
window.move(window_rect.topLeft())
# Delayed file open to give some time for the javascript to catch up.
if args.filename:
def delayed_file_open():
time.sleep(2)
window.open_file(args.filename)
t = threading.Thread(target=delayed_file_open)
t.start()
# Show and bring window to foreground.
window.show()
app.installEventFilter(window)
window.raise_()
ret_val = app.exec_()
window.__del__()
os._exit(ret_val)
def __init__(self, parent=None):
super().__init__(parent)
self.show()
self.t_start = datetime.datetime.now().timestamp()
self.command_queue = None
self.upkeep_timer = []
try:
self.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
except:
pass
self.key_value_map = {}
def __init__(self, parent=None):
super().__init__(parent)
self.show()
self.t_start = datetime.datetime.now().timestamp()
self.command_queue = None
self.upkeep_timer = []
self.callback_list = [] # This is used to avoid garbage collection
# Registration for all widgets which need default values set
self.default_registry = []
try:
self.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
except:
pass
self.key_value_map = {}
self.subscription_callback_map = {
QtWidgets.QLineEdit: {
"set": self.update_text_field
},
QtWidgets.QBoxLayout: {
"setVec3": self.update_plot_vec3,
"setDual": self.update_plot_dual,
"setSingle": self.update_plot_single,
},
QtWidgets.QDial: {
"set": self.update_valued_widget
},
QtWidgets.QProgressBar: {
"set": self.update_valued_widget
}
}
self.widget_setup_map = {
QtWidgets.QPushButton: {
"pressed": self._setup_pressed,
"released": self._setup_released
},
QtWidgets.QSlider: {
"released": self._setup_slider_released
},
QtWidgets.QLineEdit: {
"editingFinished": self._setup_line_edit_finished
},
QtWidgets.QDial: {
"released": self._setup_dial_released
}
}
self.signal_callback_factory_map = {
"set": self._set_callback_factory,
"map": self._map_callback_factory
}
def main():
app = QApplication(sys.argv)
app.setApplicationName("Music Player")
app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
create_db()
password = login()
window = MainWindow(password)
window.setWindowTitle("Music Player")
window.show()
sys.exit(app.exec_())
def __init__(self, parent=None):
super(MyPopup, self).__init__(parent)
self.setupUi(self)
dark_stylesheet = qdarkstyle.load_stylesheet_pyside2()
self.setStyleSheet(dark_stylesheet)
self.setWindowTitle(" ")
self.link = ''
self.setWindowFlags(
Qt.WindowStaysOnTopHint |
Qt.WindowCloseButtonHint) # 隱藏 FramelessWindow
self.btn_copy.clicked.connect(self.copy_url)
self.btn_ok.clicked.connect(self.hide)
def __init__(self):
super(MainWindow, self).__init__()
self.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
self.setWindowIcon(qtg.QIcon("to-do.ico"))
uic.loadUi("modules/MainWindow.ui", self)
self.model = TodoModel()
self.load()
self.todo_view.setModel(self.model)
self.btn_add.clicked.connect(self.add)
self.btn_complete.clicked.connect(self.complete)
self.btn_delete.clicked.connect(self.delete)
self.show()
def launch(config_home=CONFIG_HOME, data_home=DATA_HOME, cache_home=CACHE_HOME, test=False):
"""
Launch the Application
Args:
config_home:
data_home:
cache_home:
test: True to use test mode, default False
"""
if test:
API.query = lambda *args, **kwargs: {}
app = App(config_home, data_home, cache_home)
if test:
QTimer.singleShot(5000, app.quit)
app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
app.main_window.show()
return app.exec_()
def __init__(self):
super().__init__()
self.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
self.resize(200, 100)
text = qtw.QLabel(f"Found new update. Download it?")
text.setFont(qtg.QFont("Corbel", 15))
btn_update = qtw.QPushButton("Update")
btn_cancel = qtw.QPushButton("Cancel")
h_layout = qtw.QHBoxLayout()
h_layout.addWidget(btn_update)
h_layout.addWidget(btn_cancel)
v_layout = qtw.QVBoxLayout()
v_layout.addWidget(text)
v_layout.addLayout(h_layout)
btn_update.clicked.connect(self.update)
btn_cancel.clicked.connect(lambda: self.close())
self.setLayout(v_layout)
self.show()
# A QCompleter helps users by giving autocompletion
self.user_line = qtw.QLineEdit()
self.users = ['harry', 'hermione', 'ron', 'hagrid']
self.completer_line = qtw.QCompleter(self.users)
self.user_line.setCompleter(self.completer_line)
self.user_line.setPlaceholderText('enter you name here..')
self.combobox = qtw.QComboBox()
self.permissions_combobox = ['r', 'w', 'rx', 'rw', 'rwx']
self.combobox.addItems(self.permissions_combobox)
self.vlayout = qtw.QVBoxLayout()
self.vlayout.addWidget(self.label)
self.vlayout.addWidget(self.user_line)
self.vlayout.addWidget(self.checkbox)
self.vlayout.addWidget(self.combobox)
self.vlayout.addSpacing(25)
self.vlayout.addWidget(self.button)
self.setLayout(self.vlayout)
app = qtw.QApplication()
# setup stylesheet
app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
panel = Panel()
panel.show()
app.exec_()
def run_maya():
win = DatabasePublisher()
win.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
win.show()
def loadQDarkStyle_lib():
# Append the QDarkStyle PySide2 stylesheet to the styles list
global styles
styles.append(Style("QDarkStyle", qdarkstyle.load_stylesheet_pyside2()))
def __init__(self):
super().__init__()
if getattr(sys, "frozen", False):
# The application is frozen
self.data_folder = os.path.dirname(sys.executable)
else:
self.data_folder = os.path.dirname(__file__)
# Set default timeout used by urllib
socket.setdefaulttimeout(6)
ui_file = QtCore.QFile(
os.path.join(self.data_folder, "ui", "winMain.ui"))
# Create the main window and set all text so that translations are handled via gettext
ui_file.open(QtCore.QFile.ReadOnly)
loader = QUiLoader()
self.winMain = loader.load(ui_file, parentWidget=self)
ui_file.close()
self.winMain.setWindowFlags(QtCore.Qt.Dialog)
self.winMain.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setFixedSize(790, 470)
# Set window style
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
# Set font size explicitly to stop OS text size options from
# breaking the UI.
font = QtGui.QFont()
font.setPointSize(10)
self.app.setFont(font)
# Temporary fix for qdarkstyle dropdown issue.
# See https://github.com/ColinDuquesnoy/QDarkStyleSheet/issues/200
self.setStyleSheet("""
QComboBox::item:checked {
height: 12px;
border: 1px solid #32414B;
margin-top: 0px;
margin-bottom: 0px;
padding: 4px;
padding-left: 0px;
}
""")
# center window on screen
self.center()
# Sets some widgets to WA_NoMousePropagation to avoid window dragging issues
mouse_ignore_list = [
self.winMain.btnAbout,
self.winMain.btnExit,
self.winMain.btnLogin,
self.winMain.btnMinimize,
self.winMain.btnOptions,
self.winMain.btnAddonManager,
self.winMain.btnSwitchGame,
self.winMain.cboWorld,
self.winMain.chkSaveSettings,
]
for widget in mouse_ignore_list:
widget.setAttribute(QtCore.Qt.WA_NoMousePropagation)
# Connect signals to functions
self.winMain.btnLogin.clicked.connect(self.btnLoginClicked)
self.winMain.cboAccount.textActivated.connect(self.cboAccountChanged)
self.winMain.txtPassword.returnPressed.connect(self.txtPasswordEnter)
self.winMain.btnExit.clicked.connect(self.close)
self.winMain.btnMinimize.clicked.connect(self.showMinimized)
self.winMain.btnAbout.clicked.connect(self.btnAboutSelected)
self.winMain.btnLoginMenu = QtWidgets.QMenu()
self.winMain.btnLoginMenu.addAction(self.winMain.actionPatch)
self.winMain.actionPatch.triggered.connect(self.actionPatchSelected)
self.winMain.btnLogin.setMenu(self.winMain.btnLoginMenu)
self.winMain.btnOptions.setIcon(
QtGui.QIcon(
os.path.join(self.data_folder, "images", "SettingsGear.png")))
self.winMain.btnOptions.clicked.connect(self.btnOptionsSelected)
self.winMain.btnAddonManager.setIcon(
QtGui.QIcon(
os.path.join(self.data_folder, "images", "AddonManager.png")))
self.winMain.btnAddonManager.clicked.connect(
self.btnAddonManagerSelected)
self.winMain.btnSwitchGame.clicked.connect(self.btnSwitchGameClicked)
self.winMain.btnSwitchGameMenu = QtWidgets.QMenu()
self.winMain.btnSwitchGameMenu.addAction(self.winMain.actionLOTROTest)
self.winMain.actionLOTROTest.triggered.connect(self.SwitchToLOTROTest)
self.winMain.btnSwitchGameMenu.addAction(self.winMain.actionDDOTest)
self.winMain.actionDDOTest.triggered.connect(self.SwitchToDDOTest)
self.winMain.btnSwitchGameMenu.addAction(self.winMain.actionLOTRO)
self.winMain.actionLOTRO.triggered.connect(self.SwitchToLOTRO)
self.winMain.btnSwitchGameMenu.addAction(self.winMain.actionDDO)
self.winMain.actionDDO.triggered.connect(self.SwitchToDDO)
self.winMain.btnSwitchGame.setMenu(self.winMain.btnSwitchGameMenu)
self.ReturnLog = self.ReturnLog
self.ReturnLog.connect(self.AddLog)
self.ReturnBaseConfig = self.ReturnBaseConfig
self.ReturnBaseConfig.connect(self.GetBaseConfig)
self.ReturnGLSDataCenter = self.ReturnGLSDataCenter
self.ReturnGLSDataCenter.connect(self.GetGLSDataCenter)
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.winMain.btnLogin.setEnabled(False)
self.winMain.chkSaveSettings.setEnabled(False)
# Initialise variables
self.settings = None
self.osType = DetermineOS()
self.gameType = DetermineGame()
self.configFile = ""
self.currentGame = None
self.configureKeyring()
self.InitialSetup(first_setup=True)
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).")
# 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 = 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 = 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 = 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 = 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 = 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 = 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, reset=False):
"""Read and set window settings from a file."""
settings = QSettings('QDarkStyle', 'QDarkStyle Example')
if args.qt_from == 'pyside' or args.qt_from == 'pyside2':
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')
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
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
qdarkstyle.information()
read_settings(window, args.reset)
window.showMaximized()
app.exec_()
write_settings(window)
self.stop()
self.setting["learning_time_ms_total"] = self.learning_time_ms_total
with open("setting.json", "w") as fp:
json.dump(self.setting, fp, indent=2)
now = self.now
cur = sqlite3.connect("history.db")
cur.execute("CREATE TABLE IF NOT EXISTS LearningTimeData("
"DayOfWeek INTEGER, "
"month INTEGER, "
"day INTEGER, "
"timestamp REAL, "
"LearningTime_ms INTEGER)")
cur.execute(
"insert into LearningTimeData Values (?,?,?,?,?)",
(now.weekday(), now.month, now.day, now.timestamp(),
self.learning_time_ms),
)
cur.commit()
cur.close()
if __name__ == "__main__":
app = QApplication(sys.argv)
style_sheet = qdarkstyle.load_stylesheet_pyside2()
app.setStyleSheet(style_sheet)
win = MainWindow()
win.show()
sys.exit(app.exec_())
