Esempio n. 1
0
 def _oor_menu_item_activated(self, widget, data):
     if data == "delete_all_before":
         keep_doing = True
         while keep_doing:
             try:
                 frame, value = self.keyframes[1]
                 if frame < self.clip_in:
                     self.keyframes.pop(1)
                 else:
                     keep_doing = False 
             except:
                 keep_doing = False
     
     elif data == "delete_all_but_last_after":
     
         keep_doing = True
         index = 1
         while keep_doing:
             try:
                 frame, value = self.keyframes[index]
                 if frame > self.clip_in + self.clip_length and index < (len(self.keyframes) - 1):
                     self.keyframes.pop(index)
                 else:
                     index += 1
             except:
                 keep_doing = False
                 
     elif data == "zero_next":
         frame_zero, frame_zero_value = self.keyframes[0]
         frame, value = self.keyframes[1]
         self.keyframes.pop(0)
         self.keyframes.insert(0, (frame_zero, value))
         self.update_property_value()
     elif data == "delete_all_after":
         delete_done = False
         for i in range(0, len(self.keyframes)):
             frame, value = self.keyframes[i]
             if frame > self.clip_in + self.clip_length:
                 self.keyframes.pop(i)
                 popped = True
                 while popped:
                     try:
                         self.keyframes.pop(i)
                     except:
                         popped = False
                 delete_done = True
             if delete_done:
                 break
     elif data == "edit_brightness":
         init_tool_for_clip(edit_data["clip"] , edit_data["track"], BRIGHTNESS_KF_EDIT)
     elif data == "edit_volume":
         init_tool_for_clip(edit_data["clip"] , edit_data["track"], VOLUME_KF_EDIT)
     elif data == "exit":
         _set_no_clip_edit_data()
     elif data == "playhead_follows":
         global _playhead_follow_kf
         _playhead_follow_kf = widget.get_active()
         
         
     updater.repaint_tline()
Esempio n. 2
0
def exit_tool():
    _set_no_clip_edit_data()
    global enter_mode
    if enter_mode != None:
        gui.editor_window.kf_tool_exit_to_mode(enter_mode)
        enter_mode = None
    updater.repaint_tline()
Esempio n. 3
0
def set_waveform_displayer_clip_from_popup(data):
    clip, track, item_id, item_data = data

    global frames_cache
    if clip.path in frames_cache:
        frame_levels = frames_cache[clip.path]
        clip.waveform_data = frame_levels
        updater.repaint_tline()
        return

    cache_file_path = userfolders.get_cache_dir() + appconsts.AUDIO_LEVELS_DIR + _get_unique_name_for_media(clip.path)
    if os.path.isfile(cache_file_path):
        f = open(cache_file_path)
        frame_levels = pickle.load(f)
        frames_cache[clip.path] = frame_levels
        clip.waveform_data = frame_levels
        updater.repaint_tline()
        return

    progress_bar = Gtk.ProgressBar()
    title = _("Audio Levels Data Render")
    text = "<b>Media File: </b>" + clip.path
    dialog = _waveform_render_progress_dialog(_waveform_render_abort, title, text, progress_bar, gui.editor_window.window)
    dialog.progress_bar = progress_bar
    
    global waveform_thread
    waveform_thread = WaveformCreator(clip, track.height, dialog)
    waveform_thread.start()
Esempio n. 4
0
    def spin_value_changed(self, spin):
        if self.editable_property.clip.transition.info.name == "##auto_fade_in":
            self.editable_property.clip.set_length_from_in(int(spin.get_value()))
        else:
            self.editable_property.clip.set_length_from_out(int(spin.get_value()))

        updater.repaint_tline()
Esempio n. 5
0
def set_track_normal_height(track_index, is_retry=False):
    track = get_track(track_index)
    track.height = appconsts.TRACK_HEIGHT_NORMAL

    # Check that new height tracks can be displayed and cancel if not.
    new_h = current_sequence().get_tracks_height()
    allocation = gui.tline_canvas.widget.get_allocation()
    x, y, w, h = allocation.x, allocation.y, allocation.width, allocation.height

    if new_h > h and is_retry == False:
        current_paned_pos = gui.editor_window.app_v_paned.get_position()
        new_paned_pos = current_paned_pos - (new_h - h) - 5
        gui.editor_window.app_v_paned.set_position(new_paned_pos)
        GObject.timeout_add(200, lambda: set_track_normal_height(track_index, True))
        return False
    
    allocation = gui.tline_canvas.widget.get_allocation()
    x, y, w, h = allocation.x, allocation.y, allocation.width, allocation.height
    
    if new_h > h:
        track.height = appconsts.TRACK_HEIGHT_SMALL
        dialogutils.warning_message(_("Not enough vertical space on Timeline to expand track"), 
                                _("Maximize or resize application window to get more\nspace for tracks if possible."),
                                gui.editor_window.window,
                                True)
        return False

    tlinewidgets.set_ref_line_y(gui.tline_canvas.widget.get_allocation())
    gui.tline_column.init_listeners()
    updater.repaint_tline()

    return False
Esempio n. 6
0
def _add_autofade(data):
    clip, track, item_id, item_data = data
    x, compositor_type = item_data

    frame = tlinewidgets.get_frame(x)
    clip_index = track.get_clip_index_at(frame)

    target_track_index = track.id - 1

    clip_length = clip.clip_out - clip.clip_in
    if compositor_type == "##auto_fade_in":
        compositor_in = current_sequence().tracks[track.id].clip_start(clip_index)
        compositor_out = compositor_in + int(utils.fps()) - 1
    else:
        clip_start = current_sequence().tracks[track.id].clip_start(clip_index)
        compositor_out = clip_start + clip_length
        compositor_in = compositor_out - int(utils.fps()) + 1

    edit_data = {"origin_clip_id":clip.id,
                "in_frame":compositor_in,
                "out_frame":compositor_out,
                "a_track":target_track_index,
                "b_track":track.id,
                "compositor_type":compositor_type,
                "clip":clip}
    action = edit.add_compositor_action(edit_data)
    action.do_edit()
    
    updater.repaint_tline()
Esempio n. 7
0
def _exit_clip_end_drag():
    # Go back to enter mode
    editorstate.edit_mode = _enter_mode
    tlinewidgets.set_edit_mode(None, _enter_draw_func)

    gui.editor_window.set_cursor_to_mode()
    updater.repaint_tline()
