def __init__(self, *args, **kwargs):
super(SplitGridView, self).__init__(*args, **kwargs)
self.top_splitter = QSplitter(Qt.Horizontal)
self.top_splitter.setSizes([100, 200])
self.bottom_splitter = QSplitter(Qt.Horizontal)
self.bottom_splitter.setSizes([100, 200])
# connect splitter1 and splitter2 to move together
# TODO which version is desired? connect splitter or free moving?
# self.top_splitter.splitterMoved.connect(self.moveSplitter)
# self.bottom_splitter.splitterMoved.connect(self.moveSplitter)
# self._spltA = self.top_splitter
# self._spltB = self.bottom_splitter
self.outer_splitter = QSplitter(Qt.Vertical)
self.outer_splitter.insertWidget(0, self.top_splitter)
self.outer_splitter.insertWidget(1, self.bottom_splitter)
self.outer_splitter.setSizes([200, 400])
self.layout.addWidget(self.outer_splitter)
self.setLayout(self.layout)
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
self.setGeometry(300, 300, 300, 200)
self.max_canvases = 4
# Set attrs for when the buttons are created
self.icon = QIcon(path('icons/2x2grid.png'))
self.tool_tip = "2x2 Grid View"
self.whats_this = "Displays up to four visualized data items in a grid layout."
def __init__(self, *args, **kwargs):
super(SplitGridView, self).__init__(*args, **kwargs)
self.top_splitter = QSplitter(Qt.Horizontal)
self.top_splitter.setSizes([100, 200])
self.bottom_splitter = QSplitter(Qt.Horizontal)
self.bottom_splitter.setSizes([100, 200])
# connect splitter1 and splitter2 to move together
# TODO which version is desired? connect splitter or free moving?
# self.top_splitter.splitterMoved.connect(self.moveSplitter)
# self.bottom_splitter.splitterMoved.connect(self.moveSplitter)
# self._spltA = self.top_splitter
# self._spltB = self.bottom_splitter
self.outer_splitter = QSplitter(Qt.Vertical)
self.outer_splitter.insertWidget(0, self.top_splitter)
self.outer_splitter.insertWidget(1, self.bottom_splitter)
self.outer_splitter.setSizes([200, 400])
self.layout.addWidget(self.outer_splitter)
self.setLayout(self.layout)
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
self.setGeometry(300, 300, 300, 200)
self.max_canvases = 4
self.icon = QIcon(path('icons/2x2grid.png'))
def bootstrap(
app: QtWidgets.QApplication,
config_manager: InterfaceConfig,
theme: str = "Breeze",
aot: bool = True,
debug_no_scrcpy: bool = False,
hide_wm_frame: bool = True,
):
"""
Launch the guiscrcpy window
:return:
"""
config = config_manager.get_config()
# load fonts
font_database = QFontDatabase()
for font in FONTS:
s = font_database.addApplicationFont(
":/font/fonts/{ttf}".format(ttf=font))
if s == -1: # loading the font failed
# https://doc.qt.io/qt-5/qfontdatabase.html
print(fc("{y}Failed to load {ttf} font.{rst}", ttf=font))
# set theme
app.setStyle(theme)
# apply stylesheet
if theme == "Breeze":
# The Qdarkstylesheet is based on Breeze, lets load them on default
app.setStyleSheet(dark_stylesheet())
# load splash
splash_pix = QPixmap(":/res/ui/guiscrcpy-branding.png")
splash = QtWidgets.QSplashScreen(splash_pix)
splash.setMask(splash_pix.mask())
splash.show()
app.processEvents()
# on windows, users are likely not to add the scrcpy-server to the
# SCRCPY_SERVER_PATH
config_manager.update_config(set_scrcpy_server_path(config))
config_manager.write_file()
adb = AndroidDebugBridge(config_manager.get_config().get("adb"))
scrcpy = ScrcpyBridge(config_manager.get_config().get("scrcpy"))
config_manager["adb"] = adb.get_path()
config_manager["scrcpy"] = scrcpy.get_path()
guiscrcpy = InterfaceGuiscrcpy(
config_manager=config_manager,
adb=adb,
scrcpy=scrcpy,
force_window_frame=not hide_wm_frame,
panels_not_always_on_top=not aot,
debug_no_scrcpy=debug_no_scrcpy,
)
guiscrcpy.show()
app.processEvents()
splash.hide()
app.exec_()
def initUi(self):
print('Initializing GUI...')
w, h = 1000, 1000
self.find = ZhuNoteFind(self) # self as parent
self.tree = ZhuNoteTree()
self.form = ZhuNoteForm(self.path)
self.wbrs = QWebEngineView()
splitter1 = QSplitter(Qt.Horizontal)
splitter1.addWidget(self.form)
splitter1.addWidget(self.wbrs)
splitter1.setSizes([w / 2, w / 2])
splitter = QSplitter(Qt.Vertical)
splitter.addWidget(self.tree)
splitter.addWidget(splitter1)
splitter.setStretchFactor(0, 1)
splitter.setStretchFactor(1, 2)
vbox = QVBoxLayout()
vbox.addWidget(self.find)
vbox.addWidget(splitter)
self.setLayout(vbox)
self.wbrs.setHtml(self.html_hi)
self.tree.sigViewItem.connect(self.form.viewDict)
self.tree.sigViewItem.connect(self.viewHtml)
self.find.sigClear.connect(self.clear)
self.find.sigString.connect(self.search)
self.find.sigUpdateMaster.connect(self.updateMaster)
self.find.sigFont.connect(self.setFont)
self.setWindowTitle('Main - ZhuNote')
#self.setGeometry(x, y, w, h)
#self.move(x, y)
self.resize(w, h)
#self.show()
#self.tree.show()
#self.form.show()
styleName = 'Cleanlooks' # QStyleFactory.keys()
# ['Windows', 'Motif', 'CDE', 'Plastique', 'GTK+', 'Cleanlooks']
QApplication.setStyle(QStyleFactory.create(styleName))
self.find.txtSearch.setFocus() # not work yet
self.actExit = QAction('Exit', self)
self.actExit.setShortcut('Ctrl+Q')
self.actExit.triggered.connect(self.closeAllWindows)
self.addAction(self.actExit)
def main() -> None:
"""Startup function."""
global _app
t0 = process_time()
exit_code = 0
from sys import argv, exit
from logging import shutdown
from platform import system
from pyslvs_ui.info import ARGUMENTS, logger
if ARGUMENTS.cmd in {'gui', None}:
from qtpy.QtCore import Qt, qInstallMessageHandler
from qtpy.QtWidgets import QApplication, QSplashScreen
from qtpy.QtGui import QPixmap
_app = QApplication(argv)
# Depress Qt warning
qInstallMessageHandler(lambda _0, _1, _2: None)
# Load QRC file
from pyslvs_ui.icons_rc import qInitResources
qInitResources()
# Splash
sp = QSplashScreen(QPixmap(":/icons/splash.png"))
sp.showMessage(f"{__author__} {__copyright__}",
Qt.AlignBottom | Qt.AlignRight)
sp.show()
# Force enable fusion style on macOS
if system() == 'Darwin':
ARGUMENTS.fusion = True
if ARGUMENTS.fusion:
_app.setStyle('fusion')
# Main window
from .main_window import MainWindow
w = MainWindow.new()
sp.finish(w)
sp.deleteLater()
logger.info(f"Startup with: {process_time() - t0:.02f}s")
if not ARGUMENTS.debug_mode:
w.console_connect()
del sp, w
exit_code = _app.exec_()
elif ARGUMENTS.cmd == 'test':
from importlib import import_module
import_module('pyslvs_ui.main_window')
logger.info("All module loaded successfully.")
logger.info(f"Loaded with: {process_time() - t0:.02f}s")
elif ARGUMENTS.cmd == 'extract':
logger.info(f"Start CLI: {process_time() - t0:.02f}s")
# TODO: CLI mode
else:
raise ValueError(f"unknown command: {ARGUMENTS.cmd}")
shutdown()
exit(exit_code)
def __init__(self, *args, **kwargs):
super(SplitHorizontal, self).__init__(*args, **kwargs)
self.splitter = QSplitter(Qt.Vertical)
self.splitter.setSizes([100, 200])
self.layout.addWidget(self.splitter)
self.setLayout(self.layout)
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
self.setGeometry(300, 300, 300, 200)
self.max_canvases = 2
self.icon = QIcon(path('icons/1x1hor.png'))
def __init__(self, path=None):
QWidget.__init__(self)
self.setWindowTitle(self.NAME)
self.setWindowIcon(APP_ICON)
self.games = None # pandas dataframe
self.ranks = None # pandas dataframe
self.fn_players = None
self.fn_games = None
self.rank_order = 1 # descending
self.rank_column = 1
if path is None:
path = os.getcwd()
self.path = path
self.setup_page()
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
def main() -> None:
"""Startup function."""
global _app
from time import perf_counter
t0 = perf_counter()
from sys import argv, exit
from logging import shutdown
from platform import system
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QApplication, QSplashScreen
from qtpy.QtGui import QPixmap
from .core.info import ARGUMENTS, logger
if ARGUMENTS.test:
from importlib import import_module
import_module('pyslvs_ui.core.main_window')
logger.info("All module loaded successfully.")
logger.info(f"Loaded with: {perf_counter() - t0:.02f}s")
shutdown()
exit(0)
_app = QApplication(argv)
splash = QSplashScreen(QPixmap(":/icons/splash.png"))
splash.showMessage(f"{__author__} {__copyright__}",
Qt.AlignBottom | Qt.AlignRight)
splash.show()
# Force enable fusion style on macOS
if system() == 'Darwin':
ARGUMENTS.fusion = True
if ARGUMENTS.fusion:
_app.setStyle('fusion')
from .core.main_window import MainWindow
w = MainWindow()
w.show()
splash.finish(w)
splash.deleteLater()
logger.info(f"Startup with: {perf_counter() - t0:.02f}s")
if not ARGUMENTS.debug_mode:
w.console_connect()
del splash, t0
qt_exit_code = _app.exec_()
shutdown()
exit(qt_exit_code)
def __init__(self, *args, **kwargs):
super(SplitThreeView, self).__init__(*args, **kwargs)
self.top_splitter = QSplitter(Qt.Horizontal)
self.top_splitter.setSizes([100, 200])
self.outer_splitter = QSplitter(Qt.Vertical)
self.outer_splitter.insertWidget(0, self.top_splitter)
self.layout.addWidget(self.outer_splitter)
self.setLayout(self.layout)
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
self.setGeometry(300, 300, 300, 200)
self.max_canvases = 3
self.icon = QIcon(path('icons/2x1grid.png'))
def __init__(self, *args, **kwargs):
super(SplitHorizontal, self).__init__(*args, **kwargs)
self.splitter = QSplitter(Qt.Vertical)
self.splitter.setSizes([100, 200])
self.layout.addWidget(self.splitter)
self.setLayout(self.layout)
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
self.setGeometry(300, 300, 300, 200)
self.max_canvases = 2
# Set attrs for when the buttons are created
self.icon = QIcon(path('icons/1x1hor.png'))
self.tool_tip = "Horizontal Split View"
self.whats_this = "Displays up to two visualized data items in a horizontal layout."
def main() -> None:
"""Startup function."""
global _app
t0 = process_time()
from qtpy.QtCore import Qt, QDir, QLockFile
from qtpy.QtWidgets import QApplication, QSplashScreen
from qtpy.QtGui import QPixmap
from .info import ARGUMENTS, logger
if ARGUMENTS.test:
from importlib import import_module
import_module('pyslvs_ui.main_window')
logger.info("All module loaded successfully.")
logger.info(f"Loaded with: {process_time() - t0:.02f}s")
shutdown()
exit(0)
_app = QApplication(argv)
lf = QLockFile(join(QDir.tempPath(), "pyslvs.lock"))
if not lf.tryLock(100):
logger.info("Pyslvs can only start one instance.")
shutdown()
exit(0)
sp = QSplashScreen(QPixmap(":/icons/splash.png"))
sp.showMessage(f"{__author__} {__copyright__}",
Qt.AlignBottom | Qt.AlignRight)
sp.show()
# Force enable fusion style on macOS
if system() == 'Darwin':
ARGUMENTS.fusion = True
if ARGUMENTS.fusion:
_app.setStyle('fusion')
from .main_window import MainWindow
sp.finish(MainWindow.new())
sp.deleteLater()
del sp
logger.info(f"Startup with: {process_time() - t0:.02f}s")
qt_exit_code = _app.exec_()
del lf
shutdown()
exit(qt_exit_code)
def __init__(self, *args, **kwargs):
super(SplitThreeView, self).__init__(*args, **kwargs)
self.top_splitter = QSplitter(Qt.Horizontal)
self.top_splitter.setSizes([100, 200])
self.outer_splitter = QSplitter(Qt.Vertical)
self.outer_splitter.insertWidget(0, self.top_splitter)
self.layout.addWidget(self.outer_splitter)
self.setLayout(self.layout)
QApplication.setStyle(QStyleFactory.create('Cleanlooks'))
self.setGeometry(300, 300, 300, 200)
self.max_canvases = 3
# Set attrs for when the buttons are created
self.icon = QIcon(path('icons/2x1grid.png'))
self.tool_tip = "3-Way Split View"
self.whats_this = "Displays up to three visualized data items."
# Set Qt input method variable to use Qt virtual keyboards if config.virtualKeyboard is "True"
if config.virtualKeyboard:
os.environ["QT_IM_MODULE"] = "qtvirtualkeyboard"
# Start PySide2 gui
app = QApplication(sys.argv)
# Set application name
app.setApplicationName("UniqueBible.app")
app.setApplicationDisplayName("UniqueBible.app")
# When application name is changed
app.applicationNameChanged.connect(nameChanged)
# Assign a function to save configurations when the app is closed.
app.aboutToQuit.connect(exitApplication)
# Apply window style
if config.windowStyle and config.windowStyle in QStyleFactory.keys():
app.setStyle(config.windowStyle)
# Apply theme style
if config.qtMaterial and config.qtMaterialTheme:
apply_stylesheet(app, theme=config.qtMaterialTheme)
config.theme = "dark" if config.qtMaterialTheme.startswith("dark_") else "default"
else:
app.setPalette(Themes.getPalette())
# Active verse number colour
#config.activeVerseNoColour = config.activeVerseNoColourDark if config.theme == "dark" else config.activeVerseNoColourLight
# Assign mainWindow to config.mainWindow, to make it acessible from user customised user script
config.mainWindow = MainWindow()
# Check screen size
availableGeometry = app.desktop().availableGeometry(config.mainWindow)
setupMainWindow(availableGeometry)
vcp_name = selection[0].data()
vcp = self._vcp_data[vcp_name].get('entry_point_name', '')
self.opts.vcp = vcp
self.accept()
@Slot()
def on_cancelButton_clicked(self):
self.reject()
@Slot()
def on_fileButton_pressed(self):
vcp_file = QFileDialog.getOpenFileName(
self,
caption="Select VCP File",
directory=EXAMPLE_VCP_DIR,
filter='VCP Files (*.yml *.yaml *.ui);; All files (*)',
options=QFileDialog.DontUseNativeDialog)[0]
if vcp_file != '':
self.opts.vcp = vcp_file
self.accept()
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
app.setStyle(QStyleFactory.create('Windows'))
launcher = VCPChooser()
sys.exit(app.exec_())
def __init__(self):
QApplication.setStyle(QStyleFactory.create("Cleanlooks"))
QMainWindow.__init__(self)
autoNOM.Ui_MainWindow.__init__(self)
self.setupUi(self)
"""
self.username = self.ui.username_textbox.text()
self.registration_thread = RegisterThread(username=self.username, user_check=True)
self.registration_thread.signals.clear_textboxes_signal.connect(self.clear_all_textbox)
self.registration_thread.signals.disable_widgets_signal.connect(self.disable_widgets)
self.registration_thread.signals.popup_signal.connect(self.popup_msg)
self.registration_thread.signals.label_update_signal.connect(self.update_progress_label)
self.registration_thread.signals.play_splash_signal.connect(self.play_splash)
self.thread_pool.start(self.registration_thread)
@Slot()
def closeEvent(self, event):
"""
This function is a slot function for when the user clicks the red button to exit the window.
:param event: is the event object, so in this case, the even is closing the application (we either accept or reject)
"""
with open(_config, 'r'):
self.config['Default']['sponsor'] = self.ui.sponsor_textbox.text()
with open(_config, 'w') as config:
self.config.write(config)
event.accept()
if __name__ == '__main__':
app = QApplication(sys.argv)
QFontDatabase.addApplicationFont(_font)
app.setStyle('Fusion')
window = MainWindow()
sys.exit(app.exec_())
def __init__(self):
QApplication.setStyle(QStyleFactory.create("Cleanlooks"))
QMainWindow.__init__(self)
self.setupUi(self)
init_step1 = InitStep1(parent=self)
class CellNetAnalyzer:
'''The CellNetAnalyzer class'''
def __init__(self):
self.qapp = QApplication(sys.argv)
self.appdata = CnaData()
self.qapp.setStyle("fusion")
self.window = MainWindow(self.appdata)
self.appdata.window = self.window
self.read_config()
self.read_cobrapy_config()
config_parser = configparser.RawConfigParser()
config_parser.read(self.appdata.conf_path)
version = "unknown"
try:
version = config_parser.get('cnapy-config', 'version')
except (KeyError, NoOptionError):
print("Could not find version in cnapy-config.txt")
except NoSectionError:
print("Could not find section cnapy-config in cnapy-config.txt")
if version != self.appdata.version:
self.window.show_config_dialog()
else:
if self.appdata.selected_engine == "matlab":
self.appdata.matlab_engine = try_matlab_engine()
elif self.appdata.selected_engine == "octave":
self.appdata.octave_engine = try_octave_engine(
self.appdata.octave_executable)
self.appdata.select_engine()
self.window.disable_enable_dependent_actions()
self.window.save_project_action.setEnabled(False)
self.window.resize(1200, 1000)
self.window.show()
# Execute application
self.qapp.aboutToQuit.connect(
self.window.centralWidget().shutdown_kernel)
sys.exit(self.qapp.exec_())
def model(self):
return self.appdata.project.cobra_py_model
def set_model(self, model: cobra.Model):
self.appdata.project.cobra_py_model = model
def read_config(self):
''' Try to read data from cnapy-config.txt into appdata'''
config_parser = configparser.RawConfigParser()
config_parser.read(self.appdata.conf_path)
try:
try:
self.appdata.matlab_path = config_parser.get(
'cnapy-config', 'matlab_path')
except (KeyError, NoOptionError):
self.appdata.matlab_path = ""
try:
self.appdata.octave_executable = config_parser.get(
'cnapy-config', 'OCTAVE_EXECUTABLE')
except (KeyError, NoOptionError):
self.appdata.octave_executable = ""
try:
selected_engine = config_parser.get(
'cnapy-config', 'selected_engine')
self.appdata.selected_engine = selected_engine
except (KeyError, NoOptionError):
print("Could not find selected_engine in cnapy-config.txt")
self.appdata.selected_engine = None
try:
self.appdata.cna_path = config_parser.get(
'cnapy-config', 'cna_path')
except (KeyError, NoOptionError):
self.appdata.cna_path = ""
try:
self.appdata.work_directory = config_parser.get(
'cnapy-config', 'work_directory')
except (KeyError, NoOptionError):
print("Could not find work_directory in cnapy-config.txt")
try:
color = config_parser.get(
'cnapy-config', 'scen_color')
self.appdata.scen_color = QColor.fromRgb(int(color))
except (KeyError, NoOptionError):
print("Could not find scen_color in cnapy-config.txt")
try:
color = config_parser.get(
'cnapy-config', 'comp_color')
self.appdata.comp_color = QColor.fromRgb(int(color))
except (KeyError, NoOptionError):
print("Could not find comp_color in cnapy-config.txt")
try:
color = config_parser.get(
'cnapy-config', 'spec1_color')
self.appdata.special_color_1 = QColor.fromRgb(int(color))
except (KeyError, NoOptionError):
print("Could not find spec1_color in cnapy-config.txt")
try:
color = config_parser.get(
'cnapy-config', 'spec2_color')
self.appdata.special_color_2 = QColor.fromRgb(int(color))
except (KeyError, NoOptionError):
print("Could not find spec2_color in cnapy-config.txt")
try:
color = config_parser.get(
'cnapy-config', 'default_color')
self.appdata.default_color = QColor.fromRgb(int(color))
except (KeyError, NoOptionError):
print("Could not find default_color in cnapy-config.txt")
try:
rounding = config_parser.get(
'cnapy-config', 'rounding')
self.appdata.rounding = int(rounding)
except (KeyError, NoOptionError):
print("Could not find rounding in cnapy-config.txt")
try:
abs_tol = config_parser.get(
'cnapy-config', 'abs_tol')
self.appdata.abs_tol = float(abs_tol)
except (KeyError, NoOptionError):
print("Could not find abs_tol in cnapy-config.txt")
except NoSectionError:
print("Could not find section cnapy-config in cnapy-config.txt")
def read_cobrapy_config(self):
''' Try to read data from cobrapy-config.txt into appdata'''
config_parser = configparser.RawConfigParser()
try:
config_parser.read(self.appdata.cobrapy_conf_path)
try:
cobra.Configuration().solver = config_parser.get('cobrapy-config', 'solver')
except Exception as e:
print("Cannot set solver from cobrapy-config.txt file because:", e,
"\nReverting solver to COBRApy base setting.")
try:
cobra.Configuration().processes = int(config_parser.get('cobrapy-config', 'processes'))
except Exception as e:
print("Cannot set number of processes from cobrapy-config.txt file because:", e,
"\nReverting number of processes to COBRApy base setting.")
try:
val = float(config_parser.get('cobrapy-config', 'tolerance'))
if 1e-9 <= val <= 0.1:
cobra.Configuration().tolerance = val
else:
raise ValueError
except Exception as e:
print(e, "\nCannot set tolerance from cobrapy-config.txt file because it must be a vaule between 1e-9 and 0.1, reverting to COBRApy base setting.")
except Exception as e:
print('Could not read', self.appdata.cobrapy_conf_path, 'because:', e)
def changeStyle(self, styleName):
QApplication.setStyle(QStyleFactory.create(styleName))
self.changePalette()
