def create_splash_screen():
"""Create splash screen."""
if not running_under_pytest():
splash = QSplashScreen(QPixmap(get_image_path('splash')))
splash_font = splash.font()
splash_font.setPixelSize(14)
splash.setFont(splash_font)
else:
splash = None
return splash
def get_splash():
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QApplication, QSplashScreen
from qtpy.QtGui import QColor, QPixmap
splash_pix = QPixmap(os.path.join(
os.path.dirname(__file__), 'images', 'splash.png'))
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
splash.show()
splash.showMessage("Initializing...", Qt.AlignBottom | Qt.AlignCenter |
Qt.AlignAbsolute, QColor(Qt.white))
QApplication.processEvents()
return splash
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 run(args=[],
files=[],
datasets=[],
flags=(False, False, False, False, False, False, False),
ppath=None,
query=None):
hidecontrol = False
if flags[4]:
from CGNS.NAV.wquery import Q7Query
Q7Query.loadUserQueries()
Q7Query.fillQueries()
ql = Q7Query.queriesNamesList()
print('# CGNS.NAV available queries:')
for q in ql:
print(' ', q)
else:
app = QApplication(args)
if not flags[5]:
pixmap = QPixmap(":/images/splash.png")
splash = QSplashScreen(pixmap, Qt.WindowStaysOnTopHint)
splash.show()
splash.showMessage("Release v%s" % OCTXT._ToolVersion,
Qt.AlignHCenter | Qt.AlignBottom)
app.processEvents()
t1 = time.time()
Q7Main.verbose = flags[2]
wcontrol = Q7Main()
wcontrol._application = app
wcontrol.setOptionValue('NAVTrace', flags[2])
wcontrol.transientRecurse = flags[0]
wcontrol.transientVTK = flags[3]
wcontrol.query = query
wcontrol._T('start')
wcontrol.setDefaults()
if flags[1]:
wcontrol.loadlast()
hidecontrol = flags[6]
if files:
for ff in files:
wcontrol.loadfile(ff)
hidecontrol = flags[6]
if datasets:
for dd in datasets:
wcontrol.loadCompleted(dataset_name='FFFF',
dataset_base='BASE',
dataset_tree=dd,
dataset_references=[],
dataset_paths=[])
hidecontrol = flags[6]
wcontrol.show()
if hidecontrol:
wcontrol.hide()
if not flags[5]:
t2 = time.time()
if t2 - t1 < 2.0:
time.sleep(2)
splash.finish(wcontrol)
app.exec_()
wcontrol._T('leave')
sys.exit()
def __init__(self):
super(Restarter, self).__init__()
self.ellipsis = ['', '.', '..', '...', '..', '.']
# Widgets
self.timer_ellipsis = QTimer(self)
self.splash = QSplashScreen(QPixmap(get_image_path('splash'), 'svg'))
# Widget setup
self.setVisible(False)
font = self.splash.font()
font.setPixelSize(10)
self.splash.setFont(font)
self.splash.show()
self.timer_ellipsis.timeout.connect(self.animate_ellipsis)
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, version_string="Version string"):
QSplashScreen.__init__(self)
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.SplashScreen)
splash_width = 720
splash_height = 400
desktop = QApplication.desktop()
screen = desktop.screenGeometry(desktop.primaryScreen()).size()
screen_width, screen_height = screen.width(), screen.height()
x = screen_width // 2 - splash_width // 2
y = screen_height // 2 - splash_height // 2
self.setGeometry(x, y, splash_width, splash_height)
self.ert = "ERT"
self.ert_title = "Ensemble based Reservoir Tool"
self.version = version_string
self.timestamp = "Timestamp string"
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 create_splash_screen():
"""Create splash screen."""
if not running_under_pytest():
image = QImage(500, 400, QImage.Format_ARGB32_Premultiplied)
image.fill(0)
painter = QPainter(image)
renderer = QSvgRenderer(get_image_path('splash'))
renderer.render(painter)
painter.end()
pm = QPixmap.fromImage(image)
pm = pm.copy(0, 0, 500, 400)
splash = QSplashScreen(pm)
splash_font = splash.font()
splash_font.setPixelSize(14)
splash.setFont(splash_font)
else:
splash = None
return splash
def gui_qt(*, startup_logo=False):
"""Start a Qt event loop in which to run the application.
Parameters
----------
startup_logo : bool
Show a splash screen with the napari logo during startup.
Notes
-----
This context manager is not needed if running napari within an interactive
IPython session. In this case, use the ``%gui qt`` magic command, or start
IPython with the Qt GUI event loop enabled by default by using
``ipython --gui=qt``.
"""
splash_widget = None
app = QApplication.instance()
if not app:
# if this is the first time the Qt app is being instantiated, we set
# the name, so that we know whether to raise_ in Window.show()
app = QApplication(sys.argv)
app.setApplicationName('napari')
if startup_logo:
logopath = join(dirname(__file__), '..', 'resources', 'logo.png')
splash_widget = QSplashScreen(QPixmap(logopath).scaled(400, 400))
splash_widget.show()
yield app
# if the application already existed before this function was called,
# there's no need to start it again. By avoiding unnecessary calls to
# ``app.exec_``, we avoid blocking.
if app.applicationName() == 'napari':
if splash_widget and startup_logo:
splash_widget.close()
app.exec_()
def gui_qt(*, startup_logo=False, gui_exceptions=False):
"""Start a Qt event loop in which to run the application.
Parameters
----------
startup_logo : bool, optional
Show a splash screen with the napari logo during startup.
gui_exceptions : bool, optional
Whether to show uncaught exceptions in the GUI, by default they will be
shown in the console that launched the event loop.
Notes
-----
This context manager is not needed if running napari within an interactive
IPython session. In this case, use the ``%gui qt`` magic command, or start
IPython with the Qt GUI event loop enabled by default by using
``ipython --gui=qt``.
"""
splash_widget = None
app = QApplication.instance()
if not app:
# automatically determine monitor DPI.
# Note: this MUST be set before the QApplication is instantiated
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
# if this is the first time the Qt app is being instantiated, we set
# the name, so that we know whether to raise_ in Window.show()
app = _create_application(sys.argv)
app.setApplicationName('napari')
if startup_logo:
logopath = join(dirname(__file__), '..', 'resources', 'logo.png')
pm = QPixmap(logopath).scaled(360, 360, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
splash_widget = QSplashScreen(pm)
splash_widget.show()
app._splash_widget = splash_widget
else:
app._existed = True
# instantiate the exception handler
exception_handler = ExceptionHandler(gui_exceptions=gui_exceptions)
sys.excepthook = exception_handler.handle
try:
yield app
except Exception:
exception_handler.handle(*sys.exc_info())
# if the application already existed before this function was called,
# there's no need to start it again. By avoiding unnecessary calls to
# ``app.exec_``, we avoid blocking.
# see also https://github.com/napari/napari/pull/2016
# we add 'magicgui' so that anyone using @magicgui *before* calling gui_qt
# will also have the application executed. (a bandaid for now?...)
if app.applicationName() in ('napari', 'magicgui'):
if splash_widget and startup_logo:
splash_widget.close()
app.exec_()
def __init__(self):
super(Restarter, self).__init__()
self.ellipsis = ['', '.', '..', '...', '..', '.']
# Widgets
self.timer_ellipsis = QTimer(self)
self.splash = QSplashScreen(QPixmap(get_image_path('splash.svg'),
'svg'))
# Widget setup
self.setVisible(False)
font = self.splash.font()
font.setPixelSize(10)
self.splash.setFont(font)
self.splash.show()
self.timer_ellipsis.timeout.connect(self.animate_ellipsis)
def get_splash():
from qtpy.QtCore import Qt
from qtpy.QtWidgets import QApplication, QSplashScreen
from qtpy.QtGui import QColor, QPixmap
splash_pix = QPixmap(
os.path.join(os.path.dirname(__file__), 'images', 'splash.png'))
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
splash.show()
splash.showMessage("Initializing...",
Qt.AlignBottom | Qt.AlignCenter | Qt.AlignAbsolute,
QColor(Qt.white))
QApplication.processEvents()
return splash
def gui_qt(*, startup_logo=False, gui_exceptions=False, force=False):
"""Start a Qt event loop in which to run the application.
Parameters
----------
startup_logo : bool, optional
Show a splash screen with the napari logo during startup.
gui_exceptions : bool, optional
Whether to show uncaught exceptions in the GUI, by default they will be
shown in the console that launched the event loop.
force : bool, optional
Force the application event_loop to start, even if there are no top
level widgets to show.
Notes
-----
This context manager is not needed if running napari within an interactive
IPython session. In this case, use the ``%gui qt`` magic command, or start
IPython with the Qt GUI event loop enabled by default by using
``ipython --gui=qt``.
"""
splash_widget = None
app = get_app()
if startup_logo and app.applicationName() == 'napari':
pm = QPixmap(NAPARI_ICON_PATH).scaled(360, 360, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
splash_widget = QSplashScreen(pm)
splash_widget.show()
app._splash_widget = splash_widget
# instantiate the exception handler
exception_handler = ExceptionHandler(gui_exceptions=gui_exceptions)
sys.excepthook = exception_handler.handle
try:
yield app
except Exception:
exception_handler.handle(*sys.exc_info())
# if the application already existed before this function was called,
# there's no need to start it again. By avoiding unnecessary calls to
# ``app.exec_``, we avoid blocking.
# we add 'magicgui' so that anyone using @magicgui *before* calling gui_qt
# will also have the application executed. (a bandaid for now?...)
# see https://github.com/napari/napari/pull/2016
if app.applicationName() in ('napari', 'magicgui'):
if splash_widget and startup_logo:
splash_widget.close()
run(force=force, _func_name='gui_qt')
def gui_qt(*, startup_logo=False):
"""Start a Qt event loop in which to run the application.
Parameters
----------
startup_logo : bool
Show a splash screen with the napari logo during startup.
Notes
-----
This context manager is not needed if running napari within an interactive
IPython session. In this case, use the ``%gui qt`` magic command, or start
IPython with the Qt GUI event loop enabled by default by using
``ipython --gui=qt``.
"""
splash_widget = None
app = QApplication.instance()
if not app:
# automatically determine monitor DPI.
# Note: this MUST be set before the QApplication is instantiated
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
# if this is the first time the Qt app is being instantiated, we set
# the name, so that we know whether to raise_ in Window.show()
app = _create_application(sys.argv)
app.setApplicationName('napari')
if startup_logo:
logopath = join(dirname(__file__), '..', 'resources', 'logo.png')
pm = QPixmap(logopath).scaled(360, 360, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
splash_widget = QSplashScreen(pm)
splash_widget.show()
app._splash_widget = splash_widget
else:
app._existed = True
# instantiate the exception handler
exception_handler = ExceptionHandler()
sys.excepthook = exception_handler.handle
yield app
# if the application already existed before this function was called,
# there's no need to start it again. By avoiding unnecessary calls to
# ``app.exec_``, we avoid blocking.
if app.applicationName() == 'napari':
if splash_widget and startup_logo:
splash_widget.close()
app.exec_()
def gui_qt(*, startup_logo=False):
"""Start a Qt event loop in which to run the application.
Parameters
----------
startup_logo : bool
Show a splash screen with the napari logo during startup.
Notes
-----
This context manager is not needed if running napari within an interactive
IPython session. In this case, use the ``%gui qt`` magic command, or start
IPython with the Qt GUI event loop enabled by default by using
``ipython --gui=qt``.
"""
app = QApplication.instance() or QApplication(sys.argv)
if startup_logo:
logopath = join(dirname(__file__), '..', 'resources', 'logo.png')
splash_widget = QSplashScreen(QPixmap(logopath).scaled(400, 400))
splash_widget.show()
yield
if startup_logo:
splash_widget.close()
app.exec_()
class Restarter(QWidget):
"""Widget in charge of displaying the splash information screen and the
error messages.
"""
def __init__(self):
super(Restarter, self).__init__()
self.ellipsis = ['', '.', '..', '...', '..', '.']
# Widgets
self.timer_ellipsis = QTimer(self)
self.splash = QSplashScreen(QPixmap(get_image_path('splash.svg'),
'svg'))
# Widget setup
self.setVisible(False)
font = self.splash.font()
font.setPixelSize(10)
self.splash.setFont(font)
self.splash.show()
self.timer_ellipsis.timeout.connect(self.animate_ellipsis)
def _show_message(self, text):
"""Show message on splash screen."""
self.splash.showMessage(text, Qt.AlignBottom | Qt.AlignCenter |
Qt.AlignAbsolute, QColor(Qt.white))
def animate_ellipsis(self):
"""Animate dots at the end of the splash screen message."""
ellipsis = self.ellipsis.pop(0)
text = ' '*len(ellipsis) + self.splash_text + ellipsis
self.ellipsis.append(ellipsis)
self._show_message(text)
def set_splash_message(self, text):
"""Sets the text in the bottom of the Splash screen."""
self.splash_text = text
self._show_message(text)
self.timer_ellipsis.start(500)
def launch_error_message(self, error_type, error=None):
"""Launch a message box with a predefined error message.
Parameters
----------
error_type : int [CLOSE_ERROR, RESET_ERROR, RESTART_ERROR]
Possible error codes when restarting/reseting spyder.
error : Exception
Actual Python exception error caught.
"""
messages = {CLOSE_ERROR: _("It was not possible to close the previous "
"Spyder instance.\nRestart aborted."),
RESET_ERROR: _("Spyder could not reset to factory "
"defaults.\nRestart aborted."),
RESTART_ERROR: _("It was not possible to restart Spyder.\n"
"Operation aborted.")}
titles = {CLOSE_ERROR: _("Spyder exit error"),
RESET_ERROR: _("Spyder reset error"),
RESTART_ERROR: _("Spyder restart error")}
if error:
e = error.__repr__()
message = messages[error_type] + "\n\n{0}".format(e)
else:
message = messages[error_type]
title = titles[error_type]
self.splash.hide()
QMessageBox.warning(self, title, message, QMessageBox.Ok)
raise RuntimeError(message)
class Restarter(QWidget):
"""Widget in charge of displaying the splash information screen and the
error messages.
"""
def __init__(self):
super(Restarter, self).__init__()
self.ellipsis = ['', '.', '..', '...', '..', '.']
# Widgets
self.timer_ellipsis = QTimer(self)
self.splash = QSplashScreen(
QPixmap(get_image_path('splash.svg'), 'svg'))
# Widget setup
self.setVisible(False)
font = self.splash.font()
font.setPixelSize(10)
self.splash.setFont(font)
self.splash.show()
self.timer_ellipsis.timeout.connect(self.animate_ellipsis)
def _show_message(self, text):
"""Show message on splash screen."""
self.splash.showMessage(
text, int(Qt.AlignBottom | Qt.AlignCenter | Qt.AlignAbsolute),
QColor(Qt.white))
def animate_ellipsis(self):
"""Animate dots at the end of the splash screen message."""
ellipsis = self.ellipsis.pop(0)
text = ' ' * len(ellipsis) + self.splash_text + ellipsis
self.ellipsis.append(ellipsis)
self._show_message(text)
def set_splash_message(self, text):
"""Sets the text in the bottom of the Splash screen."""
self.splash_text = text
self._show_message(text)
self.timer_ellipsis.start(500)
def launch_error_message(self, error_type, error=None):
"""Launch a message box with a predefined error message.
Parameters
----------
error_type : int [CLOSE_ERROR, RESET_ERROR, RESTART_ERROR]
Possible error codes when restarting/reseting spyder.
error : Exception
Actual Python exception error caught.
"""
messages = {
CLOSE_ERROR:
_("It was not possible to close the previous "
"Spyder instance.\nRestart aborted."),
RESET_ERROR:
_("Spyder could not reset to factory "
"defaults.\nRestart aborted."),
RESTART_ERROR:
_("It was not possible to restart Spyder.\n"
"Operation aborted.")
}
titles = {
CLOSE_ERROR: _("Spyder exit error"),
RESET_ERROR: _("Spyder reset error"),
RESTART_ERROR: _("Spyder restart error")
}
if error:
e = error.__repr__()
message = messages[error_type] + "\n\n{0}".format(e)
else:
message = messages[error_type]
title = titles[error_type]
self.splash.hide()
QMessageBox.warning(self, title, message, QMessageBox.Ok)
raise RuntimeError(message)
# -----------------------------------------------------------------------------
atexit.register(qCleanupResources)
def _get_splash_image_name():
# gets the width of the screen where the main window was initialised
width = QGuiApplication.primaryScreen().size().width()
if width > 2048:
return ':/images/MantidSplashScreen_4k.jpg'
else:
return ':/images/MantidSplashScreen.png'
SPLASH = QSplashScreen(QPixmap(_get_splash_image_name()),
Qt.WindowStaysOnTopHint)
SPLASH.show()
SPLASH.showMessage("Starting...", Qt.AlignBottom | Qt.AlignLeft
| Qt.AlignAbsolute, QColor(Qt.black))
# The event loop has not started - force event processing
QApplication.processEvents(QEventLoop.AllEvents)
# -----------------------------------------------------------------------------
# MainWindow
# -----------------------------------------------------------------------------
class MainWindow(QMainWindow):
DOCKOPTIONS = QMainWindow.AllowTabbedDocks | QMainWindow.AllowNestedDocks
def __init__(self):
def _init_mne_qtapp(enable_icon=True, pg_app=False, splash=False):
"""Get QApplication-instance for MNE-Python.
Parameter
---------
enable_icon: bool
If to set an MNE-icon for the app.
pg_app: bool
If to create the QApplication with pyqtgraph. For an until know
undiscovered reason the pyqtgraph-browser won't show without
mkQApp from pyqtgraph.
splash : bool | str
If not False, display a splash screen. If str, set the message
to the given string.
Returns
-------
app : ``qtpy.QtWidgets.QApplication``
Instance of QApplication.
splash : ``qtpy.QtWidgets.QSplashScreen``
Instance of QSplashScreen. Only returned if splash is True or a
string.
"""
from qtpy.QtCore import Qt
from qtpy.QtGui import QIcon, QPixmap, QGuiApplication
from qtpy.QtWidgets import QApplication, QSplashScreen
app_name = 'MNE-Python'
organization_name = 'MNE'
# Fix from cbrnr/mnelab for app name in menu bar
# This has to come *before* the creation of the QApplication to work.
# It also only affects the title bar, not the application dock.
# There seems to be no way to change the application dock from "python"
# at runtime.
if sys.platform.startswith("darwin"):
try:
# set bundle name on macOS (app name shown in the menu bar)
from Foundation import NSBundle
bundle = NSBundle.mainBundle()
info = bundle.localizedInfoDictionary() or bundle.infoDictionary()
info["CFBundleName"] = app_name
except ModuleNotFoundError:
pass
if pg_app:
from pyqtgraph import mkQApp
app = mkQApp(app_name)
else:
app = QApplication.instance() or QApplication(sys.argv or [app_name])
app.setApplicationName(app_name)
app.setOrganizationName(organization_name)
if enable_icon or splash:
icons_path = _qt_init_icons()
if enable_icon:
# Set icon
kind = 'bigsur_' if platform.mac_ver()[0] >= '10.16' else 'default_'
app.setWindowIcon(QIcon(f"{icons_path}/mne_{kind}icon.png"))
out = app
if splash:
pixmap = QPixmap(f"{icons_path}/mne_splash.png")
pixmap.setDevicePixelRatio(
QGuiApplication.primaryScreen().devicePixelRatio())
qsplash = QSplashScreen(pixmap, Qt.WindowStaysOnTopHint)
qsplash.setAttribute(Qt.WA_ShowWithoutActivating, True)
if isinstance(splash, str):
alignment = int(Qt.AlignBottom | Qt.AlignHCenter)
qsplash.showMessage(
splash, alignment=alignment, color=Qt.white)
qsplash.show()
app.processEvents()
out = (out, qsplash)
return out
# not calling app.setApplicationVersion(mantid.kernel.version_str())
# because it needs to happen after logging is monkey-patched in
return app
# Create the application object early
MAIN_APP = qapplication()
# -----------------------------------------------------------------------------
# Splash screen
# -----------------------------------------------------------------------------
# Importing resources loads the data in
from workbench.app.resources import qCleanupResources # noqa
atexit.register(qCleanupResources)
SPLASH = QSplashScreen(QPixmap(':/images/MantidSplashScreen.png'),
Qt.WindowStaysOnTopHint)
SPLASH.show()
SPLASH.showMessage("Starting...",
Qt.AlignBottom | Qt.AlignLeft | Qt.AlignAbsolute,
QColor(Qt.black))
# The event loop has not started - force event processing
QApplication.processEvents(QEventLoop.AllEvents)
# -----------------------------------------------------------------------------
# Utilities/Widgets
# -----------------------------------------------------------------------------
from mantidqt.utils.qt import add_actions, create_action # noqa
from mantidqt.widgets.manageuserdirectories import ManageUserDirectories # noqa
# -----------------------------------------------------------------------------
# MainWindow
self.move(0, 0)
self.setWindowTitle('Hola, QMainWindow')
ruta_icono = Path('.', 'imgs', 'pybofractal.png')
self.setWindowIcon(QIcon(str(ruta_icono)))
self.statusBar().showMessage('Ready')
self.show()
if __name__ == '__main__':
app = QApplication(sys.argv)
# Crea y muestra el splash screen
path = Path('imgs', 'splashscreen_background.jpg')
splash_pix = QPixmap(str(path))
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
splash.setEnabled(False)
splash.show()
# Esto es un simple contador/temporizador para mostrar en pantalla
# el splash screen. En el futuro haremos que esto sea más útil.
for i in range(0, 5):
msg = ('<h1><font color="yellow">' f'Listo en {5 - i}s' '</font></h1>')
splash.showMessage(msg,
int(Qt.AlignLeft) | int(Qt.AlignBottom), Qt.black)
time.sleep(1)
app.processEvents()
w = MiVentana()
splash.finish(w)
sys.exit(app.exec_())
if app is None:
app = QApplication(['Mantid Workbench'])
return app
# Create the application object early
MAIN_APP = qapplication()
# -----------------------------------------------------------------------------
# Splash screen
# -----------------------------------------------------------------------------
# Importing resources loads the data in
from workbench.app.resources import qCleanupResources # noqa
atexit.register(qCleanupResources)
SPLASH = QSplashScreen(QPixmap(':/images/MantidSplashScreen.png'),
Qt.WindowStaysOnTopHint)
SPLASH.show()
SPLASH.showMessage("Starting...", Qt.AlignBottom | Qt.AlignLeft |
Qt.AlignAbsolute, QColor(Qt.black))
# The event loop has not started - force event processing
QApplication.processEvents(QEventLoop.AllEvents)
# -----------------------------------------------------------------------------
# Utilities/Widgets
# -----------------------------------------------------------------------------
from mantidqt.py3compat import qbytearray_to_str # noqa
from mantidqt.utils.qt import add_actions, create_action # noqa
from mantidqt.widgets.manageuserdirectories import ManageUserDirectories # noqa
from workbench.config.main import CONF # noqa
from workbench.external.mantid import prepare_mantid_env # noqa
