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 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 three_point_overwrite_pressed():
# Check that state is good for edit
if movemodes.selected_track == -1:
primary_txt = _("No Clips are selected!")
secondary_txt = _(
"You need to select clips to overwrite to perform this edit.")
dialogutils.info_message(primary_txt, secondary_txt,
gui.editor_window.window)
return
# Get data
track = get_track(movemodes.selected_track)
if editevent.track_lock_check_and_user_info(track,
three_point_overwrite_pressed,
"3 point overwrite"):
return
range_start_frame = track.clip_start(movemodes.selected_range_in)
out_clip = track.clips[movemodes.selected_range_out]
out_start = track.clip_start(movemodes.selected_range_out)
range_end_frame = out_start + out_clip.clip_out - out_clip.clip_in
range_length = range_end_frame - range_start_frame + 1 # calculated end is incl.
over_clip = _get_new_clip_from_clip_monitor()
if over_clip == None:
no_monitor_clip_info(gui.editor_window.window)
return
over_length = over_clip.mark_out - over_clip.mark_in + 1 # + 1 out incl ?????????? what if over_clip.mark_out == -1 ??????????
if over_length < range_length:
monitor_clip_too_short(gui.editor_window.window)
return
over_clip_out = over_clip.mark_in + range_length - 1 # -1 out incl
range_in = movemodes.selected_range_in
range_out = movemodes.selected_range_out
movemodes.clear_selected_clips() # edit consumes selection
updater.save_monitor_frame = False # hack to not get wrong value saved in MediaFile.current_frame
data = {
"track": track,
"clip": over_clip,
"clip_in": over_clip.mark_in,
"clip_out": over_clip_out,
"in_index": range_in,
"out_index": range_out
}
action = edit.three_point_overwrite_action(data)
action.do_edit()
if not editorstate.timeline_visible():
updater.display_sequence_in_monitor()
updater.display_tline_cut_frame(track, range_in)
def cut_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 _monitor_switch_handler(self, widget):
# We get two "clicked" events per toggle, send through only the one
# from activated button
if ((self.sequence_editor_b.get_active() == True)
and (widget == self.sequence_editor_b)):
updater.display_sequence_in_monitor()
if ((self.clip_editor_b.get_active() == True)
and (widget == self.clip_editor_b)):
updater.display_clip_in_monitor()
def _monitor_switch_handler(self, widget):
# We get two "clicked" events per toggle, send through only the one
# from activated button
if ((self.sequence_editor_b.get_active() == True)
and (widget == self.sequence_editor_b)):
updater.display_sequence_in_monitor()
if ((self.clip_editor_b.get_active() == True)
and (widget == self.clip_editor_b)):
updater.display_clip_in_monitor()
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 display_current_sequence():
# Get shorter alias.
player = editorstate.player
player.consumer.stop()
player.init_for_profile(editorstate.project.profile)
player.create_sdl_consumer()
player.set_tracktor_producer(editorstate.current_sequence().tractor)
player.connect_and_start()
updater.display_sequence_in_monitor()
player.seek_frame(0)
updater.repaint_tline()
def display_current_sequence():
# Get shorter alias.
player = editorstate.player
player.consumer.stop()
player.init_for_profile(editorstate.project.profile)
player.create_sdl_consumer()
player.set_tracktor_producer(editorstate.current_sequence().tractor)
player.connect_and_start()
updater.display_sequence_in_monitor()
player.seek_frame(0)
updater.repaint_tline()
def launch_player():
# Create SDL output consumer
editorstate.player.set_sdl_xwindow(gui.tline_display)
editorstate.player.create_sdl_consumer()
# Display current sequence tractor
updater.display_sequence_in_monitor()
# Connect buttons to player methods
gui.editor_window.connect_player(editorstate.player)
# Start player.
editorstate.player.connect_and_start()
def launch_player():
# Create SDL output consumer
editorstate.player.set_sdl_xwindow(gui.tline_display)
editorstate.player.create_sdl_consumer()
# Display current sequence tractor
updater.display_sequence_in_monitor()
# Connect buttons to player methods
gui.editor_window.connect_player(editorstate.player)
# Start player.
editorstate.player.connect_and_start()
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 create_gui():
"""
Called at app start to create gui objects and handles for them.
"""
tlinewidgets.load_icons()
kftoolmode.load_icons()
updater.set_clip_edit_mode_callback = modesetting.set_clip_monitor_edit_mode
updater.load_icons()
# Notebook indexes are different for 1 and 2 window layouts
if editorpersistance.prefs.global_layout != appconsts.SINGLE_WINDOW:
medialog.range_log_notebook_index = 0
compositeeditor.compositor_notebook_index = 2
clipeffectseditor.filters_notebook_index = 1
jobs.jobs_notebook_index = 3
if editorwindow.top_level_project_panel() == False:
jobs.jobs_notebook_index = 4
else:
if editorwindow.top_level_project_panel() == False:
jobs.jobs_notebook_index = 5
# Create window and all child components
editor_window = editorwindow.EditorWindow()
# Make references to various gui components available via gui module
gui.capture_references(editor_window)
# All widgets are now realized and references captured so can find out theme colors
gui.set_theme_colors()
tlinewidgets.set_dark_bg_color()
gui.pos_bar.set_dark_bg_color()
# Connect window global key listener
gui.editor_window.window.connect("key-press-event", keyevents.key_down)
if editorpersistance.prefs.global_layout != appconsts.SINGLE_WINDOW:
gui.editor_window.window2.connect("key-press-event",
keyevents.key_down)
# Give undo a reference to uimanager for menuitem state changes
undo.set_menu_items(gui.editor_window.uimanager)
updater.display_sequence_in_monitor()
def create_gui():
"""
Called at app start to create gui objects and handles for them.
"""
tlinewidgets.load_icons()
kftoolmode.load_icons()
updater.set_clip_edit_mode_callback = modesetting.set_clip_monitor_edit_mode
updater.load_icons()
# Make layout data available
editorlayout.init_layout_data()
# Create window and all child components
editor_window = editorwindow.EditorWindow()
# Make references to various gui components available via gui module
gui.capture_references(editor_window)
# Unused frames take 3 pixels so hide those.
editorlayout.set_positions_frames_visibility()
# All widgets are now realized and references captured so can find out theme colors
gui.set_theme_colors()
tlinewidgets.set_dark_bg_color()
gui.pos_bar.set_dark_bg_color()
# Connect window global key listener
gui.editor_window.window.connect("key-press-event", keyevents.key_down)
if editorpersistance.prefs.global_layout != appconsts.SINGLE_WINDOW:
gui.editor_window.window2.connect("key-press-event",
keyevents.key_down)
# Give undo a reference to uimanager for menuitem state changes
undo.set_menu_items(gui.editor_window.uimanager)
updater.display_sequence_in_monitor()
def create_gui():
"""
Called at app start to create gui objects and handles for them.
"""
tlinewidgets.load_icons()
kftoolmode.load_icons()
updater.set_clip_edit_mode_callback = modesetting.set_clip_monitor_edit_mode
updater.load_icons()
# Notebook indexes are differn for 1 and 2 window layouts
if editorpersistance.prefs.global_layout != appconsts.SINGLE_WINDOW:
medialog.range_log_notebook_index = 0
compositeeditor.compositor_notebook_index = 2
clipeffectseditor.filters_notebook_index = 1
# Create window and all child components
editor_window = editorwindow.EditorWindow()
# Make references to various gui components available via gui module
gui.capture_references(editor_window)
# All widgets are now realized and references captured so can find out theme colors
gui.set_theme_colors()
tlinewidgets.set_dark_bg_color()
gui.pos_bar.set_dark_bg_color()
# Connect window global key listener
gui.editor_window.window.connect("key-press-event", keyevents.key_down)
if editorpersistance.prefs.global_layout != appconsts.SINGLE_WINDOW:
gui.editor_window.window2.connect("key-press-event", keyevents.key_down)
# Give undo a reference to uimanager for menuitem state changes
undo.set_menu_items(gui.editor_window.uimanager)
updater.display_sequence_in_monitor()
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 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 tline_canvas_mouse_pressed(event, frame):
"""
Mouse event callback from timeline canvas widget
"""
editorstate.timeline_mouse_disabled = False # This is used to disable "move and "release" events when they would get bad data.
if PLAYER().looping():
return
elif PLAYER().is_playing():
PLAYER().stop_playback()
# Double click handled separately
if event.type == Gdk.EventType._2BUTTON_PRESS:
return
# Handle and exit parent clip selecting
if EDIT_MODE() == editorstate.SELECT_PARENT_CLIP:
syncsplitevent.select_sync_parent_mouse_pressed(event, frame)
editorstate.timeline_mouse_disabled = True
# Set INSERT_MODE
modesetting.set_default_edit_mode()
return
# Handle and exit tline sync clip selecting
if EDIT_MODE() == editorstate.SELECT_TLINE_SYNC_CLIP:
audiosync.select_sync_clip_mouse_pressed(event, frame)
editorstate.timeline_mouse_disabled = True
# Set INSERT_MODE
modesetting.set_default_edit_mode()
return
# Hitting timeline in clip display mode displays timeline in
# default mode.
if not timeline_visible():
updater.display_sequence_in_monitor()
if (event.button == 1):
# Now that we have correct edit mode we'll reenter
# this method to get e.g. a select action
tline_canvas_mouse_pressed(event, frame)
return
if (event.button == 3):
# Right mouse + CTRL displays clip menu if we hit clip
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
PLAYER().seek_frame(frame)
# Right mouse on timeline seeks frame
else:
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
return
# If clip end drag mode is for some reason still active, exit to default edit mode
if EDIT_MODE() == editorstate.CLIP_END_DRAG:
modesetting.set_default_edit_mode()
# This shouldn't happen unless for some reason mouse release didn't hit clipenddragmode listener.
print "EDIT_MODE() == editorstate.CLIP_END_DRAG at mouse press!"
# Check if match frame close is hit
if editorstate.current_is_move_mode() and timeline_visible():
if tlinewidgets.match_frame_close_hit(event.x, event.y) == True:
tlinewidgets.set_match_frame(-1, -1, True)
updater.repaint_tline()
return
# Check if compositor is hit and if so, handle compositor editing
if editorstate.current_is_move_mode() and timeline_visible():
hit_compositor = tlinewidgets.compositor_hit(frame, event.y, current_sequence().compositors)
if hit_compositor != None:
if editorstate.auto_follow == False or hit_compositor.obey_autofollow == False:
movemodes.clear_selected_clips()
if event.button == 1 or (event.button == 3 and event.get_state() & Gdk.ModifierType.CONTROL_MASK):
compositormodes.set_compositor_mode(hit_compositor)
mode_funcs = EDIT_MODE_FUNCS[editorstate.COMPOSITOR_EDIT]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
return
if event.button == 3:
compositormodes.set_compositor_selected(hit_compositor)
guicomponents.display_compositor_popup_menu(event, hit_compositor,
compositor_menu_item_activated)
return
elif event.button == 2:
updater.zoom_project_length()
return
compositormodes.clear_compositor_selection()
# Check if we should enter clip end drag mode
if (event.button == 3 and editorstate.current_is_move_mode()
and timeline_visible() and (event.get_state() & Gdk.ModifierType.CONTROL_MASK)):
# with CTRL right mouse
clipenddragmode.maybe_init_for_mouse_press(event, frame)
elif (timeline_visible() and (EDIT_MODE() == editorstate.INSERT_MOVE or EDIT_MODE() == editorstate.OVERWRITE_MOVE)
and (tlinewidgets.pointer_context == appconsts.POINTER_CONTEXT_END_DRAG_LEFT or tlinewidgets.pointer_context == appconsts.POINTER_CONTEXT_END_DRAG_RIGHT)):
# with pointer context
clipenddragmode.maybe_init_for_mouse_press(event, frame)
# Handle mouse button presses depending which button was pressed and
# editor state.
# RIGHT BUTTON: seek frame or display clip menu if not dragging clip end
if (event.button == 3 and EDIT_MODE() != editorstate.CLIP_END_DRAG and EDIT_MODE() != editorstate.KF_TOOL):
if ((not editorstate.current_is_active_trim_mode()) and timeline_visible()):
if not(event.get_state() & Gdk.ModifierType.CONTROL_MASK):
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
else:
# For trim modes set <X>_NO_EDIT edit mode and seek frame. and seek frame
trimmodes.set_no_edit_trim_mode()
PLAYER().seek_frame(frame)
return
# LEFT BUTTON: Select new trimmed clip in active one roll trim mode with sensitive cursor.
elif (event.button == 1 and EDIT_MODE() == editorstate.ONE_ROLL_TRIM):
track = tlinewidgets.get_track(event.y)
if track == None:
modesetting.set_default_edit_mode(True)
return
success = trimmodes.set_oneroll_mode(track, frame)
if not success:
modesetting.set_default_edit_mode(True)
return
if trimmodes.edit_data["to_side_being_edited"] == True:
pointer_context = appconsts.POINTER_CONTEXT_TRIM_LEFT
else:
pointer_context = appconsts.POINTER_CONTEXT_TRIM_RIGHT
gui.editor_window.set_tline_cursor_to_context(pointer_context)
gui.editor_window.set_tool_selector_to_mode()
if not editorpersistance.prefs.quick_enter_trims:
editorstate.timeline_mouse_disabled = True
else:
trimmodes.oneroll_trim_move(event.x, event.y, frame, None)
elif event.button == 2:
updater.zoom_project_length()
# LEFT BUTTON: Handle left mouse button edits by passing event to current edit mode
# handler func
elif event.button == 1 or event.button == 3:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
def tline_canvas_mouse_pressed(event, frame):
"""
Mouse event callback from timeline canvas widget
"""
global mouse_disabled
if PLAYER().looping():
return
elif PLAYER().is_playing():
PLAYER().stop_playback()
# Double click handled separately
if event.type == gtk.gdk._2BUTTON_PRESS:
return
# Handle and exit parent clip selecting
if EDIT_MODE() == editorstate.SELECT_PARENT_CLIP:
syncsplitevent.select_sync_parent_mouse_pressed(event, frame)
mouse_disabled = True
# Set INSERT_MODE
set_default_edit_mode()
return
# Hitting timeline in clip display mode displays timeline in
# default mode.
if not timeline_visible():
updater.display_sequence_in_monitor()
if (event.button == 1):
# Now that we have correct edit mode we'll reenter
# this method to get e.g. a select action
tline_canvas_mouse_pressed(event, frame)
return
if (event.button == 3):
mouse_disabled == True
# Right mouse + CTRL displays clip menu if we hit clip
if (event.state & gtk.gdk.CONTROL_MASK):
PLAYER().seek_frame(frame)
# Right mouse on timeline seeks frame
else:
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
return
# Check if compositor is hit and if so handle compositor editing
if editorstate.current_is_move_mode() and timeline_visible():
hit_compositor = tlinewidgets.compositor_hit(frame, event.y, current_sequence().compositors)
if hit_compositor != None:
movemodes.clear_selected_clips()
if event.button == 1:
compositormodes.set_compositor_mode(hit_compositor)
mode_funcs = EDIT_MODE_FUNCS[editorstate.COMPOSITOR_EDIT]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
elif event.button == 3:
mouse_disabled == True
compositormodes.set_compositor_selected(hit_compositor)
guicomponents.display_compositor_popup_menu(event, hit_compositor,
compositor_menu_item_activated)
elif event.button == 2:
updater.zoom_project_length()
return
compositormodes.clear_compositor_selection()
# Handle mouse button presses depending which button was pressed and
# editor state.
# RIGHT BUTTON: seek frame or display clip menu
if (event.button == 3):
if ((not editorstate.current_is_active_trim_mode()) and timeline_visible()):
if not(event.state & gtk.gdk.CONTROL_MASK):
success = display_clip_menu_pop_up(event.y, event, frame)
if not success:
PLAYER().seek_frame(frame)
else:
PLAYER().seek_frame(frame)
else:
# For trim modes set <X>_NO_EDIT edit mode and seek frame. and seek frame
trimmodes.set_no_edit_trim_mode()
PLAYER().seek_frame(frame)
return
# LEFT BUTTON + CTRL: Select new trimmed clip in one roll trim mode
elif (event.button == 1
and (event.state & gtk.gdk.CONTROL_MASK)
and EDIT_MODE() == editorstate.ONE_ROLL_TRIM):
track = tlinewidgets.get_track(event.y)
if track == None:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
success = trimmodes.set_oneroll_mode(track, frame)
if (not success) and editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
gui.editor_window.set_cursor_to_mode()
gui.editor_window.set_mode_selector_to_mode()
if not editorpersistance.prefs.quick_enter_trims:
mouse_disabled = True
else:
trimmodes.oneroll_trim_move(event.x, event.y, frame, None)
# LEFT BUTTON + CTRL: Select new trimmed clip in two roll trim mode
elif (event.button == 1
and (event.state & gtk.gdk.CONTROL_MASK)
and EDIT_MODE() == editorstate.TWO_ROLL_TRIM):
track = tlinewidgets.get_track(event.y)
if track == None:
if editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
success = trimmodes.set_tworoll_mode(track, frame)
if (not success) and editorpersistance.prefs.empty_click_exits_trims == True:
set_default_edit_mode(True)
return
if not editorpersistance.prefs.quick_enter_trims:
mouse_disabled = True
else:
trimmodes.tworoll_trim_move(event.x, event.y, frame, None)
# LEFT BUTTON: Handle left mouse button edits by passing event to current edit mode
# handler func
elif event.button == 1:
mode_funcs = EDIT_MODE_FUNCS[EDIT_MODE()]
press_func = mode_funcs[TL_MOUSE_PRESS]
press_func(event, frame)
elif event.button == 2:
updater.zoom_project_length()
