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)