def oneroll_trim_press(event, frame):
"""
User presses mouse when in one roll mode.
"""
global mouse_disabled
if not _pressed_on_edited_track(event.y):
track = tlinewidgets.get_track(event.y)
success = set_oneroll_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(
True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func(
) # further mouse events are handled at editevent.py
else:
if not editorpersistance.prefs.quick_enter_trims:
# new trim inited, editing non-active until release
tlinewidgets.trim_mode_in_non_active_state = True
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(
editorstate.ONE_ROLL_TRIM_NO_EDIT)
mouse_disabled = True
else:
# new trim inited, active immediately
oneroll_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
return
if not _pressed_on_one_roll_active_area(frame):
track = tlinewidgets.get_track(event.y)
success = set_oneroll_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(
True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func(
) # no furter mouse events will come here
else:
if not editorpersistance.prefs.quick_enter_trims:
# new trim inited, editing non-active until release
tlinewidgets.trim_mode_in_non_active_state = True
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(
editorstate.ONE_ROLL_TRIM_NO_EDIT)
mouse_disabled = True
else:
# new trim inited, active immediately
oneroll_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
return
# Get legal edit delta and set to edit mode data for overlay draw
global edit_data
frame = _legalize_one_roll_trim(frame, edit_data["trim_limits"])
edit_data["selected_frame"] = frame
PLAYER().seek_frame(frame)
def _get_selection_data(self, p1, p2):
x1, y1 = p1
x2, y2 = p2
if x1 > x2:
x1, x2 = x2, x1
if y1 > y2:
y1, y2 = y2, y1
start_frame = tlinewidgets.get_frame(x1)
end_frame = tlinewidgets.get_frame(x2)
track_top_index = self.get_bounding_track_index(y1, tlinewidgets.get_track(y1))
track_bottom_index = self.get_bounding_track_index(y2, tlinewidgets.get_track(y2))
self.topleft_track = track_top_index - 1
# Get compositors
for i in range(track_bottom_index + 1, track_top_index):
track_compositors = current_sequence().get_track_compositors(i)
for comp in track_compositors:
if comp.clip_in >= start_frame and comp.clip_out < end_frame:
self.selected_compositors.append(comp)
# Get BoxTrackSelection objects
for i in range(track_bottom_index + 1, track_top_index):
self.track_selections.append(BoxTrackSelection(i, start_frame, end_frame))
# Drop empty tracks from bottom up
while len(self.track_selections) > 0:
if self.track_selections[0].is_empty() == True:
self.track_selections.pop(0)
else:
track_bottom_index = self.track_selections[0].track_id
break
# Drop empty tracks from top down
while len(self.track_selections) > 0:
if self.track_selections[-1].is_empty() == True:
self.track_selections.pop(-1)
else:
self.topleft_track = self.track_selections[-1].track_id
break
self.height_tracks = self.topleft_track - track_bottom_index + 1# self.topleft_track is inclusive to height, track_bottom_index is eclusive to height
# Get selection bounding box
self.topleft_frame = 1000000000000
for track_selection in self.track_selections:
if track_selection.range_frame_in != -1:
if track_selection.range_frame_in < self.topleft_frame:
self.topleft_frame = track_selection.range_frame_in
last_frame = 0
for track_selection in self.track_selections:
if track_selection.range_frame_out != -1:
if track_selection.range_frame_out > last_frame:
last_frame = track_selection.range_frame_out
self.width_frames = last_frame - self.topleft_frame
def oneroll_trim_press(event, frame):
"""
User presses mouse when in one roll mode.
"""
global mouse_disabled, submode
if not _pressed_on_edited_track(event.y):
track = tlinewidgets.get_track(event.y)
success = set_oneroll_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func() # further mouse events are handled at editevent.py
else:
submode = MOUSE_EDIT_ON # to stop entering keyboard edits until mouse released
if not editorpersistance.prefs.quick_enter_trims:
# new trim inited, editing non-active until release
tlinewidgets.trim_mode_in_non_active_state = True
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(editorstate.ONE_ROLL_TRIM_NO_EDIT)
mouse_disabled = True
else:
# new trim inited, active immediately
oneroll_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
return
if not _pressed_on_one_roll_active_area(frame):
track = tlinewidgets.get_track(event.y)
success = set_oneroll_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func() # no furter mouse events will come here
else:
submode = MOUSE_EDIT_ON # to stop entering keyboard edits until mouse released
if not editorpersistance.prefs.quick_enter_trims:
# new trim inited, editing non-active until release
tlinewidgets.trim_mode_in_non_active_state = True
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(editorstate.ONE_ROLL_TRIM_NO_EDIT)
mouse_disabled = True
else:
# new trim inited, active immediately
oneroll_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
return
# Get legal edit delta and set to edit mode data for overlay draw
global edit_data
frame = _legalize_one_roll_trim(frame, edit_data["trim_limits"])
edit_data["selected_frame"] = frame
PLAYER().seek_frame(frame)
def slide_trim_press(event, frame):
global edit_data
edit_data["press_start"] = frame
if not _pressed_on_edited_track(event.y):
_attempt_reinit_slide(event, frame)
return
if frame > tlinewidgets.get_track(event.y).get_length():
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(
True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func(
) # further mouse events are handled at editevent.py
return
if not _pressed_on_slide_active_area(frame):
_attempt_reinit_slide(event, frame)
return
global submode
submode = MOUSE_EDIT_ON
display_frame = _update_slide_trim_for_mouse_frame(frame)
PLAYER().seek_frame(display_frame)
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 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 _move_mode_move(frame, x, y):
"""
Updates edit data needed for doing edit and drawing overlay
based on mouse movement.
"""
global edit_data
# Get frame that is the one where insert is attempted
press_frame = edit_data["press_frame"]
first_clip_start = edit_data["first_clip_start"]
attempt_insert_frame = first_clip_start + (frame - press_frame)
edit_data["attempt_insert_frame"] = attempt_insert_frame
# Get track where insert is attempted. Track selection forced into range of editable tracks.
to_track = tlinewidgets.get_track(y)
if to_track == None:
if y > tlinewidgets.REF_LINE_Y:
to_track = get_track(1)
else:
to_track = get_track(len(current_sequence().tracks) - 2)
if to_track.id < 1:
to_track = get_track(1)
if to_track.id > len(current_sequence().tracks) - 2:
to_track = get_track(len(current_sequence().tracks) - 2)
edit_data["to_track_object"] = to_track
# Get index for insert in target track
insert_index = to_track.get_clip_index_at(attempt_insert_frame)
edit_data["insert_index"] = insert_index
edit_data["insert_frame"] = to_track.clip_start(insert_index)
_set_current_move_frame_and_check_move_start(frame, x, y)
def display_clip_menu(y, event, frame):
# See if we actually hit a clip
track = tlinewidgets.get_track(y)
if track == None:
return False
clip_index = current_sequence().get_clip_index(track, frame)
if clip_index == -1:
return False
# Can't do anything to clips in locked tracks
if editevent.track_lock_check_and_user_info(track, display_clip_menu, "clip context menu"):
return False
# Display popup
pressed_clip = track.clips[clip_index]
if pressed_clip.is_blanck_clip == False:
movemodes.select_clip(track.id, clip_index)
else:
movemodes.select_blank_range(track, pressed_clip)
if track.type == appconsts.VIDEO:
guicomponents.display_clip_popup_menu(event, pressed_clip, \
track, _clip_menu_item_activated)
elif track.type == appconsts.AUDIO:
guicomponents.display_audio_clip_popup_menu(event, pressed_clip, \
track, _clip_menu_item_activated)
return True
def _move_mode_move(frame, x, y):
"""
Updates edit data needed for doing edit and drawing overlay
based on mouse movement.
"""
global edit_data
# Get frame that is the one where insert is attempted
press_frame = edit_data["press_frame"]
first_clip_start = edit_data["first_clip_start"]
attempt_insert_frame = first_clip_start + (frame - press_frame)
edit_data["attempt_insert_frame"] = attempt_insert_frame
# Get track where insert is attempted. Track selection forced into range of editable tracks.
to_track = tlinewidgets.get_track(y)
if to_track == None:
if y > tlinewidgets.REF_LINE_Y:
to_track = get_track(1)
else:
to_track = get_track(len(current_sequence().tracks) - 2)
if to_track.id < 1:
to_track = get_track(1)
if to_track.id > len(current_sequence().tracks) - 2:
to_track = get_track(len(current_sequence().tracks) - 2)
edit_data["to_track_object"] = to_track
# Get index for insert in target track
insert_index = to_track.get_clip_index_at(attempt_insert_frame)
edit_data["insert_index"] = insert_index
edit_data["insert_frame"] = to_track.clip_start(insert_index)
_set_current_move_frame_and_check_move_start(frame, x, y)
def tline_canvas_double_click(frame, x, y):
if PLAYER().looping():
return
elif PLAYER().is_playing():
PLAYER().stop_playback()
if not timeline_visible():
updater.display_sequence_in_monitor()
set_default_edit_mode()
return
hit_compositor = tlinewidgets.compositor_hit(frame, y, current_sequence().compositors)
if hit_compositor != None:
compositeeditor.set_compositor(hit_compositor)
return
track = tlinewidgets.get_track(y)
if track == None:
return
clip_index = current_sequence().get_clip_index(track, frame)
if clip_index == -1:
return
clip = track.clips[clip_index]
data = (clip, track, None, x)
updater.open_clip_in_effects_editor(data)
def tline_canvas_double_click(frame, x, y):
if PLAYER().looping():
return
elif PLAYER().is_playing():
PLAYER().stop_playback()
if not timeline_visible():
updater.display_sequence_in_monitor()
modesetting.set_default_edit_mode()
return
hit_compositor = tlinewidgets.compositor_hit(frame, x, y, current_sequence().compositors)
if hit_compositor != None:
compositeeditor.set_compositor(hit_compositor)
return
track = tlinewidgets.get_track(y)
if track == None:
return
clip_index = current_sequence().get_clip_index(track, frame)
if clip_index == -1:
return
clip = track.clips[clip_index]
if clip.is_blanck_clip == True:
return
data = (clip, track, None, x)
updater.open_clip_in_effects_editor(data)
def display_clip_menu(y, event, frame):
# See if we actually hit a clip
track = tlinewidgets.get_track(y)
if track == None:
return False
clip_index = current_sequence().get_clip_index(track, frame)
if clip_index == -1:
return False
# Can't do anything to clips in locked tracks
if dialogutils.track_lock_check_and_user_info(track):
return False
# Display popup
gui.tline_canvas.drag_on = False
pressed_clip = track.clips[clip_index]
if pressed_clip.is_blanck_clip == False:
movemodes.select_clip(track.id, clip_index)
else:
movemodes.select_blank_range(track, pressed_clip)
if track.type == appconsts.VIDEO:
guicomponents.display_clip_popup_menu(event, pressed_clip, \
track, _clip_menu_item_activated)
elif track.type == appconsts.AUDIO:
guicomponents.display_audio_clip_popup_menu(event, pressed_clip, \
track, _clip_menu_item_activated)
return True
def mouse_press(event, frame):
x = event.x
y = event.y
# If we have clip being edited and its edit area is hit, we do not need to init data.
if _clip_is_being_edited() and _clip_edit_area_hit(x, y):
return
# Get pressed track
track = tlinewidgets.get_track(y)
# Selecting empty clears selection
if track == None:
#clear_selected_clips()
#pressed_on_selected = False
_set_no_clip_edit_data()
updater.repaint_tline()
return
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty clears selection
if clip_index == -1:
#clear_selected_clips()
#pressed_on_selected = False
_set_no_clip_edit_data()
updater.repaint_tline()
return
clip = track.clips[clip_index]
# Save data needed to do the keyframe edits.
global edit_data #, pressed_on_selected, drag_disabled
edit_data = {"draw_function":_tline_overlay,
"clip_index":clip_index,
"clip":clip,
"track":track,
"mouse_start_x":x,
"mouse_start_y":y}
# Init for volume editing if volume filter available
for i in range(0, len(clip.filters)):
filter_object = clip.filters[i]
if filter_object.info.mlt_service_id == "volume":
editable_properties = propertyedit.get_filter_editable_properties(
clip,
filter_object,
i,
track,
clip_index)
for ep in editable_properties:
if ep.name == "gain":
_init_for_editable_property(ep)
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
def track_center_pressed(data):
if data.event.button == 1:
# handle possible mute icon presses
press_x = data.event.x
press_y = data.event.y
track = tlinewidgets.get_track(press_y)
if track == None:
return
y_off = press_y - tlinewidgets._get_track_y(track.id)
ICON_WIDTH = 12
if press_x > tlinewidgets.COLUMN_LEFT_PAD and press_x < tlinewidgets.COLUMN_LEFT_PAD + ICON_WIDTH:
# Mute icon x area hit
ix, iy = tlinewidgets.MUTE_ICON_POS
if track.height > appconsts.TRACK_HEIGHT_SMALL:
ix, iy = tlinewidgets.MUTE_ICON_POS_NORMAL
ICON_HEIGHT = 10
if track.id >= current_sequence().first_video_index:
# Video tracks
# Test mute switches
if y_off > iy and y_off < iy + ICON_HEIGHT:
# Video mute icon hit
if track.mute_state == appconsts.TRACK_MUTE_NOTHING:
new_mute_state = appconsts.TRACK_MUTE_VIDEO
elif track.mute_state == appconsts.TRACK_MUTE_VIDEO:
new_mute_state = appconsts.TRACK_MUTE_NOTHING
elif track.mute_state == appconsts.TRACK_MUTE_AUDIO:
new_mute_state = appconsts.TRACK_MUTE_ALL
elif track.mute_state == appconsts.TRACK_MUTE_ALL:
new_mute_state = appconsts.TRACK_MUTE_AUDIO
elif y_off > iy + ICON_HEIGHT and y_off < iy + ICON_HEIGHT * 2:
# Audio mute icon hit
if track.mute_state == appconsts.TRACK_MUTE_NOTHING:
new_mute_state = appconsts.TRACK_MUTE_AUDIO
elif track.mute_state == appconsts.TRACK_MUTE_VIDEO:
new_mute_state = appconsts.TRACK_MUTE_ALL
elif track.mute_state == appconsts.TRACK_MUTE_AUDIO:
new_mute_state = appconsts.TRACK_MUTE_NOTHING
elif track.mute_state == appconsts.TRACK_MUTE_ALL:
new_mute_state = appconsts.TRACK_MUTE_VIDEO
else:
return
else:
# Audio tracks
# Test mute switches
iy = iy + 6 # Mute icon is lower on audio tracks
if y_off > iy and y_off < iy + ICON_HEIGHT:
if track.mute_state == appconsts.TRACK_MUTE_VIDEO:
new_mute_state = appconsts.TRACK_MUTE_ALL
else:
new_mute_state = appconsts.TRACK_MUTE_VIDEO
else:
return
# Update track mute state
current_sequence().set_track_mute_state(track.id, new_mute_state)
gui.tline_column.widget.queue_draw()
if data.event.button == 3:
guicomponents.display_tracks_popup_menu(data.event, data.track, \
_track_menu_item_activated)
def track_center_pressed(data):
if data.event.button == 1:
# handle possible mute icon presses
press_x = data.event.x
press_y = data.event.y
track = tlinewidgets.get_track(press_y)
if track == None:
return
y_off = press_y - tlinewidgets._get_track_y(track.id)
ICON_WIDTH = 12
if press_x > tlinewidgets.COLUMN_LEFT_PAD and press_x < tlinewidgets.COLUMN_LEFT_PAD + ICON_WIDTH:
# Mute icon x area hit
ix, iy = tlinewidgets.MUTE_ICON_POS
if track.height > appconsts.TRACK_HEIGHT_SMALL:
ix, iy = tlinewidgets.MUTE_ICON_POS_NORMAL
ICON_HEIGHT = 10
if track.id >= current_sequence().first_video_index:
# Video tracks
# Test mute switches
if y_off > iy and y_off < iy + ICON_HEIGHT:
# Video mute icon hit
if track.mute_state == appconsts.TRACK_MUTE_NOTHING:
new_mute_state = appconsts.TRACK_MUTE_VIDEO
elif track.mute_state == appconsts.TRACK_MUTE_VIDEO:
new_mute_state = appconsts.TRACK_MUTE_NOTHING
elif track.mute_state == appconsts.TRACK_MUTE_AUDIO:
new_mute_state = appconsts.TRACK_MUTE_ALL
elif track.mute_state == appconsts.TRACK_MUTE_ALL:
new_mute_state = appconsts.TRACK_MUTE_AUDIO
elif y_off > iy + ICON_HEIGHT and y_off < iy + ICON_HEIGHT * 2:
# Audio mute icon hit
if track.mute_state == appconsts.TRACK_MUTE_NOTHING:
new_mute_state = appconsts.TRACK_MUTE_AUDIO
elif track.mute_state == appconsts.TRACK_MUTE_VIDEO:
new_mute_state = appconsts.TRACK_MUTE_ALL
elif track.mute_state == appconsts.TRACK_MUTE_AUDIO:
new_mute_state = appconsts.TRACK_MUTE_NOTHING
elif track.mute_state == appconsts.TRACK_MUTE_ALL:
new_mute_state = appconsts.TRACK_MUTE_VIDEO
else:
return
else:
# Audio tracks
# Test mute switches
iy = iy + 6 # Mute icon is lower on audio tracks
if y_off > iy and y_off < iy + ICON_HEIGHT:
if track.mute_state == appconsts.TRACK_MUTE_VIDEO:
new_mute_state = appconsts.TRACK_MUTE_ALL
else:
new_mute_state = appconsts.TRACK_MUTE_VIDEO
else:
return
# Update track mute state
current_sequence().set_track_mute_state(track.id, new_mute_state)
gui.tline_column.widget.queue_draw()
if data.event.button == 3:
guicomponents.display_tracks_popup_menu(data.event, data.track, \
_track_menu_item_activated)
def tline_media_drop(media_file, x, y, use_marks=False):
track = tlinewidgets.get_track(y)
if track == None:
return
if track.id < 1 or track.id >= (len(current_sequence().tracks) - 1):
return
if track_lock_check_and_user_info(track):
set_default_edit_mode()
return
set_default_edit_mode()
frame = tlinewidgets.get_frame(x)
# Create new clip.
if media_file.type != appconsts.PATTERN_PRODUCER:
new_clip = current_sequence().create_file_producer_clip(
media_file.path, media_file.name)
else:
new_clip = current_sequence().create_pattern_producer(media_file)
# Set clip in and out
if use_marks == False:
new_clip.mark_in = 0
new_clip.mark_out = new_clip.get_length(
) - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
else:
new_clip.mark_in = media_file.mark_in
new_clip.mark_out = media_file.mark_out
if new_clip.mark_in == -1:
new_clip.mark_in = 0
if new_clip.mark_out == -1:
new_clip.mark_out = new_clip.get_length(
) - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
# Graphics files get added with their default lengths
f_name, ext = os.path.splitext(media_file.name)
if utils.file_extension_is_graphics_file(
ext
) and media_file.type != appconsts.IMAGE_SEQUENCE: # image sequences are graphics files but have own length
in_fr, out_fr, l = editorpersistance.get_graphics_default_in_out_length(
)
new_clip.mark_in = in_fr
new_clip.mark_out = out_fr
if editorpersistance.prefs.overwrite_clip_drop == True:
if track.id != current_sequence().first_video_track().id:
drop_done = _attempt_dnd_overwrite(track, new_clip, frame)
if drop_done == True:
return
do_clip_insert(track, new_clip, frame)
def tline_media_drop(media_file, x, y, use_marks=False):
track = tlinewidgets.get_track(y)
if track == None:
return
if track.id < 1 or track.id >= (len(current_sequence().tracks) - 1):
return
if dialogutils.track_lock_check_and_user_info(track):
#modesetting.set_default_edit_mode()
# TODO: Info
return
modesetting.stop_looping()
frame = tlinewidgets.get_frame(x)
# Create new clip.
if media_file.type != appconsts.PATTERN_PRODUCER:
new_clip = current_sequence().create_file_producer_clip(media_file.path, media_file.name, False, media_file.ttl)
else:
new_clip = current_sequence().create_pattern_producer(media_file)
# Set clip in and out
if use_marks == False:
new_clip.mark_in = 0
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
else:
new_clip.mark_in = media_file.mark_in
new_clip.mark_out = media_file.mark_out
if new_clip.mark_in == -1:
new_clip.mark_in = 0
if new_clip.mark_out == -1:
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
# Graphics files get added with their default lengths
f_name, ext = os.path.splitext(media_file.name)
if utils.file_extension_is_graphics_file(ext) and media_file.type != appconsts.IMAGE_SEQUENCE: # image sequences are graphics files but have own length
in_fr, out_fr, l = editorpersistance.get_graphics_default_in_out_length()
new_clip.mark_in = in_fr
new_clip.mark_out = out_fr
# Non-insert DND actions
if editorpersistance.prefs.dnd_action == appconsts.DND_OVERWRITE_NON_V1:
if track.id != current_sequence().first_video_track().id:
drop_done = _attempt_dnd_overwrite(track, new_clip, frame)
if drop_done == True:
return
elif editorpersistance.prefs.dnd_action == appconsts.DND_ALWAYS_OVERWRITE:
drop_done = _attempt_dnd_overwrite(track, new_clip, frame)
if drop_done == True:
return
do_clip_insert(track, new_clip, frame)
def maybe_init_for_mouse_press(event, frame):
# See if we actually hit a clip
track = tlinewidgets.get_track(event.y)
if track == None:
return
if track.id < 1 or (track.id >= len(current_sequence().tracks) - 1):
return False
clip_index = current_sequence().get_clip_index(track, frame)
if clip_index == -1:
return
clip = track.clips[clip_index]
if clip.is_blanck_clip:
return
# Now we will in fact enter CLIP_END_DRAG edit mode
# See if we're dragging clip end or start
cut_frame = current_sequence().get_closest_cut_frame(track.id, frame)
editing_clip_end = True
if frame >= cut_frame:
editing_clip_end = False
else:
cut_frame = cut_frame - (clip.clip_out - clip.clip_in)
if editing_clip_end == True: # clip end drags
bound_end = (
cut_frame - clip.clip_in + clip.get_length() - 1
) # get_length() is available media length, not current clip length
bound_start = cut_frame - 1
if clip_index == len(track.clips) - 1: # last clip
bound_end = bound_end - 1
else: # clip beginning drags
bound_start = cut_frame - clip.clip_in
bound_end = cut_frame + (clip.clip_out - clip.clip_in) + 1
global _enter_mode, _enter_draw_func, _edit_data
_enter_mode = editorstate.edit_mode
editorstate.edit_mode = editorstate.CLIP_END_DRAG
_enter_draw_func = tlinewidgets.canvas_widget.edit_mode_overlay_draw_func
_edit_data = {}
_edit_data["track"] = track
_edit_data["clip_index"] = clip_index
_edit_data["frame"] = frame
_edit_data["press_frame"] = frame
_edit_data["editing_clip_end"] = editing_clip_end
_edit_data["bound_end"] = bound_end
_edit_data["bound_start"] = bound_start
_edit_data["track_height"] = track.height
_edit_data["orig_in"] = cut_frame - 1
_edit_data["orig_out"] = cut_frame + (clip.clip_out - clip.clip_in)
tlinewidgets.set_edit_mode(_edit_data, tlinewidgets.draw_clip_end_drag_overlay)
gui.editor_window.set_cursor_to_mode()
def is_hit(self, x, y):
hit_frame = tlinewidgets.get_frame(x)
hit_track = tlinewidgets.get_track(y).id
if ((hit_frame >= self.topleft_frame and hit_frame < self.topleft_frame + self.width_frames) and
(hit_track <= self.topleft_track and hit_track > self.topleft_track - self.height_tracks)):
return True
return False
def maybe_init_for_mouse_press(event, frame):
# See if we actually hit a clip
track = tlinewidgets.get_track(event.y)
if track == None:
return
if track.id < 1 or (track.id >= len(current_sequence().tracks) - 1):
return False
clip_index = current_sequence().get_clip_index(track, frame)
if clip_index == -1:
return
clip = track.clips[clip_index]
if clip.is_blanck_clip:
return
# Now we will in fact enter CLIP_END_DRAG edit mode
# See if we're dragging clip end or start
cut_frame = current_sequence().get_closest_cut_frame(track.id, frame)
editing_clip_end = True
if frame >= cut_frame:
editing_clip_end = False
else:
cut_frame = cut_frame - (clip.clip_out - clip.clip_in)
if editing_clip_end == True: # clip end drags
bound_end = cut_frame - clip.clip_in + clip.get_length() - 1 # get_length() is available media length, not current clip length
bound_start = cut_frame - 1
if clip_index == len(track.clips) - 1: # last clip
bound_end = bound_end - 1
else: # clip beginning drags
bound_start = cut_frame - clip.clip_in
bound_end = cut_frame + (clip.clip_out - clip.clip_in) + 1
global _enter_mode, _enter_draw_func, _edit_data
_enter_mode = editorstate.edit_mode
editorstate.edit_mode = editorstate.CLIP_END_DRAG
_enter_draw_func = tlinewidgets.canvas_widget.edit_mode_overlay_draw_func
_edit_data = {}
_edit_data["track"] = track
_edit_data["clip_index"] = clip_index
_edit_data["frame"] = frame
_edit_data["press_frame"] = frame
_edit_data["editing_clip_end"] = editing_clip_end
_edit_data["bound_end"] = bound_end
_edit_data["bound_start"] = bound_start
_edit_data["track_height"] = track.height
_edit_data["orig_in"] = cut_frame - 1
_edit_data["orig_out"] = cut_frame + (clip.clip_out - clip.clip_in)
tlinewidgets.set_edit_mode(_edit_data, tlinewidgets.draw_clip_end_drag_overlay)
gui.editor_window.set_cursor_to_mode()
def cut_single_track(event, frame):
track = tlinewidgets.get_track(event.y)
data = get_cut_data(track, frame)
if data == None:
return
action = edit.cut_action(data)
action.do_edit()
updater.repaint_tline()
def cut_single_track(event, frame):
track = tlinewidgets.get_track(event.y)
data = get_cut_data(track, frame)
if data == None:
return
action = edit.cut_action(data)
action.do_edit()
updater.repaint_tline()
def mouse_press(event, frame):
x = event.x
y = event.y
global edit_data, mouse_disabled
# Clear edit data in gui module
edit_data = None
mouse_disabled = False
tlinewidgets.set_edit_mode_data(edit_data)
# Get pressed track
track = tlinewidgets.get_track(y)
if track == None:
mouse_disabled = True
return
if dialogutils.track_lock_check_and_user_info(track):
mouse_disabled = True
return
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty or blank clip does not define edit
if clip_index == -1:
mouse_disabled = True
return
pressed_clip = track.clips[clip_index]
if pressed_clip.is_blanck_clip:
mouse_disabled = True
return
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
move_all = False
else:
move_all = True
first_moved_frame = track.clip_start(clip_index)
multi_data = MultimoveData(track, first_moved_frame, move_all)
edit_data = {
"track_id": track.id,
"press_frame": frame,
"current_frame": frame,
"first_moved_frame": first_moved_frame,
"mouse_start_x": x,
"mouse_start_y": y,
"multi_data": multi_data
}
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
def mouse_press(event, frame):
x = event.x
y = event.y
global edit_data, mouse_disabled
# Clear edit data in gui module
edit_data = None
mouse_disabled = False
tlinewidgets.set_edit_mode_data(edit_data)
# Get pressed track
track = tlinewidgets.get_track(y)
if track == None:
mouse_disabled = True
return
if dialogutils.track_lock_check_and_user_info(track):
mouse_disabled = True
return
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty or blank clip does not define edit
if clip_index == -1:
mouse_disabled = True
return
pressed_clip = track.clips[clip_index]
if pressed_clip.is_blanck_clip:
mouse_disabled = True
return
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
move_all = False
else:
move_all = True
first_moved_frame = track.clip_start(clip_index)
multi_data = MultimoveData(track, first_moved_frame, move_all)
edit_data = {"track_id":track.id,
"press_frame":frame,
"current_frame":frame,
"first_moved_frame":first_moved_frame,
"mouse_start_x":x,
"mouse_start_y":y,
"multi_data":multi_data}
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
def tline_range_item_drop(rows, x, y):
track = tlinewidgets.get_track(y)
if track == None:
return
if track.id < 1 or track.id >= (len(current_sequence().tracks) - 1):
return
if track_lock_check_and_user_info(track):
set_default_edit_mode()
return
frame = tlinewidgets.get_frame(x)
clips = medialog.get_clips_for_rows(rows)
set_default_edit_mode()
do_multiple_clip_insert(track, clips, frame)
def tline_range_item_drop(rows, x, y):
track = tlinewidgets.get_track(y)
if track == None:
return
if track.id < 1 or track.id >= (len(current_sequence().tracks) - 1):
return
if dialogutils.track_lock_check_and_user_info(track):
modesetting.set_default_edit_mode()
return
frame = tlinewidgets.get_frame(x)
clips = medialog.get_clips_for_rows(rows)
modesetting.set_default_edit_mode()
do_multiple_clip_insert(track, clips, frame)
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 cut_single_track(event, frame):
track = tlinewidgets.get_track(event.y)
if track == None or track.id == 0 or track.id == len(current_sequence().tracks) - 1:
return
if dialogutils.track_lock_check_and_user_info(track):
return
data = get_cut_data(track, frame)
if data == None:
return
action = edit.cut_action(data)
action.do_edit()
updater.repaint_tline()
def _set_sync_parent_clip(event, frame):
child_clip, child_index, child_clip_track = parent_selection_data
parent_track = tlinewidgets.get_track(event.y)
if parent_track != current_sequence().tracks[current_sequence().first_video_index]:
dialogutils.warning_message(
_("Sync parent clips must be on track V1"),
_("Selected sync parent clip is on track ")
+ utils.get_track_name(parent_track, current_sequence())
+ _(".\nYou can only sync to clips that are on track V1."),
gui.editor_window.window,
True,
)
return
# this can't have parent clip already
if child_clip.sync_data != None:
return
if parent_track == None:
return
parent_clip_index = current_sequence().get_clip_index(parent_track, frame)
if parent_clip_index == -1:
return
# Parent and child can't be on the same track.
# Now that all parent clips must be on track V1 this is no longer shoild be possible.
if parent_track == child_clip_track:
print "parent_track == child_clip_track"
return
parent_clip = parent_track.clips[parent_clip_index]
# These cannot be chained.
# Now that all parent clips must be on track V1 this is no longer shoild be possible.
if parent_clip.sync_data != None:
print "parent_clip.sync_data != None"
return
data = {
"child_index": child_index,
"child_track": child_clip_track,
"parent_index": parent_clip_index,
"parent_track": parent_track,
}
action = edit.set_sync_action(data)
action.do_edit()
def tline_media_drop(media_file, x, y, use_marks=False):
track = tlinewidgets.get_track(y)
if track == None:
return
if track.id < 1 or track.id >= (len(current_sequence().tracks) - 1):
return
if track_lock_check_and_user_info(track):
set_default_edit_mode()
return
set_default_edit_mode()
frame = tlinewidgets.get_frame(x)
# Create new clip.
if media_file.type != appconsts.PATTERN_PRODUCER:
new_clip = current_sequence().create_file_producer_clip(media_file.path, media_file.name)
else:
new_clip = current_sequence().create_pattern_producer(media_file)
# Set clip in and out
if use_marks == False:
new_clip.mark_in = 0
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
else:
new_clip.mark_in = media_file.mark_in
new_clip.mark_out = media_file.mark_out
if new_clip.mark_in == -1:
new_clip.mark_in = 0
if new_clip.mark_out == -1:
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
# Graphics files get added with their default lengths
f_name, ext = os.path.splitext(media_file.name)
if utils.file_extension_is_graphics_file(ext) and media_file.type != appconsts.IMAGE_SEQUENCE: # image sequences are graphics files but have own length
in_fr, out_fr, l = editorpersistance.get_graphics_default_in_out_length()
new_clip.mark_in = in_fr
new_clip.mark_out = out_fr
do_clip_insert(track, new_clip, frame)
def mouse_press(event, frame):
print "gggg"
x = event.x
y = event.y
# If we have clip being edited and its edit area is hit, we do not need to init data.
if _clip_is_being_edited() and _clip_edit_area_hit(x, y):
print "ooooooooooooooooooo"
return
# Get pressed track
track = tlinewidgets.get_track(y)
# Selecting empty clears selection
if track == None:
#clear_selected_clips()
#pressed_on_selected = False
_set_no_clip_edit_data()
updater.repaint_tline()
return
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty clears selection
if clip_index == -1:
#clear_selected_clips()
#pressed_on_selected = False
_set_no_clip_edit_data()
updater.repaint_tline()
return
print "kkkkkk"
global edit_data #, pressed_on_selected, drag_disabled
edit_data = {
"draw_function": _tline_overlay,
"clip_index": clip_index,
"track": track,
"mouse_start_x": x,
"mouse_start_y": y
}
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
def cut_single_track(event, frame):
track = tlinewidgets.get_track(event.y)
if track == None or track.id == 0 or track.id == len(
current_sequence().tracks) - 1:
return
if dialogutils.track_lock_check_and_user_info(track):
return
data = get_cut_data(track, frame)
if data == None:
return
action = edit.cut_action(data)
action.do_edit()
updater.repaint_tline()
def _set_sync_parent_clip(event, frame):
child_clip, child_index, child_clip_track = parent_selection_data
parent_track = tlinewidgets.get_track(event.y)
if parent_track != current_sequence().tracks[
current_sequence().first_video_index]:
dialogutils.warning_message(
_("Sync parent clips must be on track V1"),
_("Selected sync parent clip is on track ") +
utils.get_track_name(parent_track, current_sequence()) +
_(".\nYou can only sync to clips that are on track V1."),
gui.editor_window.window, True)
return
# this can't have parent clip already
if child_clip.sync_data != None:
return
if parent_track == None:
return
parent_clip_index = current_sequence().get_clip_index(parent_track, frame)
if parent_clip_index == -1:
return
# Parent and child can't be on the same track.
# Now that all parent clips must be on track V1 this is no longer shoild be possible.
if parent_track == child_clip_track:
print "parent_track == child_clip_track"
return
parent_clip = parent_track.clips[parent_clip_index]
# These cannot be chained.
# Now that all parent clips must be on track V1 this is no longer shoild be possible.
if parent_clip.sync_data != None:
print "parent_clip.sync_data != None"
return
data = {
"child_index": child_index,
"child_track": child_clip_track,
"parent_index": parent_clip_index,
"parent_track": parent_track
}
action = edit.set_sync_action(data)
action.do_edit()
def _get_sync_tline_clip(event, frame):
sync_track = tlinewidgets.get_track(event.y)
if sync_track == None:
return None
if sync_track == _tline_sync_data.origin_track:
dialogutils.warning_message(_("Audio Sync parent clips must be on differnt tracks "),
_("Selected audio sync clip is on the sametrack as the sync action origin clip."),
gui.editor_window.window,
True)
return None
sync_clip_index = current_sequence().get_clip_index(sync_track, frame)
if sync_clip_index == -1:
return None
return sync_track.clips[sync_clip_index]
def _get_sync_tline_clip(event, frame):
sync_track = tlinewidgets.get_track(event.y)
if sync_track == None:
return None
if sync_track == _tline_sync_data.origin_track:
dialogutils.warning_message(
_("Audio Sync parent clips must be on differnt tracks "),
_("Selected audio sync clip is on the sametrack as the sync action origin clip."
), gui.editor_window.window, True)
return None
sync_clip_index = current_sequence().get_clip_index(sync_track, frame)
if sync_clip_index == -1:
return None
return sync_track.clips[sync_clip_index]
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 _attempt_reinit_tworoll(event, frame):
track = tlinewidgets.get_track(event.y)
success = set_tworoll_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func() # further mouse events are handled at editevent.py
else:
if not editorpersistance.prefs.quick_enter_trims:
# new trim inited, editing non-active until release
global mouse_disabled
tlinewidgets.trim_mode_in_non_active_state = True
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(editorstate.TWO_ROLL_TRIM_NO_EDIT)
mouse_disabled = True
else:
# new trim inited, active immediately
tworoll_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
def _attempt_reinit_tworoll(event, frame):
track = tlinewidgets.get_track(event.y)
success = set_tworoll_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func() # further mouse events are handled at editevent.py
else:
if not editorpersistance.prefs.quick_enter_trims:
# new trim inited, editing non-active until release
global mouse_disabled
tlinewidgets.trim_mode_in_non_active_state = True
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(editorstate.TWO_ROLL_TRIM_NO_EDIT)
mouse_disabled = True
else:
# new trim inited, active immediately
tworoll_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
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 mouse_press(event, frame):
x = event.x
y = event.y
global edit_data #, pressed_on_selected, drag_disabled
# Clear edit data in gui module
edit_data = None
tlinewidgets.set_edit_mode_data(edit_data)
# Get pressed track
track = tlinewidgets.get_track(y)
# Selecting empty clears selection
if track == None:
#clear_selected_clips()
#pressed_on_selected = False
updater.repaint_tline()
return
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty clears selection
if clip_index == -1:
#clear_selected_clips()
#pressed_on_selected = False
updater.repaint_tline()
return
edit_data = {
"draw_function": _tline_overlay,
"clip_index": track.id,
"track": track,
"mouse_start_x": x,
"mouse_start_y": y
}
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
def _attempt_reinit_slide(event, frame):
track = tlinewidgets.get_track(event.y)
success = set_slide_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func() # further mouse events are handled at editevent.py
else:
if not editorpersistance.prefs.quick_enter_trims:
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(editorstate.SLIDE_TRIM_NO_EDIT)
tlinewidgets.trim_mode_in_non_active_state = True
global mouse_disabled
mouse_disabled = True
else:
# new trim inited, active immediately
global edit_data
edit_data["press_start"] = frame
slide_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
def slide_trim_press(event, frame):
global edit_data
edit_data["press_start"] = frame
if not _pressed_on_edited_track(event.y):
_attempt_reinit_slide(event, frame)
return
if frame > tlinewidgets.get_track(event.y).get_length():
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func() # further mouse events are handled at editevent.py
return
if not _pressed_on_slide_active_area(frame):
_attempt_reinit_slide(event, frame)
return
display_frame = _update_slide_trim_for_mouse_frame(frame)
PLAYER().seek_frame(display_frame)
def _attempt_reinit_slide(event, frame):
track = tlinewidgets.get_track(event.y)
success = set_slide_mode(track, frame)
if not success:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_exit_mode_func(True) # further mouse events are handled at editevent.py
else:
set_no_edit_mode_func() # further mouse events are handled at editevent.py
else:
if not editorpersistance.prefs.quick_enter_trims:
gui.tline_canvas.widget.queue_draw()
gui.editor_window.set_tline_cursor(editorstate.SLIDE_TRIM_NO_EDIT)
tlinewidgets.trim_mode_in_non_active_state = True
global mouse_disabled
mouse_disabled = True
else:
# new trim inited, active immediately
global edit_data
edit_data["press_start"] = frame
slide_trim_move(event.x, event.y, frame, None)
gui.tline_canvas.widget.queue_draw()
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 mouse_press(event, frame):
x = event.x
y = event.y
# If we have clip being edited and its edit area is hit, we do not need to init data.
if _kf_editor != None and _kf_editor.overlay_area_hit(x, y):
_handle_edit_mouse_press(event)
return
# Attempt to init kf tool editing on some clip
# Get pressed track
track = tlinewidgets.get_track(y)
# Selecting empty clears selection
if track == None:
#clear_selected_clips()
#pressed_on_selected = False
_set_no_clip_edit_data()
updater.repaint_tline()
return
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty clears selection
if clip_index == -1:
#clear_selected_clips()
#pressed_on_selected = False
_set_no_clip_edit_data()
updater.repaint_tline()
return
clip = track.clips[clip_index]
init_tool_for_clip(clip, track)
def mouse_press(event, frame):
x = event.x
y = event.y
# If we have clip being edited and its edit area is hit, we do not need to init data.
# If editor open we disregard track locking until it is closed.
if _kf_editor != None and _kf_editor.overlay_area_hit(x, y):
_handle_edit_mouse_press(event)
return
# Get pressed track
track = tlinewidgets.get_track(y)
# Selecting empty clears selection
if track == None or track.id == 0 or track.id == len(current_sequence().tracks) - 1:
exit_tool()
return
# No edits for locked tracks
if dialogutils.track_lock_check_and_user_info(track):
set_no_clip_edit_data()
return
# Attempt to init kf tool editing on some clip
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty clears selection
if clip_index == -1:
exit_tool()
return
clip = track.clips[clip_index]
init_tool_for_clip(clip, track)
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 mouse_press(event, frame):
x = event.x
y = event.y
# If we have clip being edited and its edit area is hit, we do not need to init data.
# If editor open we disregard track locking until it is closed.
if _kf_editor != None and _kf_editor.overlay_area_hit(x, y):
_handle_edit_mouse_press(event)
return
# Get pressed track
track = tlinewidgets.get_track(y)
# Selecting empty clears selection
if track == None or track.id == 0 or track.id == len(current_sequence().tracks) - 1:
exit_tool()
return
# No edits for locked tracks
if dialogutils.track_lock_check_and_user_info(track):
_set_no_clip_edit_data()
return
# Attempt to init kf tool editing on some clip
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty clears selection
if clip_index == -1:
exit_tool()
return
clip = track.clips[clip_index]
init_tool_for_clip(clip, track)
def _pressed_on_edited_track(y):
pressed_track = tlinewidgets.get_track(y)
if ((pressed_track == None) or (pressed_track.id != edit_data["track"])):
return False
return True
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 _move_mode_pressed(event, frame):
"""
User presses mouse when in a move mode.
Initializes move mode edit action based on user action and state.
"""
x = event.x
y = event.y
global edit_data, pressed_on_selected, drag_disabled
# Clear edit data in gui module
edit_data = None
drag_disabled = False
tlinewidgets.set_edit_mode_data(edit_data)
# Get pressed track
track = tlinewidgets.get_track(y)
# Selecting empty clears selection
if track == None:
clear_selected_clips()
pressed_on_selected = False
updater.repaint_tline()
return
# Get pressed clip index
clip_index = current_sequence().get_clip_index(track, frame)
# Selecting empty clears selection
if clip_index == -1:
clear_selected_clips()
pressed_on_selected = False
updater.repaint_tline()
return
# Check locking for pressed track
if _track_is_locked(track):
clear_selected_clips()
pressed_on_selected = False
updater.repaint_tline()
return
pressed_clip = track.clips[clip_index]
# Handle pressed clip according to current selection state
# Case: no selected clips, select single clip
if selected_track == -1:
if not pressed_clip.is_blanck_clip:
select_clip(track.id, clip_index)
pressed_on_selected = False
else:
# There may be multiple blank clips in area that for user
# seems to a single blank area. All of these must be
# selected together automatically or user will be exposed to
# this impl. detail unnecesserarely.
range_in, range_out = _get_blanck_range(track, clip_index)
_select_multiple_clips(track.id, range_in, range_out)
pressed_on_selected = False
drag_disabled = True
# case: CTRL or SHIFT down, combine selection with earlier selected clips
elif ((event.state & gtk.gdk.CONTROL_MASK) or (event.state & gtk.gdk.SHIFT_MASK)):
# CTRL pressing blank clears selection
if pressed_clip.is_blanck_clip:
clear_selected_clips()
pressed_on_selected = False
updater.repaint_tline()
return
# clip before range, make it start
if clip_index < selected_range_in:
_select_multiple_clips(track.id, clip_index,
selected_range_out)
pressed_on_selected = False
# clip after range, make it end
elif clip_index > selected_range_out:
_select_multiple_clips(track.id, selected_range_in,
clip_index)
pressed_on_selected = False
else:
# Pressing on selected clip clears selection on release
pressed_on_selected = True
# case: new single clip pressed
else:
if selected_track != track.id:
clear_selected_clips()
select_clip(track.id, clip_index)
pressed_on_selected = False
else:
if not pressed_clip.is_blanck_clip:
# Pressing on selected clip keeps selection unchanged
if clip_index < selected_range_in or clip_index > selected_range_out:
select_clip(track.id, clip_index)
pressed_on_selected = False
# Pressing on non-selected clip clears current selection and selects newly selected clip
else:
pressed_on_selected = True
else:
# Black clip, see comment above
range_in, range_out = _get_blanck_range(track, clip_index)
_select_multiple_clips(track.id, range_in, range_out)
pressed_on_selected = False
drag_disabled = True
# Get length info on selected clips
clip_lengths = []
for i in range(selected_range_in, selected_range_out + 1):
clip = track.clips[i]
clip_lengths.append(clip.clip_out - clip.clip_in + 1)
# Overwrite mode ignores this
insert_frame = track.clip_start(selected_range_in)
# Set edit mode data. This is not used unless mouse delta big enough
# to initiate move.
edit_data = {"track_id":track.id,
"track_object":track,
"to_track_object":track,
"move_on":False,
"press_frame":frame,
"current_frame":frame,
"first_clip_start":insert_frame,
"insert_frame":insert_frame,
"clip_lengths":clip_lengths,
"mouse_start_x":x,
"mouse_start_y":y,
"selected_range_in":selected_range_in, # clip index
"selected_range_out":selected_range_out} # clip index
tlinewidgets.set_edit_mode_data(edit_data)
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.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 _pressed_on_edited_track(y):
pressed_track = tlinewidgets.get_track(y)
if ((pressed_track == None)
or(pressed_track.id != edit_data["track"])):
return False
return True
def tline_media_drop(media_file, x, y, use_marks=False):
track = tlinewidgets.get_track(y)
if track == None:
return
if track.id < 1 or track.id >= (len(current_sequence().tracks) - 1):
return
if dialogutils.track_lock_check_and_user_info(track):
#modesetting.set_default_edit_mode()
# TODO: Info
return
modesetting.stop_looping()
if EDIT_MODE() == editorstate.KF_TOOL:
kftoolmode.exit_tool()
frame = tlinewidgets.get_frame(x)
# Create new clip.
if media_file.type != appconsts.PATTERN_PRODUCER:
if media_file.container_data == None:
# Standard clips
new_clip = current_sequence().create_file_producer_clip(media_file.path, media_file.name, False, media_file.ttl)
else:
# Container clips
new_clip = current_sequence().create_file_producer_clip(media_file.path, media_file.name, False, media_file.ttl)
new_clip.container_data = media_file.container_data
else:
new_clip = current_sequence().create_pattern_producer(media_file)
# Set clip in and out
if use_marks == False:
new_clip.mark_in = 0
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
else:
if new_clip.media_type == appconsts.IMAGE or new_clip.media_type == appconsts.PATTERN_PRODUCER:
# Give IMAGE and PATTERN_PRODUCER media types default mark in and mark out if not already set.
# This makes them reasonably short and trimmable in both directions.
# NOTE: WE SHOULD BE DOING THIS AT CREATION TIME, WE'RE DOING THE SAME THING IN updater.display_clip_in_monitor() ?
# ...but then we would need to patch persistance.py...maybe keep this even if not too smart.
# TODO: Make default length user settable or use graphics value
if (hasattr(new_clip, 'mark_in') == False) or (new_clip.mark_in == -1 and new_clip.mark_out == -1):
center_frame = new_clip.get_length() // 2
default_length_half = 75
mark_in = center_frame - default_length_half
mark_out = center_frame + default_length_half - 1
new_clip.mark_in = mark_in
new_clip.mark_out = mark_out
else: # All the rest
new_clip.mark_in = media_file.mark_in
new_clip.mark_out = media_file.mark_out
if new_clip.mark_in == -1:
new_clip.mark_in = 0
if new_clip.mark_out == -1:
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
# Graphics files get added with their default lengths
f_name, ext = os.path.splitext(media_file.name)
if utils.file_extension_is_graphics_file(ext) and media_file.type != appconsts.IMAGE_SEQUENCE: # image sequences are graphics files but have own length
in_fr, out_fr, l = editorpersistance.get_graphics_default_in_out_length()
new_clip.mark_in = in_fr
new_clip.mark_out = out_fr
# Non-insert DND actions
if editorpersistance.prefs.dnd_action == appconsts.DND_OVERWRITE_NON_V1:
if track.id != current_sequence().first_video_track().id:
drop_done = _attempt_dnd_overwrite(track, new_clip, frame)
if drop_done == True:
return
elif editorpersistance.prefs.dnd_action == appconsts.DND_ALWAYS_OVERWRITE:
drop_done = _attempt_dnd_overwrite(track, new_clip, frame)
if drop_done == True:
return
do_clip_insert(track, new_clip, frame)
def tline_media_drop(media_file, x, y, use_marks=False):
track = tlinewidgets.get_track(y)
if track == None:
return
if track.id < 1 or track.id >= (len(current_sequence().tracks) - 1):
return
if dialogutils.track_lock_check_and_user_info(track):
#modesetting.set_default_edit_mode()
# TODO: Info
return
modesetting.stop_looping()
if EDIT_MODE() == editorstate.KF_TOOL:
kftoolmode.exit_tool()
frame = tlinewidgets.get_frame(x)
# Create new clip.
if media_file.type != appconsts.PATTERN_PRODUCER:
new_clip = current_sequence().create_file_producer_clip(media_file.path, media_file.name, False, media_file.ttl)
else:
new_clip = current_sequence().create_pattern_producer(media_file)
# Set clip in and out
if use_marks == False:
new_clip.mark_in = 0
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
else:
if new_clip.media_type == appconsts.IMAGE or new_clip.media_type == appconsts.PATTERN_PRODUCER:
# Give IMAGE and PATTERN_PRODUCER media types default mark in and mark out if not already set.
# This makes them reasonably short and trimmable in both directions.
# NOTE: WE SHOULD BE DOING THIS AT CREATION TIME, WE'RE DOING THE SAME THING IN updater.display_clip_in_monitor() ?
# ...but then we would need to patch persistance.py...maybe keep this even if not too smart.
# TODO: Make default length user settable or use graphics value
if (hasattr(new_clip, 'mark_in') == False) or (new_clip.mark_in == -1 and new_clip.mark_out == -1):
center_frame = new_clip.get_length() / 2
default_length_half = 75
mark_in = center_frame - default_length_half
mark_out = center_frame + default_length_half - 1
new_clip.mark_in = mark_in
new_clip.mark_out = mark_out
else: # All the rest
new_clip.mark_in = media_file.mark_in
new_clip.mark_out = media_file.mark_out
if new_clip.mark_in == -1:
new_clip.mark_in = 0
if new_clip.mark_out == -1:
new_clip.mark_out = new_clip.get_length() - 1 # - 1 because out is mark_out inclusive
if media_file.type == appconsts.IMAGE_SEQUENCE:
new_clip.mark_out = media_file.length
# Graphics files get added with their default lengths
f_name, ext = os.path.splitext(media_file.name)
if utils.file_extension_is_graphics_file(ext) and media_file.type != appconsts.IMAGE_SEQUENCE: # image sequences are graphics files but have own length
in_fr, out_fr, l = editorpersistance.get_graphics_default_in_out_length()
new_clip.mark_in = in_fr
new_clip.mark_out = out_fr
# Non-insert DND actions
if editorpersistance.prefs.dnd_action == appconsts.DND_OVERWRITE_NON_V1:
if track.id != current_sequence().first_video_track().id:
drop_done = _attempt_dnd_overwrite(track, new_clip, frame)
if drop_done == True:
return
elif editorpersistance.prefs.dnd_action == appconsts.DND_ALWAYS_OVERWRITE:
drop_done = _attempt_dnd_overwrite(track, new_clip, frame)
if drop_done == True:
return
do_clip_insert(track, new_clip, 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()