def run(self):
print "Starting XML render"
player = PLAYER()
# Don't try anything if somehow this was started
# while timeline rendering is running
if player.is_rendering:
print "Can't render XML when another render is already running!"
return
# Stop all playback before producer is disconnected
self.current_playback_frame = player.producer.frame()
player.ticker.stop_ticker()
player.consumer.stop()
player.producer.set_speed(0)
player.producer.seek(0)
# Wait until producer is at start
while player.producer.frame() != 0:
time.sleep(0.1)
# Get render producer
timeline_producer = PROJECT().c_seq.tractor
# Get render consumer
xml_consumer = mlt.Consumer(PROJECT().profile, "xml", str(self.file_name))
# Connect and start rendering
xml_consumer.connect(timeline_producer)
xml_consumer.start()
timeline_producer.set_speed(1)
# Wait until done
while xml_consumer.is_stopped() == False:
print "In XML render wait loop..."
time.sleep(0.1)
print "XML render done"
# Get app player going again
player.connect_and_start()
player.seek_frame(0)
self.render_done_callback(self.data)
def set_oneroll_mode(track, current_frame=-1, editing_to_clip=None):
"""
Sets one roll mode
"""
if track == None:
return False
if track.id < 1 or (track.id >= len(current_sequence().tracks) - 1):
return False
if current_frame == -1: # from button, ctrl + mouse calls with frame
current_frame = PLAYER().producer.frame(
) + 1 # +1 because cut frame selects previous clip
if current_frame >= track.get_length():
return False
edit_frame, to_side_being_edited = _get_trim_edit(track, current_frame)
if edit_frame == -1:
return False
# hack fix for last clip out trim. If frame pointer not at very end of clip
# the other functions for getting trim frame given +1 too much
if edit_frame > track.get_length():
edit_frame = track.get_length()
if editing_to_clip != None: # This is set when mode reset after edit or after undo or redo
# _get_trim_edit() might give different(wrong) clip being edited
# because cut is now at a different place.
to_side_being_edited = editing_to_clip
_set_edit_data(track, edit_frame, True)
global edit_data
# Set side being edited to default to-side
edit_data["to_side_being_edited"] = to_side_being_edited
current_sequence().clear_hidden_track()
# Cant't trim a blank clip. Blank clips are special in MLT and can't be
# made to do things that are needed in trim.
if _trimmed_clip_is_blank():
set_exit_mode_func()
primary_txt = _("Cant ONE ROLL TRIM blank clips.")
secondary_txt = _(
"You can use MOVE OVERWRITE or TWO ROLL TRIM edits instead\nto get the desired change."
)
dialogutils.info_message(primary_txt, secondary_txt,
gui.editor_window.window)
return False
# Give timeline widget needed data
tlinewidgets.set_edit_mode(edit_data, tlinewidgets.draw_one_roll_overlay)
# Set clip as special producer on hidden track and display current frame
# from it.
trim_limits = edit_data["trim_limits"]
if edit_data["to_side_being_edited"]:
clip = edit_data["to_clip"]
clip_start = trim_limits["to_start"]
else:
clip = edit_data["from_clip"]
clip_start = trim_limits["from_start"]
# Display trim clip
if clip.media_type != appconsts.PATTERN_PRODUCER:
current_sequence().display_trim_clip(clip.path,
clip_start) # file producer
else:
current_sequence().display_trim_clip(
None, clip_start, clip.create_data) # pattern producer
PLAYER().seek_frame(edit_frame)
return True
def add_marker():
current_frame = PLAYER().current_frame()
dialogs.marker_name_dialog(utils.get_tc_string(current_frame),
_marker_add_dialog_callback)
def cut_pressed():
if not timeline_visible():
updater.display_sequence_in_monitor()
# Disable whencut action when it cut clash with ongoing edits
if EDIT_MODE() == editorstate.ONE_ROLL_TRIM or EDIT_MODE(
) == editorstate.TWO_ROLL_TRIM or EDIT_MODE() == editorstate.SLIDE_TRIM:
return
if EDIT_MODE(
) == editorstate.MULTI_MOVE and multimovemode.edit_data != None:
return
if EDIT_MODE(
) == editorstate.MULTI_MOVE and multimovemode.edit_data != None:
return
if boxmove.box_selection_data != None:
return
# Get cut frame
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 _next_frame_pressed(self):
PLAYER().seek_delta(1)
self.show_current_frame()
def next_pressed():
# This handles only movemodes, see trimmodes.py module for others.
PLAYER().seek_delta(1)
def overwrite_move_release(x, y, frame, state):
"""
User releases mouse when in overwrite move mode.
"""
global edit_data, drag_disabled
if editorstate.overwrite_mode_box == True:
boxmove.mouse_release(x, y, frame)
edit_data = None
return
if drag_disabled:
drag_disabled = False
edit_data = None
return
if edit_data == None:
return
press_frame = edit_data["press_frame"]
first_clip_start = edit_data["first_clip_start"]
track = edit_data["track_object"]
to_track = edit_data["to_track_object"]
over_in = first_clip_start + (frame - press_frame)
over_out = over_in + edit_data["moving_length"]
# Check locking of target track. Source track checked at press event.
if _track_is_locked(to_track):
edit_data = None
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
return
# Moved clips are completely out of displayable track area, can't do edit.
if over_out < 1:
edit_data = None
return
# Autocorrect moved clips to be fully on displayable track area
if over_in < 0:
over_out += abs(over_in)
over_in = 0
# Collect data for edit action
data = {"track":track,
"over_in":over_in,
"over_out":over_out,
"selected_range_in":selected_range_in,
"selected_range_out":selected_range_out,
"move_edit_done_func":move_edit_done}
# Do edit. Use different actions depending on if
# clip is moved to a differrent track
if track == to_track:
# Do edit if were moving and clips have moved
if (edit_data["move_on"] == True and (press_frame != frame)):
clear_selected_clips()
action = edit.overwrite_move_action(data)
action.do_edit()
PLAYER().seek_frame(over_in, False)
else:
_move_mode_released()
else: # Moved to different track
data["to_track"] = to_track
clear_selected_clips()
action = edit.multitrack_overwrite_move_action(data)
action.do_edit()
PLAYER().seek_frame(over_in, False)
# Clear edit mode data
edit_data = None
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
def set_monitor_playback_interpolation(new_interpolation):
PLAYER().consumer.set(
"rescale", str(new_interpolation)
) # MLT options "nearest", "bilinear", "bicubic", "hyper" hardcoded into menu items
def update_position_bar():
if timeline_visible():
gui.pos_bar.update_display_from_producer(PLAYER().producer)
else:
gui.pos_bar.update_display_from_producer(gui.pos_bar.producer)
def __init__(self, kf_editor, editor_widgets, value_labels
): # kf_editor is keyframeeditor.RotoMaskKeyFrameEditor
GObject.GObject.__init__(self)
self.set_title(_("RotoMaskEditor"))
self.connect("delete-event", lambda w, e: close_rotomask())
if editorstate.screen_size_small_height() == True:
global TEXT_LAYER_LIST_HEIGHT, TEXT_VIEW_HEIGHT, VIEW_EDITOR_HEIGHT
TEXT_LAYER_LIST_HEIGHT = 150
TEXT_VIEW_HEIGHT = 180
VIEW_EDITOR_HEIGHT = 450
if editorstate.screen_size_small_height() == True:
global VIEW_EDITOR_WIDTH
VIEW_EDITOR_WIDTH = 680
self.block_updates = False
self.kf_editor = kf_editor
self.kf_editor.set_parent_editor(self)
self.value_labels = value_labels
self.view_editor = vieweditor.ViewEditor(PLAYER().profile,
VIEW_EDITOR_WIDTH,
VIEW_EDITOR_HEIGHT)
self.guides_toggle = vieweditor.GuidesViewToggle(self.view_editor)
"""
add_b = Gtk.Button(_("Add"))
del_b = Gtk.Button(_("Delete"))
add_b.connect("clicked", lambda w:self._add_layer_pressed())
del_b.connect("clicked", lambda w:self._del_layer_pressed())
add_del_box = Gtk.HBox()
add_del_box = Gtk.HBox(True,1)
add_del_box.pack_start(add_b, True, True, 0)
add_del_box.pack_start(del_b, True, True, 0)
"""
self.tc_display = guicomponents.MonitorTCDisplay()
self.tc_display.use_internal_frame = True
self.tc_display.widget.set_valign(Gtk.Align.CENTER)
kf_mode_img = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"roto_kf_edit_mode.png")
move_mode_img = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"roto_move_mode.png")
self.kf_mode_button = Gtk.ToggleButton()
self.kf_mode_button.set_image(kf_mode_img)
self.kf_mode_button.set_active(
True) # we start with vieweditorlayer.ROTO_POINT_MODE edit mode
self.kf_mode_button.connect("clicked", self._kf_mode_clicked)
self.move_mode_button = Gtk.ToggleButton()
self.move_mode_button.set_image(move_mode_img)
self.move_mode_button.connect("clicked", self._move_mode_clicked)
self.scale_selector = vieweditor.ScaleSelector(self)
self.view_editor.scale_select = self.scale_selector
timeline_box = Gtk.HBox()
timeline_box.pack_start(self.tc_display.widget, False, False, 0)
timeline_box.pack_start(Gtk.Label(), True, True, 0)
timeline_box.pack_start(self.kf_mode_button, False, False, 0)
timeline_box.pack_start(self.move_mode_button, False, False, 0)
timeline_box.pack_start(Gtk.Label(), True, True, 0)
timeline_box.pack_start(self.scale_selector, False, False, 0)
timeline_box.set_margin_top(6)
timeline_box.set_margin_bottom(6)
mask_type_label = Gtk.Label(_("Mask Type:"))
mask_type_combo_box = Gtk.ComboBoxText()
mask_type_combo_box.append_text(_("Curve Mask"))
mask_type_combo_box.append_text(_("Line Mask"))
mask_type_combo_box.set_active(0)
mask_type_combo_box.connect("changed",
self.mask_type_selection_changed)
#exit_b = guiutils.get_sized_button(_("Cancel Edit"), 150, 32)
#exit_b.connect("clicked", lambda w:close_rotomask())
save_rotodata_b = guiutils.get_sized_button(_("Close Tool"), 150, 32)
save_rotodata_b.connect("clicked",
lambda w: self._save_rotodata_pressed())
prop_editor_row1 = Gtk.HBox()
prop_editor_row1.pack_start(Gtk.Label(), True, True, 0)
prop_editor_row1.pack_start(mask_type_label, False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(4, 4), False, False, 0)
prop_editor_row1.pack_start(mask_type_combo_box, False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row1.pack_start(editor_widgets[0], False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row1.pack_start(editor_widgets[3], False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row1.pack_start(editor_widgets[4], False, False, 0)
prop_editor_row1.pack_start(Gtk.Label(), True, True, 0)
prop_editor_row2 = Gtk.HBox()
prop_editor_row2.pack_start(Gtk.Label(), True, True, 0)
prop_editor_row2.pack_start(editor_widgets[1], False, False, 0)
prop_editor_row2.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row2.pack_start(editor_widgets[2], False, False, 0)
prop_editor_row2.pack_start(Gtk.Label(), True, True, 0)
editor_buttons_row = Gtk.HBox()
editor_buttons_row.pack_start(Gtk.Label(), True, True, 0)
editor_buttons_row.pack_start(guiutils.pad_label(24, 2), False, False,
0)
editor_buttons_row.pack_start(guiutils.pad_label(24, 2), False, False,
0)
#editor_buttons_row.pack_start(exit_b, False, False, 0)
editor_buttons_row.pack_start(save_rotodata_b, False, False, 0)
editor_panel = Gtk.VBox()
editor_panel.pack_start(self.view_editor, True, True, 0)
editor_panel.pack_start(timeline_box, False, False, 0)
editor_panel.pack_start(kf_editor, False, False, 0)
editor_panel.pack_start(guiutils.pad_label(2, 12), False, False, 0)
editor_panel.pack_start(prop_editor_row1, False, False, 0)
editor_panel.pack_start(guiutils.pad_label(2, 12), False, False, 0)
editor_panel.pack_start(prop_editor_row2, False, False, 0)
editor_panel.pack_start(guiutils.pad_label(2, 12), False, False, 0)
editor_panel.pack_start(editor_buttons_row, False, False, 0)
editor_row = Gtk.HBox()
editor_row.pack_start(editor_panel, True, True, 0)
alignment = guiutils.set_margins(editor_row, 8, 8, 8, 8)
self.add(alignment)
self.view_editor.clear_layers()
# NOTE: we start with vieweditorlayer.ROTO_POINT_MODE edit mode, see __init()__
self.roto_mask_layer = vieweditorlayer.RotoMaskEditLayer(
self.view_editor, self.kf_editor.clip_editor,
kf_editor.editable_property, self)
self.view_editor.add_layer(self.roto_mask_layer)
self.view_editor.activate_layer(0)
self.show_all()
self.kf_editor.active_keyframe_changed()
#self.connect("size-allocate", lambda w, e:self.window_resized())
self.connect("window-state-event", lambda w, e: self.window_resized())
self.connect("key-press-event", self.key_down)
self.window_resized()
def scale_changed(self, new_scale):
self.view_editor.set_scale_and_update(new_scale)
tline_frame = PLAYER().current_frame()
self.view_editor.update_layers_for_frame(tline_frame)
self.view_editor.edit_area.queue_draw()
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
if action == 'clear_io_marks':
monitorevent.marks_clear_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.
"""
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 == 'clear_io_marks':
monitorevent.marks_clear_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 == 'cut_all':
tlineaction.cut_all_pressed()
return True
if action == 'sequence_split':
tlineaction.sequence_split_pressed()
return True
if action == 'log_range':
medialog.log_range_clicked()
return True
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
if editorstate.EDIT_MODE() == editorstate.OVERWRITE_MOVE:
if action == 'nudge_back':
movemodes.nudge_selection(-1)
return True
elif action == 'nudge_forward':
movemodes.nudge_selection(1)
return True
elif action == 'nudge_back_10':
movemodes.nudge_selection(-10)
return True
elif action == 'nudge_forward_10':
movemodes.nudge_selection(10)
return True
if editorstate.EDIT_MODE() == editorstate.MULTI_TRIM:
multitrimmode.enter_pressed()
# 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 == 'overwrite_range':
tlineaction.range_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 == 'append_from_bin':
projectaction.append_selected_media_clips_into_timeline()
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':
if editorstate.EDIT_MODE() == editorstate.KF_TOOL:
kftoolmode.delete_active_keyframe()
else:
# 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 == 'lift':
tlineaction.lift_button_pressed()
return True
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 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
# Make Home and End work on name entry widget.
# TODO: See which other components could benefit from this check.
if render.widgets.file_panel.movie_name.has_focus():
return False
# 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_monitor_focus_events(event)
if was_handled:
# Stop event handling here
return True
was_handled = _handle_configurable_global_events(event)
if was_handled:
return True
# Pressing timeline button obivously leaves user expecting
# to have focus in timeline
if gui.monitor_switch.widget.has_focus() and timeline_visible():
_handle_tline_key_event(event)
return True
# Events that are available when monitor displays clip
if gui.monitor_switch.widget.has_focus() and (not timeline_visible()):
_handle_clip_key_event(event)
return True
# Events that are available when monitor displays clip
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.test help
if event.keyval == Gdk.KEY_F12:
if (event.get_state() & Gdk.ModifierType.CONTROL_MASK):
rotomask.show_rotomask()
return True
# Key event was not handled here.
return False
def _clip_frame_slider_update(editable_property, adjustment):
PLAYER().stop_playback()
editable_property.adjustment_value_changed(adjustment)
def k_pressed():
if timeline_visible():
trimmodes.set_no_edit_trim_mode()
PLAYER().stop_playback()
def __init__(self):
GObject.GObject.__init__(self)
self.set_title(_("Titler"))
self.connect("delete-event", lambda w, e: close_titler())
if editorstate.screen_size_small_height() == True:
global TEXT_LAYER_LIST_HEIGHT, TEXT_VIEW_HEIGHT, VIEW_EDITOR_HEIGHT
TEXT_LAYER_LIST_HEIGHT = 150
TEXT_VIEW_HEIGHT = 180
VIEW_EDITOR_HEIGHT = 450
if editorstate.screen_size_small_height() == True:
global VIEW_EDITOR_WIDTH
VIEW_EDITOR_WIDTH = 680
self.block_updates = False
self.view_editor = vieweditor.ViewEditor(PLAYER().profile,
VIEW_EDITOR_WIDTH,
VIEW_EDITOR_HEIGHT)
self.view_editor.active_layer_changed_listener = self.active_layer_changed
self.guides_toggle = vieweditor.GuidesViewToggle(self.view_editor)
add_b = Gtk.Button(_("Add"))
del_b = Gtk.Button(_("Delete"))
add_b.connect("clicked", lambda w: self._add_layer_pressed())
del_b.connect("clicked", lambda w: self._del_layer_pressed())
add_del_box = Gtk.HBox()
add_del_box = Gtk.HBox(True, 1)
add_del_box.pack_start(add_b, True, True, 0)
add_del_box.pack_start(del_b, True, True, 0)
center_h_icon = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"center_horizontal.png")
center_v_icon = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"center_vertical.png")
center_h = Gtk.Button()
center_h.set_image(center_h_icon)
center_h.connect("clicked", lambda w: self._center_h_pressed())
center_v = Gtk.Button()
center_v.set_image(center_v_icon)
center_v.connect("clicked", lambda w: self._center_v_pressed())
self.layer_list = TextLayerListView(self._layer_selection_changed,
self._layer_visibility_toggled)
self.layer_list.set_size_request(TEXT_LAYER_LIST_WIDTH,
TEXT_LAYER_LIST_HEIGHT)
self.text_view = Gtk.TextView()
self.text_view.set_pixels_above_lines(2)
self.text_view.set_left_margin(2)
self.text_view.get_buffer().connect("changed", self._text_changed)
self.sw = Gtk.ScrolledWindow()
self.sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
self.sw.add(self.text_view)
self.sw.set_size_request(TEXT_VIEW_WIDTH, TEXT_VIEW_HEIGHT)
scroll_frame = Gtk.Frame()
scroll_frame.add(self.sw)
self.tc_display = guicomponents.MonitorTCDisplay()
self.tc_display.use_internal_frame = True
self.tc_display.widget.set_valign(Gtk.Align.CENTER)
self.pos_bar = positionbar.PositionBar()
self.pos_bar.set_listener(self.position_listener)
self.pos_bar.update_display_from_producer(PLAYER().producer)
self.pos_bar.mouse_release_listener = self.pos_bar_mouse_released
pos_bar_frame = Gtk.Frame()
pos_bar_frame.add(self.pos_bar.widget)
pos_bar_frame.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
pos_bar_frame.set_valign(Gtk.Align.CENTER)
font_map = PangoCairo.font_map_get_default()
unsorted_families = font_map.list_families()
if len(unsorted_families) == 0:
print "No font families found in system! Titler will not work."
self.font_families = sorted(unsorted_families,
key=lambda family: family.get_name())
self.font_family_indexes_for_name = {}
combo = Gtk.ComboBoxText()
indx = 0
for family in self.font_families:
combo.append_text(family.get_name())
self.font_family_indexes_for_name[family.get_name()] = indx
indx += 1
combo.set_active(0)
self.font_select = combo
self.font_select.connect("changed", self._edit_value_changed)
adj = Gtk.Adjustment(float(DEFAULT_FONT_SIZE), float(1), float(300),
float(1))
self.size_spin = Gtk.SpinButton()
self.size_spin.set_adjustment(adj)
self.size_spin.connect("changed", self._edit_value_changed)
self.size_spin.connect("key-press-event", self._key_pressed_on_widget)
font_main_row = Gtk.HBox()
font_main_row.pack_start(self.font_select, True, True, 0)
font_main_row.pack_start(guiutils.pad_label(5, 5), False, False, 0)
font_main_row.pack_start(self.size_spin, False, False, 0)
self.bold_font = Gtk.ToggleButton()
self.italic_font = Gtk.ToggleButton()
bold_icon = Gtk.Image.new_from_stock(Gtk.STOCK_BOLD,
Gtk.IconSize.BUTTON)
italic_icon = Gtk.Image.new_from_stock(Gtk.STOCK_ITALIC,
Gtk.IconSize.BUTTON)
self.bold_font.set_image(bold_icon)
self.italic_font.set_image(italic_icon)
self.bold_font.connect("clicked", self._edit_value_changed)
self.italic_font.connect("clicked", self._edit_value_changed)
self.left_align = Gtk.RadioButton(None)
self.center_align = Gtk.RadioButton.new_from_widget(self.left_align)
self.right_align = Gtk.RadioButton.new_from_widget(self.left_align)
left_icon = Gtk.Image.new_from_stock(Gtk.STOCK_JUSTIFY_LEFT,
Gtk.IconSize.BUTTON)
center_icon = Gtk.Image.new_from_stock(Gtk.STOCK_JUSTIFY_CENTER,
Gtk.IconSize.BUTTON)
right_icon = Gtk.Image.new_from_stock(Gtk.STOCK_JUSTIFY_RIGHT,
Gtk.IconSize.BUTTON)
self.left_align.set_image(left_icon)
self.center_align.set_image(center_icon)
self.right_align.set_image(right_icon)
self.left_align.set_mode(False)
self.center_align.set_mode(False)
self.right_align.set_mode(False)
self.left_align.connect("clicked", self._edit_value_changed)
self.center_align.connect("clicked", self._edit_value_changed)
self.right_align.connect("clicked", self._edit_value_changed)
self.color_button = Gtk.ColorButton.new_with_rgba(
Gdk.RGBA(red=1.0, green=1.0, blue=1.0, alpha=1.0))
self.color_button.connect("color-set", self._edit_value_changed)
buttons_box = Gtk.HBox()
buttons_box.pack_start(Gtk.Label(), True, True, 0)
buttons_box.pack_start(self.bold_font, False, False, 0)
buttons_box.pack_start(self.italic_font, False, False, 0)
buttons_box.pack_start(guiutils.pad_label(5, 5), False, False, 0)
buttons_box.pack_start(self.left_align, False, False, 0)
buttons_box.pack_start(self.center_align, False, False, 0)
buttons_box.pack_start(self.right_align, False, False, 0)
buttons_box.pack_start(guiutils.pad_label(5, 5), False, False, 0)
buttons_box.pack_start(self.color_button, False, False, 0)
buttons_box.pack_start(Gtk.Label(), True, True, 0)
load_layers = Gtk.Button(_("Load Layers"))
load_layers.connect("clicked", lambda w: self._load_layers_pressed())
save_layers = Gtk.Button(_("Save Layers"))
save_layers.connect("clicked", lambda w: self._save_layers_pressed())
clear_layers = Gtk.Button(_("Clear All"))
clear_layers.connect("clicked", lambda w: self._clear_layers_pressed())
layers_save_buttons_row = Gtk.HBox()
layers_save_buttons_row.pack_start(save_layers, False, False, 0)
layers_save_buttons_row.pack_start(load_layers, False, False, 0)
layers_save_buttons_row.pack_start(Gtk.Label(), True, True, 0)
adj = Gtk.Adjustment(float(0), float(0), float(3000), float(1))
self.x_pos_spin = Gtk.SpinButton()
self.x_pos_spin.set_adjustment(adj)
self.x_pos_spin.connect("changed", self._position_value_changed)
self.x_pos_spin.connect("key-press-event", self._key_pressed_on_widget)
adj = Gtk.Adjustment(float(0), float(0), float(3000), float(1))
self.y_pos_spin = Gtk.SpinButton()
self.y_pos_spin.set_adjustment(adj)
self.y_pos_spin.connect("changed", self._position_value_changed)
self.y_pos_spin.connect("key-press-event", self._key_pressed_on_widget)
adj = Gtk.Adjustment(float(0), float(0), float(3000), float(1))
self.rotation_spin = Gtk.SpinButton()
self.rotation_spin.set_adjustment(adj)
self.rotation_spin.connect("changed", self._position_value_changed)
self.rotation_spin.connect("key-press-event",
self._key_pressed_on_widget)
undo_pos = Gtk.Button()
undo_icon = Gtk.Image.new_from_stock(Gtk.STOCK_UNDO,
Gtk.IconSize.BUTTON)
undo_pos.set_image(undo_icon)
next_icon = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"next_frame_s.png")
prev_icon = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"prev_frame_s.png")
prev_frame = Gtk.Button()
prev_frame.set_image(prev_icon)
prev_frame.connect("clicked", lambda w: self._prev_frame_pressed())
next_frame = Gtk.Button()
next_frame.set_image(next_icon)
next_frame.connect("clicked", lambda w: self._next_frame_pressed())
self.scale_selector = vieweditor.ScaleSelector(self)
timeline_box = Gtk.HBox()
timeline_box.pack_start(self.tc_display.widget, False, False, 0)
timeline_box.pack_start(guiutils.pad_label(12, 12), False, False, 0)
timeline_box.pack_start(pos_bar_frame, True, True, 0)
timeline_box.pack_start(guiutils.pad_label(12, 12), False, False, 0)
timeline_box.pack_start(prev_frame, False, False, 0)
timeline_box.pack_start(next_frame, False, False, 0)
timeline_box.pack_start(self.guides_toggle, False, False, 0)
timeline_box.pack_start(self.scale_selector, False, False, 0)
timeline_box.set_margin_top(6)
timeline_box.set_margin_bottom(6)
positions_box = Gtk.HBox()
positions_box.pack_start(Gtk.Label(), True, True, 0)
positions_box.pack_start(Gtk.Label(label="X:"), False, False, 0)
positions_box.pack_start(self.x_pos_spin, False, False, 0)
positions_box.pack_start(guiutils.pad_label(40, 5), False, False, 0)
positions_box.pack_start(Gtk.Label(label="Y:"), False, False, 0)
positions_box.pack_start(self.y_pos_spin, False, False, 0)
#positions_box.pack_start(Gtk.Label(label=_("Angle")), False, False, 0)
#positions_box.pack_start(self.rotation_spin, False, False, 0)
positions_box.pack_start(guiutils.pad_label(40, 5), False, False, 0)
positions_box.pack_start(center_h, False, False, 0)
positions_box.pack_start(center_v, False, False, 0)
positions_box.pack_start(Gtk.Label(), True, True, 0)
controls_panel_1 = Gtk.VBox()
controls_panel_1.pack_start(add_del_box, False, False, 0)
controls_panel_1.pack_start(self.layer_list, False, False, 0)
controls_panel_1.pack_start(layers_save_buttons_row, False, False, 0)
controls_panel_2 = Gtk.VBox()
controls_panel_2.pack_start(scroll_frame, True, True, 0)
controls_panel_2.pack_start(font_main_row, False, False, 0)
controls_panel_2.pack_start(buttons_box, False, False, 0)
controls_panel = Gtk.VBox()
controls_panel.pack_start(
guiutils.get_named_frame(_("Active Layer"), controls_panel_2),
True, True, 0)
controls_panel.pack_start(
guiutils.get_named_frame(_("Layers"), controls_panel_1), False,
False, 0)
view_editor_editor_buttons_row = Gtk.HBox()
view_editor_editor_buttons_row.pack_start(positions_box, False, False,
0)
view_editor_editor_buttons_row.pack_start(Gtk.Label(), True, True, 0)
keep_label = Gtk.Label(label=_("Keep Layers When Closed"))
self.keep_layers_check = Gtk.CheckButton()
self.keep_layers_check.set_active(_keep_titler_data)
self.keep_layers_check.connect("toggled", self._keep_layers_toggled)
open_label = Gtk.Label(label=_("Open Saved Title In Bin"))
self.open_in_current_check = Gtk.CheckButton()
self.open_in_current_check.set_active(_open_saved_in_bin)
self.open_in_current_check.connect("toggled", self._open_saved_in_bin)
exit_b = guiutils.get_sized_button(_("Close"), 150, 32)
exit_b.connect("clicked", lambda w: close_titler())
save_titles_b = guiutils.get_sized_button(_("Save Title Graphic"), 150,
32)
save_titles_b.connect("clicked", lambda w: self._save_title_pressed())
editor_buttons_row = Gtk.HBox()
editor_buttons_row.pack_start(Gtk.Label(), True, True, 0)
editor_buttons_row.pack_start(keep_label, False, False, 0)
editor_buttons_row.pack_start(self.keep_layers_check, False, False, 0)
editor_buttons_row.pack_start(guiutils.pad_label(24, 2), False, False,
0)
editor_buttons_row.pack_start(open_label, False, False, 0)
editor_buttons_row.pack_start(self.open_in_current_check, False, False,
0)
editor_buttons_row.pack_start(guiutils.pad_label(24, 2), False, False,
0)
editor_buttons_row.pack_start(exit_b, False, False, 0)
editor_buttons_row.pack_start(save_titles_b, False, False, 0)
editor_panel = Gtk.VBox()
editor_panel.pack_start(self.view_editor, True, True, 0)
editor_panel.pack_start(timeline_box, False, False, 0)
editor_panel.pack_start(
guiutils.get_in_centering_alignment(
view_editor_editor_buttons_row), False, False, 0)
editor_panel.pack_start(guiutils.pad_label(2, 24), True, True, 0)
editor_panel.pack_start(editor_buttons_row, False, False, 0)
editor_row = Gtk.HBox()
editor_row.pack_start(controls_panel, False, False, 0)
editor_row.pack_start(editor_panel, True, True, 0)
alignment = guiutils.set_margins(editor_row, 8, 8, 8, 8)
self.add(alignment)
self.layer_list.fill_data_model()
self._update_gui_with_active_layer_data()
self.show_all()
self.connect("size-allocate", lambda w, e: self.window_resized())
self.connect("window-state-event", lambda w, e: self.window_resized())
def insert_move_release(x, y, frame, state):
"""
User releases mouse when in insert move mode.
"""
global edit_data, drag_disabled
if drag_disabled:
drag_disabled = False
return
# If mouse was not pressed on clip we cant move anyhing
if edit_data == None:
return
# Get attempt insert frame
press_frame = edit_data["press_frame"]
first_clip_start = edit_data["first_clip_start"]
attempt_insert_frame = first_clip_start + (frame - press_frame)
# Get tracks and insert index
track = edit_data["track_object"]
to_track = edit_data["to_track_object"]
insert_index = to_track.get_clip_index_at(attempt_insert_frame)
# Check locking of target track. Source track checked at press event.
if _track_is_locked(to_track):
edit_data = None
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
return
# Update data for editmode overlay
edit_data["current_frame"] = frame
edit_data["insert_frame"] = track.clip_start(insert_index)
# Collect selection data
range_in = edit_data["selected_range_in"]
range_out = edit_data["selected_range_out"]
data = {"track":track,
"insert_index":insert_index,
"selected_range_in":range_in,
"selected_range_out":range_out,
"move_edit_done_func":move_edit_done}
# Do edit. Use different actions depending on if
# clip is moved to a differrent track
if track == to_track:
# Do edit if were moving and insert is not into same index
# Update selection after edit
if (edit_data["move_on"] == True
and (insert_index < selected_range_in
or insert_index > selected_range_out)):
# Remeber selected range to later find index of dropped range
# after edit
old_range_length = selected_range_out - selected_range_in
clear_selected_clips()
action = edit.insert_move_action(data)
action.do_edit()
# Move playback to first frame of dropped range
select_index = insert_index
if (range_in < insert_index):#when moving forward clips are removed affecting later indexes
select_index = insert_index - (old_range_length + 1)
PLAYER().seek_frame(track.clip_start(select_index), False)
else:
_move_mode_released()
else: # insert to different track
data["to_track"] = to_track
clear_selected_clips()
action = edit.multitrack_insert_move_action(data)
action.do_edit()
PLAYER().seek_frame(to_track.clip_start(insert_index), False)
# Clear edit mode data
edit_data = None
tlinewidgets.set_edit_mode_data(edit_data)
updater.repaint_tline()
def pos_bar_mouse_released(self, normalized_pos, length):
frame = int(normalized_pos * length)
PLAYER().seek_frame(frame)
self.show_current_frame()
def stop_pressed():
# This handles only move modes, see trimmodes.py module for others.
PLAYER().stop_playback()
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
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 __init__(self, kf_editor, property_editor_widgets_create_func,
value_labels
): # kf_editor is keyframeeditor.RotoMaskKeyFrameEditor
GObject.GObject.__init__(self)
self.set_modal(True)
self.set_transient_for(gui.editor_window.window)
self.set_title(_("RotoMaskEditor"))
self.connect("delete-event", lambda w, e: close_rotomask())
if editorstate.screen_size_small_height() == True:
global TEXT_LAYER_LIST_HEIGHT, TEXT_VIEW_HEIGHT, VIEW_EDITOR_HEIGHT
TEXT_LAYER_LIST_HEIGHT = 150
TEXT_VIEW_HEIGHT = 180
VIEW_EDITOR_HEIGHT = 450
if editorstate.screen_size_small_height() == True:
global VIEW_EDITOR_WIDTH
VIEW_EDITOR_WIDTH = 680
editor_widgets = property_editor_widgets_create_func()
self.block_updates = False
self.mask_create_freeze = False # We are not allowing user to change acrive kf when creating mask
self.kf_editor = kf_editor
self.kf_editor.set_parent_editor(self)
# mask type param was added later, we need handle it not existing.
if self.get_mask_type() == -1:
self.set_mask_type(vieweditorshape.LINE_MASK)
self.set_mask_type_on_init = False # but we don't want to destroy user's curve masks. THis is not complety back wards compatible stuff can get destroyed on second load.
else:
self.set_mask_type_on_init = True
self.value_labels = value_labels
self.view_editor = vieweditor.ViewEditor(PLAYER().profile,
VIEW_EDITOR_WIDTH,
VIEW_EDITOR_HEIGHT)
self.view_editor.draw_safe_area = False
self.tc_display = guicomponents.MonitorTCDisplay()
self.tc_display.use_internal_frame = True
self.tc_display.widget.set_valign(Gtk.Align.CENTER)
kf_mode_img = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"roto_kf_edit_mode.png")
move_mode_img = Gtk.Image.new_from_file(respaths.IMAGE_PATH +
"roto_move_mode.png")
self.kf_mode_button = Gtk.ToggleButton()
self.kf_mode_button.set_image(kf_mode_img)
self.kf_mode_button.set_active(
True) # we start with vieweditorlayer.ROTO_POINT_MODE edit mode
self.kf_mode_button.connect("clicked", self._kf_mode_clicked)
self.move_mode_button = Gtk.ToggleButton()
self.move_mode_button.set_image(move_mode_img)
self.move_mode_button.connect("clicked", self._move_mode_clicked)
self.scale_selector = vieweditor.ScaleSelector(self)
self.view_editor.scale_select = self.scale_selector
timeline_box = Gtk.HBox()
timeline_box.pack_start(self.tc_display.widget, False, False, 0)
timeline_box.pack_start(Gtk.Label(), True, True, 0)
timeline_box.pack_start(self.kf_mode_button, False, False, 0)
timeline_box.pack_start(self.move_mode_button, False, False, 0)
timeline_box.pack_start(Gtk.Label(), True, True, 0)
timeline_box.pack_start(self.scale_selector, False, False, 0)
timeline_box.set_margin_top(6)
timeline_box.set_margin_bottom(6)
mask_type_label = Gtk.Label(_("Mask Type:"))
mask_type_combo_box = Gtk.ComboBoxText()
mask_type_combo_box.append_text(_("Curve Mask"))
mask_type_combo_box.append_text(_("Line Mask"))
mask_type_combo_box.set_active(0)
mask_type_combo_box.connect("changed",
self.mask_type_selection_changed)
self.mask_type_combo_box = mask_type_combo_box
allow_adding_check = Gtk.CheckButton()
allow_adding_check.set_active(
False
) # This shows value of self.roto_mask_layer.allow_adding_points, False is default
allow_adding_check.connect("toggled", self.allow_adding_toggled)
allow_adding_label = Gtk.Label(
_("Allow to add / delete points in closed masks"))
save_rotodata_b = guiutils.get_sized_button(_("Close Tool"), 150, 32)
save_rotodata_b.connect("clicked",
lambda w: self._save_rotodata_pressed())
prop_editor_row1 = Gtk.HBox()
prop_editor_row1.pack_start(Gtk.Label(), True, True, 0)
prop_editor_row1.pack_start(mask_type_label, False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(4, 4), False, False, 0)
prop_editor_row1.pack_start(mask_type_combo_box, False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row1.pack_start(editor_widgets[0], False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row1.pack_start(editor_widgets[3], False, False, 0)
prop_editor_row1.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row1.pack_start(editor_widgets[4], False, False, 0)
prop_editor_row1.pack_start(Gtk.Label(), True, True, 0)
prop_editor_row2 = Gtk.HBox()
prop_editor_row2.pack_start(Gtk.Label(), True, True, 0)
prop_editor_row2.pack_start(editor_widgets[1], False, False, 0)
prop_editor_row2.pack_start(guiutils.pad_label(24, 20), False, False,
0)
prop_editor_row2.pack_start(editor_widgets[2], False, False, 0)
prop_editor_row2.pack_start(Gtk.Label(), True, True, 0)
editor_buttons_row = Gtk.HBox()
editor_buttons_row.pack_start(allow_adding_check, False, False, 0)
editor_buttons_row.pack_start(guiutils.pad_label(4, 2), False, False,
0)
editor_buttons_row.pack_start(allow_adding_label, False, False, 0)
editor_buttons_row.pack_start(Gtk.Label(), True, True, 0)
editor_buttons_row.pack_start(save_rotodata_b, False, False, 0)
editor_panel = Gtk.VBox()
editor_panel.pack_start(self.view_editor, True, True, 0)
editor_panel.pack_start(timeline_box, False, False, 0)
editor_panel.pack_start(kf_editor, False, False, 0)
editor_panel.pack_start(guiutils.pad_label(2, 12), False, False, 0)
editor_panel.pack_start(prop_editor_row1, False, False, 0)
editor_panel.pack_start(guiutils.pad_label(2, 12), False, False, 0)
editor_panel.pack_start(prop_editor_row2, False, False, 0)
editor_panel.pack_start(guiutils.pad_label(2, 12), False, False, 0)
editor_panel.pack_start(editor_buttons_row, False, False, 0)
editor_row = Gtk.HBox()
editor_row.pack_start(editor_panel, True, True, 0)
alignment = guiutils.set_margins(editor_row, 8, 8, 8, 8)
self.add(alignment)
self.view_editor.clear_layers()
# NOTE: we start with vieweditorlayer.ROTO_POINT_MODE edit mode, see __init()__
self.roto_mask_layer = vieweditorlayer.RotoMaskEditLayer(
self.view_editor, self.kf_editor.clip_editor,
kf_editor.editable_property, self)
self.view_editor.add_layer(self.roto_mask_layer)
self.view_editor.activate_layer(0)
self.show_all()
self.kf_editor.active_keyframe_changed()
self.connect("size-allocate", lambda w, e: self.window_resized())
self.connect("window-state-event", lambda w, e: self.window_resized())
self.connect("key-press-event", self.key_down)
self.window_resized()
self.kf_editor.clip_editor.maybe_set_first_kf_in_clip_area_active()
self.update_mask_create_freeze_gui()
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 seek_tline_frame(self, clip_frame):
PLAYER().seek_frame(self.clip_tline_pos + clip_frame - self.clip_in)
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)
_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
"""
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_clip_in_monitor(clip_monitor_currently_active=False):
"""
Sets mltplayer producer to be video file clip and updates GUI.
"""
if MONITOR_MEDIA_FILE() == None:
gui.editor_window.clip_editor_b.set_active(False)
return
global save_monitor_frame
save_monitor_frame = True
# Opening clip exits trim modes
if not editorstate.current_is_move_mode():
set_clip_edit_mode_callback()
gui.clip_editor_b.set_sensitive(True)
editorstate._timeline_displayed = False
# Save timeline pos if so directed.
if clip_monitor_currently_active == False:
global saved_timeline_pos
saved_timeline_pos = PLAYER().current_frame()
editorstate.tline_shadow_frame = saved_timeline_pos
# If we're already displaying monitor clip we stop consumer
# to supress timeline flashing between monitor clips
if clip_monitor_currently_active == False:
editorstate.PLAYER().consumer.stop()
# Clear old clip
current_sequence().clear_hidden_track()
# Create and display clip on hidden track
if MONITOR_MEDIA_FILE(
).type == appconsts.PATTERN_PRODUCER or MONITOR_MEDIA_FILE(
).type == appconsts.IMAGE_SEQUENCE:
# pattern producer or image sequence
clip_producer = current_sequence().display_monitor_clip(
None, MONITOR_MEDIA_FILE())
else:
# File producers
clip_producer = current_sequence().display_monitor_clip(
MONITOR_MEDIA_FILE().path)
# Timeline flash does not happen if we start consumer after monitor clip is
# already on sequence
if clip_monitor_currently_active == False:
editorstate.PLAYER().consumer.start()
# IMAGE_SEQUENCE files always returns 15000 for get_length from mlt so we have to monkeypatch that method to get correct results
if MONITOR_MEDIA_FILE().type == appconsts.IMAGE_SEQUENCE:
clip_producer.get_length = lambda: MONITOR_MEDIA_FILE().length
clip_producer.mark_in = MONITOR_MEDIA_FILE().mark_in
clip_producer.mark_out = MONITOR_MEDIA_FILE().mark_out
# Give IMAGE and PATTERN_PRODUCER media types default mark in and mark out if not already set.
# This makes them reasonably short and trimmable in both directions.
if clip_producer.media_type == appconsts.IMAGE or clip_producer.media_type == appconsts.PATTERN_PRODUCER:
if clip_producer.mark_in == -1 and clip_producer.mark_out == -1:
center_frame = clip_producer.get_length() / 2
default_length_half = 75
mark_in = center_frame - default_length_half
mark_out = center_frame + default_length_half - 1
clip_producer.mark_in = mark_in
clip_producer.mark_out = mark_out
MONITOR_MEDIA_FILE().mark_in = mark_in
MONITOR_MEDIA_FILE().mark_out = mark_out
# Display frame, marks and pos
gui.pos_bar.update_display_from_producer(clip_producer)
display_monitor_clip_name()
if MONITOR_MEDIA_FILE().type == appconsts.IMAGE or \
MONITOR_MEDIA_FILE().type == appconsts.PATTERN_PRODUCER:
PLAYER().seek_frame(0)
else:
if editorpersistance.prefs.remember_monitor_clip_frame:
PLAYER().seek_frame(MONITOR_MEDIA_FILE().current_frame)
else:
PLAYER().seek_frame(0)
display_marks_tc()
gui.pos_bar.widget.grab_focus()
gui.media_list_view.widget.queue_draw()
if editorpersistance.prefs.auto_play_in_clip_monitor == True:
PLAYER().start_playback()
repaint_tline()
def slide_stop_pressed():
PLAYER().stop_loop_playback(trim_looping_stopped)
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 oneroll_play_pressed():
# Start trim preview playback loop
current_sequence().hide_hidden_clips()
PLAYER().start_loop_playback(edit_data["edit_frame"], loop_half_length,
edit_data["track_object"].get_length())
def slide_trim_move(x, y, frame, state):
if mouse_disabled:
return
display_frame = _update_slide_trim_for_mouse_frame(frame)
PLAYER().seek_frame(display_frame)
