def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr #set events handlers self.cbosize.activated.connect(self.cbosize_changed) #self.spnsize.valueChanged(int).connect(self.spnsize_changed) #Init some variables #Populate compression-method compression_method = [_("Target File Size"), _("Constant Quality")] for method in compression_method: self.cbosize.addItem(method) self.hide_quality_values()
def __init__(self): QMainWindow.__init__(self) # Руссифицируем QT диалоги log.info("Установка руссификации интерфейса QT") qt_base_translator = QTranslator(app) if qt_base_translator.load(":/i18n/qtbase_ru.qm"): app.installTranslator(qt_base_translator) else: log.error("Ошибка при установке руссификации интерфейса QT.") ui_util.load_ui(self, 'main_window') ui_util.init_ui(self) # Получить данные о текущей версии приложения через HTTP self.found_version_signal.connect(self.found_current_version) get_current_version() # Восстановить настройки расположения окна self.not_fullscreen_window_state = Qt.WindowNoState # Переменная для хранения состояния до входа в полный экран self.restore_window_settings() self.setCorner(Qt.TopLeftCorner, Qt.LeftDockWidgetArea) self.setCorner(Qt.BottomLeftCorner, Qt.LeftDockWidgetArea) self.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea) self.setCorner(Qt.BottomRightCorner, Qt.RightDockWidgetArea) # После инициализации приложения вызываем окно регистрации пользователя в системе app.app_loading_is_complete.connect(self.action_connect_db_trigger) app.user_is_registered.connect(self.when_user_is_registered) self.show()
def __init__(self, node, edge=None): _ = get_app()._tr # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) self.node = node self.edge = edge self.Accept = False self.pushButtonOK.clicked.connect(self.onAccept) self.pushButtonCancel.clicked.connect(self.onCancel) self.lineEditText.setText(node["text"]) project = get_app().project coder = project.get(["coder"]) nodes = coder["nodes"] self.comboBoxToNode.addItem("select", "-1") for node in nodes: if node["nodeType"] != 1: self.comboBoxToNode.addItem(node["text"], node["id"]) '''
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("animated-title-screen") # Add blender treeview self.blenderTreeView = BlenderListView(self) self.verticalLayout.addWidget(self.blenderTreeView) # Add render button app = get_app() _ = app._tr self.buttonBox.addButton(QPushButton(_('Render')), QDialogButtonBox.AcceptRole) self.buttonBox.addButton(QPushButton(_('Cancel')), QDialogButtonBox.RejectRole) # Init variables self.unique_folder_name = str(uuid.uuid1()) self.output_dir = os.path.join(info.USER_PATH, "blender") self.selected_template = "" self.is_rendering = False self.my_blender = None # Clear all child controls self.clear_effect_controls()
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Init license #license_path = os.path.join(path_xdg, 'COPYING') #license_path = os.path.join(info.PATH, 'COPYING') #my_license = open('license_path', "r") #content = my_license.read() #for text in license_path: #self.textBrowser.append(text) #self.textBrowser.append(content) with open("(os.path.join(info.PATH, 'COPYING'))", 'r') as my_license: text = my_license.read() self.textBrowser.append(text)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Load UI from designer & init ui_util.load_ui(self, self.ui_path) ui_util.init_ui(self) metrics.track_metric_screen("animated-title-screen") app = get_app() _ = app._tr # Add render controls self.btnRender = QPushButton(_('Render')) self.btnCancel = QPushButton(_('Cancel')) self.buttonBox.addButton(self.btnRender, QDialogButtonBox.AcceptRole) self.buttonBox.addButton(self.btnCancel, QDialogButtonBox.RejectRole) # Hide render progress until needed self.statusContainer.hide() # Add blender view self.blenderView = BlenderListView(self) self.verticalLayout.addWidget(self.blenderView) # Init variables self.unique_folder_name = str(uuid.uuid1()) self.output_dir = os.path.join(info.USER_PATH, "blender") self.selected_template = "" self.is_rendering = False self.my_blender = None # Clear all child controls self.clear_effect_controls()
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Track metrics track_metric_screen("profile-screen") # Loop through profiles self.profile_names = [] self.profile_paths = {} for profile_folder in [info.USER_PROFILES_PATH, info.PROFILES_PATH]: for file in os.listdir(profile_folder): # Load Profile profile_path = os.path.join(profile_folder, file) profile = openshot.Profile(profile_path) # Add description of Profile to list self.profile_names.append(profile.info.description) self.profile_paths[profile.info.description] = profile_path # Sort list self.profile_names.sort() # Loop through sorted profiles box_index = 0 selected_index = 0 for profile_name in self.profile_names: # Add to dropdown self.cboProfile.addItem(profile_name, self.profile_paths[profile_name]) # Set default (if it matches the project) if app.project.get(['profile']) == profile_name: selected_index = box_index # increment item counter box_index += 1 # Connect signal self.cboProfile.currentIndexChanged.connect( functools.partial(self.dropdown_index_changed, self.cboProfile)) # Set current item (from project) self.cboProfile.setCurrentIndex(selected_index)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Track metrics track_metric_screen("profile-screen") # Loop through profiles self.profile_names = [] self.profile_paths = {} for profile_folder in [info.USER_PROFILES_PATH, info.PROFILES_PATH]: for file in os.listdir(profile_folder): # Load Profile profile_path = os.path.join(profile_folder, file) profile = openshot.Profile(profile_path) # Add description of Profile to list self.profile_names.append(profile.info.description) self.profile_paths[profile.info.description] = profile_path # Sort list self.profile_names.sort() # Loop through sorted profiles box_index = 0 selected_index = 0 for profile_name in self.profile_names: # Add to dropdown self.cboProfile.addItem(profile_name, self.profile_paths[profile_name]) # Set default (if it matches the project) if app.project.get(['profile']) == profile_name: selected_index = box_index # increment item counter box_index += 1 # Connect signal self.cboProfile.currentIndexChanged.connect(functools.partial(self.dropdown_index_changed, self.cboProfile)) # Set current item (from project) self.cboProfile.setCurrentIndex(selected_index)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self)
def __init__(self): QDialog.__init__(self, parent=app.main_window) ui_util.load_ui(self, 'login') ui_util.init_ui(self) login = app.settings.value("registration/login", '') if login: self.edt_login.setText(login) self.edt_password.setFocus()
def __init__(self): #Create Dockwidget class QDockWidget.__init__(self) #Load UI from designer ui_util.load_ui(self, self.ui_path) #Init UI ui_util.init_ui(self)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr #Init authors authors = [] for person in info.CREDITS['code']: name = person['name'] email = person['email'] authors.append("%s <%s>" % (name, email)) self.textBrowserwritten.append(str(authors)) #Init documentaters authors = [] for person in info.CREDITS['documentation']: name = person['name'] email = person['email'] authors.append("%s <%s>" % (name, email)) self.textBrowserdocumented.append(str(authors)) #Init artwork artists = [] for person in info.CREDITS['artwork']: name = person['name'] email = person['email'] artists.append("%s <%s>" % (name, email)) self.textBrowserartwork.append(str(artists)) #Init translation authors authors = [] for person in info.CREDITS['translation']: name = person['name'] email = person['email'] authors.append("%s <%s>" % (name, email)) self.textBrowsertranslated.append(str(authors)) #Init Kicstarter Backers #backers = [] #for person in info.CREDITS['backers'] #name = person['name'] #email = person['email'] #backers.append("%s <%s>" % (name, email)) #self.textBrowserkickstarter.append(str(backers))
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Add credits listview self.developersListView = CreditsTreeView(credits=info.CREDITS['code'], columns=["email", "website"]) self.vboxDevelopers.addWidget(self.developersListView) self.txtDeveloperFilter.textChanged.connect(partial(self.Filter_Triggered, self.txtDeveloperFilter, self.developersListView)) # Get string of translators for the current language translator_credits = [] translator_credits_string = _("translator-credits").replace("Launchpad Contributions:\n", "").replace("translator-credits","") if translator_credits_string: # Parse string into a list of dictionaries translator_rows = translator_credits_string.split("\n") for row in translator_rows: # Split each row into 2 parts (name and username) translator_parts = row.split("https://launchpad.net/") name = translator_parts[0].strip() username = translator_parts[0].strip() translator_credits.append({"name":name, "website":"https://launchpad.net/%s" % username}) # Add translators listview self.translatorsListView = CreditsTreeView(translator_credits, columns=["website"]) self.vboxTranslators.addWidget(self.translatorsListView) self.txtTranslatorFilter.textChanged.connect(partial(self.Filter_Triggered, self.txtTranslatorFilter, self.translatorsListView)) else: # No translations for this langauge, hide credits self.tabCredits.removeTab(1) # Get list of supporters supporter_list = [] import codecs with codecs.open(os.path.join(info.PATH, 'settings', 'supporters.json'), 'r', 'utf-8') as supporter_file: supporter_string = supporter_file.read() supporter_list = json.loads(supporter_string) # Add supporters listview self.supportersListView = CreditsTreeView(supporter_list, columns=["website"]) self.vboxSupporters.addWidget(self.supportersListView) self.txtSupporterFilter.textChanged.connect(partial(self.Filter_Triggered, self.txtSupporterFilter, self.supportersListView))
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Track metrics track_metric_screen("animation-screen")
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Get settings self.s = settings.get_settings() # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Track metrics track_metric_screen("preferences-screen") # Load all user values self.params = {} for item in self.settings_data: if "setting" in item and "value" in item: self.params[item["setting"]] = item # Connect search textbox self.txtSearch.textChanged.connect(self.txtSearch_changed) self.requires_restart = False self.category_names = {} self.category_tabs = {} self.category_sort = {} self.visible_category_names = {} # Tested hardware modes (default cpu mode with graphics card 0) self.hardware_tests_cards = { 0: [ 0, ] } # Populate preferences self.Populate() # Restore normal cursor get_app().restoreOverrideCursor()
def __init__(self): QDialog.__init__(self, parent=app.main_window) ui_util.load_ui(self, 'license') ui_util.init_ui(self) # Инициализация лицензии license_file = QFile(':/license.txt') license_file.open(QFile.ReadOnly) license_text = bytes(license_file.readAll()).decode('UTF-8') self.text_browser.setText(license_text) license_file.close() # Прокручиваем текст в начало документа cursor = self.text_browser.textCursor() cursor.setPosition(0) self.text_browser.setTextCursor(cursor)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr ##set even handlers self.cmbpresets.activated.connect(self.load_presets_list) self.btnclearpreset.clicked.connect(self.delete_preset) self.btnsavecurrent.clicked.connect(self.save_current_preset)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr create_text = _('Create & Edit Amazing Videos and Movies') description_text = _( 'OpenShot Video Editor 2.x is the next generation of the award-winning <br/>OpenShot video editing platform.' ) learnmore_text = _('Learn more') copyright_text = _( 'Copyright © %(begin_year)s-%(current_year)s') % { 'begin_year': '2008', 'current_year': str(datetime.datetime.today().year) } about_html = '<html><head/><body><hr/><p align="center"><span style=" font-size:10pt; font-weight:600;">%s</span></p><p align="center"><span style=" font-size:10pt;">%s </span><a href="http://%s.openshot.org?r=about-us"><span style=" font-size:10pt; text-decoration: none; color:#55aaff;">%s</span></a><span style=" font-size:10pt;">.</span></p></body></html>' % ( create_text, description_text, info.website_language(), learnmore_text) company_html = '<html><head/><body style="font-size:11pt; font-weight:400; font-style:normal;">\n<hr />\n<p align="center" style=" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">%s </span><a href="http://%s.openshotstudios.com?r=about-us"><span style=" font-size:10pt; font-weight:600; text-decoration: none; color:#55aaff;">OpenShot Studios, LLC<br /></span></a></p></body></html>' % ( copyright_text, info.website_language()) # Set description and company labels self.lblAboutDescription.setText(about_html) self.lblAboutCompany.setText(company_html) # set events handlers self.btncredit.clicked.connect(self.load_credit) self.btnlicense.clicked.connect(self.load_license) # Init some variables self.txtversion.setText(_("Version: %s") % info.VERSION) self.txtversion.setAlignment(Qt.AlignCenter) # Track metrics track_metric_screen("about-screen")
def __init__(self): #Create dialog class QDialog.__init__(self) #Load UI from designer ui_util.load_ui(self, self.ui_path) #Init UI ui_util.init_ui(self) #get translations self.app = get_app() _ = self.app._tr #set events handlers self.btnAdd.clicked.connect(self.add_preset) self.btnModified.clicked.connect(self.modified_preset) self.btnRename.clicked.connect(self.rename_preset) self.btnCopy.clicked.connect(self.copy_preset) self.btnDelete.clicked.connect(self.delete_preset)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr #set events handlers self.btncredit.clicked.connect(self.load_credit) self.btnlicense.clicked.connect(self.load_license) #Init some variables self.txtversion.setText(info.VERSION) self.txtversion.setAlignment(Qt.AlignCenter)
def __init__(self): QDialog.__init__(self, parent=app.main_window) ui_util.load_ui(self, 'about') ui_util.init_ui(self) header_html = """ <html><head/><body> <p align="center" style="font-size: 4em; font-weight: bold;"> {app_name} (Версия: {version}) </p> <p align="center" style="font-size: 2em;"> {description} </p> </body></html> """.format(app_name=constants.APP_NAME_RUS, version=constants.VERSION, description=constants.DESCRIPTION) description_text = constants.DESCRIPTION description_html = """ <html><head/><body> <hr /> <p align="center" style="font-size: 2em;"> Почта для замечаний и предложений<br /> <a href="mailto:{email}"><span style="text-decoration: none; color:#55aaff;">{email}</span></a> </p> </body></html>""".format(description=description_text, email=constants.COMPANY_EMAIL) author_html = """ <html><head/><body style="font-weight:400; font-style:normal;"> <hr /> <p align="center"> <span style="font-weight: bold;">%s</span> <br /> </p> </body></html> """ % constants.COPYRIGHT # Устанавливаем информацию о версии программы, авторе и описание self.lbl_about_description.setText(description_html) self.lbl_about_autor.setText(author_html) self.lbl_version.setText(header_html) self.lbl_version.setAlignment(Qt.AlignCenter)
def __init__(self): #Create dialog class QDialog.__init__(self) #Load UI from designer ui_util.load_ui(self, self.ui_path) #Init UI ui_util.init_ui(self) #Get translations app = get_app() _ = app._tr #set events handlers self.btncrop.clicked.connect(self.load_crop) self.btnsqueze.clicked.connect(self.load_squeze) self.btnletterbox.clicked.connect(self.load_letter_box) self.btnnone.clicked.connect(self.close_dialog) self.btnnone.pressed.connect(self.reject)
def __init__(self): # Create dialog class QDialog.__init__(self) #Load UI from designer ui_util.load_ui(self, self.ui_path) #Init UI ui_util.init_ui(self) #get translations self.app = get_app() _ = self.app._tr #set events handlers self.btnImport.clicked.connect(self.choose_transition) self.btnImport.pressed.connect(self.import_transition) #Init some variables self.buttonBox.button(QDialogButtonBox.Ok).setVisible(False) self.transition_file = ""
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Init license with open(os.path.join(info.RESOURCES_PATH, 'license.txt'), 'r') as my_license: text = my_license.read() self.textBrowser.append(text) # Scroll to top cursor = self.textBrowser.textCursor() cursor.setPosition(0) self.textBrowser.setTextCursor(cursor)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Init license with open(os.path.join(info.PATH, 'settings', 'license.txt'), 'r') as my_license: text = my_license.read() self.textBrowser.append(text) # Scroll to top cursor = self.textBrowser.textCursor() cursor.setPosition(0) self.textBrowser.setTextCursor(cursor)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # set events handlers self.btncredit.clicked.connect(self.load_credit) self.btnlicense.clicked.connect(self.load_license) # Init some variables self.txtversion.setText(_("Version: %s") % info.VERSION) self.txtversion.setAlignment(Qt.AlignCenter) # Track metrics track_metric_screen("about-screen")
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Update supporter button supporter_text = _("Become a Supporter") supporter_html = '<html><head/><body><p align="center"><a href="http://%s.openshot.org/donate/?app-about-us"><span style=" text-decoration: underline; color:#55aaff;">%s</span></a></p></body></html>' % ( info.website_language(), supporter_text) self.lblBecomeSupporter.setText(supporter_html) # Add credits listview self.developersListView = CreditsTreeView(credits=info.CREDITS['code'], columns=["email", "website"]) self.vboxDevelopers.addWidget(self.developersListView) self.txtDeveloperFilter.textChanged.connect( partial(self.Filter_Triggered, self.txtDeveloperFilter, self.developersListView)) # Get string of translators for the current language translator_credits = [] translator_credits_string = _("translator-credits").replace( "Launchpad Contributions:\n", "").replace("translator-credits", "") if translator_credits_string: # Parse string into a list of dictionaries translator_rows = translator_credits_string.split("\n") for row in translator_rows: # Split each row into 2 parts (name and username) translator_parts = row.split("https://launchpad.net/") name = translator_parts[0].strip() username = translator_parts[1].strip() translator_credits.append({ "name": name, "website": "https://launchpad.net/%s" % username }) # Add translators listview self.translatorsListView = CreditsTreeView(translator_credits, columns=["website"]) self.vboxTranslators.addWidget(self.translatorsListView) self.txtTranslatorFilter.textChanged.connect( partial(self.Filter_Triggered, self.txtTranslatorFilter, self.translatorsListView)) else: # No translations for this langauge, hide credits self.tabCredits.removeTab(1) # Get list of supporters supporter_list = [] import codecs with codecs.open( os.path.join(info.PATH, 'settings', 'supporters.json'), 'r', 'utf-8') as supporter_file: supporter_string = supporter_file.read() supporter_list = json.loads(supporter_string) # Add supporters listview self.supportersListView = CreditsTreeView(supporter_list, columns=["website"]) self.vboxSupporters.addWidget(self.supportersListView) self.txtSupporterFilter.textChanged.connect( partial(self.Filter_Triggered, self.txtSupporterFilter, self.supportersListView))
def __init__(self, file=None): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("cutting-screen") self.start_frame = 1 self.start_image = None self.end_frame = 1 self.end_image = None # Keep track of file object self.file = file self.file_path = file.absolute_path() self.video_length = int(file.data['video_length']) self.fps_num = int(file.data['fps']['num']) self.fps_den = int(file.data['fps']['den']) self.fps = float(self.fps_num) / float(self.fps_den) # Open video file with Reader log.info(self.file_path) self.r = openshot.FFmpegReader(self.file_path) self.r.Open() # Add Video Widget self.videoPreview = VideoWidget() self.videoPreview.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.verticalLayout.insertWidget(0, self.videoPreview) # Start the preview thread self.preview_parent = PreviewParent() self.preview_parent.Init(self, self.r, self.videoPreview) self.preview_thread = self.preview_parent.worker # Set slider constraints self.sliderIgnoreSignal = False self.sliderVideo.setMinimum(1) self.sliderVideo.setMaximum(self.video_length) self.sliderVideo.setSingleStep(1) self.sliderVideo.setSingleStep(1) self.sliderVideo.setPageStep(24) # Determine if a start or end attribute is in this file start_frame = 1 if 'start' in self.file.data.keys(): start_frame = (float(self.file.data['start']) * self.fps) + 1 # Display start frame (and then the previous frame) QTimer.singleShot(500, functools.partial(self.sliderVideo.setValue, start_frame + 1)) QTimer.singleShot(600, functools.partial(self.sliderVideo.setValue, start_frame)) # Connect signals self.btnPlay.clicked.connect(self.btnPlay_clicked) self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged) self.btnStart.clicked.connect(self.btnStart_clicked) self.btnEnd.clicked.connect(self.btnEnd_clicked) self.btnClear.clicked.connect(self.btnClear_clicked) self.btnAddClip.clicked.connect(self.btnAddClip_clicked)
def __init__(self): #Create dialog class QDialog.__init__(self) #Load UI from designer ui_util.load_ui(self, self.ui_path) #Init UI ui_util.init_ui(self) #get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Load all user values self.params = {} for item in self.settings_data: if "setting" in item and "value" in item: self.params[item["setting"]] = item self.category_names = {} self.category_tabs = {} # Loop through settings and find all unique categories for item in self.settings_data: category = item["category"] setting_type = item["type"] if not setting_type == "hidden": # Load setting if not category in self.category_names: self.category_names[category] = [] # Add new category as a tab tabWidget = QWidget(self) self.tabCategories.addTab(tabWidget, _(category)) self.category_tabs[category] = tabWidget # Add form layout to this tab layout = QFormLayout(tabWidget) # Append settings into correct category self.category_names[category].append(item) # Loop through each category setting, and add them to the tabs for category in self.category_tabs.keys(): tabWidget = self.category_tabs[category] # Loop through settings for each category for param in self.category_names[category]: # Create Label widget = None label = QLabel() label.setText(_(param["title"])) label.setToolTip(_(param["title"])) if param["type"] == "spinner": # create spinner widget = QDoubleSpinBox() widget.setMinimum(float(param["min"])) widget.setMaximum(float(param["max"])) widget.setValue(float(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect(functools.partial(self.spinner_value_changed, param)) elif param["type"] == "text": # create spinner widget = QLineEdit() widget.setText(_(param["value"])) widget.textChanged.connect(functools.partial(self.text_value_changed, widget, param)) elif param["type"] == "bool": # create spinner widget = QCheckBox() if param["value"] == True: widget.setCheckState(Qt.Checked) else: widget.setCheckState(Qt.Unchecked) widget.stateChanged.connect(functools.partial(self.bool_value_changed, widget, param)) elif param["type"] == "dropdown": # create spinner widget = QComboBox() # Add normal values box_index = 0 for value_item in param["values"]: k = value_item["name"] v = value_item["value"] # add dropdown item widget.addItem(_(k), v) # select dropdown (if default) if v == param["value"]: widget.setCurrentIndex(box_index) box_index = box_index + 1 widget.currentIndexChanged.connect(functools.partial(self.dropdown_index_changed, widget, param)) # Add Label and Widget to the form if (widget and label): tabWidget.layout().addRow(label, widget) elif (label): tabWidget.layout().addRow(label)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) #Init UI ui_util.init_ui(self) #get translations self.app = get_app() _ = self.app._tr self.preset_name = "" self.project = self.app.project #set events handlers self.btnfolder.clicked.connect(self.choose_folder_output) self.btndeletepreset.clicked.connect(self.delete_preset) self.btnapplypreset.clicked.connect(self.apply_preset) self.cbopreset.activated.connect(self.load_preset) self.chkentiresequence.stateChanged.connect(self.lenght_group_state) self.chkprojectprofilesettings.stateChanged.connect(self.direction_group) self.cbosqueze.activated.connect(self.load_squeze) self.cmbformatvideo.activated.connect(self.load_format_video) self.cmbvideo.activated.connect(self.video_codecs) self.cmbcompressionmethod.activated.connect(self.load_compression_method_activated) self.btnpreserveratio.clicked.connect(self.preserve_ratio) self.spbrate.valueChanged.connect(self.rate_changed) self.spbmax.valueChanged.connect(self.max_changed) self.cmbaudio.activated.connect(self.audio_codecs) self.cmbsimplerate.activated.connect(self.simple_rate_changed) self.cmbchannels.activated.connect(self.channels_selected) self.sliderbitrate.valueChanged.connect(self.bitrate_changed) self.cmbformatimage.activated.connect(self.format_image) self.sliderquality.valueChanged.connect(self.quality_changed) self.spbdigits.valueChanged.connect(self.digits_changed) self.spbinterval.valueChanged.connect(self.interval_changed) self.spboffset.valueChanged.connect(self.offset_changed) self.lblprefix.textChanged.connect(self.new_prefix) self.lblsuffix.textChanged.connect(self.new_suffix) self.btnloadffmpegcommand.clicked.connect(self.load_ffmpeg_command) self.btnexportcommand.clicked.connect(self.load_export_command) self.btnexport.clicked.connect(self.run_progress_bar_export) #self.lblframename.textChanged.connect(self.new_frame_name) #Init some variables self.chkentiresequence.setEnabled(True) #self.chkentiresequence.setChecked() self.label_17.setEnabled(False) self.spbfrom.setEnabled(False) self.label_18.setEnabled(False) self.spbto.setEnabled(False) self.chkprojectprofilesettings.setEnabled(True) #self.chkprojectprofilesettings.isChecked(True) self.chkoriginalsize.setEnabled(False) self.label_20.setEnabled(False) self.spbwidth.setEnabled(False) self.label_21.setEnabled(False) self.btnpreserveratio.setEnabled(False) self.spbheight.setEnabled(False) self.chkdirectcopy.setEnabled(True) self.lblfilename.setText("My Awesome Movie") self.lblfilename.setFocus() self.lblfilename.selectAll() #Populate new preset name self.cbopreset.addItem("<Select a Preset or Create your own>") self.preset_path = os.path.join(info.PATH, 'presets') for file in sorted(os.listdir(self.preset_path)): if fnmatch.fnmatch(file, '*.xml'): (fileName, fileExtension) = os.path.splitext(file) self.cbopreset.addItem(file.replace("_", " ")) #populate compression method compression_method = [_("Average Bit Rate")] for method in compression_method: self.cmbcompressionmethod.addItem(method) # populate image format Qcombobox image_extension = [_(".jpg"), _(".jpeg"), _(".png"), _(".bmp"), _(".svg"), _(".thm"), _(".gif"), _(".ppm"), _(".pgm"), _(".tif"), _(".tiff")] for extension in image_extension: self.cmbformatimage.addItem(extension) #populate format combo format_video = [_('.mkv'), _('.mov'), _('.mp4'), _('.dnxhd'), _('.dvd'), _('vob'), _('.mpg'), _('mpegts'), _('mpegps'), _('.dv'), _('.avi'), _('.webm'), _('.ts'), _('.ogg'), _('.3gp2'), _('.3gp'), _('.roq'), _('rm'), _('.divx'), _('.xvid'), _('.m2ts'), _('.r3d'), _('.MPG'), _('.flv'), _('avm2'), _('.asf'), _('.m4v'), _('.h264'), _('.ac3'), _('.mp2'), _('.mp3'), _('.wav'), _('.ogg'), _('.flac'), _('.aac'), _('.wma'), _('.opus'), _('.alaw'), _('.mulaw'), _('.mka')] for keys in format_video: self.cmbformatvideo.addItem(keys) for extension in format_video: self.cmbextension.addItem(extension) #populate video codecs combo video_codec = {'Xvid': 'libxvid', 'H264/MPEG-4 AVC':'libx264', 'OGG VORBIS': 'ogg', 'DV': 'dv', 'VP8': 'libvpx', 'Motion JPEG': 'mjepg', 'VP9': 'libvpx', 'H261': 'h261', 'H263': '263', 'Theora': '', 'Dirac': 'dirac', 'WMV': 'wmv', 'FLV': 'flv'} for keys in video_codec: self.cmbvideo.addItem(keys) aspect_ratio = [_('4/3'), _('16/9')] for ratio in aspect_ratio: self.cmbaspectratio.addItem(ratio) frame_per_seconds = [_('23.976'), _('24'), _('25'), _('29.976'), _('30'), _('50'), _('60')] for fps in frame_per_seconds: self.cmbfps.addItem(fps) #populate audio codecs combo audio_codec = {'MP3': 'libmp3lame', 'OGG VORBIS': 'oggvorbis','MP2': 'mpeg2audio', 'FLAC': 'flac', 'AAC-LC': 'aac', 'WAVE': 'wav', 'AC3': 'ac3', 'DTS': 'dts', 'WMA': 'wma', 'AMR-NB': '', 'PCM 8 bits': 'u8', 'PCM 16 bits little-endian': 'u16le', 'PCM 16 bits big-endian': 'u16be'} for keys in audio_codec: self.cmbaudio.addItem(keys) #Populate simplerate combo simple_rate = [_('Copy'), _('8000'), _('11025'), _('16000'), _('22050'), _('24000'), _('32000'), _('44100'), _('48000')] for rate in simple_rate: self.cmbsimplerate.addItem(rate) #populate audio channels audio_channels = [_('Copy'), _('Mono'), _('Stereo'), _('Join Stereo'), _('DTS')] for channels in audio_channels: self.cmbchannels.addItem(channels)
def __init__(self): # Create dialog class QDialog.__init__(self) self.app = get_app() self.project = self.app.project # Get translation object _ = self.app._tr # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("title-screen") # Initialize variables self.template_name = "" imp = minidom.getDOMImplementation() self.xmldoc = imp.createDocument(None, "any", None) self.bg_color_code = "" self.font_color_code = "#ffffff" self.bg_style_string = "" self.title_style_string = "" self.subtitle_style_string = "" self.font_weight = 'normal' self.font_style = 'normal' self.new_title_text = "" self.sub_title_text = "" self.subTitle = False self.display_name = "" self.font_family = "Bitstream Vera Sans" self.tspan_node = None # Hide all textboxes self.hide_textboxes() # Remove temp file (if found) temp_svg_path = os.path.join(info.TITLE_PATH, "temp.svg") if os.path.exists(temp_svg_path): os.remove(temp_svg_path) # load the template files self.cmbTemplate.addItem(_("<Select a template>")) # Add user-defined titles (if any) for file in sorted(os.listdir(info.TITLE_PATH)): # pretty up the filename for display purposes if fnmatch.fnmatch(file, '*.svg'): (fileName, fileExtension) = os.path.splitext(file) self.cmbTemplate.addItem(fileName.replace("_", " "), os.path.join(info.TITLE_PATH, file)) # Add built-in titles self.template_dir = os.path.join(info.PATH, 'titles') for file in sorted(os.listdir(self.template_dir)): # pretty up the filename for display purposes if fnmatch.fnmatch(file, '*.svg'): (fileName, fileExtension) = os.path.splitext(file) self.cmbTemplate.addItem(fileName.replace("_", " "), os.path.join(self.template_dir, file)) # set event handlers self.cmbTemplate.activated.connect(functools.partial(self.cmbTemplate_activated)) self.btnFontColor.clicked.connect(functools.partial(self.btnFontColor_clicked)) self.btnBackgroundColor.clicked.connect(functools.partial(self.btnBackgroundColor_clicked)) self.btnFont.clicked.connect(functools.partial(self.btnFont_clicked)) self.btnAdvanced.clicked.connect(functools.partial(self.btnAdvanced_clicked)) self.txtLine1.textChanged.connect(functools.partial(self.txtLine_changed)) self.txtLine2.textChanged.connect(functools.partial(self.txtLine_changed)) self.txtLine3.textChanged.connect(functools.partial(self.txtLine_changed)) self.txtLine4.textChanged.connect(functools.partial(self.txtLine_changed)) self.txtLine5.textChanged.connect(functools.partial(self.txtLine_changed)) self.txtLine6.textChanged.connect(functools.partial(self.txtLine_changed))
def __init__(self, edit_file_path=None, duplicate=False): # Create dialog class QDialog.__init__(self) self.app = get_app() self.project = self.app.project self.edit_file_path = edit_file_path self.duplicate = duplicate # Get translation object _ = self.app._tr # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("title-screen") # Initialize variables self.template_name = "" imp = minidom.getDOMImplementation() self.xmldoc = imp.createDocument(None, "any", None) self.bg_color_code = QtGui.QColor(Qt.black) self.font_color_code = QtGui.QColor(Qt.white) self.bg_style_string = "" self.title_style_string = "" self.subtitle_style_string = "" self.font_weight = 'normal' self.font_style = 'normal' self.new_title_text = "" self.sub_title_text = "" self.subTitle = False self.display_name = "" self.font_family = "Bitstream Vera Sans" self.tspan_node = None # Add titles list view self.titlesTreeView = TitlesListView(self) self.verticalLayout.addWidget(self.titlesTreeView) # Disable Save button on window load self.buttonBox.button(self.buttonBox.Save).setEnabled(False) # If editing existing title svg file if self.edit_file_path: # Hide list of templates self.widget.setVisible(False) # Create temp version of title self.create_temp_title(self.edit_file_path) # Add all widgets for editing self.load_svg_template() # Display image (slight delay to allow screen to be shown first) QTimer.singleShot(50, self.display_svg)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Track metrics track_metric_screen("preferences-screen") # Load all user values self.params = {} for item in self.settings_data: if "setting" in item and "value" in item: self.params[item["setting"]] = item self.requires_restart = False self.category_names = {} self.category_tabs = {} # Loop through settings and find all unique categories for item in self.settings_data: category = item["category"] setting_type = item["type"] if not setting_type == "hidden": # Load setting if not category in self.category_names: self.category_names[category] = [] # Add new category as a tab tabWidget = QWidget(self) self.tabCategories.addTab(tabWidget, _(category)) self.category_tabs[category] = tabWidget # Add form layout to this tab layout = QFormLayout(tabWidget) # Append settings into correct category self.category_names[category].append(item) # Loop through each category setting, and add them to the tabs for category in self.category_tabs.keys(): tabWidget = self.category_tabs[category] # Loop through settings for each category for param in self.category_names[category]: # Create Label widget = None label = QLabel() label.setText(_(param["title"])) label.setToolTip(_(param["title"])) if param["type"] == "spinner": # create QDoubleSpinBox widget = QDoubleSpinBox() widget.setMinimum(float(param["min"])) widget.setMaximum(float(param["max"])) widget.setValue(float(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect( functools.partial(self.spinner_value_changed, param)) if param["type"] == "spinner-int": # create QDoubleSpinBox widget = QSpinBox() widget.setMinimum(int(param["min"])) widget.setMaximum(int(param["max"])) widget.setValue(int(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect( functools.partial(self.spinner_value_changed, param)) elif param["type"] == "text": # create QLineEdit widget = QLineEdit() widget.setText(_(param["value"])) widget.textChanged.connect( functools.partial(self.text_value_changed, widget, param)) elif param["type"] == "bool": # create spinner widget = QCheckBox() if param["value"] == True: widget.setCheckState(Qt.Checked) else: widget.setCheckState(Qt.Unchecked) widget.stateChanged.connect( functools.partial(self.bool_value_changed, widget, param)) elif param["type"] == "dropdown": # create spinner widget = QComboBox() # Get values value_list = param["values"] # Overwrite value list (for profile dropdown) if param["setting"] == "default-profile": value_list = [] # Loop through profiles for profile_folder in [ info.USER_PROFILES_PATH, info.PROFILES_PATH ]: for file in os.listdir(profile_folder): # Load Profile and append description profile_path = os.path.join( profile_folder, file) profile = openshot.Profile(profile_path) value_list.append({ "name": profile.info.description, "value": profile.info.description }) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Overwrite value list (for language dropdown) if param["setting"] == "default-language": value_list = [] # Loop through languages for locale, language, country in get_all_languages(): # Load Profile and append description if language: lang_name = "%s (%s)" % (language, locale) value_list.append({ "name": lang_name, "value": locale }) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Add Default to top of list value_list.insert(0, { "name": _("Default"), "value": "Default" }) # Add normal values box_index = 0 for value_item in value_list: k = value_item["name"] v = value_item["value"] # add dropdown item widget.addItem(_(k), v) # select dropdown (if default) if v == param["value"]: widget.setCurrentIndex(box_index) box_index = box_index + 1 widget.currentIndexChanged.connect( functools.partial(self.dropdown_index_changed, widget, param)) # Add Label and Widget to the form if (widget and label): tabWidget.layout().addRow(label, widget) elif (label): tabWidget.layout().addRow(label)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Track metrics track_metric_screen("preferences-screen") # Load all user values self.params = {} for item in self.settings_data: if "setting" in item and "value" in item: self.params[item["setting"]] = item self.requires_restart = False self.category_names = {} self.category_tabs = {} self.category_sort = {} # Loop through settings and find all unique categories for item in self.settings_data: category = item.get("category") setting_type = item.get("type") sort_category = item.get("sort") # Indicate sorted category if sort_category: self.category_sort[category] = sort_category if not setting_type == "hidden": # Load setting if not category in self.category_names: self.category_names[category] = [] # Create scrollarea scroll_area = QScrollArea(self) scroll_area.setWidgetResizable(True) scroll_area.setVerticalScrollBarPolicy( Qt.ScrollBarAsNeeded) scroll_area.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) # Create tab widget and layout layout = QVBoxLayout() tabWidget = QWidget(self) tabWidget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) tabWidget.setLayout(layout) scroll_area.setWidget(tabWidget) # Add tab self.tabCategories.addTab(scroll_area, _(category)) self.category_tabs[category] = tabWidget # Append translated title item["title_tr"] = _(item.get("title")) # Append settings into correct category self.category_names[category].append(item) # Loop through each category setting, and add them to the tabs for category in self.category_tabs.keys(): tabWidget = self.category_tabs[category] # Get list of items in category params = self.category_names[category] if self.category_sort.get(category): # Sort this category by translated title params.sort(key=operator.itemgetter("title_tr")) # Loop through settings for each category for param in params: # Create Label widget = None extraWidget = None label = QLabel() label.setText(_(param["title"])) label.setToolTip(_(param["title"])) if param["type"] == "spinner": # create QDoubleSpinBox widget = QDoubleSpinBox() widget.setMinimum(float(param["min"])) widget.setMaximum(float(param["max"])) widget.setValue(float(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect( functools.partial(self.spinner_value_changed, param)) if param["type"] == "spinner-int": # create QDoubleSpinBox widget = QSpinBox() widget.setMinimum(int(param["min"])) widget.setMaximum(int(param["max"])) widget.setValue(int(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect( functools.partial(self.spinner_value_changed, param)) elif param["type"] == "text": # create QLineEdit widget = QLineEdit() widget.setText(_(param["value"])) widget.textChanged.connect( functools.partial(self.text_value_changed, widget, param)) elif param["type"] == "browse": # create QLineEdit widget = QLineEdit() widget.setText(_(param["value"])) widget.textChanged.connect( functools.partial(self.text_value_changed, widget, param)) extraWidget = QPushButton(_("Browse...")) extraWidget.clicked.connect( functools.partial(self.selectExecutable, widget, param)) elif param["type"] == "bool": # create spinner widget = QCheckBox() if param["value"] == True: widget.setCheckState(Qt.Checked) else: widget.setCheckState(Qt.Unchecked) widget.stateChanged.connect( functools.partial(self.bool_value_changed, widget, param)) elif param["type"] == "dropdown": # create spinner widget = QComboBox() # Get values value_list = param["values"] # Overwrite value list (for profile dropdown) if param["setting"] == "default-profile": value_list = [] # Loop through profiles for profile_folder in [ info.USER_PROFILES_PATH, info.PROFILES_PATH ]: for file in os.listdir(profile_folder): # Load Profile and append description profile_path = os.path.join( profile_folder, file) profile = openshot.Profile(profile_path) value_list.append({ "name": profile.info.description, "value": profile.info.description }) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Overwrite value list (for language dropdown) if param["setting"] == "default-language": value_list = [] # Loop through languages for locale, language, country in get_all_languages(): # Load Profile and append description if language: lang_name = "%s (%s)" % (language, locale) value_list.append({ "name": lang_name, "value": locale }) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Add Default to top of list value_list.insert(0, { "name": _("Default"), "value": "Default" }) # Add normal values box_index = 0 for value_item in value_list: k = value_item["name"] v = value_item["value"] # add dropdown item widget.addItem(_(k), v) # select dropdown (if default) if v == param["value"]: widget.setCurrentIndex(box_index) box_index = box_index + 1 widget.currentIndexChanged.connect( functools.partial(self.dropdown_index_changed, widget, param)) # Add Label and Widget to the form if (widget and label): # Add minimum size label.setMinimumWidth(180) label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) # Create HBox layout layout_hbox = QHBoxLayout() layout_hbox.addWidget(label) layout_hbox.addWidget(widget) if (extraWidget): layout_hbox.addWidget(extraWidget) # Add widget to layout tabWidget.layout().addLayout(layout_hbox) elif (label): # Add widget to layout tabWidget.layout().addWidget(label) # Add stretch to bottom of layout tabWidget.layout().addStretch()
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Track metrics track_metric_screen("preferences-screen") # Load all user values self.params = {} for item in self.settings_data: if "setting" in item and "value" in item: self.params[item["setting"]] = item self.requires_restart = False self.category_names = {} self.category_tabs = {} # Loop through settings and find all unique categories for item in self.settings_data: category = item["category"] setting_type = item["type"] if not setting_type == "hidden": # Load setting if not category in self.category_names: self.category_names[category] = [] # Add new category as a tab tabWidget = QWidget(self) self.tabCategories.addTab(tabWidget, _(category)) self.category_tabs[category] = tabWidget # Add form layout to this tab layout = QFormLayout(tabWidget) # Append settings into correct category self.category_names[category].append(item) # Loop through each category setting, and add them to the tabs for category in self.category_tabs.keys(): tabWidget = self.category_tabs[category] # Loop through settings for each category for param in self.category_names[category]: # Create Label widget = None label = QLabel() label.setText(_(param["title"])) label.setToolTip(_(param["title"])) if param["type"] == "spinner": # create QDoubleSpinBox widget = QDoubleSpinBox() widget.setMinimum(float(param["min"])) widget.setMaximum(float(param["max"])) widget.setValue(float(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect(functools.partial(self.spinner_value_changed, param)) if param["type"] == "spinner-int": # create QDoubleSpinBox widget = QSpinBox() widget.setMinimum(int(param["min"])) widget.setMaximum(int(param["max"])) widget.setValue(int(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect(functools.partial(self.spinner_value_changed, param)) elif param["type"] == "text": # create QLineEdit widget = QLineEdit() widget.setText(_(param["value"])) widget.textChanged.connect(functools.partial(self.text_value_changed, widget, param)) elif param["type"] == "bool": # create spinner widget = QCheckBox() if param["value"] == True: widget.setCheckState(Qt.Checked) else: widget.setCheckState(Qt.Unchecked) widget.stateChanged.connect(functools.partial(self.bool_value_changed, widget, param)) elif param["type"] == "dropdown": # create spinner widget = QComboBox() # Get values value_list = param["values"] # Overwrite value list (for profile dropdown) if param["setting"] == "default-profile": value_list = [] # Loop through profiles for profile_folder in [info.USER_PROFILES_PATH, info.PROFILES_PATH]: for file in os.listdir(profile_folder): # Load Profile and append description profile_path = os.path.join(profile_folder, file) profile = openshot.Profile(profile_path) value_list.append({"name":profile.info.description, "value":profile.info.description}) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Overwrite value list (for language dropdown) if param["setting"] == "default-language": value_list = [] # Loop through languages for locale, language, country in get_all_languages(): # Load Profile and append description if language: lang_name = "%s (%s)" % (language, locale) value_list.append({"name":lang_name, "value":locale}) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Add Default to top of list value_list.insert(0, {"name":_("Default"), "value":"Default"}) # Add normal values box_index = 0 for value_item in value_list: k = value_item["name"] v = value_item["value"] # add dropdown item widget.addItem(_(k), v) # select dropdown (if default) if v == param["value"]: widget.setCurrentIndex(box_index) box_index = box_index + 1 widget.currentIndexChanged.connect(functools.partial(self.dropdown_index_changed, widget, param)) # Add Label and Widget to the form if (widget and label): tabWidget.layout().addRow(label, widget) elif (label): tabWidget.layout().addRow(label)
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations _ = get_app()._tr # Connections to objects imported from .ui file tab = { "openshot-qt": self.tab_openshot_qt, "libopenshot": self.tab_libopenshot, "libopenshot-audio": self.tab_libopenshot_audio, } vbox = { "openshot-qt": self.vbox_openshot_qt, "libopenshot": self.vbox_libopenshot, "libopenshot-audio": self.vbox_libopenshot_audio, } filter = { "openshot-qt": self.txtChangeLogFilter_openshot_qt, "libopenshot": self.txtChangeLogFilter_libopenshot, "libopenshot-audio": self.txtChangeLogFilter_libopenshot_audio, } # Update github link button github_text = _("OpenShot on GitHub") github_html = ''' <html><head/><body> <p align="center"> <a href="https://github.com/OpenShot/"> <span style=" text-decoration: underline; color:#55aaff;">%s</span> </a> </p> </body></html> ''' % (github_text) self.lblGitHubLink.setText(github_html) # Read changelog file for each project for project in ['openshot-qt', 'libopenshot', 'libopenshot-audio']: new_changelog_path = os.path.join(info.PATH, 'resources', '{}.log'.format(project)) old_changelog_path = os.path.join(info.PATH, 'settings', '{}.log'.format(project)) if os.path.exists(new_changelog_path): log.debug("Reading changelog file: {}".format(new_changelog_path)) changelog_list = parse_new_changelog(new_changelog_path) elif os.path.isfile(old_changelog_path): log.debug("Reading legacy changelog file: {}".format(old_changelog_path)) changelog_list = parse_changelog(old_changelog_path) else: changelog_list = None # Hopefully we found ONE of the two if changelog_list is None: log.warn("Could not load changelog for {}".format(project)) # Hide the tab for this changelog tabindex = self.tabChangelog.indexOf(tab[project]) if tabindex >= 0: self.tabChangelog.removeTab(tabindex) continue # Populate listview widget with changelog data cl_treeview = ChangelogTreeView( commits=changelog_list, commit_url="https://github.com/OpenShot/{}/commit/%s/".format(project)) vbox[project].addWidget(cl_treeview) filter[project].textChanged.connect( partial(self.Filter_Triggered, filter[project], cl_treeview))
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer & init ui_util.load_ui(self, self.ui_path) ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Hide chnagelog button by default self.btnchangelog.setVisible(False) projects = ['openshot-qt', 'libopenshot', 'libopenshot-audio'] # Old paths paths = [os.path.join(info.PATH, 'settings', '{}.log'.format(p)) for p in projects] # New paths paths.extend([os.path.join(info.PATH, 'resources', '{}.log'.format(p)) for p in projects]) if any([os.path.exists(path) for path in paths]): self.btnchangelog.setVisible(True) else: log.warn("No changelog files found, disabling button") create_text = _('Create & Edit Amazing Videos and Movies') description_text = _( "OpenShot Video Editor 2.x is the next generation of the award-winning <br/>" "OpenShot video editing platform.") learnmore_text = _('Learn more') copyright_text = _('Copyright © %(begin_year)s-%(current_year)s') % { 'begin_year': '2008', 'current_year': str(datetime.datetime.today().year) } about_html = ''' <html><head/><body><hr/> <p align="center"> <span style=" font-size:10pt; font-weight:600;">%s</span> </p> <p align="center"> <span style=" font-size:10pt;">%s </span> <a href="https://www.openshot.org/%s?r=about-us"> <span style=" font-size:10pt; text-decoration: none; color:#55aaff;">%s</span> </a> <span style=" font-size:10pt;">.</span> </p> </body></html> ''' % ( create_text, description_text, info.website_language(), learnmore_text) company_html = ''' <html><head/> <body style="font-size:11pt; font-weight:400; font-style:normal;"> <hr /> <p align="center" style="margin:12px 12px 0 0; -qt-block-indent:0; text-indent:0;"> <span style="font-size:10pt; font-weight:600;">%s </span> <a href="http://www.openshotstudios.com?r=about-us"> <span style="font-size:10pt; font-weight:600; text-decoration: none; color:#55aaff;"> OpenShot Studios, LLC<br /></span></a> </p> </body></html> ''' % (copyright_text) # Set description and company labels self.lblAboutDescription.setText(about_html) self.lblAboutCompany.setText(company_html) # set events handlers self.btncredit.clicked.connect(self.load_credit) self.btnlicense.clicked.connect(self.load_license) self.btnchangelog.clicked.connect(self.load_changelog) # Look for frozen version info frozen_version_label = "" 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()) if version_info: frozen_version_label = "<br/><br/><b>%s</b><br/>Build Date: %s" % \ (version_info.get('build_name'), version_info.get('date')) # Init some variables openshot_qt_version = _("Version: %s") % info.VERSION libopenshot_version = "libopenshot: %s" % openshot.OPENSHOT_VERSION_FULL self.txtversion.setText( "<b>%s</b><br/>%s%s" % (openshot_qt_version, libopenshot_version, frozen_version_label)) self.txtversion.setAlignment(Qt.AlignCenter) # Track metrics track_metric_screen("about-screen")
def __init__(self, file): self.file = file # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Track metrics track_metric_screen("file-properties-screen") # Add buttons to interface self.update_button = QPushButton(_('Update')) self.buttonBox.addButton(self.update_button, QDialogButtonBox.AcceptRole) self.buttonBox.addButton(QPushButton(_('Cancel')), QDialogButtonBox.RejectRole) # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Get file properties path, filename = os.path.split(self.file.data["path"]) baseFilename, ext = os.path.splitext(filename) fps_float = float(self.file.data["fps"]["num"]) / float(self.file.data["fps"]["den"]) tags = "" if "tags" in self.file.data.keys(): tags = self.file.data["tags"] name = filename if "name" in self.file.data.keys(): name = self.file.data["name"] # Populate fields self.txtFileName.setText(name) self.txtTags.setText(tags) self.txtFilePath.setText(os.path.join(path, filename)) self.btnBrowse.clicked.connect(self.browsePath) # Populate video fields self.txtWidth.setValue(self.file.data["width"]) self.txtHeight.setValue(self.file.data["height"]) self.txtFrameRateNum.setValue(self.file.data["fps"]["num"]) self.txtFrameRateDen.setValue(self.file.data["fps"]["den"]) self.txtAspectRatioNum.setValue(self.file.data["display_ratio"]["num"]) self.txtAspectRatioDen.setValue(self.file.data["display_ratio"]["den"]) self.txtPixelRatioNum.setValue(self.file.data["pixel_ratio"]["num"]) self.txtPixelRatioDen.setValue(self.file.data["pixel_ratio"]["den"]) # Disable Framerate if audio stream found if self.file.data["has_audio"]: self.txtFrameRateNum.setEnabled(False) self.txtFrameRateDen.setEnabled(False) self.txtStartFrame.setMaximum(int(self.file.data["video_length"])) if 'start' not in file.data.keys(): self.txtStartFrame.setValue(1) else: self.txtStartFrame.setValue(round(float(file.data["start"]) * fps_float) + 1) self.txtEndFrame.setMaximum(int(self.file.data["video_length"])) if 'end' not in file.data.keys(): self.txtEndFrame.setValue(int(self.file.data["video_length"])) else: self.txtEndFrame.setValue(round(float(file.data["end"]) * fps_float) + 1) # Populate video & audio format self.txtVideoFormat.setText(ext.replace(".", "")) self.txtVideoCodec.setText(self.file.data["vcodec"]) self.txtAudioCodec.setText(self.file.data["acodec"]) self.txtSampleRate.setValue(int(self.file.data["sample_rate"])) self.txtChannels.setValue(int(self.file.data["channels"])) self.txtVideoBitRate.setValue(int(self.file.data["video_bit_rate"])) self.txtAudioBitRate.setValue(int(self.file.data["audio_bit_rate"])) # Populate output field self.txtOutput.setText(json.dumps(file.data, sort_keys=True, indent=4, separators=(',', ': '))) # Add channel layouts channel_layout_index = 0 selected_channel_layout_index = 0 current_channel_layout = 0 if self.file.data["has_audio"]: current_channel_layout = int(self.file.data["channel_layout"]) self.channel_layout_choices = [] for layout in [(0, _("Unknown")), (openshot.LAYOUT_MONO, _("Mono (1 Channel)")), (openshot.LAYOUT_STEREO, _("Stereo (2 Channel)")), (openshot.LAYOUT_SURROUND, _("Surround (3 Channel)")), (openshot.LAYOUT_5POINT1, _("Surround (5.1 Channel)")), (openshot.LAYOUT_7POINT1, _("Surround (7.1 Channel)"))]: log.info(layout) self.channel_layout_choices.append(layout[0]) self.cboChannelLayout.addItem(layout[1], layout[0]) if current_channel_layout == layout[0]: selected_channel_layout_index = channel_layout_index channel_layout_index += 1 # Select matching channel layout self.cboChannelLayout.setCurrentIndex(selected_channel_layout_index) # Load the interlaced options self.cboInterlaced.clear() self.cboInterlaced.addItem(_("Yes"), "Yes") self.cboInterlaced.addItem(_("No"), "No") if self.file.data["interlaced_frame"]: self.cboInterlaced.setCurrentIndex(0) else: self.cboInterlaced.setCurrentIndex(1) # Switch to 1st page self.toolBox.setCurrentIndex(0)
def __init__(self): QDialog.__init__(self, parent=app.main_window) ui_util.load_ui(self, 'settings_db') ui_util.init_ui(self) self._fill_settings_fields()
def __init__(self, file=None, preview=False): _ = get_app()._tr # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("cutting-screen") # If preview, hide cutting controls if preview: self.lblInstructions.setVisible(False) self.widgetControls.setVisible(False) self.setWindowTitle(_("Preview")) self.start_frame = 1 self.start_image = None self.end_frame = 1 self.end_image = None # Keep track of file object self.file = file self.file_path = file.absolute_path() self.video_length = int(file.data['video_length']) self.fps_num = int(file.data['fps']['num']) self.fps_den = int(file.data['fps']['den']) self.fps = float(self.fps_num) / float(self.fps_den) self.width = int(file.data['width']) self.height = int(file.data['height']) self.sample_rate = int(file.data['sample_rate']) self.channels = int(file.data['channels']) self.channel_layout = int(file.data['channel_layout']) # Open video file with Reader log.info(self.file_path) # Create an instance of a libopenshot Timeline object self.r = openshot.Timeline(self.width, self.height, openshot.Fraction(self.fps_num, self.fps_den), self.sample_rate, self.channels, self.channel_layout) self.r.info.channel_layout = self.channel_layout try: # Add clip for current preview file self.clip = openshot.Clip(self.file_path) # Show waveform for audio files if not self.clip.Reader().info.has_video and self.clip.Reader().info.has_audio: self.clip.Waveform(True) # Set has_audio property self.r.info.has_audio = self.clip.Reader().info.has_audio if preview: # Display frame #'s during preview self.clip.display = openshot.FRAME_DISPLAY_CLIP self.r.AddClip(self.clip) except: log.error('Failed to load media file into preview player: %s' % self.file_path) return # Add Video Widget self.videoPreview = VideoWidget() self.videoPreview.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.verticalLayout.insertWidget(0, self.videoPreview) # Set max size of video preview (for speed) viewport_rect = self.videoPreview.centeredViewport(self.videoPreview.width(), self.videoPreview.height()) self.r.SetMaxSize(viewport_rect.width(), viewport_rect.height()) # Open reader self.r.Open() # Start the preview thread self.initialized = False self.transforming_clip = False self.preview_parent = PreviewParent() self.preview_parent.Init(self, self.r, self.videoPreview) self.preview_thread = self.preview_parent.worker # Set slider constraints self.sliderIgnoreSignal = False self.sliderVideo.setMinimum(1) self.sliderVideo.setMaximum(self.video_length) self.sliderVideo.setSingleStep(1) self.sliderVideo.setSingleStep(1) self.sliderVideo.setPageStep(24) # Determine if a start or end attribute is in this file start_frame = 1 if 'start' in self.file.data.keys(): start_frame = (float(self.file.data['start']) * self.fps) + 1 # Display start frame (and then the previous frame) QTimer.singleShot(500, functools.partial(self.sliderVideo.setValue, start_frame + 1)) QTimer.singleShot(600, functools.partial(self.sliderVideo.setValue, start_frame)) # Connect signals self.actionPlay.triggered.connect(self.actionPlay_Triggered) self.btnPlay.clicked.connect(self.btnPlay_clicked) self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged) self.btnStart.clicked.connect(self.btnStart_clicked) self.btnEnd.clicked.connect(self.btnEnd_clicked) self.btnClear.clicked.connect(self.btnClear_clicked) self.btnAddClip.clicked.connect(self.btnAddClip_clicked) self.initialized = True
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Track metrics track_metric_screen("export-screen") # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Add buttons to interface self.export_button = QPushButton(_('Export Video')) self.buttonBox.addButton(self.export_button, QDialogButtonBox.AcceptRole) self.buttonBox.addButton(QPushButton(_('Cancel')), QDialogButtonBox.RejectRole) self.exporting = False # Clear timeline preview cache (to get more avaiable memory) if get_app().window.cache_object: get_app().window.cache_object.Clear() # Hide audio channels self.lblChannels.setVisible(False) self.txtChannels.setVisible(False) # Get the original timeline settings width = get_app().window.timeline_sync.timeline.info.width height = get_app().window.timeline_sync.timeline.info.height fps = get_app().window.timeline_sync.timeline.info.fps sample_rate = get_app().window.timeline_sync.timeline.info.sample_rate channels = get_app().window.timeline_sync.timeline.info.channels channel_layout = get_app( ).window.timeline_sync.timeline.info.channel_layout # Create new "export" openshot.Timeline object self.timeline = openshot.Timeline(width, height, openshot.Fraction(fps.num, fps.den), sample_rate, channels, channel_layout) # Init various properties self.timeline.info.channel_layout = get_app( ).window.timeline_sync.timeline.info.channel_layout self.timeline.info.has_audio = get_app( ).window.timeline_sync.timeline.info.has_audio self.timeline.info.has_video = get_app( ).window.timeline_sync.timeline.info.has_video self.timeline.info.video_length = get_app( ).window.timeline_sync.timeline.info.video_length self.timeline.info.duration = get_app( ).window.timeline_sync.timeline.info.duration self.timeline.info.sample_rate = get_app( ).window.timeline_sync.timeline.info.sample_rate self.timeline.info.channels = get_app( ).window.timeline_sync.timeline.info.channels # Load the "export" Timeline reader with the JSON from the real timeline json_timeline = json.dumps(get_app().project._data) self.timeline.SetJson(json_timeline) # Open the "export" Timeline reader self.timeline.Open() # Default export path recommended_path = recommended_path = os.path.join(info.HOME_PATH) if app.project.current_filepath: recommended_path = os.path.dirname(app.project.current_filepath) export_path = get_app().project.get(["export_path"]) if os.path.exists(export_path): # Use last selected export path self.txtExportFolder.setText(export_path) else: # Default to home dir self.txtExportFolder.setText(recommended_path) # Is this a saved project? if not get_app().project.current_filepath: # Not saved yet self.txtFileName.setText(_("Untitled Project")) else: # Yes, project is saved # Get just the filename parent_path, filename = os.path.split( get_app().project.current_filepath) filename, ext = os.path.splitext(filename) self.txtFileName.setText( filename.replace("_", " ").replace("-", " ").capitalize()) # Default image type self.txtImageFormat.setText("%05.png") # Loop through Export To options export_options = [_("Video & Audio"), _("Image Sequence")] for option in export_options: # append profile to list self.cboExportTo.addItem(option) # Add channel layouts self.channel_layout_choices = [] for layout in [(openshot.LAYOUT_MONO, _("Mono (1 Channel)")), (openshot.LAYOUT_STEREO, _("Stereo (2 Channel)")), (openshot.LAYOUT_SURROUND, _("Surround (3 Channel)")), (openshot.LAYOUT_5POINT1, _("Surround (5.1 Channel)")), (openshot.LAYOUT_7POINT1, _("Surround (7.1 Channel)"))]: log.info(layout) self.channel_layout_choices.append(layout[0]) self.cboChannelLayout.addItem(layout[1], layout[0]) # Connect signals self.btnBrowse.clicked.connect( functools.partial(self.btnBrowse_clicked)) self.cboSimpleProjectType.currentIndexChanged.connect( functools.partial(self.cboSimpleProjectType_index_changed, self.cboSimpleProjectType)) self.cboProfile.currentIndexChanged.connect( functools.partial(self.cboProfile_index_changed, self.cboProfile)) self.cboSimpleTarget.currentIndexChanged.connect( functools.partial(self.cboSimpleTarget_index_changed, self.cboSimpleTarget)) self.cboSimpleVideoProfile.currentIndexChanged.connect( functools.partial(self.cboSimpleVideoProfile_index_changed, self.cboSimpleVideoProfile)) self.cboSimpleQuality.currentIndexChanged.connect( functools.partial(self.cboSimpleQuality_index_changed, self.cboSimpleQuality)) self.cboChannelLayout.currentIndexChanged.connect(self.updateChannels) get_app().window.ExportFrame.connect(self.updateProgressBar) # ********* Advaned Profile List ********** # Loop through profiles self.profile_names = [] self.profile_paths = {} for profile_folder in [info.USER_PROFILES_PATH, info.PROFILES_PATH]: for file in os.listdir(profile_folder): # Load Profile profile_path = os.path.join(profile_folder, file) profile = openshot.Profile(profile_path) # Add description of Profile to list self.profile_names.append(profile.info.description) self.profile_paths[profile.info.description] = profile_path # Sort list self.profile_names.sort() # Loop through sorted profiles box_index = 0 self.selected_profile_index = 0 for profile_name in self.profile_names: # Add to dropdown self.cboProfile.addItem(profile_name, self.profile_paths[profile_name]) # Set default (if it matches the project) if app.project.get(['profile']) == profile_name: self.selected_profile_index = box_index # increment item counter box_index += 1 # ********* Simple Project Type ********** # load the simple project type dropdown presets = [] for file in os.listdir(info.EXPORT_PRESETS_DIR): xmldoc = xml.parse(os.path.join(info.EXPORT_PRESETS_DIR, file)) type = xmldoc.getElementsByTagName("type") presets.append(_(type[0].childNodes[0].data)) # Exclude duplicates type_index = 0 selected_type = 0 presets = list(set(presets)) for item in sorted(presets): self.cboSimpleProjectType.addItem(item, item) if item == _("All Formats"): selected_type = type_index type_index += 1 # Always select 'All Formats' option self.cboSimpleProjectType.setCurrentIndex(selected_type) # Populate all profiles self.populateAllProfiles(app.project.get(['profile'])) # Connect framerate signals self.txtFrameRateNum.valueChanged.connect(self.updateFrameRate) self.txtFrameRateDen.valueChanged.connect(self.updateFrameRate) self.txtWidth.valueChanged.connect(self.updateFrameRate) self.txtHeight.valueChanged.connect(self.updateFrameRate) self.txtSampleRate.valueChanged.connect(self.updateFrameRate) self.txtChannels.valueChanged.connect(self.updateFrameRate) self.cboChannelLayout.currentIndexChanged.connect(self.updateFrameRate) # Determine the length of the timeline (in frames) self.updateFrameRate()
def __init__(self): # Create main window base class QMainWindow.__init__(self) # set window on app for reference during initialization of children get_app().window = self # Load UI from designer ui_util.load_ui(self, self.ui_path) # Load user settings for window s = settings.get_settings() self.recent_menu = None # Init UI ui_util.init_ui(self) # Setup toolbars that aren't on main window, set initial state of items, etc self.setup_toolbars() # Add window as watcher to receive undo/redo status updates get_app().updates.add_watcher(self) # Track the selected file(s) self.selected_files = [] self.selected_clips = [] self.selected_transitions = [] self.selected_markers = [] self.selected_tracks = [] self.selected_effects = [] # Init fullscreen menu visibility self.init_fullscreen_menu() # Setup timeline self.timeline = TimelineWebView(self) self.frameWeb.layout().addWidget(self.timeline) # Set Window title self.SetWindowTitle() # Setup files tree if s.get("file_view") == "details": self.filesTreeView = FilesTreeView(self) else: self.filesTreeView = FilesListView(self) self.tabFiles.layout().addWidget(self.filesTreeView) # Setup transitions tree if s.get("transitions_view") == "details": self.transitionsTreeView = TransitionsTreeView(self) else: self.transitionsTreeView = TransitionsListView(self) self.tabTransitions.layout().addWidget(self.transitionsTreeView) # Setup effects tree if s.get("effects_view") == "details": self.effectsTreeView = EffectsTreeView(self) else: self.effectsTreeView = EffectsListView(self) self.tabEffects.layout().addWidget(self.effectsTreeView) # Setup properties table self.propertyTableView = PropertiesTableView(self) self.dockPropertiesContent.layout().addWidget(self.propertyTableView, 3, 1) # Setup video preview QWidget self.videoPreview = VideoWidget() self.tabVideo.layout().insertWidget(0, self.videoPreview) # Load window state and geometry self.load_settings() # Create the timeline sync object (used for previewing timeline) self.timeline_sync = TimelineSync() # Start the preview thread self.preview_parent = PreviewParent() self.preview_parent.Init(self, self.timeline_sync.timeline) self.preview_thread = self.preview_parent.worker
def __init__(self, files=None, position=0.0): # Create dialog class QDialog.__init__(self) # Load UI from Designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Get settings self.settings = settings.get_settings() # Get translation object self.app = get_app() _ = self.app._tr # Track metrics track_metric_screen("add-to-timeline-screen") # Add custom treeview to window self.treeFiles = TimelineTreeView(self) self.vboxTreeParent.insertWidget(0, self.treeFiles) # Update data in model self.treeFiles.timeline_model.update_model(files) # Refresh view self.treeFiles.refresh_view() # Init start position self.txtStartTime.setValue(position) # Init default image length self.txtImageLength.setValue(self.settings.get("default-image-length")) self.txtImageLength.valueChanged.connect(self.updateTotal) self.cmbTransition.currentIndexChanged.connect(self.updateTotal) self.cmbFade.currentIndexChanged.connect(self.updateTotal) self.txtFadeLength.valueChanged.connect(self.updateTotal) self.txtTransitionLength.valueChanged.connect(self.updateTotal) # Add all tracks to dropdown tracks = Track.filter() for track in reversed(tracks): # Add to dropdown self.cmbTrack.addItem(_('Track %s' % track.data['number']), track.data['number']) # Add all fade options self.cmbFade.addItem(_('None'), None) self.cmbFade.addItem(_('Fade In'), 'Fade In') self.cmbFade.addItem(_('Fade Out'), 'Fade Out') self.cmbFade.addItem(_('Fade In & Out'), 'Fade In & Out') # Add all zoom options self.cmbZoom.addItem(_('None'), None) self.cmbZoom.addItem(_('Random'), 'Random') self.cmbZoom.addItem(_('Zoom In'), 'Zoom In') self.cmbZoom.addItem(_('Zoom Out'), 'Zoom Out') # Add all transitions transitions_dir = os.path.join(info.PATH, "transitions") common_dir = os.path.join(transitions_dir, "common") extra_dir = os.path.join(transitions_dir, "extra") transition_groups = [{ "type": "common", "dir": common_dir, "files": os.listdir(common_dir) }, { "type": "extra", "dir": extra_dir, "files": os.listdir(extra_dir) }] self.cmbTransition.addItem(_('None'), None) self.cmbTransition.addItem(_('Random'), 'random') self.transitions = [] for group in transition_groups: type = group["type"] dir = group["dir"] files = group["files"] for filename in sorted(files): path = os.path.join(dir, filename) (fileBaseName, fileExtension) = os.path.splitext(filename) # Skip hidden files (such as .DS_Store, etc...) if filename[0] == "." or "thumbs.db" in filename.lower(): continue # split the name into parts (looking for a number) suffix_number = None name_parts = fileBaseName.split("_") if name_parts[-1].isdigit(): suffix_number = name_parts[-1] # get name of transition trans_name = fileBaseName.replace("_", " ").capitalize() # replace suffix number with placeholder (if any) if suffix_number: trans_name = trans_name.replace(suffix_number, "%s") trans_name = _(trans_name) % suffix_number else: trans_name = _(trans_name) # Check for thumbnail path (in build-in cache) thumb_path = os.path.join(info.IMAGES_PATH, "cache", "{}.png".format(fileBaseName)) # Check built-in cache (if not found) if not os.path.exists(thumb_path): # Check user folder cache thumb_path = os.path.join(info.CACHE_PATH, "{}.png".format(fileBaseName)) # Add item self.transitions.append(path) self.cmbTransition.addItem(QIcon(thumb_path), _(trans_name), path) # Connections self.btnMoveUp.clicked.connect(self.btnMoveUpClicked) self.btnMoveDown.clicked.connect(self.btnMoveDownClicked) self.btnShuffle.clicked.connect(self.btnShuffleClicked) self.btnRemove.clicked.connect(self.btnRemoveClicked) self.btnBox.accepted.connect(self.accept) self.btnBox.rejected.connect(self.reject) # Update total self.updateTotal()
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Update github link button github_text = _("OpenShot on GitHub") github_html = '<html><head/><body><p align="center"><a href="https://github.com/OpenShot/"><span style=" text-decoration: underline; color:#55aaff;">%s</span></a></p></body></html>' % ( github_text) self.lblGitHubLink.setText(github_html) # Get changelog for openshot-qt (if any) changelog_list = [] changelog_path = os.path.join(info.PATH, 'settings', 'openshot-qt.log') if os.path.exists(changelog_path): # Attempt to open changelog with utf-8, and then utf-16-le (for unix / windows support) for encoding_name in ('utf-8', 'utf_16_le'): try: with codecs.open(changelog_path, 'r', encoding=encoding_name) as changelog_file: for line in changelog_file: changelog_list.append({ 'hash': line[:9].strip(), 'date': line[9:20].strip(), 'author': line[20:45].strip(), 'subject': line[45:].strip() }) break except: # Ignore decoding errors pass self.openshot_qt_ListView = ChangelogTreeView( commits=changelog_list, commit_url="https://github.com/OpenShot/openshot-qt/commit/%s/") self.vbox_openshot_qt.addWidget(self.openshot_qt_ListView) self.txtChangeLogFilter_openshot_qt.textChanged.connect( partial(self.Filter_Triggered, self.txtChangeLogFilter_openshot_qt, self.openshot_qt_ListView)) # Get changelog for libopenshot (if any) changelog_list = [] changelog_path = os.path.join(info.PATH, 'settings', 'libopenshot.log') if os.path.exists(changelog_path): # Attempt to open changelog with utf-8, and then utf-16-le (for unix / windows support) for encoding_name in ('utf-8', 'utf_16_le'): try: with codecs.open(changelog_path, 'r', encoding=encoding_name) as changelog_file: for line in changelog_file: changelog_list.append({ 'hash': line[:9].strip(), 'date': line[9:20].strip(), 'author': line[20:45].strip(), 'subject': line[45:].strip() }) except: # Ignore decoding errors pass self.libopenshot_ListView = ChangelogTreeView( commits=changelog_list, commit_url="https://github.com/OpenShot/libopenshot/commit/%s/") self.vbox_libopenshot.addWidget(self.libopenshot_ListView) self.txtChangeLogFilter_libopenshot.textChanged.connect( partial(self.Filter_Triggered, self.txtChangeLogFilter_libopenshot, self.libopenshot_ListView)) # Get changelog for libopenshot-audio (if any) changelog_list = [] changelog_path = os.path.join(info.PATH, 'settings', 'libopenshot-audio.log') if os.path.exists(changelog_path): # Attempt to open changelog with utf-8, and then utf-16-le (for unix / windows support) for encoding_name in ('utf-8', 'utf_16_le'): try: with codecs.open(changelog_path, 'r', encoding=encoding_name) as changelog_file: for line in changelog_file: changelog_list.append({ 'hash': line[:9].strip(), 'date': line[9:20].strip(), 'author': line[20:45].strip(), 'subject': line[45:].strip() }) except: # Ignore decoding errors pass self.libopenshot_audio_ListView = ChangelogTreeView( commits=changelog_list, commit_url= "https://github.com/OpenShot/libopenshot-audio/commit/%s/") self.vbox_libopenshot_audio.addWidget(self.libopenshot_audio_ListView) self.txtChangeLogFilter_libopenshot_audio.textChanged.connect( partial(self.Filter_Triggered, self.txtChangeLogFilter_libopenshot_audio, self.libopenshot_audio_ListView))
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Add buttons to interface self.export_button = QPushButton(_('Export Video')) self.buttonBox.addButton(self.export_button, QDialogButtonBox.AcceptRole) self.buttonBox.addButton(QPushButton(_('Cancel')), QDialogButtonBox.RejectRole) self.exporting = False # Default export path recommended_path = recommended_path = os.path.join(info.HOME_PATH) if app.project.current_filepath: recommended_path = os.path.dirname(app.project.current_filepath) export_path = get_app().project.get(["export_path"]) if os.path.exists(export_path): # Use last selected export path self.txtExportFolder.setText(export_path) else: # Default to home dir self.txtExportFolder.setText(recommended_path) # Is this a saved project? if not get_app().project.current_filepath: # Not saved yet self.txtFileName.setText(_("Untitled Project")) else: # Yes, project is saved # Get just the filename parent_path, filename = os.path.split(get_app().project.current_filepath) filename, ext = os.path.splitext(filename) self.txtFileName.setText(filename.replace("_", " ").replace("-", " ").capitalize()) # Default image type self.txtImageFormat.setText("%05.png") # Loop through Export To options export_options = [_("Video & Audio"), _("Image Sequence")] for option in export_options: # append profile to list self.cboExportTo.addItem(option) # Connect signals self.btnBrowse.clicked.connect(functools.partial(self.btnBrowse_clicked)) self.cboSimpleProjectType.currentIndexChanged.connect( functools.partial(self.cboSimpleProjectType_index_changed, self.cboSimpleProjectType)) self.cboProfile.currentIndexChanged.connect(functools.partial(self.cboProfile_index_changed, self.cboProfile)) self.cboSimpleTarget.currentIndexChanged.connect( functools.partial(self.cboSimpleTarget_index_changed, self.cboSimpleTarget)) self.cboSimpleVideoProfile.currentIndexChanged.connect( functools.partial(self.cboSimpleVideoProfile_index_changed, self.cboSimpleVideoProfile)) self.cboSimpleQuality.currentIndexChanged.connect( functools.partial(self.cboSimpleQuality_index_changed, self.cboSimpleQuality)) # ********* Advaned Profile List ********** # Loop through profiles self.profile_names = [] self.profile_paths = {} for file in os.listdir(info.PROFILES_PATH): # Load Profile profile_path = os.path.join(info.PROFILES_PATH, file) profile = openshot.Profile(profile_path) # Add description of Profile to list self.profile_names.append(profile.info.description) self.profile_paths[profile.info.description] = profile_path # Sort list self.profile_names.sort() # Loop through sorted profiles box_index = 0 self.selected_profile_index = 0 for profile_name in self.profile_names: # Add to dropdown self.cboProfile.addItem(profile_name, self.profile_paths[profile_name]) # Set default (if it matches the project) if app.project.get(['profile']) == profile_name: self.selected_profile_index = box_index # increment item counter box_index += 1 # ********* Simple Project Type ********** # load the simple project type dropdown presets = [] for file in os.listdir(info.EXPORT_PRESETS_DIR): xmldoc = xml.parse(os.path.join(info.EXPORT_PRESETS_DIR, file)) type = xmldoc.getElementsByTagName("type") presets.append(_(type[0].childNodes[0].data)) # Exclude duplicates presets = list(set(presets)) for item in sorted(presets): self.cboSimpleProjectType.addItem(item, item) # Populate all profiles self.populateAllProfiles(app.project.get(['profile'])) # Connect framerate signals self.txtFrameRateNum.valueChanged.connect(self.updateFrameRate) self.txtFrameRateDen.valueChanged.connect(self.updateFrameRate) self.txtWidth.valueChanged.connect(self.updateFrameRate) self.txtHeight.valueChanged.connect(self.updateFrameRate) self.txtSampleRate.valueChanged.connect(self.updateFrameRate) self.txtChannels.valueChanged.connect(self.updateFrameRate) # Determine the length of the timeline (in frames) self.updateFrameRate()
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init Ui ui_util.init_ui(self) # get translations self.app = get_app() _ = self.app._tr # Hide chnagelog button by default self.btnchangelog.setVisible(False) for project in ['openshot-qt', 'libopenshot', 'libopenshot-audio']: changelog_path = os.path.join(info.PATH, 'settings', '%s.log' % project) if os.path.exists(changelog_path): # Attempt to open changelog with utf-8, and then utf-16-le (for unix / windows support) for encoding_name in ('utf-8', 'utf_16_le'): try: with codecs.open( changelog_path, 'r', encoding=encoding_name) as changelog_file: if changelog_file.read(): self.btnchangelog.setVisible(True) break except: # Ignore decoding errors pass create_text = _('Create & Edit Amazing Videos and Movies') description_text = _( 'OpenShot Video Editor 2.x is the next generation of the award-winning <br/>OpenShot video editing platform.' ) learnmore_text = _('Learn more') copyright_text = _( 'Copyright © %(begin_year)s-%(current_year)s') % { 'begin_year': '2008', 'current_year': str(datetime.datetime.today().year) } about_html = '<html><head/><body><hr/><p align="center"><span style=" font-size:10pt; font-weight:600;">%s</span></p><p align="center"><span style=" font-size:10pt;">%s </span><a href="https://www.openshot.org/%s?r=about-us"><span style=" font-size:10pt; text-decoration: none; color:#55aaff;">%s</span></a><span style=" font-size:10pt;">.</span></p></body></html>' % ( create_text, description_text, info.website_language(), learnmore_text) company_html = '<html><head/><body style="font-size:11pt; font-weight:400; font-style:normal;">\n<hr />\n<p align="center" style=" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">%s </span><a href="http://www.openshotstudios.com?r=about-us"><span style=" font-size:10pt; font-weight:600; text-decoration: none; color:#55aaff;">OpenShot Studios, LLC<br /></span></a></p></body></html>' % ( copyright_text) # Set description and company labels self.lblAboutDescription.setText(about_html) self.lblAboutCompany.setText(company_html) # set events handlers self.btncredit.clicked.connect(self.load_credit) self.btnlicense.clicked.connect(self.load_license) self.btnchangelog.clicked.connect(self.load_changelog) # Init some variables openshot_qt_version = _("Version: %s") % info.VERSION libopenshot_version = "libopenshot: %s" % openshot.OPENSHOT_VERSION_FULL self.txtversion.setText("<b>%s</b><br/>%s" % (openshot_qt_version, libopenshot_version)) self.txtversion.setAlignment(Qt.AlignCenter) # Track metrics track_metric_screen("about-screen")
def __init__(self, edit_file_path=None, duplicate=False): # Create dialog class QDialog.__init__(self) self.app = get_app() self.project = self.app.project self.edit_file_path = edit_file_path self.duplicate = duplicate # Get translation object _ = self.app._tr # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("title-screen") # Initialize variables self.template_name = "" imp = minidom.getDOMImplementation() self.xmldoc = imp.createDocument(None, "any", None) self.bg_color_code = QtGui.QColor(Qt.black) self.font_color_code = QtGui.QColor(Qt.white) self.bg_style_string = "" self.title_style_string = "" self.subtitle_style_string = "" self.font_weight = 'normal' self.font_style = 'normal' self.new_title_text = "" self.sub_title_text = "" self.subTitle = False self.display_name = "" self.font_family = "Bitstream Vera Sans" self.tspan_node = None self.qfont = QtGui.QFont(self.font_family) # Add titles list view self.titlesTreeView = TitlesListView(self) self.verticalLayout.addWidget(self.titlesTreeView) # Disable Save button on window load self.buttonBox.button(self.buttonBox.Save).setEnabled(False) # If editing existing title svg file if self.edit_file_path: # Hide list of templates self.widget.setVisible(False) # Create temp version of title self.create_temp_title(self.edit_file_path) # Add all widgets for editing self.load_svg_template() # Display image (slight delay to allow screen to be shown first) QTimer.singleShot(50, self.display_svg)
def __init__(self, file=None): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("cutting-screen") self.start_frame = 1 self.start_image = None self.end_frame = 1 self.end_image = None # Keep track of file object self.file = file self.file_path = file.absolute_path() self.video_length = int(file.data['video_length']) self.fps_num = int(file.data['fps']['num']) self.fps_den = int(file.data['fps']['den']) self.fps = float(self.fps_num) / float(self.fps_den) # Open video file with Reader log.info(self.file_path) self.r = openshot.FFmpegReader(self.file_path) self.r.Open() # Add Video Widget self.videoPreview = VideoWidget() self.videoPreview.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.verticalLayout.insertWidget(0, self.videoPreview) # Start the preview thread self.preview_parent = PreviewParent() self.preview_parent.Init(self, self.r, self.videoPreview) self.preview_thread = self.preview_parent.worker # Set slider constraints self.sliderIgnoreSignal = False self.sliderVideo.setMinimum(1) self.sliderVideo.setMaximum(self.video_length) self.sliderVideo.setSingleStep(1) self.sliderVideo.setSingleStep(1) self.sliderVideo.setPageStep(24) # Determine if a start or end attribute is in this file start_frame = 1 if 'start' in self.file.data.keys(): start_frame = (float(self.file.data['start']) * self.fps) + 1 # Display start frame (and then the previous frame) QTimer.singleShot( 500, functools.partial(self.sliderVideo.setValue, start_frame + 1)) QTimer.singleShot( 600, functools.partial(self.sliderVideo.setValue, start_frame)) # Connect signals self.btnPlay.clicked.connect(self.btnPlay_clicked) self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged) self.btnStart.clicked.connect(self.btnStart_clicked) self.btnEnd.clicked.connect(self.btnEnd_clicked) self.btnClear.clicked.connect(self.btnClear_clicked) self.btnAddClip.clicked.connect(self.btnAddClip_clicked)
def __init__(self, files=None, position=0.0): # Create dialog class QDialog.__init__(self) # Load UI from Designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Get settings self.settings = settings.get_settings() # Get translation object self.app = get_app() _ = self.app._tr # Track metrics track_metric_screen("add-to-timeline-screen") # Add custom treeview to window self.treeFiles = TimelineTreeView(self) self.vboxTreeParent.insertWidget(0, self.treeFiles) # Update data in model self.treeFiles.timeline_model.update_model(files) # Refresh view self.treeFiles.refresh_view() # Init start position self.txtStartTime.setValue(position) # Init default image length self.txtImageLength.setValue(self.settings.get("default-image-length")) self.txtImageLength.valueChanged.connect(self.updateTotal) self.cmbTransition.currentIndexChanged.connect(self.updateTotal) self.cmbFade.currentIndexChanged.connect(self.updateTotal) self.txtFadeLength.valueChanged.connect(self.updateTotal) self.txtTransitionLength.valueChanged.connect(self.updateTotal) # Add all tracks to dropdown tracks = Track.filter() for track in reversed(tracks): # Add to dropdown self.cmbTrack.addItem(_('Track %s' % track.data['number']), track.data['number']) # Add all fade options self.cmbFade.addItem(_('None'), None) self.cmbFade.addItem(_('Fade In'), 'Fade In') self.cmbFade.addItem(_('Fade Out'), 'Fade Out') self.cmbFade.addItem(_('Fade In & Out'), 'Fade In & Out') # Add all zoom options self.cmbZoom.addItem(_('None'), None) self.cmbZoom.addItem(_('Random'), 'Random') self.cmbZoom.addItem(_('Zoom In'), 'Zoom In') self.cmbZoom.addItem(_('Zoom Out'), 'Zoom Out') # Add all transitions transitions_dir = os.path.join(info.PATH, "transitions") common_dir = os.path.join(transitions_dir, "common") extra_dir = os.path.join(transitions_dir, "extra") transition_groups = [{"type": "common", "dir": common_dir, "files": os.listdir(common_dir)}, {"type": "extra", "dir": extra_dir, "files": os.listdir(extra_dir)}] self.cmbTransition.addItem(_('None'), None) self.cmbTransition.addItem(_('Random'), 'random') self.transitions = [] for group in transition_groups: type = group["type"] dir = group["dir"] files = group["files"] for filename in sorted(files): path = os.path.join(dir, filename) (fileBaseName, fileExtension) = os.path.splitext(filename) # Skip hidden files (such as .DS_Store, etc...) if filename[0] == "." or "thumbs.db" in filename.lower(): continue # split the name into parts (looking for a number) suffix_number = None name_parts = fileBaseName.split("_") if name_parts[-1].isdigit(): suffix_number = name_parts[-1] # get name of transition trans_name = fileBaseName.replace("_", " ").capitalize() # replace suffix number with placeholder (if any) if suffix_number: trans_name = trans_name.replace(suffix_number, "%s") trans_name = _(trans_name) % suffix_number else: trans_name = _(trans_name) # Check for thumbnail path (in build-in cache) thumb_path = os.path.join(info.IMAGES_PATH, "cache", "{}.png".format(fileBaseName)) # Check built-in cache (if not found) if not os.path.exists(thumb_path): # Check user folder cache thumb_path = os.path.join(info.CACHE_PATH, "{}.png".format(fileBaseName)) # Add item self.transitions.append(path) self.cmbTransition.addItem(QIcon(thumb_path), _(trans_name), path) # Connections self.btnMoveUp.clicked.connect(self.btnMoveUpClicked) self.btnMoveDown.clicked.connect(self.btnMoveDownClicked) self.btnShuffle.clicked.connect(self.btnShuffleClicked) self.btnRemove.clicked.connect(self.btnRemoveClicked) self.btnBox.accepted.connect(self.accept) self.btnBox.rejected.connect(self.reject) # Update total self.updateTotal()
def __init__(self): # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # get translations app = get_app() _ = app._tr # Get settings self.s = settings.get_settings() # Dynamically load tabs from settings data self.settings_data = settings.get_settings().get_all_settings() # Track metrics track_metric_screen("preferences-screen") # Load all user values self.params = {} for item in self.settings_data: if "setting" in item and "value" in item: self.params[item["setting"]] = item self.requires_restart = False self.category_names = {} self.category_tabs = {} self.category_sort = {} # Loop through settings and find all unique categories for item in self.settings_data: category = item.get("category") setting_type = item.get("type") sort_category = item.get("sort") # Indicate sorted category if sort_category: self.category_sort[category] = sort_category if not setting_type == "hidden": # Load setting if not category in self.category_names: self.category_names[category] = [] # Create scrollarea scroll_area = QScrollArea(self) scroll_area.setWidgetResizable(True) scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) scroll_area.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) # Create tab widget and layout layout = QVBoxLayout() tabWidget = QWidget(self) tabWidget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) tabWidget.setLayout(layout) scroll_area.setWidget(tabWidget) # Add tab self.tabCategories.addTab(scroll_area, _(category)) self.category_tabs[category] = tabWidget # Append translated title item["title_tr"] = _(item.get("title")) # Append settings into correct category self.category_names[category].append(item) # Loop through each category setting, and add them to the tabs for category in self.category_tabs.keys(): tabWidget = self.category_tabs[category] # Get list of items in category params = self.category_names[category] if self.category_sort.get(category): # Sort this category by translated title params.sort(key=operator.itemgetter("title_tr")) # Loop through settings for each category for param in params: # Create Label widget = None extraWidget = None label = QLabel() label.setText(_(param["title"])) label.setToolTip(_(param["title"])) if param["type"] == "spinner": # create QDoubleSpinBox widget = QDoubleSpinBox() widget.setMinimum(float(param["min"])) widget.setMaximum(float(param["max"])) widget.setValue(float(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect(functools.partial(self.spinner_value_changed, param)) if param["type"] == "spinner-int": # create QDoubleSpinBox widget = QSpinBox() widget.setMinimum(int(param["min"])) widget.setMaximum(int(param["max"])) widget.setValue(int(param["value"])) widget.setSingleStep(1.0) widget.setToolTip(param["title"]) widget.valueChanged.connect(functools.partial(self.spinner_value_changed, param)) elif param["type"] == "text": # create QLineEdit widget = QLineEdit() widget.setText(_(param["value"])) widget.textChanged.connect(functools.partial(self.text_value_changed, widget, param)) elif param["type"] == "browse": # create QLineEdit widget = QLineEdit() widget.setText(_(param["value"])) widget.textChanged.connect(functools.partial(self.text_value_changed, widget, param)) extraWidget = QPushButton(_("Browse...")) extraWidget.clicked.connect(functools.partial(self.selectExecutable, widget, param)) elif param["type"] == "bool": # create spinner widget = QCheckBox() if param["value"] == True: widget.setCheckState(Qt.Checked) else: widget.setCheckState(Qt.Unchecked) widget.stateChanged.connect(functools.partial(self.bool_value_changed, widget, param)) elif param["type"] == "dropdown": # create spinner widget = QComboBox() # Get values value_list = param["values"] # Overwrite value list (for profile dropdown) if param["setting"] == "default-profile": value_list = [] # Loop through profiles for profile_folder in [info.USER_PROFILES_PATH, info.PROFILES_PATH]: for file in os.listdir(profile_folder): # Load Profile and append description profile_path = os.path.join(profile_folder, file) profile = openshot.Profile(profile_path) value_list.append({"name":profile.info.description, "value":profile.info.description}) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Overwrite value list (for language dropdown) if param["setting"] == "default-language": value_list = [] # Loop through languages for locale, language, country in get_all_languages(): # Load Profile and append description if language: lang_name = "%s (%s)" % (language, locale) value_list.append({"name":lang_name, "value":locale}) # Sort profile list value_list.sort(key=operator.itemgetter("name")) # Add Default to top of list value_list.insert(0, {"name":_("Default"), "value":"Default"}) # Add normal values box_index = 0 for value_item in value_list: k = value_item["name"] v = value_item["value"] # add dropdown item widget.addItem(_(k), v) # select dropdown (if default) if v == param["value"]: widget.setCurrentIndex(box_index) box_index = box_index + 1 widget.currentIndexChanged.connect(functools.partial(self.dropdown_index_changed, widget, param)) # Add Label and Widget to the form if (widget and label): # Add minimum size label.setMinimumWidth(180); label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) # Create HBox layout layout_hbox = QHBoxLayout() layout_hbox.addWidget(label) layout_hbox.addWidget(widget) if (extraWidget): layout_hbox.addWidget(extraWidget) # Add widget to layout tabWidget.layout().addLayout(layout_hbox) elif (label): # Add widget to layout tabWidget.layout().addWidget(label) # Add stretch to bottom of layout tabWidget.layout().addStretch()
def __init__(self, cuts_json, clips_json, preview=False): _ = get_app()._tr # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("cutting-screen") # If preview, hide cutting controls if preview: self.lblInstructions.setVisible(False) self.widgetControls.setVisible(False) self.setWindowTitle(_("Preview")) self.start_frame = 1 self.start_image = None self.end_frame = 1 self.end_image = None project = get_app().project # Keep track of file object #self.file = file self.file_path = file.absolute_path() self.video_length = int(file.data['video_length']) self.fps_num = int(file.data['fps']['num']) self.fps_den = int(file.data['fps']['den']) self.fps = float(self.fps_num) / float(self.fps_den) self.width = int(file.data['width']) self.height = int(file.data['height']) self.sample_rate = int(file.data['sample_rate']) self.channels = int(file.data['channels']) self.channel_layout = int(file.data['channel_layout']) # Open video file with Reader log.info(self.file_path) # Create an instance of a libopenshot Timeline object self.r = openshot.Timeline( self.width, self.height, openshot.Fraction(self.fps_num, self.fps_den), self.sample_rate, self.channels, self.channel_layout) self.r.info.channel_layout = self.channel_layout try: # Add clip for current preview file self.clip = openshot.Clip(self.file_path) # Show waveform for audio files if not self.clip.Reader().info.has_video and self.clip.Reader( ).info.has_audio: self.clip.Waveform(True) # Set has_audio property self.r.info.has_audio = self.clip.Reader().info.has_audio if preview: # Display frame #'s during preview self.clip.display = openshot.FRAME_DISPLAY_CLIP self.r.AddClip(self.clip) except: log.error('Failed to load media file into preview player: %s' % self.file_path) return # Add Video Widget self.videoPreview = VideoWidget() self.videoPreview.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.verticalLayout.insertWidget(0, self.videoPreview) # Set max size of video preview (for speed) viewport_rect = self.videoPreview.centeredViewport( self.videoPreview.width(), self.videoPreview.height()) self.r.SetMaxSize(viewport_rect.width(), viewport_rect.height()) # Open reader self.r.Open() # Start the preview thread self.initialized = False self.transforming_clip = False self.preview_parent = PreviewParent() self.preview_parent.Init(self, self.r, self.videoPreview) self.preview_thread = self.preview_parent.worker # Set slider constraints self.sliderIgnoreSignal = False self.sliderVideo.setMinimum(1) self.sliderVideo.setMaximum(self.video_length) self.sliderVideo.setSingleStep(1) self.sliderVideo.setSingleStep(1) self.sliderVideo.setPageStep(24) # Determine if a start or end attribute is in this file start_frame = 1 if 'start' in self.file.data.keys(): start_frame = (float(self.file.data['start']) * self.fps) + 1 # Display start frame (and then the previous frame) QTimer.singleShot( 500, functools.partial(self.sliderVideo.setValue, start_frame + 1)) QTimer.singleShot( 600, functools.partial(self.sliderVideo.setValue, start_frame)) # Connect signals self.actionPlay.triggered.connect(self.actionPlay_Triggered) self.btnPlay.clicked.connect(self.btnPlay_clicked) self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged) self.btnStart.clicked.connect(self.btnStart_clicked) self.btnEnd.clicked.connect(self.btnEnd_clicked) self.btnClear.clicked.connect(self.btnClear_clicked) self.btnAddClip.clicked.connect(self.btnAddClip_clicked) self.initialized = True
def __init__(self, cuts=[], preview=False): _ = get_app()._tr # Create dialog class QDialog.__init__(self) # Load UI from designer ui_util.load_ui(self, self.ui_path) # Init UI ui_util.init_ui(self) # Track metrics track_metric_screen("cutting-screen") # If preview, hide cutting controls if preview: self.lblInstructions.setVisible(False) self.widgetControls.setVisible(False) self.setWindowTitle(_("Preview")) self.start_frame = 1 self.start_image = None self.end_frame = 1 self.end_image = None #timeline = get_app().window.timeline_sync.timeline #app = get_app() #project = app.project # Get some settings from the project ''' self.fps = project.get(["fps"]) self.width = project.get(["width"]) self.height = project.get(["height"]) self.sample_rate = project.get(["sample_rate"]) self.channels = project.get(["channels"]) self.channel_layout = project.get(["channel_layout"]) self.fps_num = int(self.fps['num']) self.fps_den = int(self.fps['den']) self.fps = float(self.fps_num) / float(self.fps_den) ''' # Get the original timeline settings self.width = get_app().window.timeline_sync.timeline.info.width self.height = get_app().window.timeline_sync.timeline.info.height self.fps = get_app().window.timeline_sync.timeline.info.fps self.sample_rate = get_app( ).window.timeline_sync.timeline.info.sample_rate self.channels = get_app().window.timeline_sync.timeline.info.channels self.channel_layout = get_app( ).window.timeline_sync.timeline.info.channel_layout self.fps_num = int(self.fps.num) self.fps_den = int(self.fps.den) #self.fps = float(self.fps_num) / float(self.fps_den) ''' # Keep track of file object self.file = file self.file_path = file.absolute_path() self.video_length = 0 self.fps_num = int(file.data['fps']['num']) self.fps_den = int(file.data['fps']['den']) self.fps = float(self.fps_num) / float(self.fps_den) self.width = int(file.data['width']) self.height = int(file.data['height']) self.sample_rate = int(file.data['sample_rate']) self.channels = int(file.data['channels']) self.channel_layout = int(file.data['channel_layout']) # Open video file with Reader log.info(self.file_path) ''' self.video_length = 0 # Create an instance of a libopenshot Timeline object self.r = openshot.Timeline( self.width, self.height, openshot.Fraction(self.fps_num, self.fps_den), self.sample_rate, self.channels, self.channel_layout) self.r.info.channel_layout = self.channel_layout ''' #cuts = [{"start_seconds":8.466666666666667, "end_seconds":15.3}, {"start_seconds":18.9, "end_seconds":22.133333333333333}] position = 0 print(cuts) cs = app.window.timeline_sync.timeline.Clips() for c in cs: print("-----id=", c.Id()) clip_json = Clip.filter(id=c.Id()) path = clip_json[0].data["reader"]["path"] print("==============", path, c.Position()) offset = c.Position() for cut in cuts: try: # Add clip for current preview file clip = openshot.Clip(path) self.clips.append(clip) # Show waveform for audio files if not clip.Reader().info.has_video and clip.Reader().info.has_audio: clip.Waveform(True) # Set has_audio property self.r.info.has_audio = clip.Reader().info.has_audio if preview: # Display frame #'s during preview clip.display = openshot.FRAME_DISPLAY_CLIP start = float(cut["start_seconds"] - offset) end = float(cut["end_seconds"] - offset) print("=======================-------start:", start, "end:", end) clip.Start(start) clip.End(end) #clip.Position(0) clip.Position(position) position = position + (end - start) - offset #clip.Duration(end-start) self.r.AddClip(clip) self.video_length = self.video_length + (end - start) except: log.error('Failed to load media file into preview player: %s' % self.file_path) return ''' self.clips, self.video_length = CutsToClips(cuts) for clip in self.clips: # Show waveform for audio files if not clip.Reader().info.has_video and clip.Reader( ).info.has_audio: clip.Waveform(True) if preview: # Display frame #'s during preview clip.display = openshot.FRAME_DISPLAY_CLIP self.r.AddClip(clip) #self.video_length = self.video_length * self.fps_num / self.fps_den # Add Video Widget self.videoPreview = VideoWidget() self.videoPreview.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.verticalLayout.insertWidget(0, self.videoPreview) # Set max size of video preview (for speed) viewport_rect = self.videoPreview.centeredViewport( self.videoPreview.width(), self.videoPreview.height()) self.r.SetMaxSize(viewport_rect.width(), viewport_rect.height()) # Open reader self.r.Open() # Start the preview thread self.initialized = False self.transforming_clip = False self.preview_parent = PreviewParent() self.preview_parent.Init(self, self.r, self.videoPreview) self.preview_thread = self.preview_parent.worker # Set slider constraints self.sliderIgnoreSignal = False self.sliderVideo.setMinimum(1) self.sliderVideo.setMaximum(self.video_length) self.sliderVideo.setSingleStep(1) self.sliderVideo.setSingleStep(1) self.sliderVideo.setPageStep(24) # Determine if a start or end attribute is in this file start_frame = 1 #if 'start' in self.file.data.keys(): # start_frame = (float(self.file.data['start']) * self.fps) + 1 # Display start frame (and then the previous frame) QTimer.singleShot( 500, functools.partial(self.sliderVideo.setValue, start_frame + 1)) QTimer.singleShot( 600, functools.partial(self.sliderVideo.setValue, start_frame)) # Connect signals self.actionPlay.triggered.connect(self.actionPlay_Triggered) self.btnPlay.clicked.connect(self.btnPlay_clicked) self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged) self.btnStart.clicked.connect(self.btnStart_clicked) self.btnEnd.clicked.connect(self.btnEnd_clicked) self.btnClear.clicked.connect(self.btnClear_clicked) self.btnAddClip.clicked.connect(self.btnAddClip_clicked) self.initialized = True