def __init__(self, context):
super().__init__()
self.context = context
self.main_window = MainWindow(
self.context,
handle_generate_apk=self.handle_generate_apk,
handle_install_apk=self.handle_install_apk,
handle_create_project=self.handle_create_project,
handle_clean_project=self.handle_clean_project,
handle_power_on_emulator=self.handle_power_on_emulator,
handle_open_project=self.handle_open_project)
self.main_window.show_configuration()
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
try:
# Import modules
from classes import info
from classes.logger import log, reroute_output
# Log the session's start
import time
log.info("------------------------------------------------")
log.info(time.asctime().center(48))
log.info('Starting new session'.center(48))
from classes import settings, project_data, updates, language, ui_util, logger_libopenshot
import openshot
# Re-route stdout and stderr to logger
reroute_output()
except ImportError as ex:
tb = traceback.format_exc()
log.error('OpenShotApp::Import Error: %s' % str(ex))
QMessageBox.warning(
None, "Import Error", "Module: %(name)s\n\n%(tb)s" % {
"name": ex.name,
"tb": tb
})
# Stop launching and exit
raise
sys.exit()
except Exception as ex:
log.error('OpenShotApp::Init Error: %s' % str(ex))
sys.exit()
# Log some basic system info
try:
log.info("------------------------------------------------")
log.info(
("OpenShot (version %s)" % info.SETUP['version']).center(48))
log.info("------------------------------------------------")
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" %
openshot.OPENSHOT_VERSION_FULL)
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except Exception:
pass
# Setup application
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
self.settings.load()
# Init and attach exception handler
from classes import exceptions
sys.excepthook = exceptions.ExceptionHandler
# Init translation system
language.init_language()
# Detect minimum libopenshot version
_ = self._tr
libopenshot_version = openshot.OPENSHOT_VERSION_FULL
if mode != "unittest" and libopenshot_version < info.MINIMUM_LIBOPENSHOT_VERSION:
QMessageBox.warning(
None, _("Wrong Version of libopenshot Detected"),
_("<b>Version %(minimum_version)s is required</b>, but %(current_version)s was detected. Please update libopenshot or download our latest installer."
) % {
"minimum_version": info.MINIMUM_LIBOPENSHOT_VERSION,
"current_version": libopenshot_version
})
# Stop launching and exit
sys.exit()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Test for permission issues (and display message if needed)
try:
# Create test paths
TEST_PATH_DIR = os.path.join(info.USER_PATH, 'PERMISSION')
TEST_PATH_FILE = os.path.join(TEST_PATH_DIR, 'test.osp')
os.makedirs(TEST_PATH_DIR, exist_ok=True)
with open(TEST_PATH_FILE, 'w') as f:
f.write('{}')
f.flush()
# Delete test paths
os.unlink(TEST_PATH_FILE)
os.rmdir(TEST_PATH_DIR)
except PermissionError as ex:
log.error(
'Failed to create PERMISSION/test.osp file (likely permissions error): %s'
% TEST_PATH_FILE)
QMessageBox.warning(
None, _("Permission Error"),
_("%(error)s. Please delete <b>%(path)s</b> and launch OpenShot again."
% {
"error": str(ex),
"path": info.USER_PATH
}))
# Stop launching and exit
raise
sys.exit()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info(
"Setting font to %s" %
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.Light, QColor(68, 68, 68))
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218, 192))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
#
# Disabled palette
#
darkPalette.setColor(QPalette.Disabled, QPalette.WindowText,
QColor(255, 255, 255, 128))
darkPalette.setColor(QPalette.Disabled, QPalette.Base,
QColor(68, 68, 68))
darkPalette.setColor(QPalette.Disabled, QPalette.Text,
QColor(255, 255, 255, 128))
darkPalette.setColor(QPalette.Disabled, QPalette.Button,
QColor(53, 53, 53, 128))
darkPalette.setColor(QPalette.Disabled, QPalette.ButtonText,
QColor(255, 255, 255, 128))
darkPalette.setColor(QPalette.Disabled, QPalette.Highlight,
QColor(151, 151, 151, 192))
darkPalette.setColor(QPalette.Disabled, QPalette.HighlightedText,
Qt.black)
# Tooltips
darkPalette.setColor(QPalette.ToolTipBase, QColor(42, 130, 218))
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
self.setPalette(darkPalette)
self.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }"
)
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.OpenProjectSignal.emit(path)
else:
# Apply the default settings and Auto import media file
self.project.load("")
self.window.filesTreeView.add_file(path)
else:
# Recover backup file (this can't happen until after the Main Window has completely loaded)
self.window.RecoverBackup.emit()
def __init__(self, *args):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup appication
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
try:
self.settings.load()
except Exception as ex:
log.error("Couldn't load user settings. Exiting.\n{}".format(ex))
exit()
# Init translation system
language.init_language()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set unique install id (if blank)
if not self.settings.get("unique_install_id"):
self.settings.set("unique_install_id", str(uuid4()))
# Track 1st launch metric
import classes.metrics
classes.metrics.track_metric_screen("initial-launch-screen")
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
log.info("Setting font to %s" %
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(
os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
self.setPalette(darkPalette)
self.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }"
)
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow()
self.window.show()
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.open_project(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
cur_frame = inspect.currentframe()
cur_file = inspect.getfile(cur_frame)
base = os.path.split(cur_file)[0]
base_abs = os.path.abspath(base)
# Override settings.BASE_PATH
settings.BASE_PATH = os.path.realpath(base_abs)
print "MASE_PATH", settings.BASE_PATH
# Add import directories to path
for dir in settings.IMPORT_DIRS:
dir_real = os.path.join(settings.BASE_PATH, dir)
if dir_real not in sys.path:
sys.path.insert(0, dir_real)
for item in sys.path:
print "PATH", item
# Import main window after path set
from windows.main_window import MainWindow
# Create QT app and show MainWindow
app = QApplication(sys.argv)
# app.setStyle("plastique")
# Create and show the main window
main_window = MainWindow()
main_window.show()
sys.exit(app.exec_())
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup application
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
self.settings.load()
# Init and attach exception handler
from classes import exceptions
sys.excepthook = exceptions.ExceptionHandler
# Init translation system
language.init_language()
# Detect minimum libopenshot version
_ = self._tr
libopenshot_version = openshot.GetVersion().ToString()
if mode != "unittest" and libopenshot_version < info.MINIMUM_LIBOPENSHOT_VERSION:
QMessageBox.warning(None, _("Wrong Version of libopenshot Detected"),
_("<b>Version %(minimum_version)s is required</b>, but %(current_version)s was detected. Please update libopenshot or download our latest installer.") %
{"minimum_version": info.MINIMUM_LIBOPENSHOT_VERSION, "current_version": libopenshot_version})
# Stop launching and exit
sys.exit()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info("Setting font to %s" % os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, QColor(104, 104, 104))
self.setPalette(darkPalette)
self.setStyleSheet("QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.OpenProjectSignal.emit(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
else:
# Recover backup file (this can't happen until after the Main Window has completely loaded)
self.window.RecoverBackup.emit()
cur_frame = inspect.currentframe()
cur_file = inspect.getfile(cur_frame)
base = os.path.split(cur_file)[0]
base_abs = os.path.abspath(base)
# Override settings.BASE_PATH
settings.BASE_PATH = os.path.realpath(base_abs)
# Add import directories to path
for dir in settings.IMPORT_DIRS:
dir_real = os.path.join(settings.BASE_PATH, dir)
if dir_real not in sys.path:
sys.path.insert(0, dir_real)
# Import main window after path set
from windows.main_window import MainWindow
# Create QT app and show MainWindow
app = QApplication(sys.argv)
app.setStyle("plastique")
# Create epics monitor that emits PyQt signals.
# Widgets can connect to the signals for real time updates
monitor = EpicsMonitor()
# Create and show the main window
main_window = MainWindow(monitor=monitor)
main_window.show()
sys.exit(app.exec_())
import sys from PyQt4 import QtCore, QtGui from windows.main_window import MainWindow app = QtGui.QApplication(sys.argv) mw = MainWindow() mw.show() app.exec_()
def launch_main_window():
app = QApplication([])
main_window = MainWindow()
main_window.show()
app.exec_()
def run():
"""
The main method starts the GUI after asking for an api key if necessary.
"""
if not check_internet_connection_and_obtain_api_key():
return 0
# Create the data folder if it doesn't exist.
if not os.path.exists(Config.data_folder):
os.makedirs(Config.data_folder)
if Config.online:
if len(sys.argv) > 1:
if sys.argv[1] in {'--test', '-t'}:
import test
test.run_tests()
return 0
elif sys.argv[1] in ('--download-molecule-images', '-dmi'):
import res_gen.image_downloader as id
id.download_images()
return 0
elif sys.argv[1] in ("-gba", "--generate-broadener-availability"):
import res_gen.generate_broadener_availability as gba
gba.generate_availability()
return 0
if Config.high_dpi:
# Enable High DPI display with PyQt5
QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True)
# Fix for mac-based systems...
os.environ['no_proxy'] = '*'
##
# The following blocks of code verify the hapi API key is in place, and it
# is valid. If it is not valid or in place the user will we prompted for
# one. This code also checks for a working internet connection, as hapi
# needs one to download data. In the future, if there is no internet
# connection the GUI should simply disable the features that require it,
# and there could be a periodic check for internet connection that will
# re-enable them.
from metadata.molecule_meta import MoleculeMeta
WorkRequest.start_work_process()
# Hapi is now started automatically in the work process
# start = HapiWorker(WorkRequest.START_HAPI, {})
# start.start() # When a start_hapi request is sent, it starts automatically.
_ = MoleculeMeta(0)
from metadata.xsc_meta import CrossSectionMeta
# If the cache is expired, download a list of the cross section meta file.
# This also populates the CrossSectionMeta.molecule_metas field.
_ = CrossSectionMeta(0)
app = QtWidgets.QApplication(sys.argv)
app.setStyle(QStyleFactory.create("Fusion"))
window = MainWindow()
window.gui.adjustSize()
TextReceiver.init(window)
_qt_result = app.exec_()
TextReceiver.redirect_close()
close = HapiWorker(WorkRequest.END_WORK_PROCESS, {}, callback=None)
close.safe_exit()
WorkRequest.WORKER.process.join()
HapiThread.kill_all()
return 0
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from windows.main_window import MainWindow # Start the Main Window MainWindow()
def gui(self):
from classes import language, sentry, ui_util, logger_libopenshot
from PyQt5.QtGui import QFont, QFontDatabase as QFD
_ = self._tr
info = self.info
log = self.log
# Init translation system
language.init_language()
sentry.set_tag("locale", info.CURRENT_LANGUAGE)
# Load ui theme if not set by OS
ui_util.load_theme()
# Test for permission issues (and display message if needed)
try:
log.debug("Testing write access to user directory")
# Create test paths
TEST_PATH_DIR = os.path.join(info.USER_PATH, 'PERMISSION')
TEST_PATH_FILE = os.path.join(TEST_PATH_DIR, 'test.osp')
os.makedirs(TEST_PATH_DIR, exist_ok=True)
with open(TEST_PATH_FILE, 'w') as f:
f.write('{}')
f.flush()
# Delete test paths
os.unlink(TEST_PATH_FILE)
os.rmdir(TEST_PATH_DIR)
except PermissionError as ex:
log.error('Failed to create file %s', TEST_PATH_FILE, exc_info=1)
self.errors.append(
StartupError(
_("Permission Error"),
_("%(error)s. Please delete <b>%(path)s</b> and launch OpenShot again."
) % {
"error": str(ex),
"path": info.USER_PATH,
},
level="error",
))
# Display any outstanding startup messages
self.show_errors()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
log.debug("Loading UI theme")
if self.settings.get("theme") != "No Theme":
# Load embedded font
font_path = os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf")
if os.path.exists(font_path):
log.info("Setting font to %s", font_path)
try:
font_id = QFD.addApplicationFont(font_path)
font_family = QFD.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception:
log.warning("Error setting Ubuntu-R.ttf QFont", exc_info=1)
# Set Dark Theme, if selected
if self.settings.get("theme") == "Humanity: Dark":
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = ui_util.make_dark_palette(self.palette())
self.setPalette(darkPalette)
self.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }"
)
# Create main window
from windows.main_window import MainWindow
log.debug("Creating main interface window")
self.window = MainWindow(mode=self.mode)
# Clear undo/redo history
self.window.updateStatusChanged(False, False)
# Connect our exit signals
self.aboutToQuit.connect(self.cleanup)
args = self.args
if len(args) < 2:
# Recover backup file (this can't happen until after the Main Window has completely loaded)
self.window.RecoverBackup.emit()
return
log.info('Process command-line arguments: %s' % args)
# Auto load project if passed as argument
if args[1].endswith(".osp"):
self.window.OpenProjectSignal.emit(args[1])
return
# Start a new project and auto import any media files
self.project.load("")
for arg in args[1:]:
self.window.filesView.add_file(arg)
