def get_project_info_panel():
project_name_label = gtk.Label(PROJECT().name)
name_row = guiutils.get_left_justified_box([project_name_label])
name_panel = guiutils.get_named_frame(_("Name"), name_row, 4)
profile = PROJECT().profile
desc_label = gtk.Label(profile.description())
info_box = guicomponents.get_profile_info_small_box(profile)
vbox = gtk.VBox()
vbox.pack_start(guiutils.get_left_justified_box([desc_label]), False, True, 0)
vbox.pack_start(info_box, False, True, 0)
profile_panel = guiutils.get_named_frame(_("Profile"), vbox, 4)
events_list = ProjectEventListView()
events_list.set_size_request(270, 300)
events_list.fill_data_model()
events_panel = guiutils.get_named_frame(_("Project Events"), events_list, 4)
project_info_vbox = gtk.VBox()
project_info_vbox.pack_start(name_panel, False, True, 0)
project_info_vbox.pack_start(profile_panel, False, True, 0)
project_info_vbox.pack_start(events_panel, True, True, 0)
align = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
align.set_padding(0, 0, 0, 0)
align.add(project_info_vbox)
widgets.project_name_label = project_name_label
widgets.desc_label = desc_label
widgets.info_box = info_box
widgets.events_list = events_list
return align
def render_slowmo_from_item(row):
log_events = get_current_filtered_events()
event_item = log_events[row]
media_file = PROJECT().get_media_file_for_path(event_item.path)
media_file.mark_in = event_item.mark_in
media_file.mark_out = event_item.mark_out
render.render_frame_buffer_clip(media_file, True)
def update_project_info():
profile = PROJECT().profile
widgets.project_name_label.set_markup(guiutils.bold_text(PROJECT().name))
widgets.desc_label.set_text(profile.description())
profile_info_text = guicomponents.get_profile_info_text(profile)
widgets.info_box.get_children()[0].set_text(profile_info_text)
widgets.events_list.fill_data_model()
def get_top_level_project_info_panel():
project_name_label = Gtk.Label(label=PROJECT().name)
name_row = guiutils.get_left_justified_box([project_name_label])
name_panel = guiutils.get_named_frame(_("Project"), name_row, 0, 6, 4, _("A <b>Project</b> contains one or more <b>Sequences</b> of edited media and a collection of media files stored in <b>Bins.</b>"))
profile = PROJECT().profile
desc_label = Gtk.Label(label=profile.description())
info_box = guicomponents.get_profile_info_small_box(profile)
vbox = Gtk.VBox()
vbox.pack_start(guiutils.get_left_justified_box([desc_label]), False, True, 0)
vbox.pack_start(info_box, False, True, 0)
profile_panel = guiutils.get_named_frame(_("Profile"), vbox, 0, 6, 4, _("<b>Profile</b> determines frame rate per second, image size in pixels and pixel aspect ratio for all <b>Sequences</b> in <b>Project</b> ."))
events_list = ProjectEventListView()
events_list.fill_data_model()
events_panel = guiutils.get_named_frame(_("Project Events"), events_list, 0)
project_info_vbox = Gtk.VBox()
project_info_vbox.pack_start(name_panel, False, True, 0)
project_info_vbox.pack_start(profile_panel, False, True, 0)
guiutils.set_margins(project_info_vbox, 4,4,4,4)
widgets.project_name_label = project_name_label
widgets.desc_label = desc_label
widgets.info_box = info_box
widgets.events_list = events_list
return project_info_vbox
def get_project_info_panel():
project_name_label = Gtk.Label(label=PROJECT().name)
name_row = guiutils.get_left_justified_box([project_name_label])
name_panel = guiutils.get_named_frame(_("Name"), name_row, 4)
profile = PROJECT().profile
desc_label = Gtk.Label(label=profile.description())
info_box = guicomponents.get_profile_info_small_box(profile)
vbox = Gtk.VBox()
vbox.pack_start(guiutils.get_left_justified_box([desc_label]), False, True, 0)
vbox.pack_start(info_box, False, True, 0)
profile_panel = guiutils.get_named_frame(_("Profile"), vbox, 4)
events_list = ProjectEventListView()
events_list.fill_data_model()
events_panel = guiutils.get_named_frame(_("Project Events"), events_list, 4)
project_info_vbox = Gtk.VBox()
project_info_vbox.pack_start(name_panel, False, True, 0)
project_info_vbox.pack_start(profile_panel, False, True, 0)
project_info_vbox.set_size_request(250, PROJECT_INFO_PANEL_HEIGHT)
project_info_hbox = Gtk.HBox()
project_info_hbox.pack_start(project_info_vbox, False, False, 0)
project_info_hbox.pack_start(events_panel, True, True, 0)
widgets.project_name_label = project_name_label
widgets.desc_label = desc_label
widgets.info_box = info_box
widgets.events_list = events_list
return project_info_hbox
def _open_clip_in_clip_monitor(data):
clip, track, item_id, x = data
media_file = PROJECT().get_media_file_for_path(clip.path)
media_file.mark_in = clip.clip_in
media_file.mark_out = clip.clip_out
updater.set_and_display_monitor_media_file(media_file)
gui.pos_bar.widget.grab_focus()
def display_item(row):
log_events = get_current_filtered_events()
event_item = log_events[row]
media_file = PROJECT().get_media_file_for_path(event_item.path)
media_file.mark_in = event_item.mark_in
media_file.mark_out = event_item.mark_out
updater.set_and_display_monitor_media_file(media_file)
monitorevent.to_mark_in_pressed()
def run(self):
print "Starting XML render"
player = PLAYER()
# Don't try anything if somehow this was started
# while timeline rendering is running
if player.is_rendering:
print "Can't render XML when another render is already running!"
return
# Stop all playback before producer is disconnected
self.current_playback_frame = player.producer.frame()
player.ticker.stop_ticker()
player.consumer.stop()
player.producer.set_speed(0)
player.producer.seek(0)
# Wait until producer is at start
while player.producer.frame() != 0:
time.sleep(0.1)
# Get render producer
timeline_producer = PROJECT().c_seq.tractor
# Get render consumer
xml_consumer = mlt.Consumer(PROJECT().profile, "xml", str(self.file_name))
# Connect and start rendering
xml_consumer.connect(timeline_producer)
xml_consumer.start()
timeline_producer.set_speed(1)
# Wait until done
while xml_consumer.is_stopped() == False:
print "In XML render wait loop..."
time.sleep(0.1)
print "XML render done"
# Get app player going again
player.connect_and_start()
player.seek_frame(0)
self.render_done_callback(self.data)
def run(self):
# NEEDS FIXING FOR COMPACT PROJECTS
Gdk.threads_enter()
recreate_progress_window = dialogs.recreate_icons_progress_dialog()
time.sleep(0.1)
Gdk.threads_leave()
no_icon_path = respaths.IMAGE_PATH + projectdata.FALLBACK_THUMB
loaded = 0
for key in PROJECT().media_files.iterkeys():
media_file = PROJECT().media_files[key]
Gdk.threads_enter()
recreate_progress_window.info.set_text(media_file.name)
Gdk.threads_leave()
if ((not isinstance(media_file, patternproducer.AbstractBinClip))
and (not isinstance(media_file, projectdata.BinColorClip))):
if media_file.icon_path == no_icon_path:
if media_file.type == appconsts.AUDIO:
icon_path = respaths.IMAGE_PATH + "audio_file.png"
else:
(icon_path, length) = projectdata.thumbnailer.write_image(media_file.path)
media_file.icon_path = icon_path
media_file.create_icon()
loaded = loaded + 1
Gdk.threads_enter()
loaded_frac = float(loaded) / float(len(PROJECT().media_files))
recreate_progress_window.progress_bar.set_fraction(loaded_frac)
time.sleep(0.01)
Gdk.threads_leave()
# Update editor gui
Gdk.threads_enter()
recreate_progress_window.destroy()
time.sleep(0.3)
Gdk.threads_leave()
Gdk.threads_enter()
gui.media_list_view.fill_data_model()
gui.bin_list_view.fill_data_model()
gui.enable_save()
Gdk.threads_leave()
def create_icon(self):
icon_path, length, info = _write_thumbnail_image(PROJECT().profile, self.container_data.unrendered_media, self)
cr, surface = _create_image_surface(icon_path)
cr.rectangle(0, 0, appconsts.THUMB_WIDTH, appconsts.THUMB_HEIGHT)
cr.set_source_rgba(*OVERLAY_COLOR)
cr.fill()
type_icon = _get_type_icon(appconsts.CONTAINER_CLIP_GMIC)
cr.set_source_surface(type_icon, 1, 30)
cr.set_operator (cairo.OPERATOR_OVERLAY)
cr.paint_with_alpha(0.5)
return (surface, length, icon_path)
def bin_name_edited(cell, path, new_text, user_data):
"""
Sets edited value to liststore and project data.
"""
# Can't have empty string names
if len(new_text) == 0:
return
liststore, column = user_data
liststore[path][column] = new_text
PROJECT().bins[int(path)].name = new_text
_enable_save()
def _new_project_dialog_callback(dialog, response_id, profile_combo,
tracks_combo, tracks_combo_values_list):
v_tracks, a_tracks = tracks_combo_values_list[tracks_combo.get_active()]
if response_id == Gtk.ResponseType.ACCEPT:
app.new_project(profile_combo.get_active(), v_tracks, a_tracks)
dialog.destroy()
project_event = projectdata.ProjectEvent(
projectdata.EVENT_CREATED_BY_NEW_DIALOG, None)
PROJECT().events.append(project_event)
else:
dialog.destroy()
def _actions_callback(widget, data):
if data == "newfromselected":
next_index = len(PROJECT().media_log_groups)
dialogs.new_media_log_group_name_dialog(_new_group_name_callback,
next_index, True)
elif data == "new":
next_index = len(PROJECT().media_log_groups)
dialogs.new_media_log_group_name_dialog(_new_group_name_callback,
next_index, False)
elif data == "delete":
current_group_index = widgets.group_view_select.get_active() - 1
if current_group_index < 0:
return
PROJECT().media_log_groups.pop(current_group_index)
_create_group_select()
widgets.group_view_select.set_active(0)
elif data == "deletewithitems":
current_group_index = widgets.group_view_select.get_active() - 1
if current_group_index < 0:
return
name, items = PROJECT().media_log_groups[current_group_index]
primary_txt = _("Delete Group and Items?")
secondary_txt = _("Are you sure you want to delete group ") + name + _(" and ") + str(len(items)) + _(" items it contains?\n") + \
_("This operation cannot be undone.")
dialogutils.warning_confirmation(_delete_with_items_dialog_callback,
primary_txt, secondary_txt,
gui.editor_window.window, None, True)
elif data == "rename":
current_group_index = widgets.group_view_select.get_active() - 1
name, items = PROJECT().media_log_groups[current_group_index]
dialogs.group_rename_dialog(_rename_callback, name)
else:
try:
to_group_index = int(data)
except:
return
current_group_index = widgets.group_view_select.get_active() - 1
if to_group_index == current_group_index:
return
# Get items to move
selected = widgets.media_log_view.get_selected_rows_list()
log_events = get_current_filtered_events()
move_items = []
for row in selected:
index = max(row) # these are tuples, max to extract only value
move_items.append(log_events[index])
# Move items and update
PROJECT().remove_from_group(current_group_index, move_items)
PROJECT().add_to_group(to_group_index, move_items)
widgets.group_view_select.set_active(
to_group_index +
1) # 0 index items is "All" items group not a user created group
def __init__(self, clip, track_height, dialog):
threading.Thread.__init__(self)
self.clip = clip
self.temp_clip = self._get_temp_producer(clip)
self.file_cache_path = utils.get_hidden_user_dir_path(
) + appconsts.AUDIO_LEVELS_DIR + _get_unique_name_for_media(clip.path)
self.track_height = track_height
self.abort = False
self.clip_media_length = PROJECT().get_media_file_for_path(
self.clip.path).length
self.last_rendered_frame = 0
self.stopped = False
self.dialog = dialog
def run(self):
"""
Writes thumbnail image from file producer
"""
# Create consumer
matchframe_path = utils.get_hidden_user_dir_path(
) + appconsts.TRIM_VIEW_DIR + "/" + self.frame_name
consumer = mlt.Consumer(PROJECT().profile, "avformat", matchframe_path)
consumer.set("real_time", 0)
consumer.set("vcodec", "png")
# Create one frame producer
producer = mlt.Producer(PROJECT().profile, str(self.clip_path))
producer.set("mlt_service", "avformat-novalidate")
producer = producer.cut(int(self.clip_frame), int(self.clip_frame))
# Delete match frame
try:
os.remove(matchframe_path)
except:
# This fails when done first time ever
pass
# Save producer and consumer for view needing continues match frame update
global _producer, _consumer
if _widget.view != START_TRIM_VIEW and _widget.view != END_TRIM_VIEW:
_producer = producer
_consumer = consumer
# Connect and write image
consumer.connect(producer)
consumer.run()
# Wait until new file exists
while os.path.isfile(matchframe_path) != True:
time.sleep(0.1)
# Do completion callback
self.completion_callback(self.frame_name)
def set_timeline_height():
if len(current_sequence().tracks) == 11 or PROJECT().get_project_property(appconsts.P_PROP_TLINE_SHRINK_VERTICAL) == False:
tlinewidgets.HEIGHT = appconsts.TLINE_HEIGHT
else:
tlinewidgets.HEIGHT = current_sequence().get_shrunk_tline_height_min()
gui.tline_canvas.widget.set_size_request(tlinewidgets.WIDTH, tlinewidgets.HEIGHT)
gui.tline_column.widget.set_size_request(tlinewidgets.COLUMN_WIDTH, tlinewidgets.HEIGHT)
current_sequence().resize_tracks_to_fit(gui.tline_canvas.widget.get_allocation())
tlinewidgets.set_ref_line_y(gui.tline_canvas.widget.get_allocation())
gui.tline_column.init_listeners()
repaint_tline()
def run(self):
Gdk.threads_enter()
recreate_progress_window = dialogs.recreate_icons_progress_dialog()
time.sleep(0.1)
Gdk.threads_leave()
no_icon_path = respaths.IMAGE_PATH + projectdata.FALLBACK_THUMB
loaded = 0
for key in PROJECT().media_files.keys():
media_file = PROJECT().media_files[key]
Gdk.threads_enter()
recreate_progress_window.info.set_text(media_file.name)
Gdk.threads_leave()
if ((not isinstance(media_file, patternproducer.AbstractBinClip))
and (not isinstance(media_file, projectdata.BinColorClip))):
if media_file.type == appconsts.AUDIO:
icon_path = respaths.IMAGE_PATH + "audio_file.png"
media_file.info = None
else:
(icon_path, length, info) = projectdata.thumbnailer.write_image(media_file.path)
media_file.info = info
media_file.icon_path = icon_path
media_file.create_icon()
loaded = loaded + 1
Gdk.threads_enter()
loaded_frac = float(loaded) / float(len(PROJECT().media_files))
recreate_progress_window.progress_bar.set_fraction(loaded_frac)
time.sleep(0.01)
Gdk.threads_leave()
# Update editor gui
Gdk.threads_enter()
recreate_progress_window.destroy()
time.sleep(0.3)
Gdk.threads_leave()
Gdk.threads_enter()
gui.media_list_view.fill_data_model()
gui.bin_list_view.fill_data_model()
gui.enable_save()
Gdk.threads_leave()
def add_to_render_queue():
args_vals_list = render.get_args_vals_list_for_current_selections()
render_path = render.get_file_path()
# Get render start and end points
if render.widgets.range_cb.get_active() == 0:
start_frame = 0
end_frame = -1 # renders till finish
else:
start_frame = current_sequence().tractor.mark_in
end_frame = current_sequence().tractor.mark_out
# Only do if range defined.
if start_frame == -1 or end_frame == -1:
if render.widgets.range_cb.get_active() == 1:
rendergui.no_good_rander_range_info()
return
# Create render data object
if render.widgets.args_panel.use_args_check.get_active() == False:
enc_index = render.widgets.encoding_panel.encoding_selector.widget.get_active(
)
quality_index = render.widgets.encoding_panel.quality_selector.widget.get_active(
)
user_args = False
else: # This is not implemented
enc_index = render.widgets.encoding_panel.encoding_selector.widget.get_active(
)
quality_index = render.widgets.encoding_panel.quality_selector.widget.get_active(
)
user_args = False
profile = render.get_current_profile()
profile_text = guicomponents.get_profile_info_text(profile)
fps = profile.fps()
profile_name = profile.description()
r_data = batchrendering.RenderData(enc_index, quality_index, user_args,
profile_text, profile_name, fps)
# Add item
try:
batchrendering.add_render_item(PROJECT(), render_path, args_vals_list,
start_frame, end_frame, r_data)
except Exception as e:
primary_txt = _("Adding item to render queue failed!")
secondary_txt = _("Error message: ") + str(e)
dialogutils.warning_message(primary_txt,
secondary_txt,
gui.editor_window.window,
is_info=False)
return
def run(self):
# Image produceer
img_producer = current_sequence().create_file_producer_clip(
str(self.image_file)
) # , new_clip_name=None, novalidate=False, ttl=None):
# Create tractor and track to get right length
tractor = mlt.Tractor()
multitrack = tractor.multitrack()
track0 = mlt.Playlist()
multitrack.connect(track0, 0)
track0.insert(img_producer, 0, 0, self.length)
# Consumer
write_file = userfolders.get_cache_dir() + "/unrendered_clip.mp4"
# Delete earlier created files
if os.path.exists(write_file):
os.remove(write_file)
consumer = renderconsumer.get_default_render_consumer(
write_file,
PROJECT().profile)
clip_renderer = renderconsumer.FileRenderPlayer(
write_file, tractor, consumer, 0, self.length)
clip_renderer.wait_for_producer_end_stop = True
clip_renderer.start()
Gdk.threads_enter()
info_text = _("<b>Rendering Placeholder Media For:</b> "
) + self.data.get_program_name() + ".blend"
progress_bar = Gtk.ProgressBar()
dialog = rendergui.clip_render_progress_dialog(
None, self.window_text, info_text, progress_bar,
gui.editor_window.window, True)
motion_progress_update = renderconsumer.ProgressWindowThread(
dialog, progress_bar, clip_renderer, self.progress_thread_complete)
motion_progress_update.start()
Gdk.threads_leave()
while clip_renderer.stopped == False:
time.sleep(0.5)
Gdk.threads_enter()
self.callback(write_file, self.data)
Gdk.threads_leave()
def _get_affine_filt_geom_sliders_2(ep):
scr_width = PROJECT().profile.width()
scr_height = PROJECT().profile.height()
# "0=0,0:SCREENSIZE:100"
frame_value = ep.value.split("=")
tokens = frame_value[1].split(":")
pos_tokens = tokens[0].split("/")
size_tokens = tokens[1].split("x")
x_adj = Gtk.Adjustment(float(pos_tokens[0]), float(-scr_width), float(scr_width), float(1))
y_adj = Gtk.Adjustment(float(pos_tokens[1]), float(-scr_height), float(scr_height), float(1))
xs_adj = Gtk.Adjustment(float(size_tokens[0]), float(10), float(scr_width * 3), float(1))
#ys_adj = Gtk.Adjustment(float(size_tokens[1]), float(10), float(scr_height * 3), float(1))
x_slider, x_spin, x_row = _get_affine_slider("X", x_adj)
y_slider, y_spin, y_row = _get_affine_slider("Y", y_adj)
xs_slider, xs_spin, xs_row = _get_affine_slider(_("Width"), xs_adj)
#ys_slider, ys_spin, ys_row = _get_affine_slider(_("Height"), ys_adj)
all_sliders = (x_slider, y_slider, xs_slider)
x_slider.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders, scr_height))
x_spin.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders, scr_height))
y_slider.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders, scr_height))
y_spin.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders, scr_height))
xs_slider.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders, scr_height))
xs_spin.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders, scr_height))
#ys_slider.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders))
#ys_spin.get_adjustment().connect("value-changed", lambda w: ep.slider_values_changed(all_sliders))
vbox = Gtk.VBox(False, 4)
vbox.pack_start(x_row, True, True, 0)
vbox.pack_start(y_row, True, True, 0)
vbox.pack_start(xs_row, True, True, 0)
#vbox.pack_start(ys_row, True, True, 0)
return vbox
def set_saved_gui_selections(selections):
#widgets.render_type_panel.type_combo.set_active(selections["use_user_encodings"])
try:
enc_op_name = selections["encoding_option_name"]
widgets.encoding_panel.encoding_selector.categorised_combo.set_selected(
enc_op_name)
except:
print("Old style encoding option value could not be loaded.")
widgets.encoding_panel.quality_selector.widget.set_active(
selections["quality_option_index"])
#widgets.render_type_panel.presets_selector.widget.set_active(selections["presets_index"])
widgets.file_panel.out_folder.set_current_folder(selections["folder"])
widgets.file_panel.movie_name.set_text(selections["name"])
widgets.range_cb.set_active(selections["range"])
try:
# These were added later so we may not have the data
if selections["range"] == 1:
mark_in, mark_out = selections["markinmarkout"]
PROJECT().c_seq.tractor.mark_in = mark_in
PROJECT().c_seq.tractor.mark_out = mark_out
widgets.profile_panel.use_project_profile_check.set_active(
selections["use_project_profile"])
try:
profile_name = selections["render_profile_name"]
widgets.profile_panel.out_profile_combo.categories_combo.set_selected(
profile_name)
except:
print("Old style profile option value could not be loaded.")
if selections["render_args"] != None:
widgets.args_panel.use_args_check.set_active(True)
if widgets.args_panel.text_buffer == None:
buf = widgets.args_panel.opts_view.get_buffer()
else:
buf = widgets.args_panel.text_buffer
widgets.encoding_panel.sample_rate_selector.widget.set_active(
selections["audio_frequency"])
except:
pass
def get_current_gui_selections():
selections = {}
selections[
"use_user_encodings"] = widgets.render_type_panel.type_combo.get_active(
)
selections[
"encoding_option_index"] = widgets.encoding_panel.encoding_selector.get_selected_encoding_index(
)
selections[
"quality_option_index"] = widgets.encoding_panel.quality_selector.widget.get_active(
)
selections[
"presets_index"] = widgets.render_type_panel.presets_selector.widget.get_active(
)
selections["folder"] = widgets.file_panel.out_folder.get_current_folder()
selections["name"] = widgets.file_panel.movie_name.get_text()
selections["range"] = widgets.range_cb.get_active()
selections["markinmarkout"] = (PROJECT().c_seq.tractor.mark_in,
PROJECT().c_seq.tractor.mark_out)
selections[
"use_project_profile"] = widgets.profile_panel.use_project_profile_check.get_active(
)
selections[
"render_profile"] = widgets.profile_panel.out_profile_combo.widget.get_active(
)
if widgets.args_panel.use_args_check.get_active() == True:
if widgets.args_panel.text_buffer == None:
buf = widgets.args_panel.opts_view.get_buffer()
else:
buf = widgets.args_panel.text_buffer
buf_text = buf.get_text(buf.get_start_iter(),
buf.get_end_iter(),
include_hidden_chars=True)
selections["render_args"] = buf_text
else:
selections["render_args"] = None
return selections
def delete_selected_sequence():
"""
Deletes selected sequence if confirmed and at least one will be left.
"""
selection = gui.sequence_list_view.treeview.get_selection()
model, iter = selection.get_selected()
(model, rows) = selection.get_selected_rows()
row = max(rows[0])
name = PROJECT().sequences[row].name
dialogutils.warning_confirmation(_delete_confirm_callback,
_("Are you sure you want to delete\nsequence \'") + name + _("\'?"),
_("This operation can not be undone. Sequence will be permanently lost."),
gui.editor_window.window)
def update_current_bin_files_count():
# Get index for selected bin
selection = gui.editor_window.bin_list_view.treeview.get_selection()
(model, rows) = selection.get_selected_rows()
if len(rows) == 0:
return
row = max(rows[0])
value = str(len(PROJECT().bins[row].file_ids))
tree_path = Gtk.TreePath.new_from_string(str(row))
store_iter = gui.editor_window.bin_list_view.storemodel.get_iter(tree_path)
gui.editor_window.bin_list_view.storemodel.set_value(store_iter, 2, value)
def _change_project_profile_callback(dialog, response_id, profile_combo,
out_folder, project_name_entry):
if response_id == Gtk.ResponseType.ACCEPT:
folder = "/" + out_folder.get_uri().lstrip("file:/")
name = project_name_entry.get_text()
profile = mltprofiles.get_profile_for_index(profile_combo.get_active())
path = folder + "/" + name
persistance.save_project(PROJECT(), path,
profile.description()) #<----- HERE
dialog.destroy()
else:
dialog.destroy()
def get_top_level_project_info_panel():
project_name_label = Gtk.Label(label=PROJECT().name)
name_row = guiutils.get_left_justified_box([project_name_label])
name_panel = guiutils.get_named_frame(
_("Project"), name_row, 0, 6, 4,
_("A <b>Project</b> contains one or more <b>Sequences</b> of edited media and a collection of media files stored in <b>Bins.</b>"
))
profile = PROJECT().profile
desc_label = Gtk.Label(label=profile.description())
info_box = guicomponents.get_profile_info_small_box(profile)
vbox = Gtk.VBox()
vbox.pack_start(guiutils.get_left_justified_box([desc_label]), False, True,
0)
vbox.pack_start(info_box, False, True, 0)
profile_panel = guiutils.get_named_frame(
_("Profile"), vbox, 0, 6, 4,
_("<b>Profile</b> determines frame rate per second, image size in pixels and pixel aspect ratio for all <b>Sequences</b> in <b>Project</b> ."
))
events_list = ProjectEventListView()
events_list.fill_data_model()
events_panel = guiutils.get_named_frame(_("Project Events"), events_list,
0)
project_info_vbox = Gtk.VBox()
project_info_vbox.pack_start(name_panel, False, True, 0)
project_info_vbox.pack_start(profile_panel, False, True, 0)
guiutils.set_margins(project_info_vbox, 4, 4, 4, 4)
widgets.project_name_label = project_name_label
widgets.desc_label = desc_label
widgets.info_box = info_box
widgets.events_list = events_list
return project_info_vbox
def _compositor_hamburger_item_activated(widget, msg):
if msg == "save":
comp_name = mlttransitions.name_for_type[compositor.transition.info.name]
default_name = comp_name.replace(" ", "_") + _("_compositor_values") + ".data"
dialogs.save_effects_compositors_values(_save_compositor_values_dialog_callback, default_name, False)
elif msg == "load":
dialogs.load_effects_compositors_values_dialog(_load_compositor_values_dialog_callback, False)
elif msg == "reset":
_reset_compositor_pressed()
elif msg == "delete":
_delete_compositor_pressed()
elif msg == "close":
clear_compositor()
elif msg == "fade_length":
dialogs.set_fade_length_default_dialog(_set_fade_length_dialog_callback, PROJECT().get_project_property(appconsts.P_PROP_DEFAULT_FADE_LENGTH))
def _add_new_sequence_dialog_callback(dialog, response_id, widgets):
"""
Adds new unnamed sequence and sets it selected
"""
if response_id != gtk.RESPONSE_ACCEPT:
dialog.destroy()
return
name_entry, tracks_combo, open_check = widgets
# Get dialog data
name = name_entry.get_text()
if len(name) == 0:
name = _("sequence_") + str(PROJECT().next_seq_number)
v_tracks, a_tracks = appconsts.TRACK_CONFIGURATIONS[
tracks_combo.get_active()]
open_right_away = open_check.get_active()
# Get index for selected sequence
selection = gui.sequence_list_view.treeview.get_selection()
(model, rows) = selection.get_selected_rows()
row = max(rows[0])
# Add new sequence
sequence.AUDIO_TRACKS_COUNT = a_tracks
sequence.VIDEO_TRACKS_COUNT = v_tracks
PROJECT().add_named_sequence(name)
gui.sequence_list_view.fill_data_model()
if open_right_away == False:
selection.select_path(str(row)) # Keep previous selection
else:
app.change_current_sequence(len(PROJECT().sequences) - 1)
dialog.destroy()
def get_top_level_project_info_panel():
project_name_label = Gtk.Label(label=PROJECT().name)
name_row = guiutils.get_left_justified_box([project_name_label])
name_panel = guiutils.get_named_frame(_("Project"), name_row, 0)
profile = PROJECT().profile
desc_label = Gtk.Label(label=profile.description())
info_box = guicomponents.get_profile_info_small_box(profile)
vbox = Gtk.VBox()
vbox.pack_start(guiutils.get_left_justified_box([desc_label]), False, True,
0)
vbox.pack_start(info_box, False, True, 0)
profile_panel = guiutils.get_named_frame(_("Profile"), vbox, 0)
events_list = ProjectEventListView()
events_list.fill_data_model()
events_panel = guiutils.get_named_frame(_("Project Events"), events_list,
0)
project_info_vbox = Gtk.VBox()
project_info_vbox.pack_start(name_panel, False, True, 0)
project_info_vbox.pack_start(profile_panel, False, True, 0)
guiutils.set_margins(project_info_vbox, 4, 4, 4, 4)
#project_info_vbox.set_size_request(250, PROJECT_INFO_PANEL_HEIGHT)
#project_info_hbox = Gtk.HBox()
#project_info_hbox.pack_start(project_info_vbox, False, False, 0)
#project_info_hbox.pack_start(events_panel, True, True, 0)
widgets.project_name_label = project_name_label
widgets.desc_label = desc_label
widgets.info_box = info_box
widgets.events_list = events_list
return project_info_vbox
def change_edit_sequence():
selection = gui.sequence_list_view.treeview.get_selection()
(model, rows) = selection.get_selected_rows()
row = max(rows[0])
current_index = PROJECT().sequences.index(current_sequence())
if row == current_index:
dialogutils.warning_message(_("Selected sequence is already being edited"),
_("Select another sequence. Press Add -button to create a\nnew sequence if needed."),
gui.editor_window.window)
return
# Clear clips selection at exit. This is transient user focus state and
# therefore is not saved.
movemodes.clear_selected_clips()
app.change_current_sequence(row)
def remove_unused_media():
# Create path -> media item dict
path_to_media_object = {}
for key, media_item in PROJECT().media_files.items():
if media_item.path != "" and media_item.path != None:
path_to_media_object[media_item.path] = media_item
# Remove all items from created dict that have a clip with same path on any of the sequences
for seq in PROJECT().sequences:
for track in seq.tracks:
for clip in track.clips:
try:
removed = path_to_media_object.pop(clip.path)
except:
pass
# Create a list of unused media objects
unused = []
for path, media_item in path_to_media_object.items():
unused.append(media_item)
# It is most convenient to do remove via gui object
gui.media_list_view.select_media_file_list(unused)
delete_media_files()
def screenshot_export():
length = current_sequence().tractor.get_length()
if length < 2:
dialogutils.info_message("Sequence is too short", "Sequence needs to be at least 2 frames long to allow frame export.", None)
return
frame = PLAYER().current_frame()
# Can't get last frame to render easily, so just force range.
if frame > length - 2:
frame = length - 2
render_screen_shot(frame, get_displayed_image_render_path(), "png")
export_screenshot_dialog(_export_screenshot_dialog_callback, frame,
gui.editor_window.window, PROJECT().name)
PLAYER().seek_frame(frame)
def _ladspa_slider_update(editable_property, adjustment):
# ...or segphault
PLAYER().stop_playback()
# Change property value
editable_property.adjustment_value_changed(adjustment)
# Update output by cloning and replacing filter
ladspa_filter = editable_property._get_filter_object()
filter_clone = mltfilters.clone_filter_object(ladspa_filter, PROJECT().profile)
clip = editable_property.track.clips[editable_property.clip_index]
mltfilters.detach_all_filters(clip)
clip.filters.pop(editable_property.filter_index)
clip.filters.insert(editable_property.filter_index, filter_clone)
mltfilters.attach_all_filters(clip)
def matches_project_profile(self):
if (not hasattr(self, "info")): # to make really sure that old projects don't crash,
return True # but probably is not needed as attr is added at load
if self.info == None:
return True
is_match = True # this is true for audio and graphics and image sequences and is only
# set false for video that does not match profile
if self.type == appconsts.VIDEO:
best_media_profile_index = mltprofiles.get_closest_matching_profile_index(self.info)
project_profile_index = mltprofiles.get_index_for_name(PROJECT().profile.description())
if best_media_profile_index != project_profile_index:
is_match = False
return is_match
def __init__(self, filter_info):
self.info = filter_info
# Values of these are edited by the user.
self.properties = copy.deepcopy(filter_info.properties)
try:
self.non_mlt_properties = copy.deepcopy(filter_info.non_mlt_properties)
except:
self.non_mlt_properties = [] # Versions prior 0.14 do not have non_mlt_properties and fail here on load
self.mlt_filter = None # reference to MLT C-object
self.active = True
# PROP_EXPR values may have keywords that need to be replaced with
# numerical values that depend on the profile we have. These need
# to be replaced now that we have profile and we are ready to connect this.
# For example default values of some properties depend on the screen size of the project
propertyparse.replace_value_keywords(self.properties, PROJECT().profile)
def run(self):
Gdk.threads_enter()
dialog = dialogs.audio_sync_active_dialog()
dialog.progress_bar.set_pulse_step(0.2)
time.sleep(0.1)
Gdk.threads_leave()
while self.running:
dialog.progress_bar.pulse()
time.sleep(0.2)
PROJECT().update_media_lengths_on_load = False
Gdk.threads_enter()
dialog.destroy()
Gdk.threads_leave()
def render_single_track_transition_clip(transition_producer,
encoding_option_index,
quality_option_index, file_ext,
transition_render_complete_cb,
window_text):
# Set render complete callback to availble render stop callback using global variable
global transition_render_done_callback
transition_render_done_callback = transition_render_complete_cb
# Profile
profile = PROJECT().profile
folder = userfolders.get_render_dir()
file_name = hashlib.md5(str(os.urandom(32)).encode('utf-8')).hexdigest()
write_file = folder + "/" + file_name + file_ext
# Render consumer
consumer = renderconsumer.get_render_consumer_for_encoding_and_quality(
write_file, profile, encoding_option_index, quality_option_index)
# start and end frames
start_frame = 0
end_frame = transition_producer.get_length() - 1
# Launch render
# TODO: fix naming, this isn't motion renderer
global motion_renderer, motion_progress_update
motion_renderer = renderconsumer.FileRenderPlayer(write_file,
transition_producer,
consumer, start_frame,
end_frame)
motion_renderer.start()
title = _("Rendering Transition Clip")
progress_bar = Gtk.ProgressBar()
dialog = rendergui.clip_render_progress_dialog(_transition_render_stop,
title, window_text,
progress_bar,
gui.editor_window.window)
motion_progress_update = renderconsumer.ProgressWindowThread(
dialog, progress_bar, motion_renderer, _transition_render_stop)
motion_progress_update.start()
def render_screen_shot(frame, render_path, vcodec):
producer = current_sequence().tractor
consumer = mlt.Consumer(PROJECT().profile, "avformat", str(render_path))
consumer.set("real_time", -1)
consumer.set("rescale", "bicubic")
consumer.set("vcodec", str(vcodec))
renderer = renderconsumer.FileRenderPlayer(None, producer, consumer, frame, frame + 1)
renderer.wait_for_producer_end_stop = False
renderer.consumer_pos_stop_add = 2 # Hack, see FileRenderPlayer
renderer.start()
while renderer.has_started_running == False:
time.sleep(0.05)
while renderer.stopped == False:
time.sleep(0.05)
def _clip_hamburger_item_activated(widget, msg):
if msg == "fade_length":
dialogs.set_fade_length_default_dialog(
_set_fade_length_dialog_callback,
PROJECT().get_project_property(
appconsts.P_PROP_DEFAULT_FADE_LENGTH))
if _filter_stack == None:
return False
if msg == "close":
clear_clip()
elif msg == "expanded":
_filter_stack.set_all_filters_expanded_state(True)
elif msg == "unexpanded":
_filter_stack.set_all_filters_expanded_state(False)
elif msg == "toggle":
_toggle_all_pressed()
def do_export(self):
clip, track = self.data
media_file = PROJECT().get_media_file_for_path(clip.path)
media_file.mark_in = clip.clip_in
media_file.mark_out = clip.clip_out
render.render_reverse_clip(media_file, True)
