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()
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)
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('YYSportCoder')
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 YYSportCoder 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()
'''
#from windows.yy_main_window import YYMainWindow
#self.window = YYMainWindow(mode)
from windows.yymain_window import YYMainWindow
self.window = YYMainWindow()
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 __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)
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)
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)
