def main():
"""
Main application entry point
"""
logging.basicConfig(level=logging.DEBUG)
app = QtGui.QApplication(sys.argv)
window = MainWindow(app)
window.show()
sys.exit(app.exec_())
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):
QApplication.__init__(self, *args)
# Setup appication
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# self.setWindowIcon(QIcon("xdg/openshot.svg"))
# 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 Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
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.Link, QColor(42, 130, 218))
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: 1px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow()
self.window.show()
class ApkGenerator(object):
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 run(self):
self.main_window.mainloop()
def handle_generate_apk(self, logger):
proc = GenerateApkProcedure(self.context, logger)
proc.start()
def handle_install_apk(self, target, logger):
proc = InstallProcedure(self.context, target, logger)
proc.start()
def handle_create_project(self):
proc = CreateProjectProcedure(context=self.context,
parent_window=self.main_window)
proc.run()
#self.main_window.update_info_list()
def handle_clean_project(self, logger):
proc = CleanProjectProcedure(self.context, logger)
proc.run()
def handle_power_on_emulator(self, logger):
self.context["tools"][
"emulator"] = "C:/Program Files/AndroidSDK/tools/emulator.exe"
proc = PowerOnEmulatorProcedure(avd="MyPhone",
adb=self.context["tools"]["emulator"],
logger=logger)
proc.run()
def handle_open_project(self):
OpenProjectProcedure(context=self.context).run()
self.main_window.update_info_list()
# 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)
for item in sys.path:
print item
# Import components after path set
from windows.main_window import MainWindow
from monitor import EpicsMonitor
# 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.set_clipboard(app.clipboard())
main_window.show()
sys.exit(app.exec_())
import sys
from PyQt5.QtWidgets import QApplication
from windows.main_window import MainWindow
if __name__ == '__main__':
app = QApplication(sys.argv)
main_win = MainWindow()
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 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()
# 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 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
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)
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)
import sys from PyQt4 import QtCore, QtGui from windows.main_window import MainWindow app = QtGui.QApplication(sys.argv) mw = MainWindow() mw.show() app.exec_()
class OpenShotApp(QApplication):
""" This class is the primary QApplication for OpenShot.
mode=None (normal), mode=unittest (testing)"""
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
self.mode = mode or "normal"
self.args = super().arguments()
self.errors = []
try:
# Import modules
from classes import info, sentry
from classes.logger import log, reroute_output
# Log the session's start
if mode != "unittest":
import time
log.info("-" * 48)
log.info(time.asctime().center(48))
log.info('Starting new session'.center(48))
log.debug("Starting up in {} mode".format(self.mode))
log.debug("Command line: {}".format(self.args))
from classes import settings, project_data, updates
import openshot
# Re-route stdout and stderr to logger
if mode != "unittest":
reroute_output()
except ImportError as ex:
tb = traceback.format_exc()
log.error('OpenShotApp::Import Error', exc_info=1)
self.errors.append(
StartupError("Import Error",
"Module: %(name)s\n\n%(tb)s" % {
"name": ex.name,
"tb": tb
},
level="error"))
# Stop launching
raise
except Exception:
log.error('OpenShotApp::Init Error', exc_info=1)
sys.exit()
self.info = info
# Log some basic system info
self.log = log
self.show_environment(info, openshot)
if self.mode != "unittest":
self.check_libopenshot_version(info, openshot)
# Init data objects
self.settings = settings.SettingStore(parent=self)
self.settings.load()
self.project = project_data.ProjectDataStore()
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)
self.updates.reset()
# Set location of OpenShot program (for libopenshot)
openshot.Settings.Instance().PATH_OPENSHOT_INSTALL = info.PATH
# Check to disable sentry
if not self.settings.get('send_metrics'):
sentry.disable_tracing()
def show_environment(self, info, openshot):
log = self.log
try:
log.info("-" * 48)
log.info(
("OpenShot (version %s)" % info.SETUP['version']).center(48))
log.info("-" * 48)
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)
# Look for frozen version info
version_path = os.path.join(info.PATH, "settings", "version.json")
if os.path.exists(version_path):
with open(version_path, "r", encoding="UTF-8") as f:
version_info = json.loads(f.read())
log.info(
"Frozen version info from build server:\n%s" %
json.dumps(version_info, indent=4, sort_keys=True))
except Exception:
log.debug("Error displaying dependency/system details", exc_info=1)
def check_libopenshot_version(self, info, openshot):
"""Detect minimum libopenshot version"""
_ = self._tr
ver = openshot.OPENSHOT_VERSION_FULL
min_ver = info.MINIMUM_LIBOPENSHOT_VERSION
if ver >= min_ver:
return True
self.errors.append(
StartupError(
_("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": min_ver,
"current_version": ver,
},
level="error",
))
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)
def settings_load_error(self, filepath=None):
"""Use QMessageBox to warn the user of a settings load issue"""
_ = self._tr
self.errors.append(
StartupError(
_("Settings Error"),
_("Error loading settings file: %(file_path)s. Settings will be reset."
) % {"file_path": filepath},
level="warning",
))
def get_settings(self):
if not hasattr(self, "settings"):
return None
return self.settings
def show_errors(self):
count = len(self.errors)
if count > 0:
self.log.warning("Displaying %d startup messages", count)
while self.errors:
error = self.errors.pop(0)
error.show()
def _tr(self, message):
return self.translate("", message)
@pyqtSlot()
def cleanup(self):
"""aboutToQuit signal handler for application exit"""
self.log.debug("Saving settings in app.cleanup")
try:
self.settings.save()
except Exception:
self.log.error("Couldn't save user settings on exit.", exc_info=1)
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)
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()
def launch_main_window():
app = QApplication([])
main_window = MainWindow()
main_window.show()
app.exec_()
def main():
app = MainWindow()
app.mainloop()
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()
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_())
def __init__(self, *args):
QApplication.__init__(self, *args)
# 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 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()
# Load new/blank project (which sets default profile)
self.project.load("")
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)
class OpenShotApp(QApplication):
""" This class is the primary QApplication for OpenShot.
mode=None (normal), mode=unittest (testing) """
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 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 and attach exception handler
from classes import exceptions
sys.excepthook = exceptions.ExceptionHandler
# 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()
# 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)
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)
def _tr(self, message):
return self.translate("", message)
# Start event loop
def run(self):
""" Start the primary Qt event loop for the interface """
res = self.exec_()
try:
self.settings.save()
except Exception as ex:
log.error("Couldn't save user settings on exit.\n{}".format(ex))
# return exit result
return res
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_())
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 __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 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)