Esempio n. 8
0
def splice_out_button_pressed():
    """
    Removes 1 - n long continuous clip range from track and closes
    the created gap.
    """
    if movemodes.selected_track == -1:
        return

    # Edit consumes selection, so clear selected from clips
    movemodes.set_range_selection(movemodes.selected_track,
                                  movemodes.selected_range_in,
                                  movemodes.selected_range_out,
                                  False)
    
    track = get_track(movemodes.selected_track)

    if editevent.track_lock_check_and_user_info(track, splice_out_button_pressed, "splice out"):
        movemodes.clear_selection_values()
        return

    data = {"track":track,
            "from_index":movemodes.selected_range_in,
            "to_index":movemodes.selected_range_out}
    edit_action = edit.remove_multiple_action(data)
    edit_action.do_edit()

    # Nothing is selected after edit
    movemodes.clear_selection_values()

    updater.repaint_tline()
Esempio n. 9
0
def lift_button_pressed():
    """
    Removes 1 - n long continuous clip range from track and fills
    the created gap with a black clip
    """
    if movemodes.selected_track == -1:
        return

    # Edit consumes selection, set clips seletion attr to false
    movemodes.set_range_selection(movemodes.selected_track, 
                                  movemodes.selected_range_in,
                                  movemodes.selected_range_out, 
                                  False)
                         
    track = get_track(movemodes.selected_track)

    if editevent.track_lock_check_and_user_info(track, lift_button_pressed, "lift"):
        movemodes.clear_selection_values()
        return

    data = {"track":track,
            "from_index":movemodes.selected_range_in,
            "to_index":movemodes.selected_range_out}
    edit_action = edit.lift_multiple_action(data)
    edit_action.do_edit()

    # Nothing is left selected after edit
    movemodes.clear_selection_values()

    updater.repaint_tline()
Esempio n. 10
0
def delete_effect_pressed():
    if len(clip.filters) == 0:
        return

    # Block updates until we have set selected row
    global edit_effect_update_blocked
    edit_effect_update_blocked = True

    treeselection = widgets.effect_stack_view.treeview.get_selection()
    (model, rows) = treeselection.get_selected_rows()
    
    try:
        row = rows[0]
    except:
        return # This fails when there are filters but no rows are selected
        
    row_index = max(row)
    data = {"clip":clip,
            "index":row_index,
            "filter_edit_done_func":filter_edit_done}
    action = edit.remove_filter_action(data)
    action.do_edit()

    updater.repaint_tline()

    # Set last filter selected and display in editor
    edit_effect_update_blocked = False
    if len(clip.filters) == 0:
        return
    path = str(len(clip.filters) - 1)
    # Causes edit_effect_selected() called as it is the "change" listener
    widgets.effect_stack_view.treeview.get_selection().select_path(path)
Esempio n. 11
0
def overwrite_move_move(x, y, frame, state):
    """
    User moves mouse when in overwrite move mode.
    """
    global edit_data, drag_disabled    
    if drag_disabled:
        return 
    if edit_data == None:
        return

    _move_mode_move(frame, x, y)

    # Calculate overwrite area if moving
    if edit_data["move_on"] == True:
        # get in point
        over_in = edit_data["attempt_insert_frame"]
        
        # Check and do magnet
        cut_x = tlinewidgets._get_frame_x(edit_data["insert_frame"])
        clip_head_x = tlinewidgets._get_frame_x(edit_data["attempt_insert_frame"])
        if abs(clip_head_x - cut_x) < MAGNETIC_AREA_IN_PIX:
            over_in = edit_data["insert_frame"]

        over_out = over_in + edit_data["moving_length"] 

        edit_data["over_in"] = over_in
        edit_data["over_out"] = over_out

    updater.repaint_tline()
Esempio n. 12
0
    def motion_notify_event(self, x, y, state):
        """
        Mouse move callback
        """
        lx = self._legalize_x(x)
        ly = self._legalize_y(y)

        if abs(self.mouse_start_y - ly) > DRAG_MIN_Y:
            self.value_drag_on = True

        self.mouse_x = lx
        self.mouse_y = ly
        
        if self.current_mouse_action == POSITION_DRAG:
            frame = self._get_drag_frame(lx)
            self.current_clip_frame = frame
            self.clip_editor_frame_changed(self.current_clip_frame)
            updater.repaint_tline()
        elif self.current_mouse_action == KF_DRAG or self.current_mouse_action == KF_DRAG_FRAME_ZERO_KF:
            frame = self._get_drag_frame(lx)
            if self.current_mouse_action == KF_DRAG_FRAME_ZERO_KF:
                frame = 0
            if self.value_drag_on == True:
                value = round(self._get_value_for_panel_y(ly))
                self.edit_value = value
                self.set_active_kf_frame_and_value(frame, value)
            else:
                self.set_active_kf_frame_and_value(frame, self.edit_value)
            if _playhead_follow_kf == True:
                self.current_clip_frame = frame
                self.clip_editor_frame_changed(self.current_clip_frame)

        updater.repaint_tline()
Esempio n. 13
0
def mouse_press(event, frame):
    track = current_sequence().tracks[compositor.transition.b_track - 1]

    global edit_data, sub_mode
    
    compositor_y = tlinewidgets._get_track_y(track.id) - tlinewidgets.COMPOSITOR_HEIGHT_OFF
    
    if abs(event.x - tlinewidgets._get_frame_x(compositor.clip_in)) < TRIM_HANDLE_WIDTH:
        edit_data = {"clip_in":compositor.clip_in,
                     "clip_out":compositor.clip_out,
                     "trim_is_clip_in":True,
                     "compositor_y":  compositor_y,
                     "compositor": compositor}
        tlinewidgets.set_edit_mode(edit_data, tlinewidgets.draw_compositor_trim)
        sub_mode = TRIM_EDIT
    elif abs(event.x - tlinewidgets._get_frame_x(compositor.clip_out + 1)) < TRIM_HANDLE_WIDTH:
        edit_data = {"clip_in":compositor.clip_in,
                     "clip_out":compositor.clip_out,
                     "trim_is_clip_in":False,
                     "compositor_y": compositor_y,
                     "compositor": compositor}
        tlinewidgets.set_edit_mode(edit_data, tlinewidgets.draw_compositor_trim)
        sub_mode = TRIM_EDIT
    else:
        edit_data = {"press_frame":frame,
                     "current_frame":frame,
                     "clip_in":compositor.clip_in,
                     "clip_length":(compositor.clip_out - compositor.clip_in + 1),
                     "compositor_y": compositor_y,
                     "compositor": compositor}
        tlinewidgets.set_edit_mode(edit_data, tlinewidgets.draw_compositor_move_overlay)
        sub_mode = MOVE_EDIT
    updater.repaint_tline()
