def tline_canvas_mouse_released(x, y, frame, button, state):
"""
Mouse event callback from timeline canvas widget
"""
gui.editor_window.set_cursor_to_mode() # we need this for box move at least, probably trims too
if editorstate.timeline_mouse_disabled == True:
gui.editor_window.set_cursor_to_mode() # we only need this update when mode change (to active trim mode) disables mouse, so we'll only do this then
tlinewidgets.trim_mode_in_non_active_state = False # we only need this update when mode change (to active trim mode) disables mouse, so we'll only do this then
gui.tline_canvas.widget.queue_draw()
editorstate.timeline_mouse_disabled = False
return
if not timeline_visible():
return
if PLAYER().looping():
PLAYER().stop_loop_playback(trimmodes.trim_looping_stopped)
return
# Handle timeline position setting with right mouse button
if button == 3 and EDIT_MODE() != editorstate.CLIP_END_DRAG and EDIT_MODE() != editorstate.COMPOSITOR_EDIT and EDIT_MODE() != editorstate.KF_TOOL:
if not timeline_visible():
return
PLAYER().seek_frame(frame)
# Handle mouse button edits
elif button == 1 or button == 3:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
release_func = mode_funcs[TL_MOUSE_RELEASE]
release_func(x, y, frame, state)
def tline_canvas_mouse_released(x, y, frame, button, state):
"""
Mouse event callback from timeline canvas widget
"""
gui.editor_window.set_cursor_to_mode()
global mouse_disabled
if mouse_disabled == True:
gui.editor_window.set_cursor_to_mode() # we only need this update when mode change (to active trim mode) disables mouse, so we'll only do this then
tlinewidgets.trim_mode_in_non_active_state = False # we only need this update when mode change (to active trim mode) disables mouse, so we'll only do this then
gui.tline_canvas.widget.queue_draw()
mouse_disabled = False
return
if not timeline_visible():
return
if PLAYER().looping():
PLAYER().stop_loop_playback(trimmodes.trim_looping_stopped)
return
# Handle timeline position setting with right mouse button
if button == 3:
#if not editorstate.current_is_move_mode():
# return
if not timeline_visible():
return
PLAYER().seek_frame(frame)
# Handle left mouse button edits
elif button == 1:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
release_func = mode_funcs[TL_MOUSE_RELEASE]
release_func(x, y, frame, state)
def to_mark_out_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
mark_out = PLAYER().producer.mark_out
if not timeline_visible():
mark_out = current_sequence().monitor_clip.mark_out
if mark_out == -1:
return
PLAYER().seek_frame(mark_out)
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 get_active_length(self):
# Displayed range is different
# for timeline and clip displays
if timeline_visible():
return self.producer.get_length()
else:
return gui.pos_bar.producer.get_length()
def _timeline_has_focus():
if(gui.tline_canvas.widget.is_focus()
or gui.tline_column.widget.is_focus()
or gui.editor_window.modes_selector.widget.is_focus()
or (gui.pos_bar.widget.is_focus() and timeline_visible())
or gui.tline_scale.widget.is_focus()
or glassbuttons.focus_group_has_focus(glassbuttons.DEFAULT_FOCUS_GROUP)):
return True
return False
def set_and_display_monitor_media_file(media_file):
"""
Displays media_file in clip monitor when new media file
selected for display by double clicking or drag'n'drop
"""
editorstate._monitor_media_file = media_file
if editorstate.timeline_visible() == True: # This was changed
display_clip_in_monitor(clip_monitor_currently_active = True)
else:
display_clip_in_monitor()
def set_and_display_monitor_media_file(media_file):
"""
Displays media_file in clip monitor when new media file
selected for display by double clicking or drag'n'drop
"""
editorstate._monitor_media_file = media_file
if editorstate.timeline_visible() == True:
display_clip_in_monitor()
else:
display_clip_in_monitor(clip_monitor_currently_active = True)
def _timeline_has_focus():
if (gui.tline_canvas.widget.has_focus()
or gui.tline_column.widget.has_focus()
or gui.editor_window.modes_selector.widget.has_focus()
or (gui.pos_bar.widget.has_focus() and timeline_visible())
or gui.tline_scale.widget.has_focus()
or glassbuttons.focus_group_has_focus(
glassbuttons.DEFAULT_FOCUS_GROUP)):
return True
return False
def marks_clear_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
PLAYER().producer.mark_in = -1
PLAYER().producer.mark_out = -1
else:
current_sequence().monitor_clip.mark_in = -1
current_sequence().monitor_clip.mark_out = -1
_do_marks_update()
updater.display_marks_tc()
def mark_out_pressed():
mark_out = PLAYER().producer.frame()
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
mark_in_old = PLAYER().producer.mark_in
PLAYER().producer.mark_out = mark_out
else:
mark_in_old = current_sequence().monitor_clip.mark_in
current_sequence().monitor_clip.mark_out = mark_out
# Clear illegal old mark in
if mark_in_old > mark_out:
if timeline_visible():
PLAYER().producer.mark_in = -1
else:
current_sequence().monitor_clip.mark_in = -1
_do_marks_update()
updater.display_marks_tc()
def _show_monitor_info_toggled(widget):
editorpersistance.prefs.show_sequence_profile = widget.get_active()
editorpersistance.save()
if editorstate.timeline_visible():
name = editorstate.current_sequence().name
profile_desc = editorstate.current_sequence().profile.description()
if editorpersistance.prefs.show_sequence_profile:
gui.editor_window.monitor_source.set_text(name + " / " + profile_desc)
else:
gui.editor_window.monitor_source.set_text(name)
def _timeline_has_focus(): # copied from keyevents.by. maybe put in utils?
if (gui.tline_canvas.widget.is_focus()
or gui.tline_column.widget.is_focus()
or gui.editor_window.modes_selector.widget.is_focus()
or (gui.pos_bar.widget.is_focus() and timeline_visible())
or gui.tline_scale.widget.is_focus()
or glassbuttons.focus_group_has_focus(
glassbuttons.DEFAULT_FOCUS_GROUP)):
return True
return False
def marks_clear_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
PLAYER().producer.mark_in = -1
PLAYER().producer.mark_out = -1
else:
current_sequence().monitor_clip.mark_in = -1
current_sequence().monitor_clip.mark_out = -1
_do_marks_update()
updater.display_marks_tc()
def _show_monitor_info_toggled(widget):
editorpersistance.prefs.show_sequence_profile = widget.get_active()
editorpersistance.save()
if editorstate.timeline_visible():
name = editorstate.current_sequence().name
profile_desc = editorstate.current_sequence().profile.description()
if editorpersistance.prefs.show_sequence_profile:
gui.editor_window.monitor_source.set_text(name + " / " + profile_desc)
else:
gui.editor_window.monitor_source.set_text(name)
def mark_out_pressed():
mark_out = PLAYER().producer.frame()
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
mark_in_old = PLAYER().producer.mark_in
PLAYER().producer.mark_out = mark_out
else:
mark_in_old = current_sequence().monitor_clip.mark_in
current_sequence().monitor_clip.mark_out = mark_out
# Clear illegal old mark in
if mark_in_old > mark_out:
if timeline_visible():
PLAYER().producer.mark_in = -1
else:
current_sequence().monitor_clip.mark_in = -1
_do_marks_update()
updater.display_marks_tc()
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 _do_marks_update():
if timeline_visible():
producer = PLAYER().producer
else:
producer = current_sequence().monitor_clip
MONITOR_MEDIA_FILE().mark_in = producer.mark_in
MONITOR_MEDIA_FILE().mark_out = producer.mark_out
gui.media_list_view.widget.queue_draw()
gui.pos_bar.update_display_from_producer(producer)
gui.tline_scale.widget.queue_draw()
def _do_marks_update():
if timeline_visible():
producer = PLAYER().producer
else:
producer = current_sequence().monitor_clip
MONITOR_MEDIA_FILE().mark_in = producer.mark_in
MONITOR_MEDIA_FILE().mark_out = producer.mark_out
gui.media_list_view.widget.queue_draw()
gui.pos_bar.update_display_from_producer(producer)
gui.tline_scale.widget.queue_draw()
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 l_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
jkl_index = _get_jkl_speed_index()
if jkl_index < JKL_STOPPED_INDEX + 1:# JKL_STOPPPED_INDEX + 1 is first forward speed, any smaller is backward, l starts forward slow from any backwards speed
jkl_index = JKL_STOPPED_INDEX + 1
else:
jkl_index = jkl_index + 1
if jkl_index == len(JKL_SPEEDS):
jkl_index = len(JKL_SPEEDS) - 1
new_speed = JKL_SPEEDS[jkl_index]
PLAYER().start_variable_speed_playback(new_speed)
def j_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
jkl_index = _get_jkl_speed_index()
if jkl_index > JKL_STOPPED_INDEX - 1: # JKL_STOPPPED_INDEX - 1 is first backwards speed, any bigger is forward, j starts backwards slow from any forward speed
jkl_index = JKL_STOPPED_INDEX - 1
else:
jkl_index = jkl_index - 1
if jkl_index < 0:
jkl_index = 0
new_speed = JKL_SPEEDS[jkl_index]
PLAYER().start_variable_speed_playback(new_speed)
def j_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
jkl_index = _get_jkl_speed_index()
if jkl_index > JKL_STOPPED_INDEX - 1: # JKL_STOPPPED_INDEX - 1 is first backwards speed, any bigger is forward, j starts backwards slow from any forward speed
jkl_index = JKL_STOPPED_INDEX - 1
else:
jkl_index = jkl_index - 1
if jkl_index < 0:
jkl_index = 0
new_speed = JKL_SPEEDS[jkl_index]
PLAYER().start_variable_speed_playback(new_speed)
def tline_canvas_mouse_moved(x, y, frame, button, state):
"""
Mouse event callback from timeline canvas widget
"""
# Refuse mouse events for some editor states.
if PLAYER().looping():
return
if editorstate.timeline_mouse_disabled == True:
return
if not timeline_visible():
return
# Handle timeline position setting with right mouse button
if button == 3 and EDIT_MODE() != editorstate.CLIP_END_DRAG and EDIT_MODE() != editorstate.COMPOSITOR_EDIT and EDIT_MODE() != editorstate.KF_TOOL:
if not timeline_visible():
return
PLAYER().seek_frame(frame)
# Handle mouse button edits
elif button == 1 or button == 3:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
move_func = mode_funcs[TL_MOUSE_MOVE]
move_func(x, y, frame, state)
def l_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
jkl_index = _get_jkl_speed_index()
if jkl_index < JKL_STOPPED_INDEX + 1: # JKL_STOPPPED_INDEX + 1 is first forward speed, any smaller is backward, l starts forward slow from any backwards speed
jkl_index = JKL_STOPPED_INDEX + 1
else:
jkl_index = jkl_index + 1
if jkl_index == len(JKL_SPEEDS):
jkl_index = len(JKL_SPEEDS) - 1
new_speed = JKL_SPEEDS[jkl_index]
PLAYER().start_variable_speed_playback(new_speed)
def tline_canvas_mouse_moved(x, y, frame, button, state):
"""
Mouse event callback from timeline canvas widget
"""
# Refuse mouse events for some editor states.
if PLAYER().looping():
return
if mouse_disabled == True:
return
if not timeline_visible():
return
# Handle timeline position setting with right mouse button
if button == 3:
if not timeline_visible():
return
PLAYER().seek_frame(frame)
# Handle left mouse button edits
elif button == 1:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
move_func = mode_funcs[TL_MOUSE_MOVE]
move_func(x, y, frame, state)
def _strip_menu_item_callback(widget, data):
msg, segment = data
if msg == "render_segment":
segment.segment_state = SEGMENT_DIRTY
get_renderer().clear_selection()
get_renderer().launch_update_thread()
elif msg == "delete_all":
get_renderer().segments = []
if timeline_visible() == True:
current_sequence().update_hidden_track_for_timeline_rendering()
gui.tline_render_strip.widget.queue_draw()
else:
get_renderer().delete_segment(segment)
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 display_tline_cut_frame(track, index):
"""
Displays sequence frame at cut
"""
if not timeline_visible():
display_sequence_in_monitor()
if index < 0:
index = 0
if index > (len(track.clips) - 1):
index = len(track.clips) - 1
clip_start_frame = track.clip_start(index)
PLAYER().seek_frame(clip_start_frame)
def display_tline_cut_frame(track, index):
"""
Displays sequence frame at cut
"""
if not timeline_visible():
display_sequence_in_monitor()
if index < 0:
index = 0
if index > (len(track.clips) - 1):
index = len(track.clips) - 1
clip_start_frame = track.clip_start(index)
PLAYER().seek_frame(clip_start_frame)
def start_marks_looping():
if PLAYER().looping():
PLAYER().stop_loop_playback()
if PLAYER().is_playing():
PLAYER().stop_playback()
if timeline_visible():
mark_in = PLAYER().producer.mark_in
mark_out = PLAYER().producer.mark_out
else:
mark_in = current_sequence().monitor_clip.mark_in
mark_out = current_sequence().monitor_clip.mark_out
if mark_in == -1 or mark_out == -1:
return
PLAYER().start_loop_playback_range(mark_in, mark_out)
def _press_event(self, event):
"""
Mouse button callback
"""
if self.disabled:
return
if editorstate.timeline_visible():
trimmodes.set_no_edit_trim_mode()
if((event.button == 1)
or(event.button == 3)):
# Set pos to in active range to get normalized pos
self._pos = self._legalize_x(event.x)
# Listener calls self.set_normalized_pos()
# _pos gets actually set twice
# Listener also updates other frame displayers
self.position_listener(self.normalized_pos(), self.producer.get_length())
def select_prev_clip_for_filter_edit():
if not editorstate.timeline_visible():
updater.display_sequence_in_monitor()
tline_frame = PLAYER().tracktor_producer.frame() - 1
clip, track = current_sequence().find_prev_editable_clip_and_track(
tline_frame)
if clip == None:
return
range_in = track.clips.index(clip)
frame = track.clip_start(range_in)
movemodes.select_clip(track.id, range_in)
PLAYER().seek_frame(frame)
clipeffectseditor.set_clip(clip, track, range_in)
def set_and_display_monitor_media_file(media_file):
"""
Displays media_file in clip monitor when new media file
selected for display by double clicking or drag'n'drop
"""
editorstate._monitor_media_file = media_file
#display_clip_in_monitor(clip_monitor_currently_active = True)
# !!???!! I'm not understandung this after new monitor switch, see if we have problems here
# If we're already displaying clip monitor, then already button is down we call display_clip_in_monitor(..)
# directly, but dont save position because we're not displaying now.
#
# If we're displaying sequence we do programmatical click on "Clip" button
# to display clip via it's signal listener.
if editorstate.timeline_visible() == True: # This was changed
display_clip_in_monitor(clip_monitor_currently_active=True)
else:
display_clip_in_monitor()
def update_frame_displayers(frame):
"""
Display frame position in position bar and time code display.
"""
# Update position bar with normalized pos
if timeline_visible():
producer_length = PLAYER().producer.get_length()
else:
producer_length = gui.pos_bar.producer.get_length()
if save_monitor_frame:
MONITOR_MEDIA_FILE().current_frame = frame
norm_pos = frame / float(producer_length)
gui.pos_bar.set_normalized_pos(norm_pos)
gui.tline_scale.widget.queue_draw()
gui.tline_canvas.widget.queue_draw()
gui.big_tc.widget.queue_draw()
clipeffectseditor.display_kfeditors_tline_frame(frame)
compositeeditor.display_kfeditors_tline_frame(frame)
def update_frame_displayers(frame):
"""
Display frame position in position bar and time code display.
"""
# Update position bar with normalized pos
if timeline_visible():
producer_length = PLAYER().producer.get_length()
else:
producer_length = gui.pos_bar.producer.get_length()
if save_monitor_frame:
MONITOR_MEDIA_FILE().current_frame = frame
norm_pos = frame / float(producer_length)
gui.pos_bar.set_normalized_pos(norm_pos)
gui.tline_scale.widget.queue_draw()
gui.tline_canvas.widget.queue_draw()
gui.big_tc.widget.queue_draw()
clipeffectseditor.display_kfeditors_tline_frame(frame)
compositeeditor.display_kfeditors_tline_frame(frame)
def k_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
PLAYER().stop_playback()
def maybe_autocenter():
if timeline_visible():
if editorpersistance.prefs.auto_center_on_play_stop == True:
center_tline_to_current_frame()
def _ticker_event(self):
current_frame = self.producer.frame()
loop_clips = editorpersistance.prefs.loop_clips
if loop_clips and current_frame >= self.get_active_length() and timeline_visible() == False: # Looping for clips
self.seek_frame(0, False) #NOTE: False==GUI not updated
self.producer.set_speed(1)
Gdk.threads_enter()
updater.update_frame_displayers(current_frame)
Gdk.threads_leave()
return
# Stop ticker if playback has stopped.
if (self.consumer.is_stopped() or self.producer.get_speed() == 0):
self.ticker.stop_ticker()
# Stop rendering if last frame reached.
if self.is_rendering == True and current_frame >= self.render_stop_frame:
self.stop_rendering()
return
# If we're currently rendering, set progress bar and exit event handler.
if self.is_rendering:
if (self.producer.get_length() - 1) < 1:
render_fraction = 1.0
else:
render_fraction = ((float(current_frame - self.render_start_frame)) /
(float(self.render_stop_frame - self.render_start_frame)))
self.render_gui_update_count = self.render_gui_update_count + 1
if self.render_gui_update_count % 8 == 0: # we need quick updates for stop accuracy, but slower gui updating
self.render_gui_update_count = 1
Gdk.threads_enter()
self.render_callbacks.set_render_progress_gui(render_fraction)
Gdk.threads_leave()
return
# If we're out of active range seek end.
if current_frame >= self.get_active_length():
Gdk.threads_enter()
self.seek_frame(current_frame)
Gdk.threads_leave()
return
# If trim looping and past loop end, start from loop start
if ((not(self.loop_start == -1)) and
((current_frame >= self.loop_end)
or (current_frame >= self.get_active_length()))):
self.seek_frame(self.loop_start, False) #NOTE: False==GUI not updated
self.producer.set_speed(1)
# Frame displayers update
Gdk.threads_enter()
if timeline_visible() == False:
updater.update_frame_displayers(current_frame)
else:
# If prefs set and frame out tline view, move tline view
range_moved = updater.maybe_move_playback_tline_range(current_frame) # range_moved flag returned just to avoid two updates
if range_moved == False:
# Just display tline
updater.update_frame_displayers(current_frame)
Gdk.threads_leave()
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 _handle_clip_key_event(event):
# Key bindings for MOVE MODES
if editorstate.current_is_move_mode():
action = _get_shortcut_action(event)
# Apr-2017 - SvdB - Add different speeds for different modifiers
# Allow user to select what speed belongs to what modifier, knowing that a combo of mods
# will MULTIPLY all speeds
# Available: SHIFT_MASK LOCK_MASK CONTROL_MASK
prefs = editorpersistance.prefs
if action == 'prev_frame' or action == 'next_frame':
if action == 'prev_frame':
seek_amount = -1
else:
seek_amount = 1
if (event.get_state() & Gdk.ModifierType.SHIFT_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_shift
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_ctrl
if (event.get_state() & Gdk.ModifierType.LOCK_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_caps
PLAYER().seek_delta(seek_amount)
return True
if action == 'next_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
return True
if action == 'prev_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
if action == 'play_pause':
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
if action == 'mark_in':
monitorevent.mark_in_pressed()
return True
if action == 'to_mark_in':
monitorevent.to_mark_in_pressed()
return True
if action == 'mark_out':
monitorevent.mark_out_pressed()
return True
if action == 'to_mark_out':
monitorevent.to_mark_out_pressed()
return True
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 == 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)
mouse_disabled = True
# Set INSERT_MODE
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)
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.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:
editorstate.edit_mode = editorstate.INSERT_MOVE
# 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:
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)
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()
# 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)):
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):
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:
# 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.get_state() & Gdk.ModifierType.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.get_state() & Gdk.ModifierType.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)
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 _handle_clip_key_event(event):
# Key bindings for MOVE MODES
if editorstate.current_is_move_mode():
# LEFT ARROW, prev frame
if event.keyval == Gdk.KEY_Left:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(-10)
else:
PLAYER().seek_delta(-1)
return True
# RIGHT ARROW, next frame
if event.keyval == Gdk.KEY_Right:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(10)
else:
PLAYER().seek_delta(1)
return True
# UP ARROW
if event.keyval == Gdk.KEY_Up:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
return True
# DOWN ARROW, prev cut
if event.keyval == Gdk.KEY_Down:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
# SPACE
if event.keyval == Gdk.KEY_space:
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
# I
if event.keyval == Gdk.KEY_i:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.mark_in_pressed()
return True
if event.keyval == Gdk.KEY_I:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.to_mark_in_pressed()
return True
# O
if event.keyval == Gdk.KEY_o:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.mark_out_pressed()
return True
if event.keyval == Gdk.KEY_O:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.to_mark_out_pressed()
return True
def display_marks_tc():
if not timeline_visible():
display_monitor_clip_name()
else:
update_seqence_info_text()
def _handle_tline_key_event(event):
"""
This is called when timeline widgets have focus and key is pressed.
Returns True for handled key presses to stop those
keyevents from going forward.
"""
tool_was_selected = workflow.tline_tool_keyboard_selected(event)
if tool_was_selected == True:
return True
action = _get_shortcut_action(event)
prefs = editorpersistance.prefs
if action == 'mark_in':
monitorevent.mark_in_pressed()
return True
if action == 'to_mark_in':
monitorevent.to_mark_in_pressed()
return True
if action == 'zoom_out':
updater.zoom_out()
if action == 'zoom_in':
updater.zoom_in()
if action == 'mark_out':
monitorevent.mark_out_pressed()
return True
if action == 'to_mark_out':
monitorevent.to_mark_out_pressed()
return True
if action == 'play_pause':
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
return True
if action == 'switch_monitor':
updater.switch_monitor_display()
return True
if action == 'add_marker':
tlineaction.add_marker()
return True
if action == 'cut':
tlineaction.cut_pressed()
return True
if action == 'sequence_split':
tlineaction.sequence_split_pressed()
return True
if action == 'log_range':
medialog.log_range_clicked()
return True
"""
THis may need rethinking
if action == 'toggle_ripple':
gui.editor_window.toggle_trim_ripple_mode()
return True
"""
# Key bindings for keyboard trimming
if editorstate.current_is_active_trim_mode() == True:
if action == 'prev_frame':
trimmodes.left_arrow_pressed((event.get_state() & Gdk.ModifierType.CONTROL_MASK))
return True
elif action == 'next_frame':
trimmodes.right_arrow_pressed((event.get_state() & Gdk.ModifierType.CONTROL_MASK))
return True
elif action == 'enter_edit':
trimmodes.enter_pressed()
return True
# Key bindings for MOVE MODES and _NO_EDIT modes
if editorstate.current_is_move_mode() or editorstate.current_is_active_trim_mode() == False:
if action == 'next_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
if action == 'prev_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
# Apr-2017 - SvdB - Add different speeds for different modifiers
# Allow user to select what speed belongs to what modifier, knowing that a combo of mods
# will MULTIPLY all speeds
# Available: SHIFT_MASK LOCK_MASK CONTROL_MASK
if action == 'prev_frame' or action == 'next_frame':
if action == 'prev_frame':
seek_amount = -1
else:
seek_amount = 1
if (event.get_state() & Gdk.ModifierType.SHIFT_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_shift
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_ctrl
if (event.get_state() & Gdk.ModifierType.LOCK_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_caps
PLAYER().seek_delta(seek_amount)
return True
if action == '3_point_overwrite':
tlineaction.three_point_overwrite_pressed()
return True
if action == 'insert':
if not (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
tlineaction.insert_button_pressed()
return True
if action == 'append':
tlineaction.append_button_pressed()
return True
if action == 'slower':
monitorevent.j_pressed()
return True
if action == 'stop':
monitorevent.k_pressed()
return True
if action == 'faster':
monitorevent.l_pressed()
return True
if action == 'log_range':
medialog.log_range_clicked()
return True
if action == 'resync':
tlineaction.resync_button_pressed()
return True
if action == 'delete':
# Clip selection and compositor selection are mutually exclusive,
# so max one one these will actually delete something
tlineaction.splice_out_button_pressed()
compositormodes.delete_current_selection()
if action == 'to_start':
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_frame(0)
_move_to_beginning()
return True
if action == 'to_end':
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_end()
_move_to_end()
return True
else:
if action == 'to_start':
if PLAYER().is_playing():
monitorevent.stop_pressed()
gui.editor_window.set_default_edit_tool()
PLAYER().seek_frame(0)
_move_to_beginning()
return True
if action == 'to_end':
if PLAYER().is_playing():
monitorevent.stop_pressed()
gui.editor_window.set_default_edit_tool()
PLAYER().seek_end()
_move_to_end()
return True
return False
def _ticker_event(self):
current_frame = self.producer.frame()
loop_clips = editorpersistance.prefs.loop_clips
if loop_clips and current_frame >= self.get_active_length() and timeline_visible() == False: # Looping for clips
self.seek_frame(0, False) #NOTE: False==GUI not updated
self.producer.set_speed(1)
Gdk.threads_enter()
updater.update_frame_displayers(current_frame)
Gdk.threads_leave()
return
# Stop ticker if playback has stopped.
if (self.consumer.is_stopped() or self.producer.get_speed() == 0):
self.ticker.stop_ticker()
# Stop rendering if last frame reached.
if self.is_rendering == True and current_frame >= self.render_stop_frame:
self.stop_rendering()
return
# If we're currently rendering, set progress bar and exit event handler.
if self.is_rendering:
if (self.producer.get_length() - 1) < 1:
render_fraction = 1.0
else:
render_fraction = ((float(current_frame - self.render_start_frame)) /
(float(self.render_stop_frame - self.render_start_frame)))
self.render_gui_update_count = self.render_gui_update_count + 1
if self.render_gui_update_count % 8 == 0: # we need quick updates for stop accuracy, but slower gui updating
self.render_gui_update_count = 1
Gdk.threads_enter()
self.render_callbacks.set_render_progress_gui(render_fraction)
Gdk.threads_leave()
return
# If we're out of active range seek end.
if current_frame >= self.get_active_length():
Gdk.threads_enter()
self.seek_frame(current_frame)
Gdk.threads_leave()
return
# If trim looping and past loop end, start from loop start
if ((not(self.loop_start == -1)) and
((current_frame >= self.loop_end)
or (current_frame >= self.get_active_length()))):
self.seek_frame(self.loop_start, False) #NOTE: False==GUI not updated
self.producer.set_speed(1)
# Frame displayers update
Gdk.threads_enter()
if timeline_visible() == False:
updater.update_frame_displayers(current_frame)
else:
# If prefs set and frame out tline view, move tline view
range_moved = updater.maybe_move_playback_tline_range(current_frame) # range_moved flag returned just to avoid two updates
if range_moved == False:
# Just display tline
updater.update_frame_displayers(current_frame)
Gdk.threads_leave()
def key_down(widget, event):
"""
Global key press listener.
"""
# Handle ESCAPE
if event.keyval == Gdk.KEY_Escape:
if audiowaveform.waveform_thread != None:
audiowaveform.waveform_thread.abort_rendering()
return True
else:
if editorstate.current_is_move_mode() == False:
editevent.set_default_edit_mode()
return True
# Compositor editors keyevents
was_handled = _handle_geometry_editor_keys(event)
if was_handled:
# Stop widget focus from travelling if arrow key pressed
gui.editor_window.window.emit_stop_by_name("key_press_event")
return True
was_handled = _handle_effects_editor_keys(event)
if was_handled:
# Stop widget focus from travelling if arrow key pressed
gui.editor_window.window.emit_stop_by_name("key_press_event")
return True
# If timeline widgets are in focus timeline keyevents are available
if _timeline_has_focus():
was_handled = _handle_tline_key_event(event)
if was_handled:
# Stop widget focus from travelling if arrow key pressed for next frame
# by stopping signal
gui.editor_window.window.emit_stop_by_name("key_press_event")
return was_handled
# Insert shortcut keys need more focus then timeline shortcuts.
# these may already have been handled in timeline focus events
was_handled = _handle_extended_tline_focus_events(event)
if was_handled:
# Stop event handling here
return True
# Pressing timeline button obivously leaves user expecting
# to have focus in timeline
if gui.sequence_editor_b.has_focus():
_handle_tline_key_event(event)
# Stop event handling here
return True
# Clip button or posbar focus with clip displayed leaves playback keyshortcuts available
if (gui.clip_editor_b.has_focus()
or (gui.pos_bar.widget.is_focus() and (not timeline_visible()))):
_handle_clip_key_event(event)
# Stop event handling here
return True
# Handle non-timeline delete
if event.keyval == Gdk.KEY_Delete:
return _handle_delete()
# Home
if event.keyval == Gdk.KEY_Home:
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_frame(0)
return True
# Select all with CTRL + A in media panel
if event.keyval == Gdk.KEY_a:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
if gui.media_list_view.widget.has_focus() or gui.media_list_view.widget.get_focus_child() != None:
gui.media_list_view.select_all()
return True
#debug
if event.keyval == Gdk.KEY_F11:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
pass
return True
#debug
if event.keyval == Gdk.KEY_F12:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
pass
return True
# Key event was not handled here.
return False
def _handle_clip_key_event(event):
# Key bindings for MOVE MODES
if editorstate.current_is_move_mode():
# LEFT ARROW, prev frame
if event.keyval == Gdk.KEY_Left:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(-10)
else:
PLAYER().seek_delta(-1)
return True
# RIGHT ARROW, next frame
if event.keyval == Gdk.KEY_Right:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(10)
else:
PLAYER().seek_delta(1)
return True
# UP ARROW
if event.keyval == Gdk.KEY_Up:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
return True
# DOWN ARROW, prev cut
if event.keyval == Gdk.KEY_Down:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
# SPACE
if event.keyval == Gdk.KEY_space:
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
# I
if event.keyval == Gdk.KEY_i:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.mark_in_pressed()
return True
if event.keyval == Gdk.KEY_I:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.to_mark_in_pressed()
return True
# O
if event.keyval == Gdk.KEY_o:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.mark_out_pressed()
return True
if event.keyval == Gdk.KEY_O:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.to_mark_out_pressed()
return True
def _handle_tline_key_event(event):
"""
This is called when timeline widgets have focus and key is pressed.
Returns True for handled key presses to stop those
keyevents from going forward.
"""
# I
if event.keyval == Gdk.KEY_i:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.mark_in_pressed()
return True
if event.keyval == Gdk.KEY_I:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.to_mark_in_pressed()
return True
# O
if event.keyval == Gdk.KEY_o:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.mark_out_pressed()
return True
if event.keyval == Gdk.KEY_O:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.to_mark_out_pressed()
return True
# SPACE
if event.keyval == Gdk.KEY_space:
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
return True
# TAB
if event.keyval == Gdk.KEY_Tab:
updater.switch_monitor_display()
return True
# M
if event.keyval == Gdk.KEY_m:
tlineaction.add_marker()
return True
# Number edit mode changes
if event.keyval == Gdk.KEY_1:
gui.editor_window.handle_insert_move_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_2:
gui.editor_window.handle_over_move_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_3:
gui.editor_window.handle_one_roll_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_4:
gui.editor_window.handle_two_roll_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_5:
gui.editor_window.handle_slide_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_6:
gui.editor_window.handle_multi_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
# X
if event.keyval == Gdk.KEY_x:
tlineaction.cut_pressed()
return True
# G
if event.keyval == Gdk.KEY_g:
medialog.log_range_clicked()
return True
# Key bindings for MOVE MODES and _NO_EDIT modes
if editorstate.current_is_move_mode() or editorstate.current_is_active_trim_mode() == False:
# UP ARROW, next cut
if event.keyval == Gdk.KEY_Up:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
# DOWN ARROW, prev cut
if event.keyval == Gdk.KEY_Down:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
# LEFT ARROW, prev frame
if event.keyval == Gdk.KEY_Left:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(-10)
else:
PLAYER().seek_delta(-1)
return True
# RIGHT ARROW, next frame
if event.keyval == Gdk.KEY_Right:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(10)
else:
PLAYER().seek_delta(1)
return True
# T
if event.keyval == Gdk.KEY_t:
tlineaction.three_point_overwrite_pressed()
return True
# Y
if event.keyval == Gdk.KEY_y:
if not (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
tlineaction.insert_button_pressed()
return True
# U
if event.keyval == Gdk.KEY_u:
tlineaction.append_button_pressed()
return True
# J
if event.keyval == Gdk.KEY_j:
monitorevent.j_pressed()
return True
# K
if event.keyval == Gdk.KEY_k:
monitorevent.k_pressed()
return True
# L
if event.keyval == Gdk.KEY_l:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
medialog.log_range_clicked()
else:
monitorevent.l_pressed()
return True
# CTRL+C
if event.keyval == Gdk.KEY_c:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
tlineaction.do_timeline_objects_copy()
return True
# CTRL+V
if event.keyval == Gdk.KEY_v:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
tlineaction.do_timeline_objects_paste()
return True
# DELETE
if event.keyval == Gdk.KEY_Delete:
# Clip selection and compositor selection are mutually exclusive,
# so max one one these will actually delete something
tlineaction.splice_out_button_pressed()
compositormodes.delete_current_selection()
# HOME
if event.keyval == Gdk.KEY_Home:
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_frame(0)
return True
else:
# HOME
if event.keyval == Gdk.KEY_Home:
if PLAYER().is_playing():
monitorevent.stop_pressed()
gui.editor_window.handle_insert_move_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
PLAYER().seek_frame(0)
return True
return False
def _handle_clip_key_event(event):
# Key bindings for MOVE MODES
if editorstate.current_is_move_mode():
action = _get_shortcut_action(event)
# Apr-2017 - SvdB - Add different speeds for different modifiers
# Allow user to select what speed belongs to what modifier, knowing that a combo of mods
# will MULTIPLY all speeds
# Available: SHIFT_MASK LOCK_MASK CONTROL_MASK
prefs = editorpersistance.prefs
if action == 'prev_frame' or action == 'next_frame':
if action == 'prev_frame':
seek_amount = -1
else:
seek_amount = 1
if (event.get_state() & Gdk.ModifierType.SHIFT_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_shift
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_ctrl
if (event.get_state() & Gdk.ModifierType.LOCK_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_caps
PLAYER().seek_delta(seek_amount)
return True
if action == 'next_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
return True
if action == 'prev_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
if action == 'play_pause':
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
if action == 'mark_in':
monitorevent.mark_in_pressed()
return True
if action == 'to_mark_in':
monitorevent.to_mark_in_pressed()
return True
if action == 'mark_out':
monitorevent.mark_out_pressed()
return True
if action == 'to_mark_out':
monitorevent.to_mark_out_pressed()
return True
def display_marks_tc():
if not timeline_visible():
display_monitor_clip_name()
def _handle_tline_key_event(event):
"""
This is called when timeline widgets have focus and key is pressed.
Returns True for handled key presses to stop those
keyevents from going forward.
"""
# I
if event.keyval == Gdk.KEY_i:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.mark_in_pressed()
return True
if event.keyval == Gdk.KEY_I:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_in_pressed()
return True
monitorevent.to_mark_in_pressed()
return True
# O
if event.keyval == Gdk.KEY_o:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.mark_out_pressed()
return True
if event.keyval == Gdk.KEY_O:
if (event.get_state() & Gdk.ModifierType.MOD1_MASK):
monitorevent.to_mark_out_pressed()
return True
monitorevent.to_mark_out_pressed()
return True
# SPACE
if event.keyval == Gdk.KEY_space:
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
return True
# TAB
if event.keyval == Gdk.KEY_Tab:
updater.switch_monitor_display()
return True
# M
if event.keyval == Gdk.KEY_m:
tlineaction.add_marker()
return True
# Number edit mode changes
if event.keyval == Gdk.KEY_1:
gui.editor_window.handle_insert_move_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_2:
gui.editor_window.handle_over_move_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_3:
if editorstate.edit_mode != editorstate.ONE_ROLL_TRIM and editorstate.edit_mode != editorstate.ONE_ROLL_TRIM_NO_EDIT:
gui.editor_window.handle_one_roll_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
else:
gui.editor_window.toggle_trim_ripple_mode()
return True
if event.keyval == Gdk.KEY_4:
gui.editor_window.handle_two_roll_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_5:
gui.editor_window.handle_slide_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_6:
gui.editor_window.handle_multi_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
if event.keyval == Gdk.KEY_7:
gui.editor_window.handle_box_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
return True
# X
if event.keyval == Gdk.KEY_x:
tlineaction.cut_pressed()
return True
# G
if event.keyval == Gdk.KEY_g:
medialog.log_range_clicked()
return True
# R
if event.keyval == Gdk.KEY_r:
gui.editor_window.toggle_trim_ripple_mode()
return True
# Key bindings for keyboard trimming
if editorstate.current_is_active_trim_mode() == True:
# LEFT ARROW, prev frame
if event.keyval == Gdk.KEY_Left:
trimmodes.left_arrow_pressed(
(event.get_state() & Gdk.ModifierType.CONTROL_MASK))
return True
# RIGHT ARROW, next frame
if event.keyval == Gdk.KEY_Right:
trimmodes.right_arrow_pressed(
(event.get_state() & Gdk.ModifierType.CONTROL_MASK))
return True
if event.keyval == Gdk.KEY_Return:
trimmodes.enter_pressed()
return True
# Key bindings for MOVE MODES and _NO_EDIT modes
if editorstate.current_is_move_mode(
) or editorstate.current_is_active_trim_mode() == False:
# UP ARROW, next cut
if event.keyval == Gdk.KEY_Up:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
# DOWN ARROW, prev cut
if event.keyval == Gdk.KEY_Down:
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
# LEFT ARROW, prev frame
if event.keyval == Gdk.KEY_Left:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(-10)
else:
PLAYER().seek_delta(-1)
return True
# RIGHT ARROW, next frame
if event.keyval == Gdk.KEY_Right:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_delta(10)
else:
PLAYER().seek_delta(1)
return True
# T
if event.keyval == Gdk.KEY_t:
tlineaction.three_point_overwrite_pressed()
return True
# Y
if event.keyval == Gdk.KEY_y:
if not (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
tlineaction.insert_button_pressed()
return True
# U
if event.keyval == Gdk.KEY_u:
tlineaction.append_button_pressed()
return True
# J
if event.keyval == Gdk.KEY_j:
monitorevent.j_pressed()
return True
# K
if event.keyval == Gdk.KEY_k:
monitorevent.k_pressed()
return True
# L
if event.keyval == Gdk.KEY_l:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
medialog.log_range_clicked()
else:
monitorevent.l_pressed()
return True
# S
if event.keyval == Gdk.KEY_s:
tlineaction.resync_button_pressed()
return True
# DELETE
if event.keyval == Gdk.KEY_Delete:
# Clip selection and compositor selection are mutually exclusive,
# so max one one these will actually delete something
tlineaction.splice_out_button_pressed()
compositormodes.delete_current_selection()
# HOME
if event.keyval == Gdk.KEY_Home:
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_frame(0)
_move_to_beginning()
return True
# END
if event.keyval == Gdk.KEY_End:
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_end()
_move_to_end()
return True
else:
# HOME
if event.keyval == Gdk.KEY_Home:
if PLAYER().is_playing():
monitorevent.stop_pressed()
gui.editor_window.handle_insert_move_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
PLAYER().seek_frame(0)
_move_to_beginning()
return True
# END
if event.keyval == Gdk.KEY_End:
if PLAYER().is_playing():
monitorevent.stop_pressed()
gui.editor_window.handle_insert_move_mode_button_press()
gui.editor_window.set_mode_selector_to_mode()
PLAYER().seek_end()
_move_to_end()
return True
return False
def k_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
PLAYER().stop_playback()
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 display_marks_tc():
if not timeline_visible():
display_monitor_clip_name()
else:
update_seqence_info_text()
def _handle_tline_key_event(event):
"""
This is called when timeline widgets have focus and key is pressed.
Returns True for handled key presses to stop those
keyevents from going forward.
"""
tool_was_selected = workflow.tline_tool_keyboard_selected(event)
if tool_was_selected == True:
return True
action = _get_shortcut_action(event)
prefs = editorpersistance.prefs
if action == 'mark_in':
monitorevent.mark_in_pressed()
return True
if action == 'to_mark_in':
monitorevent.to_mark_in_pressed()
return True
if action == 'zoom_out':
updater.zoom_out()
if action == 'zoom_in':
updater.zoom_in()
if action == 'mark_out':
monitorevent.mark_out_pressed()
return True
if action == 'to_mark_out':
monitorevent.to_mark_out_pressed()
return True
if action == 'play_pause':
if PLAYER().is_playing():
monitorevent.stop_pressed()
else:
monitorevent.play_pressed()
return True
if action == 'switch_monitor':
updater.switch_monitor_display()
return True
if action == 'add_marker':
tlineaction.add_marker()
return True
if action == 'cut':
tlineaction.cut_pressed()
return True
if action == 'sequence_split':
tlineaction.sequence_split_pressed()
return True
if action == 'log_range':
medialog.log_range_clicked()
return True
"""
THis may need rethinking
if action == 'toggle_ripple':
gui.editor_window.toggle_trim_ripple_mode()
return True
"""
# Key bindings for keyboard trimming
if editorstate.current_is_active_trim_mode() == True:
if action == 'prev_frame':
trimmodes.left_arrow_pressed((event.get_state() & Gdk.ModifierType.CONTROL_MASK))
return True
elif action == 'next_frame':
trimmodes.right_arrow_pressed((event.get_state() & Gdk.ModifierType.CONTROL_MASK))
return True
elif action == 'enter_edit':
trimmodes.enter_pressed()
return True
# Key bindings for MOVE MODES and _NO_EDIT modes
if editorstate.current_is_move_mode() or editorstate.current_is_active_trim_mode() == False:
if action == 'next_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_next_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.up_arrow_seek_on_monitor_clip()
if action == 'prev_cut':
if editorstate.timeline_visible():
tline_frame = PLAYER().tracktor_producer.frame()
frame = current_sequence().find_prev_cut_frame(tline_frame)
if frame != -1:
PLAYER().seek_frame(frame)
if editorpersistance.prefs.center_on_arrow_move == True:
updater.center_tline_to_current_frame()
return True
else:
monitorevent.down_arrow_seek_on_monitor_clip()
return True
# Apr-2017 - SvdB - Add different speeds for different modifiers
# Allow user to select what speed belongs to what modifier, knowing that a combo of mods
# will MULTIPLY all speeds
# Available: SHIFT_MASK LOCK_MASK CONTROL_MASK
if action == 'prev_frame' or action == 'next_frame':
if action == 'prev_frame':
seek_amount = -1
else:
seek_amount = 1
if (event.get_state() & Gdk.ModifierType.SHIFT_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_shift
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_ctrl
if (event.get_state() & Gdk.ModifierType.LOCK_MASK):
seek_amount = seek_amount * prefs.ffwd_rev_caps
PLAYER().seek_delta(seek_amount)
return True
if action == '3_point_overwrite':
tlineaction.three_point_overwrite_pressed()
return True
if action == 'insert':
if not (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
tlineaction.insert_button_pressed()
return True
if action == 'append':
tlineaction.append_button_pressed()
return True
if action == 'slower':
monitorevent.j_pressed()
return True
if action == 'stop':
monitorevent.k_pressed()
return True
if action == 'faster':
monitorevent.l_pressed()
return True
if action == 'log_range':
medialog.log_range_clicked()
return True
if action == 'resync':
tlineaction.resync_button_pressed()
return True
if action == 'delete':
# Clip selection and compositor selection are mutually exclusive,
# so max one one these will actually delete something
tlineaction.splice_out_button_pressed()
compositormodes.delete_current_selection()
if action == 'to_start':
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_frame(0)
_move_to_beginning()
return True
if action == 'to_end':
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_end()
_move_to_end()
return True
else:
if action == 'to_start':
if PLAYER().is_playing():
monitorevent.stop_pressed()
gui.editor_window.set_default_edit_tool()
PLAYER().seek_frame(0)
_move_to_beginning()
return True
if action == 'to_end':
if PLAYER().is_playing():
monitorevent.stop_pressed()
gui.editor_window.set_default_edit_tool()
PLAYER().seek_end()
_move_to_end()
return True
return False
def maybe_autocenter():
if timeline_visible():
if editorpersistance.prefs.auto_center_on_play_stop == True:
center_tline_to_current_frame()
def key_down(widget, event):
"""
Global key press listener.
"""
# Handle ESCAPE
if event.keyval == Gdk.KEY_Escape:
if audiowaveform.waveform_thread != None:
audiowaveform.waveform_thread.abort_rendering()
return True
elif editorstate.current_is_move_mode() == False:
modesetting.set_default_edit_mode()
return True
elif gui.big_tc.get_visible_child_name() == "BigTCEntry":
gui.big_tc.set_visible_child_name("BigTCDisplay")
return True
# Compositor editors keyevents
was_handled = _handle_geometry_editor_keys(event)
if was_handled:
# Stop widget focus from travelling if arrow key pressed
gui.editor_window.window.emit_stop_by_name("key_press_event")
return True
was_handled = _handle_effects_editor_keys(event)
if was_handled:
# Stop widget focus from travelling if arrow key pressed
gui.editor_window.window.emit_stop_by_name("key_press_event")
return True
# If timeline widgets are in focus timeline keyevents are available
if _timeline_has_focus():
was_handled = _handle_tline_key_event(event)
if was_handled:
# Stop widget focus from travelling if arrow key pressed for next frame
# by stopping signal
gui.editor_window.window.emit_stop_by_name("key_press_event")
return was_handled
# Insert shortcut keys need more focus then timeline shortcuts.
# these may already have been handled in timeline focus events
was_handled = _handle_extended_tline_focus_events(event)
if was_handled:
# Stop event handling here
return True
# Pressing timeline button obivously leaves user expecting
# to have focus in timeline
"""
TODO: this needs something
if gui.sequence_editor_b.has_focus():
_handle_tline_key_event(event)
# Stop event handling here
return True
"""
# Clip button or posbar focus with clip displayed leaves playback keyshortcuts available
"""
if (gui.clip_editor_b.has_focus()
TODO: this needs something
or (gui.pos_bar.widget.is_focus() and (not timeline_visible()))):
_handle_clip_key_event(event)
# Stop event handling here
return True
"""
if gui.monitor_switch.widget.has_focus() and timeline_visible():
_handle_tline_key_event(event)
return True
if gui.monitor_switch.widget.has_focus() and (not timeline_visible()):
_handle_clip_key_event(event)
return True
if gui.pos_bar.widget.is_focus() and (not timeline_visible()):
_handle_clip_key_event(event)
return True
# Handle non-timeline delete
if event.keyval == Gdk.KEY_Delete:
return _handle_delete()
# Home
if event.keyval == Gdk.KEY_Home:
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_frame(0)
_move_to_beginning()
return True
# End
if event.keyval == Gdk.KEY_End:
if PLAYER().is_playing():
monitorevent.stop_pressed()
PLAYER().seek_end()
_move_to_end()
return True
# Select all with CTRL + A in media panel
if event.keyval == Gdk.KEY_a:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
if gui.media_list_view.widget.has_focus() or gui.media_list_view.widget.get_focus_child() != None:
gui.media_list_view.select_all()
return True
if event.keyval == Gdk.KEY_F11:
menuactions.toggle_fullscreen()
return True
#debug
if event.keyval == Gdk.KEY_F12:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
pass
return True
# Key event was not handled here.
return False
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()