def oneroll_trim_mode_init(x, y):
"""
User enters ONE_ROLL_TRIM mode from ONE_ROLL_TRIM_NO_EDIT
"""
track = tlinewidgets.get_track(y)
if track == None:
return False
if track_lock_check_and_user_info(track, oneroll_trim_mode_init,
"one roll trim mode"):
set_default_edit_mode()
return False
stop_looping()
editorstate.edit_mode = editorstate.ONE_ROLL_TRIM
movemodes.clear_selected_clips(
) # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
# init mode
press_frame = tlinewidgets.get_frame(x)
trimmodes.set_exit_mode_func = set_default_edit_mode
trimmodes.set_no_edit_mode_func = oneroll_trim_no_edit_init
success = trimmodes.set_oneroll_mode(track, press_frame)
return success
def _cover_blank_from_next(data, called_from_next_clip=False):
clip, track, item_id, item_data = data
if not called_from_next_clip:
clip_index = movemodes.selected_range_out + 1
blank_index = movemodes.selected_range_in
if clip_index < 0: # we are not getting a legal clip index
return
cover_clip = track.clips[clip_index]
else:
clip_index = track.clips.index(clip) + 1
blank_index = clip_index - 1
cover_clip = track.clips[clip_index]
# Check that clip covers blank area
total_length = 0
for i in range(movemodes.selected_range_in, movemodes.selected_range_out + 1):
total_length += track.clips[i].clip_length()
if total_length > cover_clip.clip_in: # handle not long enough to cover blanks
primary_txt = _("Next clip does not have enough material to cover blank area")
secondary_txt = _("Requested edit can't be done.")
dialogutils.info_message(primary_txt, secondary_txt, gui.editor_window.window)
return
# Do edit
movemodes.clear_selected_clips()
data = {"track":track, "clip":cover_clip, "blank_index":blank_index}
action = edit.trim_start_over_blanks(data)
action.do_edit()
def slide_trim_mode_init(x, y):
"""
User selects two roll mode
"""
track = tlinewidgets.get_track(y)
if track == None:
return False
if track_lock_check_and_user_info(track, tworoll_trim_mode_init,
"two roll trim mode"):
set_default_edit_mode()
return False
stop_looping()
editorstate.edit_mode = editorstate.SLIDE_TRIM
movemodes.clear_selected_clips(
) # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
press_frame = tlinewidgets.get_frame(x)
trimmodes.set_exit_mode_func = set_default_edit_mode
trimmodes.set_no_edit_mode_func = slide_trim_no_edit_init
success = trimmodes.set_slide_mode(track, press_frame)
return success
def _cover_blank_from_prev(data):
clip, track, item_id, item_data = data
clip_index = movemodes.selected_range_in - 1
if clip_index < 0: # we're not getting legal clip index
return
cover_clip = track.clips[clip_index]
# Check that clip covers blank area
total_length = 0
for i in range(movemodes.selected_range_in,
movemodes.selected_range_out + 1):
total_length += track.clips[i].clip_length()
clip_handle = cover_clip.get_length() - cover_clip.clip_out - 1
if total_length > clip_handle: # handle not long enough to cover blanks
primary_txt = _(
"Previous clip does not have enough material to cover blank area")
secondary_txt = _("Requested edit can't be done.")
dialogutils.info_message(primary_txt, secondary_txt,
gui.editor_window.window)
return
# Do edit
movemodes.clear_selected_clips()
data = {"track": track, "clip": cover_clip, "clip_index": clip_index}
action = edit.trim_end_over_blanks(data)
action.do_edit()
def _cover_blank_from_next(data, called_from_next_clip=False):
clip, track, item_id, item_data = data
if not called_from_next_clip:
clip_index = movemodes.selected_range_out + 1
blank_index = movemodes.selected_range_in
if clip_index < 0: # we are not getting a legal clip index
return
cover_clip = track.clips[clip_index]
else:
clip_index = track.clips.index(clip) + 1
blank_index = clip_index - 1
cover_clip = track.clips[clip_index]
# Check that clip covers blank area
total_length = 0
for i in range(movemodes.selected_range_in,
movemodes.selected_range_out + 1):
total_length += track.clips[i].clip_length()
if total_length > cover_clip.clip_in: # handle not long enough to cover blanks
primary_txt = _(
"Next clip does not have enough material to cover blank area")
secondary_txt = _("Requested edit can't be done.")
dialogutils.info_message(primary_txt, secondary_txt,
gui.editor_window.window)
return
# Do edit
movemodes.clear_selected_clips()
data = {"track": track, "clip": cover_clip, "blank_index": blank_index}
action = edit.trim_start_over_blanks(data)
action.do_edit()
def slide_trim_no_edit_init():
stop_looping() # Stops looping
editorstate.edit_mode = editorstate.SLIDE_TRIM_NO_EDIT
gui.editor_window.set_cursor_to_mode()
tlinewidgets.set_edit_mode(None, None) # No overlays are drawn in this edit mode
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
def multitrim_mode_pressed():
stop_looping()
editorstate.edit_mode = editorstate.MULTI_TRIM
tlinewidgets.set_edit_mode(None,
None) # No overlays are drawn in this edit mode
movemodes.clear_selected_clips(
) # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
def resync_everything():
# Selection not valid after resync action
if movemodes.selected_track == -1:
movemodes.clear_selected_clips()
action = edit.resync_all_action({})
action.do_edit()
updater.repaint_tline()
def cut_mode_pressed():
stop_looping()
current_sequence().clear_hidden_track()
# Box tool is implemeted as sub mode of OVERWRITE_MOVE
editorstate.edit_mode = editorstate.CUT
tlinewidgets.set_edit_mode(None, tlinewidgets.draw_cut_overlay)
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
def _delete_blank(data):
clip, track, item_id, x = data
movemodes.select_blank_range(track, clip)
from_index = movemodes.selected_range_in
to_index = movemodes.selected_range_out
movemodes.clear_selected_clips()
data = {"track": track, "from_index": from_index, "to_index": to_index}
action = edit.remove_multiple_action(data)
action.do_edit()
def resync_everything():
# Selection not valid after resync action
if movemodes.selected_track == -1:
movemodes.clear_selected_clips()
action = edit.resync_all_action({})
action.do_edit()
updater.repaint_tline()
def three_point_overwrite_pressed():
# Check that state is good for edit
if movemodes.selected_track == -1:
primary_txt = _("No Clips are selected!")
secondary_txt = _(
"You need to select clips to overwrite to perform this edit.")
dialogutils.info_message(primary_txt, secondary_txt,
gui.editor_window.window)
return
# Get data
track = get_track(movemodes.selected_track)
if editevent.track_lock_check_and_user_info(track,
three_point_overwrite_pressed,
"3 point overwrite"):
return
range_start_frame = track.clip_start(movemodes.selected_range_in)
out_clip = track.clips[movemodes.selected_range_out]
out_start = track.clip_start(movemodes.selected_range_out)
range_end_frame = out_start + out_clip.clip_out - out_clip.clip_in
range_length = range_end_frame - range_start_frame + 1 # calculated end is incl.
over_clip = _get_new_clip_from_clip_monitor()
if over_clip == None:
no_monitor_clip_info(gui.editor_window.window)
return
over_length = over_clip.mark_out - over_clip.mark_in + 1 # + 1 out incl ?????????? what if over_clip.mark_out == -1 ??????????
if over_length < range_length:
monitor_clip_too_short(gui.editor_window.window)
return
over_clip_out = over_clip.mark_in + range_length - 1 # -1 out incl
range_in = movemodes.selected_range_in
range_out = movemodes.selected_range_out
movemodes.clear_selected_clips() # edit consumes selection
updater.save_monitor_frame = False # hack to not get wrong value saved in MediaFile.current_frame
data = {
"track": track,
"clip": over_clip,
"clip_in": over_clip.mark_in,
"clip_out": over_clip_out,
"in_index": range_in,
"out_index": range_out
}
action = edit.three_point_overwrite_action(data)
action.do_edit()
if not editorstate.timeline_visible():
updater.display_sequence_in_monitor()
updater.display_tline_cut_frame(track, range_in)
def cut_mode_pressed():
stop_looping()
current_sequence().clear_hidden_track()
# Box tool is implemeted as sub mode of OVERWRITE_MOVE
editorstate.edit_mode = editorstate.CUT
tlinewidgets.set_edit_mode(None, tlinewidgets.draw_cut_overlay)
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
def _delete_blank(data):
clip, track, item_id, x = data
movemodes.select_blank_range(track, clip)
from_index = movemodes.selected_range_in
to_index = movemodes.selected_range_out
movemodes.clear_selected_clips()
data = {"track":track,"from_index":from_index,"to_index":to_index}
action = edit.remove_multiple_action(data)
action.do_edit()
def cut_pressed():
if not timeline_visible():
updater.display_sequence_in_monitor()
if EDIT_MODE() == editorstate.ONE_ROLL_TRIM:
editevent.oneroll_trim_no_edit_init()
return
if EDIT_MODE() == editorstate.TWO_ROLL_TRIM:
editevent.tworoll_trim_no_edit_init()
return
tline_frame = PLAYER().current_frame()
movemodes.clear_selected_clips()
# Iterate tracks and do cut on all active that have non-blanck
# clips and frame is not on previous edits
for i in range(1, len(current_sequence().tracks)):
track = get_track(i)
if track.active == False:
continue
if editevent.track_lock_check_and_user_info(
track, cut_pressed, "cut"): # so the other tracks get cut...
continue
# Get index and clip
index = track.get_clip_index_at(int(tline_frame))
try:
clip = track.clips[index]
# don't cut blanck clip
if clip.is_blanck_clip:
continue
except Exception:
continue # Frame after last clip in track
# Get cut frame in clip frames
clip_start_in_tline = track.clip_start(index)
clip_frame = tline_frame - clip_start_in_tline + clip.clip_in
# Dont edit if frame on cut.
if clip_frame == clip.clip_in:
continue
# Do edit
data = {
"track": track,
"index": index,
"clip": clip,
"clip_cut_frame": clip_frame
}
action = edit.cut_action(data)
action.do_edit()
updater.repaint_tline()
def clear_sync_relation(popup_data):
clip, track, item_id, x = popup_data
data = {"child_clip": clip, "child_track": track}
action = edit.clear_sync_action(data)
action.do_edit()
# Edit consumes selection
movemodes.clear_selected_clips()
updater.repaint_tline()
def clear_sync_relation(popup_data):
clip, track, item_id, x = popup_data
data = {"child_clip": clip, "child_track": track}
action = edit.clear_sync_action(data)
action.do_edit()
# Edit consumes selection
movemodes.clear_selected_clips()
updater.repaint_tline()
def kftool_mode_pressed():
stop_looping()
current_sequence().clear_hidden_track()
# Box tool is implemeted as sub mode of OVERWRITE_MOVE
editorstate.edit_mode = editorstate.KF_TOOL
kftoolmode.enter_mode = None
kftoolmode.set_no_clip_edit_data()
tlinewidgets.set_edit_mode(None, tlinewidgets.draw_kftool_overlay)
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
def kftool_mode_pressed():
stop_looping()
current_sequence().clear_hidden_track()
# Box tool is implemeted as sub mode of OVERWRITE_MOVE
editorstate.edit_mode = editorstate.KF_TOOL
kftoolmode.enter_mode = None
kftoolmode.set_no_clip_edit_data()
tlinewidgets.set_edit_mode(None, tlinewidgets.draw_kftool_overlay)
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
def cut_pressed():
if not timeline_visible():
updater.display_sequence_in_monitor()
if EDIT_MODE() == editorstate.ONE_ROLL_TRIM:
editevent.oneroll_trim_no_edit_init()
return
if EDIT_MODE() == editorstate.TWO_ROLL_TRIM:
editevent.tworoll_trim_no_edit_init()
return
tline_frame = PLAYER().current_frame()
movemodes.clear_selected_clips()
# Iterate tracks and do cut on all active that have non-blanck
# clips and frame is not on previous edits
for i in range(1, len(current_sequence().tracks)):
track = get_track(i)
if track.active == False:
continue
if editevent.track_lock_check_and_user_info(track, cut_pressed, "cut"): # so the other tracks get cut...
continue
# Get index and clip
index = track.get_clip_index_at(int(tline_frame))
try:
clip = track.clips[index]
# don't cut blanck clip
if clip.is_blanck_clip:
continue
except Exception:
continue # Frame after last clip in track
# Get cut frame in clip frames
clip_start_in_tline = track.clip_start(index)
clip_frame = tline_frame - clip_start_in_tline + clip.clip_in
# Dont edit if frame on cut.
if clip_frame == clip.clip_in:
continue
# Do edit
data = {"track":track,
"index":index,
"clip":clip,
"clip_cut_frame":clip_frame}
action = edit.cut_action(data)
action.do_edit()
updater.repaint_tline()
def kftool_mode_from_popup_menu(clip, track):
stop_looping()
current_sequence().clear_hidden_track()
# Box tool is implemeted as sub mode of OVERWRITE_MOVE
editorstate.edit_mode = editorstate.KF_TOOL
tlinewidgets.set_edit_mode(None, tlinewidgets.draw_kftool_overlay)
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
kftoolmode.init_tool_for_clip(clip, track)
gui.editor_window.set_cursor_to_mode()
def resync_selected():
if movemodes.selected_track == -1:
return
track = get_track(movemodes.selected_track)
clip_list = []
for index in range(movemodes.selected_range_in,
movemodes.selected_range_out + 1):
clip_list.append((track.clips[index], track))
# Selection not valid after resync action
movemodes.clear_selected_clips()
# Chack if synced clips have same or consecutive parent clips
all_same_or_consecutive = True
master_id = -1
current_master_clip = -1
current_master_index = -1
master_track = current_sequence().first_video_track()
for t in clip_list:
clip, track = t
try:
if master_id == -1:
master_id = clip.sync_data.master_clip.id
current_master_clip = clip.sync_data.master_clip
current_master_index = master_track.clips.index(
current_master_clip)
else:
if clip.sync_data.master_clip.id != master_id:
next_master_index = master_track.clips.index(
clip.sync_data.master_clip)
if current_master_index + 1 == next_master_index:
# Masters are consecutive, save data to test next
master_id = clip.sync_data.master_clip.id
current_master_index = master_track.clips.index(
current_master_clip)
else:
all_same_or_consecutive = False
except:
all_same_or_consecutive = False
# If clips are all for same or consecutive sync parent clips, sync them as a unit.
if len(clip_list) > 1 and all_same_or_consecutive == True:
data = {"clips": clip_list}
action = edit.resync_clips_sequence_action(data)
action.do_edit()
else: # Single or non-consecutive clips are synched separately
data = {"clips": clip_list}
action = edit.resync_some_clips_action(data)
action.do_edit()
updater.repaint_tline()
def range_overwrite_pressed():
# Get data
track = current_sequence().get_first_active_track()
if editevent.track_lock_check_and_user_info(track, range_overwrite_pressed,
"range overwrite"):
return
# tractor is has mark in and mark
mark_in_frame = current_sequence().tractor.mark_in
mark_out_frame = current_sequence().tractor.mark_out
range_length = mark_out_frame - mark_in_frame + 1 # end is incl.
if mark_in_frame == -1 or mark_out_frame == -1:
primary_txt = _("Timeline Range not set!")
secondary_txt = _(
"You need to set Timeline Range using Mark In and Mark Out buttons\nto perform this edit."
)
dialogutils.info_message(primary_txt, secondary_txt,
gui.editor_window.window)
return
# Get over clip and check it overwrite range area
over_clip = _get_new_clip_from_clip_monitor()
if over_clip == None:
no_monitor_clip_info(gui.editor_window.window)
return
over_length = over_clip.mark_out - over_clip.mark_in + 1 # + 1 out incl
if over_length < range_length:
monitor_clip_too_short(gui.editor_window.window)
return
over_clip_out = over_clip.mark_in + range_length - 1
movemodes.clear_selected_clips() # edit consumes selection
updater.save_monitor_frame = False # hack to not get wrong value saved in MediaFile.current_frame
data = {
"track": track,
"clip": over_clip,
"clip_in": over_clip.mark_in,
"clip_out": over_clip_out,
"mark_in_frame": mark_in_frame,
"mark_out_frame": mark_out_frame + 1
} # +1 because mark is displayed and end of frame end this
# confirms to user expectation of
# of how this should work
action = edit.range_overwrite_action(data)
action.do_edit()
updater.display_tline_cut_frame(track,
track.get_clip_index_at(mark_in_frame))
def select_sync_parent_mouse_pressed(event, frame):
_set_sync_parent_clip(event, frame)
gdk_window = gui.tline_display.get_parent_window()
gdk_window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR))
global parent_selection_data
parent_selection_data = None
# Edit consumes selection
movemodes.clear_selected_clips()
updater.repaint_tline()
def select_sync_parent_mouse_pressed(event, frame):
_set_sync_parent_clip(event, frame)
gdk_window = gui.tline_display.get_parent_window();
gdk_window.set_cursor(gtk.gdk.Cursor(gtk.gdk.LEFT_PTR))
global parent_selection_data
parent_selection_data = None
# Edit consumes selection
movemodes.clear_selected_clips()
updater.repaint_tline()
def oneroll_trim_no_edit_init():
"""
This mode is entered and this method is called when:
- user first selects trim tool
- user does cut(X) action while in trim mode
- user clicks empty and preference is to keep using trim tool (to not exit to INSERT_MOVE)
"""
stop_looping()
editorstate.edit_mode = editorstate.ONE_ROLL_TRIM_NO_EDIT
gui.editor_window.set_cursor_to_mode()
tlinewidgets.set_edit_mode(None, None) # No overlays are drawn in this edit mode
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
def kftool_mode_from_popup_menu(clip, track, edit_type):
stop_looping()
current_sequence().clear_hidden_track()
kftoolmode.enter_mode = editorstate.edit_mode
editorstate.edit_mode = editorstate.KF_TOOL
tlinewidgets.set_edit_mode(None, tlinewidgets.draw_kftool_overlay)
movemodes.clear_selected_clips() # Entering this edit mode clears selection
kftoolmode.set_no_clip_edit_data()
kftoolmode.init_tool_for_clip(clip, track, edit_type)
gui.editor_window.set_cursor_to_mode()
def kftool_mode_from_popup_menu(clip, track, edit_type):
stop_looping()
current_sequence().clear_hidden_track()
kftoolmode.enter_mode = editorstate.edit_mode
editorstate.edit_mode = editorstate.KF_TOOL
tlinewidgets.set_edit_mode(None, tlinewidgets.draw_kftool_overlay)
movemodes.clear_selected_clips() # Entering this edit mode clears selection
kftoolmode.set_no_clip_edit_data()
kftoolmode.init_tool_for_clip(clip, track, edit_type)
gui.editor_window.set_cursor_to_mode()
def clear_filters():
if movemodes.selected_track == -1:
return
track = get_track(movemodes.selected_track)
clips = []
for i in range(movemodes.selected_range_in, movemodes.selected_range_out + 1):
clips.append(track.clips[i])
data = {"clips":clips}
action = edit.remove_multiple_filters_action(data)
action.do_edit()
movemodes.clear_selected_clips()
updater.repaint_tline()
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 clear_filters():
if movemodes.selected_track == -1:
return
track = get_track(movemodes.selected_track)
clips = []
for i in range(movemodes.selected_range_in, movemodes.selected_range_out + 1):
clips.append(track.clips[i])
data = {"clips":clips}
action = edit.remove_multiple_filters_action(data)
action.do_edit()
movemodes.clear_selected_clips()
updater.repaint_tline()
def select_sync_clip_mouse_pressed(event, frame):
sync_clip = _get_sync_tline_clip(event, frame)
if sync_clip == None:
return # selection wasn't good
if utils.is_mlt_xml_file(sync_clip.path) == True:
# This isn't translated because 1.14 translation window is close, translation coming for 1.16
dialogutils.warning_message(
_("Cannot Timeline Audio Sync with MLT XML Container Clips!"),
_("Audio syncing for MLT XML Container Clips is not supported."),
gui.editor_window.window, True)
return
sync_track = tlinewidgets.get_track(event.y)
sync_clip_index = sync_track.clips.index(sync_clip)
_tline_sync_data.sync_clip = sync_clip
_tline_sync_data.sync_track = sync_track
_tline_sync_data.sync_clip_index = sync_clip_index
# TImeline media offset for clips
sync_clip_start_in_tline = sync_track.clip_start(sync_clip_index)
_tline_sync_data.origin_clip_start_in_tline = _tline_sync_data.origin_track.clip_start(
_tline_sync_data.origin_clip_index)
_tline_sync_data.clip_tline_media_offset = (
sync_clip_start_in_tline -
sync_clip.clip_in) - (_tline_sync_data.origin_clip_start_in_tline -
_tline_sync_data.origin_clip.clip_in)
gdk_window = gui.tline_display.get_parent_window()
gdk_window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR))
global _compare_dialog_thread
_compare_dialog_thread = AudioCompareActiveThread()
_compare_dialog_thread.start()
# This or GUI freezes, we really can't do Popen.wait() in a Gtk thread
clapperless_thread = ClapperlesLaunchThread(
_tline_sync_data.origin_clip.path, sync_clip.path,
_tline_sync_offsets_computed_callback)
clapperless_thread.start()
# Edit consumes selection
movemodes.clear_selected_clips()
updater.repaint_tline()
def three_point_overwrite_pressed():
# Check that state is good for edit
if movemodes.selected_track == -1:
primary_txt = _("No Clips are selected!")
secondary_txt = _("You need to select clips to overwrite to perform this edit.")
dialogutils.info_message(primary_txt, secondary_txt, gui.editor_window.window)
return
# Get data
track = get_track(movemodes.selected_track)
if editevent.track_lock_check_and_user_info(track, three_point_overwrite_pressed, "3 point overwrite"):
return
range_start_frame = track.clip_start(movemodes.selected_range_in)
out_clip = track.clips[movemodes.selected_range_out]
out_start = track.clip_start(movemodes.selected_range_out)
range_end_frame = out_start + out_clip.clip_out - out_clip.clip_in
range_length = range_end_frame - range_start_frame + 1 # calculated end is incl.
over_clip = _get_new_clip_from_clip_monitor()
if over_clip == None:
no_monitor_clip_info(gui.editor_window.window)
return
over_length = over_clip.mark_out - over_clip.mark_in + 1 # + 1 out incl ?????????? what if over_clip.mark_out == -1 ??????????
if over_length < range_length:
monitor_clip_too_short(gui.editor_window.window)
return
over_clip_out = over_clip.mark_in + range_length - 1 # -1 out incl
range_in = movemodes.selected_range_in
range_out = movemodes.selected_range_out
movemodes.clear_selected_clips() # edit consumes selection
updater.save_monitor_frame = False # hack to not get wrong value saved in MediaFile.current_frame
data = {"track":track,
"clip":over_clip,
"clip_in":over_clip.mark_in,
"clip_out":over_clip_out,
"in_index":range_in,
"out_index":range_out}
action = edit.three_point_overwrite_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, range_in)
def resync_selected():
if movemodes.selected_track == -1:
return
track = get_track(movemodes.selected_track)
clip_list = []
for index in range(movemodes.selected_range_in, movemodes.selected_range_out + 1):
clip_list.append((track.clips[index], track))
# Selection not valid after resync action
movemodes.clear_selected_clips()
# Chack if synced clips have same or consecutive parent clips
all_same_or_consecutive = True
master_id = -1
current_master_clip = -1
current_master_index = -1
master_track = current_sequence().first_video_track()
for t in clip_list:
clip, track = t
try:
if master_id == -1:
master_id = clip.sync_data.master_clip.id
current_master_clip = clip.sync_data.master_clip
current_master_index = master_track.clips.index(current_master_clip)
else:
if clip.sync_data.master_clip.id != master_id:
next_master_index = master_track.clips.index(clip.sync_data.master_clip)
if current_master_index + 1 == next_master_index:
# Masters are consecutive, save data to test next
master_id = clip.sync_data.master_clip.id
current_master_index = master_track.clips.index(current_master_clip)
else:
all_same_or_consecutive = False
except:
all_same_or_consecutive = False
# If clips are all for same or consecutive sync parent clips, sync them as a unit.
if len(clip_list) > 1 and all_same_or_consecutive == True:
data = {"clips":clip_list}
action = edit.resync_clips_sequence_action(data)
action.do_edit()
else: # Single or non-consecutive clips are synched separately
data = {"clips":clip_list}
action = edit.resync_some_clips_action(data)
action.do_edit()
updater.repaint_tline()
def do_multiple_clip_insert(track, clips, tline_pos):
index = _get_insert_index(track, tline_pos)
# Can't put audio media on video track
for new_clip in clips:
if (new_clip.media_type == appconsts.AUDIO) and (track.type == appconsts.VIDEO):
_display_no_audio_on_video_msg(track)
return
movemodes.clear_selected_clips()
# Do edit
data = {"track": track, "clips": clips, "index": index}
action = edit.insert_multiple_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index)
def range_overwrite_pressed():
# Get data
track = current_sequence().get_first_active_track()
if editevent.track_lock_check_and_user_info(track, range_overwrite_pressed, "range overwrite"):
return
# tractor is has mark in and mark
mark_in_frame = current_sequence().tractor.mark_in
mark_out_frame = current_sequence().tractor.mark_out
range_length = mark_out_frame - mark_in_frame + 1 # end is incl.
if mark_in_frame == -1 or mark_out_frame == -1:
primary_txt = _("Timeline Range not set!")
secondary_txt = _("You need to set Timeline Range using Mark In and Mark Out buttons\nto perform this edit.")
dialogutils.info_message(primary_txt, secondary_txt, gui.editor_window.window)
return
# Get over clip and check it overwrite range area
over_clip = _get_new_clip_from_clip_monitor()
if over_clip == None:
no_monitor_clip_info(gui.editor_window.window)
return
over_length = over_clip.mark_out - over_clip.mark_in + 1 # + 1 out incl
if over_length < range_length:
monitor_clip_too_short(gui.editor_window.window)
return
over_clip_out = over_clip.mark_in + range_length - 1
movemodes.clear_selected_clips() # edit consumes selection
updater.save_monitor_frame = False # hack to not get wrong value saved in MediaFile.current_frame
data = {"track":track,
"clip":over_clip,
"clip_in":over_clip.mark_in,
"clip_out":over_clip_out,
"mark_in_frame":mark_in_frame,
"mark_out_frame":mark_out_frame + 1} # +1 because mark is displayed and end of frame end this
# confirms to user expectation of
# of how this should work
action = edit.range_overwrite_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, track.get_clip_index_at(mark_in_frame))
def do_multiple_clip_insert(track, clips, tline_pos):
index = _get_insert_index(track, tline_pos)
# Can't put audio media on video track
for new_clip in clips:
if ((new_clip.media_type == appconsts.AUDIO)
and (track.type == appconsts.VIDEO)):
_display_no_audio_on_video_msg(track)
return
movemodes.clear_selected_clips()
# Do edit
data = {"track": track, "clips": clips, "index": index}
action = edit.insert_multiple_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index)
def delete_range_button_pressed():
# Get data
#track = current_sequence().get_first_active_track()
#if editevent.track_lock_check_and_user_info(track, range_overwrite_pressed, "range overwrite"):
# return
tracks = []
for i in range(1, len(current_sequence().tracks) - 1):
track = current_sequence().tracks[i]
if track.edit_freedom != appconsts.LOCKED:
tracks.append(track)
if len(tracks) == 0:
# all tracks are locked!
return
# tractor is has mark in and mark
mark_in_frame = current_sequence().tractor.mark_in
mark_out_frame = current_sequence().tractor.mark_out
range_length = mark_out_frame - mark_in_frame + 1 # end is incl.
if mark_in_frame == -1 or mark_out_frame == -1:
primary_txt = _("Timeline Range not set!")
secondary_txt = _(
"You need to set Timeline Range using Mark In and Mark Out buttons\nto perform this edit."
)
dialogutils.info_message(primary_txt, secondary_txt,
gui.editor_window.window)
return
movemodes.clear_selected_clips() # edit consumes selection
updater.save_monitor_frame = False # hack to not get wrong value saved in MediaFile.current_frame
data = {
"tracks": tracks,
"mark_in_frame": mark_in_frame,
"mark_out_frame": mark_out_frame + 1
} # +1 because mark is displayed and end of frame end this
# confirms to user expectation of
# of how this should work
action = edit.range_delete_action(data)
action.do_edit()
PLAYER().seek_frame(mark_in_frame)
def tworoll_trim_mode_init(x, y):
"""
User selects two roll mode
"""
track = tlinewidgets.get_track(y)
if track == None:
return False
stop_looping()
editorstate.edit_mode = editorstate.TWO_ROLL_TRIM
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
press_frame = tlinewidgets.get_frame(x)
trimmodes.set_exit_mode_func = set_default_edit_mode
trimmodes.set_no_edit_mode_func = tworoll_trim_no_edit_init
success = trimmodes.set_tworoll_mode(track, press_frame)
return success
def slide_trim_mode_init(x, y):
"""
User selects two roll mode
"""
track = tlinewidgets.get_track(y)
if track == None:
return False
stop_looping()
editorstate.edit_mode = editorstate.SLIDE_TRIM
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
press_frame = tlinewidgets.get_frame(x)
trimmodes.set_exit_mode_func = set_default_edit_mode
trimmodes.set_no_edit_mode_func = slide_trim_no_edit_init
success = trimmodes.set_slide_mode(track, press_frame)
return success
def select_sync_clip_mouse_pressed(event, frame):
sync_clip = _get_sync_tline_clip(event, frame)
if sync_clip == None:
return # selection wasn't good
if utils.is_mlt_xml_file(sync_clip.path) == True:
# This isn't translated because 1.14 translation window is close, translation coming for 1.16
dialogutils.warning_message(_("Cannot Timeline Audio Sync with Compound Clips!"),
_("Audio syncing for Compound Clips is not supported."),
gui.editor_window.window,
True)
return
sync_track = tlinewidgets.get_track(event.y)
sync_clip_index = sync_track.clips.index(sync_clip)
_tline_sync_data.sync_clip = sync_clip
_tline_sync_data.sync_track = sync_track
_tline_sync_data.sync_clip_index = sync_clip_index
# TImeline media offset for clips
sync_clip_start_in_tline = sync_track.clip_start(sync_clip_index)
_tline_sync_data.origin_clip_start_in_tline = _tline_sync_data.origin_track.clip_start(_tline_sync_data.origin_clip_index)
_tline_sync_data.clip_tline_media_offset = (sync_clip_start_in_tline - sync_clip.clip_in) - (_tline_sync_data.origin_clip_start_in_tline - _tline_sync_data.origin_clip.clip_in)
gdk_window = gui.tline_display.get_parent_window();
gdk_window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR))
global _compare_dialog_thread
_compare_dialog_thread = AudioCompareActiveThread()
_compare_dialog_thread.start()
# This or GUI freezes, we really can't do Popen.wait() in a Gtk thread
clapperless_thread = ClapperlesLaunchThread(_tline_sync_data.origin_clip.path, sync_clip.path, _tline_sync_offsets_computed_callback)
clapperless_thread.start()
# Edit consumes selection
movemodes.clear_selected_clips()
updater.repaint_tline()
def oneroll_trim_mode_init(x, y):
"""
User enters ONE_ROLL_TRIM mode from ONE_ROLL_TRIM_NO_EDIT
"""
track = tlinewidgets.get_track(y)
if track == None:
return False
stop_looping()
editorstate.edit_mode = editorstate.ONE_ROLL_TRIM
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
# init mode
press_frame = tlinewidgets.get_frame(x)
trimmodes.set_exit_mode_func = set_default_edit_mode
trimmodes.set_no_edit_mode_func = oneroll_trim_no_edit_init
success = trimmodes.set_oneroll_mode(track, press_frame)
return success
def do_clip_insert(track, new_clip, tline_pos):
index = _get_insert_index(track, tline_pos)
# Can't put audio media on video track
if ((new_clip.media_type == appconsts.AUDIO)
and (track.type == appconsts.VIDEO)):
_display_no_audio_on_video_msg(track)
return
movemodes.clear_selected_clips()
# Do edit
data = {"track":track,
"clip":new_clip,
"index":index,
"clip_in":new_clip.mark_in,
"clip_out":new_clip.mark_out}
action = edit.insert_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index)
def tworoll_trim_mode_init(x, y):
"""
User selects two roll mode
"""
track = tlinewidgets.get_track(y)
if track == None:
return False
if track_lock_check_and_user_info(track, tworoll_trim_mode_init, "two roll trim mode",):
set_default_edit_mode()
return False
stop_looping()
editorstate.edit_mode = editorstate.TWO_ROLL_TRIM
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
press_frame = tlinewidgets.get_frame(x)
trimmodes.set_exit_mode_func = set_default_edit_mode
trimmodes.set_no_edit_mode_func = tworoll_trim_no_edit_init
success = trimmodes.set_tworoll_mode(track, press_frame)
return success
def _cover_blank_from_prev(data):
clip, track, item_id, item_data = data
clip_index = movemodes.selected_range_in - 1
if clip_index < 0: # we're not getting legal clip index
return
cover_clip = track.clips[clip_index]
# Check that clip covers blank area
total_length = 0
for i in range(movemodes.selected_range_in, movemodes.selected_range_out + 1):
total_length += track.clips[i].clip_length()
clip_handle = cover_clip.get_length() - cover_clip.clip_out - 1
if total_length > clip_handle: # handle not long enough to cover blanks
primary_txt = _("Previous clip does not have enough material to cover blank area")
secondary_txt = _("Requested edit can't be done.")
dialogutils.info_message(primary_txt, secondary_txt, gui.editor_window.window)
return
# Do edit
movemodes.clear_selected_clips()
data = {"track":track, "clip":cover_clip, "clip_index":clip_index}
action = edit.trim_end_over_blanks(data)
action.do_edit()
def select_sync_clip_mouse_pressed(event, frame):
sync_clip = _get_sync_tline_clip(event, frame)
if sync_clip == None:
return # selection wasn't good
sync_track = tlinewidgets.get_track(event.y)
sync_clip_index = sync_track.clips.index(sync_clip)
_tline_sync_data.sync_clip = sync_clip
_tline_sync_data.sync_track = sync_track
_tline_sync_data.sync_clip_index = sync_clip_index
# TImeline media offset for clips
sync_clip_start_in_tline = sync_track.clip_start(sync_clip_index)
_tline_sync_data.origin_clip_start_in_tline = _tline_sync_data.origin_track.clip_start(
_tline_sync_data.origin_clip_index)
_tline_sync_data.clip_tline_media_offset = (
sync_clip_start_in_tline -
sync_clip.clip_in) - (_tline_sync_data.origin_clip_start_in_tline -
_tline_sync_data.origin_clip.clip_in)
gdk_window = gui.tline_display.get_parent_window()
gdk_window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR))
# This or GUI freezes, we really can't do Popen.wait() in a Gtk thread
clapperless_thread = ClapperlesLaunchThread(
_tline_sync_data.origin_clip.path, sync_clip.path,
_tline_sync_offsets_computed_callback)
clapperless_thread.start()
# Edit consumes selection
movemodes.clear_selected_clips()
updater.repaint_tline()
def tline_canvas_mouse_pressed(event, frame):
"""
Mouse event callback from timeline canvas widget
"""
editorstate.timeline_mouse_disabled = False # This is used to disable "move and "release" events when they would get bad data.
if PLAYER().looping():
return
elif PLAYER().is_playing():
PLAYER().stop_playback()
# Double click handled separately
if event.type == Gdk.EventType._2BUTTON_PRESS:
return
# Handle and exit parent clip selecting
if EDIT_MODE() == editorstate.SELECT_PARENT_CLIP:
syncsplitevent.select_sync_parent_mouse_pressed(event, frame)
editorstate.timeline_mouse_disabled = True
# Set INSERT_MODE
modesetting.set_default_edit_mode()
return
# Handle and exit tline sync clip selecting
if EDIT_MODE() == editorstate.SELECT_TLINE_SYNC_CLIP:
audiosync.select_sync_clip_mouse_pressed(event, frame)
editorstate.timeline_mouse_disabled = True
# Set INSERT_MODE
modesetting.set_default_edit_mode()
return
# Hitting timeline in clip display mode displays timeline in
# default mode.
if not timeline_visible():
updater.display_sequence_in_monitor()
if (event.button == 1):
# Now that we have correct edit mode we'll reenter
# this method to get e.g. a select action
tline_canvas_mouse_pressed(event, frame)
return
if (event.button == 3):
# Right mouse + CTRL displays clip menu if we hit clip
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_frame(frame)
# Right mouse on timeline seeks frame
else:
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
return
# If clip end drag mode is for some reason still active, exit to default edit mode
if EDIT_MODE() == editorstate.CLIP_END_DRAG:
modesetting.set_default_edit_mode()
# This shouldn't happen unless for some reason mouse release didn't hit clipenddragmode listener.
print("EDIT_MODE() == editorstate.CLIP_END_DRAG at mouse press!")
# Check if match frame close is hit
if editorstate.current_is_move_mode() and timeline_visible():
if tlinewidgets.match_frame_close_hit(event.x, event.y) == True:
tlinewidgets.set_match_frame(-1, -1, True)
updater.repaint_tline()
return
# Check if compositor is hit and if so, handle compositor editing
if editorstate.current_is_move_mode() and timeline_visible():
hit_compositor = tlinewidgets.compositor_hit(frame, event.x, event.y, current_sequence().compositors)
if hit_compositor != None:
if editorstate.get_compositing_mode() == appconsts.COMPOSITING_MODE_STANDARD_AUTO_FOLLOW:
compositeeditor.set_compositor(hit_compositor)
compositormodes.set_compositor_selected(hit_compositor)
movemodes.clear_selected_clips()
editorstate.timeline_mouse_disabled = True
return
elif editorstate.auto_follow_active() == False or hit_compositor.obey_autofollow == False:
movemodes.clear_selected_clips()
if event.button == 1 or (event.button == 3 and event.get_state() & Gdk.ModifierType.CONTROL_MASK):
compositormodes.set_compositor_mode(hit_compositor)
mode_funcs = EDIT_MODE_FUNCS[editorstate.COMPOSITOR_EDIT]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
return
if event.button == 3:
compositormodes.set_compositor_selected(hit_compositor)
guicomponents.display_compositor_popup_menu(event, hit_compositor,
compositor_menu_item_activated)
return
elif event.button == 2:
updater.zoom_project_length()
return
compositormodes.clear_compositor_selection()
# Check if we should enter clip end drag mode
if (event.button == 3 and editorstate.current_is_move_mode()
and timeline_visible() and (event.get_state() & Gdk.ModifierType.CONTROL_MASK)):
# with CTRL right mouse
clipenddragmode.maybe_init_for_mouse_press(event, frame)
elif (timeline_visible() and (EDIT_MODE() == editorstate.INSERT_MOVE or EDIT_MODE() == editorstate.OVERWRITE_MOVE)
and (tlinewidgets.pointer_context == appconsts.POINTER_CONTEXT_END_DRAG_LEFT or tlinewidgets.pointer_context == appconsts.POINTER_CONTEXT_END_DRAG_RIGHT)):
# with pointer context
clipenddragmode.maybe_init_for_mouse_press(event, frame)
# Handle mouse button presses depending which button was pressed and
# editor state.
# RIGHT BUTTON: seek frame or display clip menu if not dragging clip end
if (event.button == 3 and EDIT_MODE() != editorstate.CLIP_END_DRAG and EDIT_MODE() != editorstate.KF_TOOL):
if ((not editorstate.current_is_active_trim_mode()) and timeline_visible()):
if not(event.get_state() & Gdk.ModifierType.CONTROL_MASK):
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
else:
# For trim modes set <X>_NO_EDIT edit mode and seek frame. and seek frame
trimmodes.set_no_edit_trim_mode()
PLAYER().seek_frame(frame)
return
# LEFT BUTTON: Select new trimmed clip in active one roll trim mode with sensitive cursor.
elif (event.button == 1 and EDIT_MODE() == editorstate.ONE_ROLL_TRIM):
track = tlinewidgets.get_track(event.y)
if track == None:
modesetting.set_default_edit_mode(True)
return
success = trimmodes.set_oneroll_mode(track, frame)
if not success:
modesetting.set_default_edit_mode(True)
return
if trimmodes.edit_data["to_side_being_edited"] == True:
pointer_context = appconsts.POINTER_CONTEXT_TRIM_LEFT
else:
pointer_context = appconsts.POINTER_CONTEXT_TRIM_RIGHT
gui.editor_window.set_tline_cursor_to_context(pointer_context)
gui.editor_window.set_tool_selector_to_mode()
if not editorpersistance.prefs.quick_enter_trims:
editorstate.timeline_mouse_disabled = True
else:
trimmodes.oneroll_trim_move(event.x, event.y, frame, None)
elif event.button == 2:
updater.zoom_project_length()
# LEFT BUTTON: Handle left mouse button edits by passing event to current edit mode
# handler func
elif event.button == 1 or event.button == 3:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
def _attempt_dnd_overwrite(track, clip, frame):
# Can't put audio media on video track
if ((clip.media_type == appconsts.AUDIO)
and (track.type == appconsts.VIDEO)):
return
# Dropping on first available frame after last clip is append
# and is handled by insert code
if track.get_length() == frame:
return False
# Clip dropped after last clip on track
if track.get_length() < frame:
index = _get_insert_index(track, track.get_length())
movemodes.clear_selected_clips()
data = {"track":track,
"clip":clip,
"blank_length":frame - track.get_length(),
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_after_track_end_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index + 1)
return True
else: # Clip dropped before end of last clip on track
index = track.get_clip_index_at(frame)
overwritten_clip = track.clips[index]
# dnd overwrites can only done on blank clips
# Drops on clips are considered inserts
if overwritten_clip.is_blanck_clip == False:
return False
drop_length = clip.mark_out - clip.mark_in + 1 # +1 , mark out incl.
blank_start = track.clip_start(index)
blank_end = track.clip_start(index + 1)
movemodes.clear_selected_clips()
# Clip dropped on first frame of blank
if blank_start == frame:
# If dropped clip longer then blank, replace blank
if frame + drop_length >= blank_end:
data = {"track":track,
"clip":clip,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in}
action = edit.dnd_on_blank_replace_action(data)
action.do_edit()
else: # If dropped clip shorter then blank, replace start part of blank
data = {"track":track,
"clip":clip,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_on_blank_start_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index)
return True
# Clip dropped after first frame of blank
if frame + drop_length >= blank_end:
# Overwrite end half of blank
data = {"track":track,
"clip":clip,
"overwritten_blank_length":frame - blank_start,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_on_blank_end_action(data)
action.do_edit()
else: # Overwrite part of blank ei toimi
data = {"track":track,
"clip":clip,
"overwritten_start_frame":frame - blank_start,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_on_blank_middle_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index + 1)
return True
return False # this won't be hit
def multitrim_mode_pressed():
stop_looping()
editorstate.edit_mode = editorstate.MULTI_TRIM
tlinewidgets.set_edit_mode(None, None) # No overlays are drawn in this edit mode
movemodes.clear_selected_clips() # Entering trim edit mode clears selection
updater.set_trim_mode_gui()
transition_data["from_handle"],
to_part - (1 - add_thingy),
transition_data["to_handle"]) == False:
return
# Get from in and out frames
from_in = from_clip.clip_out - from_part + add_thingy
from_out = from_in + length # or transition will include one frame too many
# Get to in and out frames
to_in = to_clip.clip_in - to_part - 1
to_out = to_in + length # or transition will include one frame too many
# Edit clears selection, get track index before selection is cleared
trans_index = movemodes.selected_range_out
movemodes.clear_selected_clips()
producer_tractor = mlttransitions.get_rendered_transition_tractor( editorstate.current_sequence(),
from_clip,
to_clip,
from_out,
from_in,
to_out,
to_in,
transition_type_selection_index,
sorted_wipe_luma_index,
color_str)
# Save transition data into global variable to be available at render complete callback
global transition_render_data
transition_render_data = (trans_index, from_clip, to_clip, transition_data["track"], from_in, to_out, transition_type_selection_index)
def _attempt_dnd_overwrite(track, clip, frame):
# Can't put audio media on video track
if ((clip.media_type == appconsts.AUDIO)
and (track.type == appconsts.VIDEO)):
return
# Dropping on first available frame after last clip is append
# and is handled by insert code
if track.get_length() == frame:
return False
# Clip dropped after last clip on track
if track.get_length() < frame:
index = _get_insert_index(track, track.get_length())
movemodes.clear_selected_clips()
data = {"track":track,
"clip":clip,
"blank_length":frame - track.get_length(),
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_after_track_end_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index + 1)
return True
else: # Clip dropped before end of last clip on track
index = track.get_clip_index_at(frame)
overwritten_clip = track.clips[index]
# dnd overwrites can only done on blank clips
# Drops on clips are considered inserts
if overwritten_clip.is_blanck_clip == False:
return False
drop_length = clip.mark_out - clip.mark_in + 1 # +1 , mark out incl.
blank_start = track.clip_start(index)
blank_end = track.clip_start(index + 1)
movemodes.clear_selected_clips()
# Clip dropped on first frame of blank
if blank_start == frame:
# If dropped clip longer then blank, replace blank
if frame + drop_length >= blank_end:
data = {"track":track,
"clip":clip,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in}
action = edit.dnd_on_blank_replace_action(data)
action.do_edit()
else: # If dropped clip shorter then blank, replace start part of blank
data = {"track":track,
"clip":clip,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_on_blank_start_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index)
return True
# Clip dropped after first frame of blank
if frame + drop_length >= blank_end:
# Overwrite end half of blank
data = {"track":track,
"clip":clip,
"overwritten_blank_length":frame - blank_start,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_on_blank_end_action(data)
action.do_edit()
else: # Overwrite part of blank ei toimi
data = {"track":track,
"clip":clip,
"overwritten_start_frame":frame - blank_start,
"blank_length":blank_end - blank_start,
"index":index,
"clip_in":clip.mark_in,
"clip_out":clip.mark_out}
action = edit.dnd_on_blank_middle_action(data)
action.do_edit()
updater.display_tline_cut_frame(track, index + 1)
return True
return False # this won't be hit
def tline_canvas_mouse_pressed(event, frame):
"""
Mouse event callback from timeline canvas widget
"""
editorstate.timeline_mouse_disabled = False # This is used to disable "move and "release" events when they would get bad data.
if PLAYER().looping():
return
elif PLAYER().is_playing():
PLAYER().stop_playback()
# Double click handled separately
if event.type == Gdk.EventType._2BUTTON_PRESS:
return
# Handle and exit parent clip selecting
if EDIT_MODE() == editorstate.SELECT_PARENT_CLIP:
syncsplitevent.select_sync_parent_mouse_pressed(event, frame)
editorstate.timeline_mouse_disabled = True
# Set INSERT_MODE
modesetting.set_default_edit_mode()
return
# Handle and exit tline sync clip selecting
if EDIT_MODE() == editorstate.SELECT_TLINE_SYNC_CLIP:
audiosync.select_sync_clip_mouse_pressed(event, frame)
editorstate.timeline_mouse_disabled = True
# Set INSERT_MODE
modesetting.set_default_edit_mode()
return
# Hitting timeline in clip display mode displays timeline in
# default mode.
if not timeline_visible():
updater.display_sequence_in_monitor()
if (event.button == 1):
# Now that we have correct edit mode we'll reenter
# this method to get e.g. a select action
tline_canvas_mouse_pressed(event, frame)
return
if (event.button == 3):
# Right mouse + CTRL displays clip menu if we hit clip
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_frame(frame)
# Right mouse on timeline seeks frame
else:
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
return
# If clip end drag mode is for some reason still active, exit to default edit mode
if EDIT_MODE() == editorstate.CLIP_END_DRAG:
modesetting.set_default_edit_mode()
# This shouldn't happen unless for some reason mouse release didn't hit clipenddragmode listener.
print "EDIT_MODE() == editorstate.CLIP_END_DRAG at mouse press!"
# Check if match frame close is hit
if editorstate.current_is_move_mode() and timeline_visible():
if tlinewidgets.match_frame_close_hit(event.x, event.y) == True:
tlinewidgets.set_match_frame(-1, -1, True)
updater.repaint_tline()
return
# Check if compositor is hit and if so, handle compositor editing
if editorstate.current_is_move_mode() and timeline_visible():
hit_compositor = tlinewidgets.compositor_hit(frame, event.y, current_sequence().compositors)
if hit_compositor != None:
if editorstate.auto_follow == False or hit_compositor.obey_autofollow == False:
movemodes.clear_selected_clips()
if event.button == 1 or (event.button == 3 and event.get_state() & Gdk.ModifierType.CONTROL_MASK):
compositormodes.set_compositor_mode(hit_compositor)
mode_funcs = EDIT_MODE_FUNCS[editorstate.COMPOSITOR_EDIT]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
return
if event.button == 3:
compositormodes.set_compositor_selected(hit_compositor)
guicomponents.display_compositor_popup_menu(event, hit_compositor,
compositor_menu_item_activated)
return
elif event.button == 2:
updater.zoom_project_length()
return
compositormodes.clear_compositor_selection()
# Check if we should enter clip end drag mode
if (event.button == 3 and editorstate.current_is_move_mode()
and timeline_visible() and (event.get_state() & Gdk.ModifierType.CONTROL_MASK)):
# with CTRL right mouse
clipenddragmode.maybe_init_for_mouse_press(event, frame)
elif (timeline_visible() and (EDIT_MODE() == editorstate.INSERT_MOVE or EDIT_MODE() == editorstate.OVERWRITE_MOVE)
and (tlinewidgets.pointer_context == appconsts.POINTER_CONTEXT_END_DRAG_LEFT or tlinewidgets.pointer_context == appconsts.POINTER_CONTEXT_END_DRAG_RIGHT)):
# with pointer context
clipenddragmode.maybe_init_for_mouse_press(event, frame)
# Handle mouse button presses depending which button was pressed and
# editor state.
# RIGHT BUTTON: seek frame or display clip menu if not dragging clip end
if (event.button == 3 and EDIT_MODE() != editorstate.CLIP_END_DRAG and EDIT_MODE() != editorstate.KF_TOOL):
if ((not editorstate.current_is_active_trim_mode()) and timeline_visible()):
if not(event.get_state() & Gdk.ModifierType.CONTROL_MASK):
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
else:
# For trim modes set <X>_NO_EDIT edit mode and seek frame. and seek frame
trimmodes.set_no_edit_trim_mode()
PLAYER().seek_frame(frame)
return
# LEFT BUTTON: Select new trimmed clip in active one roll trim mode with sensitive cursor.
elif (event.button == 1 and EDIT_MODE() == editorstate.ONE_ROLL_TRIM):
track = tlinewidgets.get_track(event.y)
if track == None:
modesetting.set_default_edit_mode(True)
return
success = trimmodes.set_oneroll_mode(track, frame)
if not success:
modesetting.set_default_edit_mode(True)
return
if trimmodes.edit_data["to_side_being_edited"] == True:
pointer_context = appconsts.POINTER_CONTEXT_TRIM_LEFT
else:
pointer_context = appconsts.POINTER_CONTEXT_TRIM_RIGHT
gui.editor_window.set_tline_cursor_to_context(pointer_context)
gui.editor_window.set_tool_selector_to_mode()
if not editorpersistance.prefs.quick_enter_trims:
editorstate.timeline_mouse_disabled = True
else:
trimmodes.oneroll_trim_move(event.x, event.y, frame, None)
elif event.button == 2:
updater.zoom_project_length()
# LEFT BUTTON: Handle left mouse button edits by passing event to current edit mode
# handler func
elif event.button == 1 or event.button == 3:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
def tline_canvas_mouse_pressed(event, frame):
"""
Mouse event callback from timeline canvas widget
"""
global mouse_disabled
if PLAYER().looping():
return
elif PLAYER().is_playing():
PLAYER().stop_playback()
# Double click handled separately
if event.type == gtk.gdk._2BUTTON_PRESS:
return
# Handle and exit parent clip selecting
if EDIT_MODE() == editorstate.SELECT_PARENT_CLIP:
syncsplitevent.select_sync_parent_mouse_pressed(event, frame)
mouse_disabled = True
# Set INSERT_MODE
set_default_edit_mode()
return
# Hitting timeline in clip display mode displays timeline in
# default mode.
if not timeline_visible():
updater.display_sequence_in_monitor()
if (event.button == 1):
# Now that we have correct edit mode we'll reenter
# this method to get e.g. a select action
tline_canvas_mouse_pressed(event, frame)
return
if (event.button == 3):
mouse_disabled == True
# Right mouse + CTRL displays clip menu if we hit clip
if (event.state & gtk.gdk.CONTROL_MASK):
PLAYER().seek_frame(frame)
# Right mouse on timeline seeks frame
else:
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
return
# Check if compositor is hit and if so handle compositor editing
if editorstate.current_is_move_mode() and timeline_visible():
hit_compositor = tlinewidgets.compositor_hit(frame, event.y, current_sequence().compositors)
if hit_compositor != None:
movemodes.clear_selected_clips()
if event.button == 1:
compositormodes.set_compositor_mode(hit_compositor)
mode_funcs = EDIT_MODE_FUNCS[editorstate.COMPOSITOR_EDIT]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
elif event.button == 3:
mouse_disabled == True
compositormodes.set_compositor_selected(hit_compositor)
guicomponents.display_compositor_popup_menu(event, hit_compositor,
compositor_menu_item_activated)
elif event.button == 2:
updater.zoom_project_length()
return
compositormodes.clear_compositor_selection()
# Handle mouse button presses depending which button was pressed and
# editor state.
# RIGHT BUTTON: seek frame or display clip menu
if (event.button == 3):
if ((not editorstate.current_is_active_trim_mode()) and timeline_visible()):
if not(event.state & gtk.gdk.CONTROL_MASK):
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
else:
PLAYER().seek_frame(frame)
else:
# For trim modes set <X>_NO_EDIT edit mode and seek frame. and seek frame
trimmodes.set_no_edit_trim_mode()
PLAYER().seek_frame(frame)
return
# LEFT BUTTON + CTRL: Select new trimmed clip in one roll trim mode
elif (event.button == 1
and (event.state & gtk.gdk.CONTROL_MASK)
and EDIT_MODE() == editorstate.ONE_ROLL_TRIM):
track = tlinewidgets.get_track(event.y)
if track == None:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
success = trimmodes.set_oneroll_mode(track, frame)
if (not success) and editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
gui.editor_window.set_cursor_to_mode()
gui.editor_window.set_mode_selector_to_mode()
if not editorpersistance.prefs.quick_enter_trims:
mouse_disabled = True
else:
trimmodes.oneroll_trim_move(event.x, event.y, frame, None)
# LEFT BUTTON + CTRL: Select new trimmed clip in two roll trim mode
elif (event.button == 1
and (event.state & gtk.gdk.CONTROL_MASK)
and EDIT_MODE() == editorstate.TWO_ROLL_TRIM):
track = tlinewidgets.get_track(event.y)
if track == None:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
success = trimmodes.set_tworoll_mode(track, frame)
if (not success) and editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
if not editorpersistance.prefs.quick_enter_trims:
mouse_disabled = True
else:
trimmodes.tworoll_trim_move(event.x, event.y, frame, None)
# LEFT BUTTON: Handle left mouse button edits by passing event to current edit mode
# handler func
elif event.button == 1:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
elif event.button == 2:
updater.zoom_project_length()
if _check_transition_handles(
(from_part - add_thingy), transition_data["from_handle"],
to_part - (1 - add_thingy), transition_data["to_handle"]) == False:
return
# Get from in and out frames
from_in = from_clip.clip_out - from_part + add_thingy
from_out = from_in + length # or transition will include one frame too many
# Get to in and out frames
to_in = to_clip.clip_in - to_part - 1
to_out = to_in + length # or transition will include one frame too many
# Edit clears selection, get track index before selection is cleared
trans_index = movemodes.selected_range_out
movemodes.clear_selected_clips()
transition_type_selection_index = type_combo.get_active(
) # these corespond with ...
producer_tractor = mlttransitions.get_rendered_transition_tractor(
editorstate.current_sequence(), from_clip, to_clip, from_out, from_in,
to_out, to_in, transition_type_selection_index, sorted_wipe_luma_index,
color_str)
# Save transition data into global variable to be available at render complete callback
global transition_render_data
transition_render_data = (trans_index, from_clip, to_clip,
transition_data["track"], from_in, to_out,
transition_type_selection_index)
window_text, type_id = mlttransitions.rendered_transitions[
transition_type_selection_index]
window_text = _("Rendering ") + window_text
def range_overwrite_pressed():
# Get data
track = current_sequence().get_first_active_track()
if editevent.track_lock_check_and_user_info(track, range_overwrite_pressed,
"range overwrite"):
return
# Get over clip and check it overwrite range area
over_clip = _get_new_clip_from_clip_monitor()
if over_clip == None:
no_monitor_clip_info(gui.editor_window.window)
return
# tractor is has mark in and mark
mark_in_frame = current_sequence().tractor.mark_in
mark_out_frame = current_sequence().tractor.mark_out
# Case timeline marked
if mark_in_frame != -1 and mark_out_frame != -1:
range_length = mark_out_frame - mark_in_frame + 1 # end is incl.
if over_clip.mark_in == -1:
# This actually never hit because mark in and mark out seem to first and last frame if nothing set
show_three_point_edit_not_defined()
return
over_length = over_clip.mark_out - over_clip.mark_in + 1 # + 1 out incl
if over_length < range_length:
monitor_clip_too_short(gui.editor_window.window)
return
over_clip_out = over_clip.mark_in + range_length - 1
# Case clip marked
elif over_clip.mark_out != -1 and over_clip.mark_in != -1:
range_length = over_clip.mark_out - over_clip.mark_in + 1 # end is incl.
if mark_in_frame == -1:
show_three_point_edit_not_defined()
return
over_length = track.get_length() - mark_in_frame + 1 # + 1 out incl
if over_length < range_length:
monitor_clip_too_short(gui.editor_window.window)
return
over_clip_out = over_clip.mark_out
mark_out_frame = mark_in_frame + range_length - 1 # -1 because it gets readded later
# case neither clip or timeline has both in and out points
else:
show_three_point_edit_not_defined()
return
movemodes.clear_selected_clips() # edit consumes selection
updater.save_monitor_frame = False # hack to not get wrong value saved in MediaFile.current_frame
data = {
"track": track,
"clip": over_clip,
"clip_in": over_clip.mark_in,
"clip_out": over_clip_out,
"mark_in_frame": mark_in_frame,
"mark_out_frame": mark_out_frame + 1
} # +1 because mark is displayed and end of frame end this
# confirms to user expectation of
# of how this should work
action = edit.range_overwrite_action(data)
action.do_edit()
updater.display_tline_cut_frame(track,
track.get_clip_index_at(mark_in_frame))