Esempio n. 14
0
def _audio_levels_item_activated(widget, msg):
    if msg == "all":
        editorstate.display_all_audio_levels = True
        updater.repaint_tline()
    else:
        editorstate.display_all_audio_levels = False
        current_sequence().drop_audio_levels()
        updater.repaint_tline()
Esempio n. 15
0
def mouse_move(x, y, frame, state):
    if mouse_disabled:
        return

    global edit_data
    edit_data["current_frame"] = frame

    updater.repaint_tline()
Esempio n. 16
0
def mouse_move(x, y, frame, state):
    global edit_data
    if sub_mode == TRIM_EDIT:
        _bounds_check_trim(frame, edit_data)
    else:
        edit_data["current_frame"] = frame

    updater.repaint_tline()
Esempio n. 17
0
def _exit_clip_end_drag(): 
    # Go back to enter mode
    editorstate.edit_mode = _enter_mode
    tlinewidgets.set_edit_mode(None, _enter_draw_func)
    tlinewidgets.pointer_context = appconsts.POINTER_CONTEXT_NONE
    
    gui.editor_window.set_cursor_to_mode()
    updater.repaint_tline()
Esempio n. 18
0
def resync_everything():
    # Selection not valid after resync action
    if movemodes.selected_track == -1:
        movemodes.clear_selected_clips()
    
    action = edit.resync_all_action({})
    action.do_edit()
    
    updater.repaint_tline()
Esempio n. 19
0
def _exit_to_overwrite():
    # If we entered box mode from overwite mode empty click, this is used to enter back into overwrite mode.
    global entered_from_overwrite
    entered_from_overwrite = False
    editorstate.overwrite_mode_box = False
    tlinewidgets.set_edit_mode_data(None)
    gui.editor_window.set_cursor_to_mode() # This gets set wrong in editevent.tline_canvas_mouse_released() and were putting it back here, 
                                           # this could be investigated for better solution, this could cause a cursor flash, but on dev system we're not getting it.
    updater.repaint_tline()
Esempio n. 20
0
def resync_clip(popup_data):
    clip, track, item_id, x = popup_data
    clip_list=[(clip, track)]
    
    data = {"clips":clip_list}
    action = edit.resync_some_clips_action(data)
    action.do_edit()
    
    updater.repaint_tline()
Esempio n. 21
0
def multi_mode_pressed():
    stop_looping()
    current_sequence().clear_hidden_track()

    editorstate.edit_mode = editorstate.MULTI_MOVE
    tlinewidgets.set_edit_mode(None, tlinewidgets.draw_multi_overlay)
    
    updater.set_move_mode_gui()
    updater.repaint_tline()
Esempio n. 22
0
def set_track_small_height(track_index):
    track = get_track(track_index)
    track.height = appconsts.TRACK_HEIGHT_SMALL
    if editorstate.SCREEN_HEIGHT < 863:
        track.height = appconsts.TRACK_HEIGHT_SMALLEST
    
    tlinewidgets.set_ref_line_y(gui.tline_canvas.widget.get_allocation())
    gui.tline_column.init_listeners()
    updater.repaint_tline()
Esempio n. 23
0
def enter_pressed():
    # With Enter key we enter keyboard trim on current pointer context
    x = editorstate.last_mouse_x
    y = editorstate.last_mouse_y
    frame = tlinewidgets.get_frame(x)
    
    _enter_trim_mode_edit(x, y, frame)
    trimmodes.submode = trimmodes.KEYB_EDIT_ON
    updater.repaint_tline()
Esempio n. 24
0
def init_sequence_gui():
    """
    Called after project load or changing current sequence 
    to initialize interface.
    """
    # Set initial timeline scale draw params
    editorstate.current_sequence().update_length()
    updater.update_pix_per_frame_full_view()
    updater.init_tline_scale()
    updater.repaint_tline()
Esempio n. 25
0
def cut_single_track(event, frame):
    track = tlinewidgets.get_track(event.y)
    data = get_cut_data(track, frame)
    if data == None:
        return

    action = edit.cut_action(data)
    action.do_edit()

    updater.repaint_tline()
Esempio n. 26
0
def add_currently_selected_effect():
    # Check we have clip
    if clip == None:
        return
    
    filter_info = get_selected_filter_info()
    action = get_filter_add_action(filter_info, clip)
    action.do_edit() # gui update in callback from EditAction object.
    
    updater.repaint_tline()
Esempio n. 27
0
def cut_all_tracks(frame):
    tracks_cut_data = []

    for i in range(1, len(current_sequence().tracks) - 1):
        tracks_cut_data.append(get_cut_data(current_sequence().tracks[i], frame))

    data = {"tracks_cut_data":tracks_cut_data}
    action = edit.cut_all_action(data)
    action.do_edit()

    updater.repaint_tline()
Esempio n. 28
0
    def run(self):
        global frames_cache
        frame_levels = [None] * self.clip_media_length 
        frames_cache[self.clip.path] = frame_levels

        Gdk.threads_enter()
        self.dialog.progress_bar.set_fraction(0.0)
        self.dialog.progress_bar.set_text(str(0) + "%")
        while(Gtk.events_pending()):
            Gtk.main_iteration()
        Gdk.threads_leave()
        time.sleep(0.2)

        for frame in range(0, len(frame_levels)):
            if self.abort:
                break
            self.temp_clip.seek(frame)
            mlt.frame_get_waveform(self.temp_clip.get_frame(), 10, 50)
            val = self.levels.get(RIGHT_CHANNEL)
            if val == None:
                val = 0.0
            frame_levels[frame] = float(val)
            self.last_rendered_frame = frame
            if frame % 500 == 0:
                render_fraction = float(self.last_rendered_frame) / float(self.clip_media_length)
                Gdk.threads_enter()
                self.dialog.progress_bar.set_fraction(render_fraction)
                pros = int(render_fraction * 100)
                self.dialog.progress_bar.set_text(str(pros) + "%")
                while(Gtk.events_pending()):
                    Gtk.main_iteration()
                Gdk.threads_leave()
                time.sleep(0.1)

        if not self.abort:
            self.clip.waveform_data = frame_levels
            write_file = file(self.file_cache_path, "wb")
            pickle.dump(frame_levels, write_file)

            Gdk.threads_enter()
            self.dialog.progress_bar.set_fraction(1.0)
            self.dialog.progress_bar.set_text(_("Saving to Hard Drive"))
            Gdk.threads_leave()
        
        else:
            frames_cache.pop(self.clip.path, None)

        updater.repaint_tline()

        # Set thread ref to None to flag that no waveforms are being created
        global waveform_thread
        waveform_thread = None
        
        _waveform_render_stop(self.dialog, None)
Esempio n. 29
0
 def delete_active_keyframe(self):
     if self.active_kf_index == 0:
         # keyframe frame 0 cannot be removed
         return
     self.keyframes.pop(self.active_kf_index)
     self.active_kf_index -= 1
     if self.active_kf_index < 0:
         self.active_kf_index = 0
     self._set_pos_to_active_kf()
 
     updater.repaint_tline()
Esempio n. 30
0
 def run(self):
     # Launch render process and wait for it to end
     FLOG = open(utils.get_hidden_user_dir_path() + "log_audio_levels_render", 'w')
     process = subprocess.Popen([sys.executable, respaths.LAUNCH_DIR + "flowbladeaudiorender", \
               self.rendered_media, self.profile_desc, respaths.ROOT_PATH], \
               stdin=FLOG, stdout=FLOG, stderr=FLOG)
     process.wait()
     
     Gdk.threads_enter()
     updater.repaint_tline()
     Gdk.threads_leave()
Esempio n. 31
0
def clear_filters():
    if movemodes.selected_track == -1:
        return

    track = get_track(movemodes.selected_track)
    clips = []
    for i in range(movemodes.selected_range_in,
                   movemodes.selected_range_out + 1):
        clips.append(track.clips[i])

    data = {"clips": clips}
    action = edit.remove_multiple_filters_action(data)
    action.do_edit()

    movemodes.clear_selected_clips()
    updater.repaint_tline()
Esempio n. 32
0
def _marker_add_dialog_callback(dialog, response_id, name_entry):
    name = name_entry.get_text()
    dialog.destroy()
    current_frame = PLAYER().current_frame()
    dupl_index = -1
    for i in range(0, len(current_sequence().markers)):
        marker_name, frame = current_sequence().markers[i]
        if frame == current_frame:
            dupl_index = i
    if dupl_index != -1:
        current_sequence().markers.pop(dupl_index)

    current_sequence().markers.append((name, current_frame))
    current_sequence().markers = sorted(current_sequence().markers,
                                        key=itemgetter(1))
    updater.repaint_tline()
Esempio n. 33
0
def clips_drag_out_started(event):
    # Abort move edit
    global edit_data, drag_disabled
    edit_data = None
    drag_disabled = True
    tlinewidgets.set_edit_mode_data(None)

    # Set dnd
    track = current_sequence().tracks[selected_track]
    clips = []
    for i in range(selected_range_in, selected_range_out + 1):
        clips.append(track.clips[i])
    dnd.start_tline_clips_out_drag(event, clips, gui.tline_canvas.widget)

    # Update tlione gui
    updater.repaint_tline()
Esempio n. 34
0
def mouse_press(event, frame):
    track = current_sequence().tracks[compositor.transition.b_track - 1]

    global edit_data, sub_mode

    compositor_y = tlinewidgets._get_track_y(
        track.id) - tlinewidgets.COMPOSITOR_HEIGHT_OFF

    if abs(event.x -
           tlinewidgets._get_frame_x(compositor.clip_in)) < TRIM_HANDLE_WIDTH:
        edit_data = {
            "clip_in": compositor.clip_in,
            "clip_out": compositor.clip_out,
            "trim_is_clip_in": True,
            "orig_clip_in": compositor.clip_in,
            "compositor_y": compositor_y,
            "compositor": compositor
        }
        tlinewidgets.set_edit_mode(edit_data,
                                   tlinewidgets.draw_compositor_trim)
        sub_mode = TRIM_EDIT
    elif abs(event.x - tlinewidgets._get_frame_x(compositor.clip_out +
                                                 1)) < TRIM_HANDLE_WIDTH:
        edit_data = {
            "clip_in": compositor.clip_in,
            "clip_out": compositor.clip_out,
            "trim_is_clip_in": False,
            "orig_clip_out": compositor.clip_out,
            "compositor_y": compositor_y,
            "compositor": compositor
        }
        tlinewidgets.set_edit_mode(edit_data,
                                   tlinewidgets.draw_compositor_trim)
        sub_mode = TRIM_EDIT
    else:
        edit_data = {
            "press_frame": frame,
            "current_frame": frame,
            "clip_in": compositor.clip_in,
            "clip_length": (compositor.clip_out - compositor.clip_in + 1),
            "compositor_y": compositor_y,
            "compositor": compositor
        }
        tlinewidgets.set_edit_mode(edit_data,
                                   tlinewidgets.draw_compositor_move_overlay)
        sub_mode = MOVE_EDIT
    updater.repaint_tline()
Esempio n. 35
0
def cut_single_track(event, frame):
    track = tlinewidgets.get_track(event.y)
    if track == None or track.id == 0 or track.id == len(
            current_sequence().tracks) - 1:
        return

    if dialogutils.track_lock_check_and_user_info(track):
        return

    data = get_cut_data(track, frame)
    if data == None:
        return

    action = edit.cut_action(data)
    action.do_edit()

    updater.repaint_tline()
Esempio n. 36
0
def _clip_marker_add_dialog_callback(dialog, response_id, name_entry, data):
    clip, track, clip_frame = data
    name = name_entry.get_text()
    dialog.destroy()

    # remove older on same frame
    dupl_index = -1
    for i in range(0, len(clip.markers)):
        marker_name, frame = clip.markers[i]
        if frame == clip_frame:
            dupl_index = i
    if dupl_index != -1:
        current_sequence().markers.pop(dupl_index)

    clip.markers.append((name, clip_frame))
    clip.markers = sorted(clip.markers, key=itemgetter(1))
    updater.repaint_tline()
Esempio n. 37
0
def mouse_release(x, y, frame, state):
    global sub_mode
    tlinewidgets.pointer_context = appconsts.POINTER_CONTEXT_NONE

    # Se we're only handling 3 editmodes here.
    editorstate.edit_mode = prev_edit_mode
    if editorstate.edit_mode == editorstate.INSERT_MOVE:
        tlinewidgets.set_edit_mode(None, tlinewidgets.draw_insert_overlay)
    elif editorstate.edit_mode == editorstate.OVERWRITE_MOVE:
        tlinewidgets.set_edit_mode(None, tlinewidgets.draw_overwrite_overlay)
    elif editorstate.edit_mode == editorstate.MULTI_MOVE:
        tlinewidgets.set_edit_mode(None, tlinewidgets.draw_multi_overlay)
    else:
        print("COMPOSITOR MODE EXIT PROBLEM at compositormodes.mouse_release")

    gui.editor_window.set_cursor_to_mode()

    if sub_mode == TRIM_EDIT:
        _bounds_check_trim(frame, edit_data)
        data = {
            "compositor": compositor,
            "clip_in": edit_data["clip_in"],
            "clip_out": edit_data["clip_out"]
        }
        action = edit.move_compositor_action(data)
        action.do_edit()
    else:
        press_frame = edit_data["press_frame"]
        current_frame = frame
        delta = current_frame - press_frame

        data = {
            "compositor": compositor,
            "clip_in": compositor.clip_in + delta,
            "clip_out": compositor.clip_out + delta
        }
        if data["clip_in"] < 0:
            data["clip_in"] = 0
        if data["clip_out"] < 0:
            data["clip_out"] = 0
        action = edit.move_compositor_action(data)
        action.do_edit()

    sub_mode = NO_COMPOSITOR_EDIT

    updater.repaint_tline()
Esempio n. 38
0
def delete_effect_pressed():
    if len(clip.filters) == 0:
        return

    # Block updates until we have set selected row
    global edit_effect_update_blocked
    edit_effect_update_blocked = True

    current_filter = clip.filters[current_filter_index]
    
    if current_filter.info.filter_mask_filter == "":
        # Regular filters
        data = {"clip":clip,
                "index":current_filter_index,
                "filter_edit_done_func":filter_edit_done}
        action = edit.remove_filter_action(data)
        action.do_edit()
    else:
        # Filter mask filters.
        index_1 = -1
        index_2 = -1
        for i in range(0, len(clip.filters)):
            f = clip.filters[i]
            if f.info.filter_mask_filter != "":
                if index_1 == -1:
                    index_1 = i
                else:
                    index_2 = i
        
        data = {"clip":clip,
                "index_1":index_1,
                "index_2":index_2,
                "filter_edit_done_func":filter_edit_done}
        action = edit.remove_two_filters_action(data)
        action.do_edit()
        
    updater.repaint_tline()

    # Set last filter selected and display in editor
    edit_effect_update_blocked = False
    if len(clip.filters) == 0:
        effect_selection_changed() # to display info text
        return
    path = str(len(clip.filters) - 1)
    # Causes edit_effect_selected() called as it is the "change" listener
    widgets.effect_stack_view.treeview.get_selection().select_path(path)
Esempio n. 39
0
def _clip_color(data):
    clip, track, item_id, clip_color = data
    if clip_color == "default":
        clip.color = None
    elif clip_color == "red":
        clip.color = (1, 0, 0)
    elif clip_color == "green":
        clip.color = (0, 1, 0)
    elif clip_color == "blue":
        clip.color = (0.2, 0.2, 0.9)
    elif clip_color == "orange":
        clip.color = (0.929, 0.545, 0.376)
    elif clip_color == "brown":
        clip.color = (0.521, 0.352, 0.317)
    elif clip_color == "olive":
        clip.color = (0.5, 0.55, 0.5)

    updater.repaint_tline()
Esempio n. 40
0
def set_track_normal_height(track_index):
    track = get_track(track_index)
    track.height = appconsts.TRACK_HEIGHT_NORMAL

    # Check that new height tracks can be displayed and cancel if not.
    new_h = current_sequence().get_tracks_height()
    x, y, w, h = gui.tline_canvas.widget.allocation
    if new_h > h:
        track.height = appconsts.TRACK_HEIGHT_SMALL
        dialogutils.warning_message(
            _("Not enough vertical space on Timeline to expand track"),
            _("Maximize or resize application window to get more\nspace for tracks if possible."
              ), gui.editor_window.window, True)
        return

    tlinewidgets.set_ref_line_y(gui.tline_canvas.widget.allocation)
    gui.tline_column.init_listeners()
    updater.repaint_tline()
Esempio n. 41
0
    def motion_notify_event(self, x, y, state):
        """
        Mouse move callback
        """
        lx = self._legalize_x(x)
        ly = self._legalize_y(y)

        if self.current_mouse_action == POSITION_DRAG:
            self._set_clip_frame(lx)
            self.clip_editor_frame_changed(self.current_clip_frame)
        elif self.current_mouse_action == KF_DRAG:
            frame = self._get_drag_frame(lx)
            value = self._get_value_for_panel_y(ly)
            self.set_active_kf_frame_and_value(frame, value)
            self.current_clip_frame = frame
            self.clip_editor_frame_changed(self.current_clip_frame)

        updater.repaint_tline()
Esempio n. 42
0
    def write_image(self):
        """
        Writes thumbnail image from file producer
        """
        clip_path = self.clip.path

        # Create consumer
        matchframe_new_path = userfolders.get_cache_dir() + appconsts.MATCH_FRAME_NEW
        consumer = mlt.Consumer(PROJECT().profile, "avformat", matchframe_new_path)
        consumer.set("real_time", 0)
        consumer.set("vcodec", "png")

        # Create one frame producer
        producer = mlt.Producer(PROJECT().profile, str(clip_path))
        producer = producer.cut(int(self.clip_frame), int(self.clip_frame))

        # Delete new match frame
        try:
            os.remove(matchframe_new_path)
        except:
            # This fails when done first time ever  
            pass

        # Connect and write image
        consumer.connect(producer)
        consumer.run()
        
        # Wait until new file exists
        while os.path.isfile(matchframe_new_path) != True:
            time.sleep(0.1)

        # Copy to match frame
        matchframe_path = userfolders.get_cache_dir() + appconsts.MATCH_FRAME
        shutil.copyfile(matchframe_new_path, matchframe_path)

        # Update timeline data           
        # Get frame of clip.clip_in_in on timeline.
        clip_index = self.track.clips.index(self.clip)
        clip_start_in_tline = self.track.clip_start(clip_index)
        tline_match_frame = clip_start_in_tline + (self.clip_frame - self.clip.clip_in)
        tlinewidgets.set_match_frame(tline_match_frame, self.track.id, self.display_on_right)

        # Update view
        updater.repaint_tline()
Esempio n. 43
0
def select_sync_clip_mouse_pressed(event, frame):
    sync_clip = _get_sync_tline_clip(event, frame)

    if sync_clip == None:
        return  # selection wasn't good

    if utils.is_mlt_xml_file(sync_clip.path) == True:
        # This isn't translated because 1.14 translation window is close, translation coming for 1.16
        dialogutils.warning_message(
            _("Cannot Timeline Audio Sync with Compound Clips!"),
            _("Audio syncing for Compound Clips is not supported."),
            gui.editor_window.window, True)
        return

    sync_track = tlinewidgets.get_track(event.y)
    sync_clip_index = sync_track.clips.index(sync_clip)

    _tline_sync_data.sync_clip = sync_clip
    _tline_sync_data.sync_track = sync_track
    _tline_sync_data.sync_clip_index = sync_clip_index

    # TImeline media offset for clips
    sync_clip_start_in_tline = sync_track.clip_start(sync_clip_index)
    _tline_sync_data.origin_clip_start_in_tline = _tline_sync_data.origin_track.clip_start(
        _tline_sync_data.origin_clip_index)

    _tline_sync_data.clip_tline_media_offset = (
        sync_clip_start_in_tline -
        sync_clip.clip_in) - (_tline_sync_data.origin_clip_start_in_tline -
                              _tline_sync_data.origin_clip.clip_in)

    gdk_window = gui.tline_display.get_parent_window()
    gdk_window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR))

    # This or GUI freezes, we really can't do Popen.wait() in a Gtk thread
    clapperless_thread = ClapperlesLaunchThread(
        _tline_sync_data.origin_clip.path, sync_clip.path,
        _tline_sync_offsets_computed_callback)
    clapperless_thread.start()

    # Edit consumes selection
    movemodes.clear_selected_clips()

    updater.repaint_tline()
Esempio n. 44
0
def _marker_menu_item_activated(widget, msg):
    current_frame = PLAYER().current_frame()
    if msg == "add":
        dialogs.marker_name_dialog(utils.get_tc_string(current_frame), _marker_add_dialog_callback)
    elif msg == "delete":
        mrk_index = -1
        for i in range(0, len(current_sequence().markers)):
            name, frame = current_sequence().markers[i]
            if frame == current_frame:
                mrk_index = i
        if mrk_index != -1:
            current_sequence().markers.pop(mrk_index)
            updater.repaint_tline()
    elif msg == "deleteall":
        current_sequence().markers = []
        updater.repaint_tline()
    else: # seek to marker
        name, frame = current_sequence().markers[int(msg)]
        PLAYER().seek_frame(frame)
Esempio n. 45
0
def _workflow_menu_callback(widget, data):
    tool_id, msg = data
    
    if msg == "activity":
        if widget.get_active() == False:
            editorpersistance.prefs.active_tools.remove(tool_id)
        else:
            editorpersistance.prefs.active_tools.append(tool_id)
    elif msg == "preset standard":
        _set_workflow_STANDARD()
    elif msg == "preset filmstyle":
        _set_workflow_FILM_STYLE()
    elif msg == "autofollow":
        active = widget.get_active()
        editorstate.auto_follow = active
        PROJECT().set_project_property(appconsts.P_PROP_AUTO_FOLLOW, active)
        if active == True:
            # Do autofollow update if auto follow activated
            compositor_autofollow_data = edit.get_full_compositor_sync_data()
            edit.do_autofollow_redo(compositor_autofollow_data)
        updater.repaint_tline()
    elif  msg == "always overwrite":
        editorpersistance.prefs.dnd_action = appconsts.DND_ALWAYS_OVERWRITE
    elif  msg == "overwrite nonV1":
        editorpersistance.prefs.dnd_action = appconsts.DND_OVERWRITE_NON_V1
    elif  msg == "always insert":
        editorpersistance.prefs.dnd_action = appconsts.DND_ALWAYS_INSERT
    elif  msg ==  "tooltips":
        editorpersistance.prefs.show_tool_tooltips = widget.get_active()
    elif msg == "delete lift" and widget.get_active() == True:
        print "lift"
    elif msg == "delete splice" and widget.get_active() == True:
        print "splice"
    else:
        try:
            pos = int(msg)
            current_index = editorpersistance.prefs.active_tools.index(tool_id)
            editorpersistance.prefs.active_tools.remove(tool_id)
            editorpersistance.prefs.active_tools.insert(pos - 1, tool_id)
        except:
            pass
    
    editorpersistance.save()
Esempio n. 46
0
def _add_filter_from_effect_select_panel(row_index, group_index):
    # Add filter
    group_name, filters_array = mltfilters.groups[group_index]
    filter_info = filters_array[row_index]

    data = {
        "clip": _filter_stack.clip,
        "filter_info": filter_info,
        "filter_edit_done_func": filter_edit_done_stack_update
    }
    action = edit.add_filter_action(data)

    set_stack_update_blocked()
    action.do_edit()
    set_stack_update_unblocked()

    clip, track, clip_index = _filter_stack.get_clip_data()
    set_clip(clip, track, clip_index)

    updater.repaint_tline()
Esempio n. 47
0
def init_sequence_gui():
    """
    Called after project load or changing current sequence 
    to initialize interface.
    """
    # Set correct compositing mode menu item selected
    gui.editor_window.init_compositing_mode_menu()
    gui.editor_window.init_timeline_rendering_menu()

    # Set initial timeline scale draw params
    editorstate.current_sequence().update_length()

    # Handle timeline rendering GUI and data
    tlinerender.init_for_sequence(editorstate.current_sequence())
    gui.editor_window.hide_tline_render_strip()
    if editorstate.get_tline_rendering_mode() != appconsts.TLINE_RENDERING_OFF:
        gui.editor_window.show_tline_render_strip()

    updater.update_pix_per_frame_full_view()
    updater.init_tline_scale()
    updater.repaint_tline()
Esempio n. 48
0
def mouse_press(event, frame):
    global edit_data, box_selection_data
    if box_selection_data == None: # mouse action to select
        press_point = (event.x, event.y)
        
        edit_data = {"action_on":True,
                     "press_point":press_point,
                     "mouse_point":press_point,
                     "box_selection_data":None}
    else: # mouse action to move
        if box_selection_data.is_hit(event.x, event.y) == False:
            # Back to start state
            edit_data = None
            box_selection_data = None
        else:
            edit_data = {"action_on":True,
                         "press_frame":frame,
                         "delta":0,
                         "box_selection_data":box_selection_data}
    
    tlinewidgets.set_edit_mode(edit_data, tlinewidgets.draw_overwrite_box_overlay)
    updater.repaint_tline()
Esempio n. 49
0
    def release_event(self, x,y):
        """
        Mouse release callback.
        """
        lx = self._legalize_x(x)
        ly = self._legalize_y(y)

        if abs(self.mouse_start_y - ly) < DRAG_MIN_Y:
            value_drag_on = True
            
        self.mouse_x = lx
        self.mouse_y = ly

        if self.current_mouse_action == POSITION_DRAG:
            frame = self._get_drag_frame(lx)
            self.current_clip_frame = frame
            self.clip_editor_frame_changed(self.current_clip_frame)
            updater.repaint_tline()
        elif self.current_mouse_action == KF_DRAG or self.current_mouse_action == KF_DRAG_FRAME_ZERO_KF:
            frame = self._get_drag_frame(lx)
            if self.current_mouse_action == KF_DRAG_FRAME_ZERO_KF:
                frame = 0
            if self.value_drag_on == True:
                value = round(self._get_value_for_panel_y(ly))
                self.set_active_kf_frame_and_value(frame, value)
                self.hack_fix_for_zero_one_keyframe_problem()
            else:
                self.set_active_kf_frame_and_value(frame, self.edit_value)
                self.hack_fix_for_zero_one_keyframe_problem()

            if _playhead_follow_kf == True:
                self.current_clip_frame = frame
                self.clip_editor_frame_changed(self.current_clip_frame)
            self.update_property_value()

        self.edit_value = None
        
        updater.repaint_tline()
        self.current_mouse_action = None
Esempio n. 50
0
def mouse_release(x, y, frame, state):
    if mouse_disabled:
        return

    global edit_data

    press_frame = edit_data["press_frame"]
    min_allowed_delta = -edit_data["multi_data"].max_backwards

    delta = frame - press_frame
    if delta < min_allowed_delta:
        delta = min_allowed_delta

    if delta != 0:
        data = {"edit_delta": delta, "multi_data": edit_data["multi_data"]}
        action = edit.multi_move_action(data)
        action.do_edit()

    edit_data = None
    tlinewidgets.set_edit_mode_data(edit_data)

    updater.repaint_tline()
Esempio n. 51
0
def _add_compositor(data):
    clip, track, item_id, item_data = data
    x, compositor_type = item_data

    frame = tlinewidgets.get_frame(x)
    clip_index = track.get_clip_index_at(frame)

    target_track_index = track.id - 1

    compositor_in = current_sequence().tracks[track.id].clip_start(clip_index)
    clip_length = clip.clip_out - clip.clip_in
    compositor_out = compositor_in + clip_length

    edit_data = {"origin_clip_id":clip.id,
                "in_frame":compositor_in,
                "out_frame":compositor_out,
                "a_track":target_track_index,
                "b_track":track.id,
                "compositor_type":compositor_type}
    action = edit.add_compositor_action(edit_data)
    action.do_edit()
    
    updater.repaint_tline()
Esempio n. 52
0
def mouse_press(event, frame):

    x = event.x
    y = event.y

    # If we have clip being edited and its edit area is hit, we do not need to init data.
    if _kf_editor != None and _kf_editor.overlay_area_hit(x, y):
        _handle_edit_mouse_press(event)
        return

    # Attempt to init kf tool editing on some clip

    # Get pressed track
    track = tlinewidgets.get_track(y)

    # Selecting empty clears selection
    if track == None:
        #clear_selected_clips()
        #pressed_on_selected = False
        _set_no_clip_edit_data()
        updater.repaint_tline()
        return

    # Get pressed clip index
    clip_index = current_sequence().get_clip_index(track, frame)

    # Selecting empty clears selection
    if clip_index == -1:
        #clear_selected_clips()
        #pressed_on_selected = False
        _set_no_clip_edit_data()
        updater.repaint_tline()
        return

    clip = track.clips[clip_index]

    init_tool_for_clip(clip, track)
Esempio n. 53
0
def select_sync_clip_mouse_pressed(event, frame):
    sync_clip = _get_sync_tline_clip(event, frame)

    if sync_clip == None:
        return  # selection wasn't good

    sync_track = tlinewidgets.get_track(event.y)
    sync_clip_index = sync_track.clips.index(sync_clip)

    _tline_sync_data.sync_clip = sync_clip
    _tline_sync_data.sync_track = sync_track
    _tline_sync_data.sync_clip_index = sync_clip_index

    # TImeline media offset for clips
    sync_clip_start_in_tline = sync_track.clip_start(sync_clip_index)
    _tline_sync_data.origin_clip_start_in_tline = _tline_sync_data.origin_track.clip_start(
        _tline_sync_data.origin_clip_index)

    _tline_sync_data.clip_tline_media_offset = (
        sync_clip_start_in_tline -
        sync_clip.clip_in) - (_tline_sync_data.origin_clip_start_in_tline -
                              _tline_sync_data.origin_clip.clip_in)

    gdk_window = gui.tline_display.get_parent_window()
    gdk_window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR))

    # This or GUI freezes, we really can't do Popen.wait() in a Gtk thread
    clapperless_thread = ClapperlesLaunchThread(
        _tline_sync_data.origin_clip.path, sync_clip.path,
        _tline_sync_offsets_computed_callback)
    clapperless_thread.start()

    # Edit consumes selection
    movemodes.clear_selected_clips()

    updater.repaint_tline()
Esempio n. 54
0
def mouse_release(x, y, frame, state):
    editorstate.edit_mode = prev_edit_mode
    if editorstate.edit_mode == editorstate.INSERT_MOVE:
        tlinewidgets.set_edit_mode(None, tlinewidgets.draw_insert_overlay)
    elif editorstate.edit_mode == editorstate.INSERT_MOVE:
        tlinewidgets.set_edit_mode(None, tlinewidgets.draw_overwrite_overlay)
    elif editorstate.edit_mode == editorstate.MULTI_MOVE:
        tlinewidgets.set_edit_mode(None, tlinewidgets.draw_multi_overlay)
    else:
        print "COMPOSITOR MODE EXIT PROBLEM at compositormodes.mouse_release"

    gui.editor_window.set_cursor_to_mode()

    if sub_mode == TRIM_EDIT:
        _bounds_check_trim(frame, edit_data)
        data = {"compositor":compositor,
                "clip_in":edit_data["clip_in"],
                "clip_out":edit_data["clip_out"]}
        action = edit.move_compositor_action(data)
        action.do_edit()
    else:
        press_frame = edit_data["press_frame"]
        current_frame = frame
        delta = current_frame - press_frame

        data = {"compositor":compositor,
                "clip_in":compositor.clip_in + delta,
                "clip_out":compositor.clip_out + delta}
        if data["clip_in"] < 0:
            data["clip_in"] = 0
        if data["clip_out"] < 0:
            data["clip_out"] = 0
        action = edit.move_compositor_action(data)
        action.do_edit()
    
    updater.repaint_tline()
Esempio n. 55
0
def delete_effect_pressed():
    if len(clip.filters) == 0:
        return

    # Block updates until we have set selected row
    global edit_effect_update_blocked
    edit_effect_update_blocked = True
    """
    treeselection = widgets.effect_stack_view.treeview.get_selection()
    (model, rows) = treeselection.get_selected_rows()
    
    try:
        row = rows[0]
    except:
        return # This fails when there are filters but no rows are selected
    """

    #row_index = current_filter_index
    data = {
        "clip": clip,
        "index": current_filter_index,
        "filter_edit_done_func": filter_edit_done
    }
    action = edit.remove_filter_action(data)
    action.do_edit()

    updater.repaint_tline()

    # Set last filter selected and display in editor
    edit_effect_update_blocked = False
    if len(clip.filters) == 0:
        effect_selection_changed()  # to display info text
        return
    path = str(len(clip.filters) - 1)
    # Causes edit_effect_selected() called as it is the "change" listener
    widgets.effect_stack_view.treeview.get_selection().select_path(path)
Esempio n. 56
0
    def release_event(self, x, y):
        """
        Mouse release callback.
        """
        lx = self._legalize_x(x)
        ly = self._legalize_y(y)

        if self.current_mouse_action == POSITION_DRAG:
            self._set_clip_frame(lx)
            self.clip_editor_frame_changed(self.current_clip_frame)
            self.update_slider_value_display(self.current_clip_frame)
        elif self.current_mouse_action == KF_DRAG:
            frame = self._get_drag_frame(lx)
            value = self._get_value_for_panel_y(ly)
            self.set_active_kf_frame_and_value(frame, value)
            self.current_clip_frame = frame
            self.clip_editor_frame_changed(self.current_clip_frame)
            self.update_property_value()
            self.update_slider_value_display(frame)

        updater.repaint_tline()
        self.current_mouse_action = None

        self.drag_on = False
Esempio n. 57
0
def delete_effect_pressed():
    if len(clip.filters) == 0:
        return

    # Block updates until we have set selected row
    global edit_effect_update_blocked
    edit_effect_update_blocked = True

    data = {"clip":clip,
            "index":current_filter_index,
            "filter_edit_done_func":filter_edit_done}
    action = edit.remove_filter_action(data)
    action.do_edit()

    updater.repaint_tline()

    # Set last filter selected and display in editor
    edit_effect_update_blocked = False
    if len(clip.filters) == 0:
        effect_selection_changed() # to display info text
        return
    path = str(len(clip.filters) - 1)
    # Causes edit_effect_selected() called as it is the "change" listener
    widgets.effect_stack_view.treeview.get_selection().select_path(path)
Esempio n. 58
0
def _audio_levels_item_activated(widget, msg):
    if msg == "all":
        editorstate.display_all_audio_levels = True
        updater.repaint_tline()
    elif msg == "on request":
        editorstate.display_all_audio_levels = False
        current_sequence().drop_audio_levels()
        updater.repaint_tline()
    elif msg == "snapping":
        snapping.snapping_on = widget.get_active()
    elif msg == "magnet":
        snapping.show_magnet_icon = widget.get_active()
    elif msg == "autofollow":
        active = widget.get_active()
        editorstate.auto_follow = active
        PROJECT().set_project_property(appconsts.P_PROP_AUTO_FOLLOW, active)
        updater.repaint_tline()
    else:  # media thumbnails
        editorstate.display_clip_media_thumbnails = widget.get_active()
        updater.repaint_tline()
Esempio n. 59
0
def _audio_levels_item_activated(widget, msg):
    if msg == "all":
        editorstate.display_all_audio_levels = True
        updater.repaint_tline()
    elif msg == "on request":
        editorstate.display_all_audio_levels = False
        current_sequence().drop_audio_levels()
        updater.repaint_tline()
    elif msg == "snapping":
        snapping.snapping_on = widget.get_active()
    else:  # media thumbnails
        editorstate.display_clip_media_thumbnails = widget.get_active()
        updater.repaint_tline()
Esempio n. 60
0
def _audio_levels_item_activated(widget, msg):
    if msg == "all":
        editorstate.display_all_audio_levels = True
        updater.repaint_tline()
    elif msg == "on request":
        editorstate.display_all_audio_levels = False
        current_sequence().drop_audio_levels()
        updater.repaint_tline()
    elif msg == "snapping":
        snapping.snapping_on = widget.get_active()
    elif msg == "autofollow":
        active = widget.get_active()
        editorstate.auto_follow = active
        PROJECT().set_project_property(appconsts.P_PROP_AUTO_FOLLOW, active)
        if active == True:
            # Do autofollow update if auto follow activated
            compositor_autofollow_data = edit.get_full_compositor_sync_data()
            edit.do_autofollow_redo(compositor_autofollow_data)
        updater.repaint_tline()
    elif msg == "pointer_sensitive_item":
        editorstate.cursor_is_tline_sensitive = widget.get_active()
    else:  # media thumbnails
        editorstate.display_clip_media_thumbnails = widget.get_active()
        updater.repaint_tline()