Ripple mode edit actions

flowblade-trunk/Flowblade/edit.py

@@ -1120,6 +1120,168 @@ def _get_tracks_compositors_list():
 
     return tracks_list
 
+#-------------------------------------------- RIPPLE TRIM END
+# "track","clip","index","edit_delta","first_do","multi_data"
+# self.multi_data is trimmodes.RippleData
+def ripple_trim_end_action(data):
+    action = EditAction(_ripple_trim_end_undo, _ripple_trim_end_redo, data)
+    action.exit_active_trimmode_on_edit = False
+    action.update_hidden_track_blank = False
+    return action
+
+def _ripple_trim_end_undo(self):
+    _remove_clip(self.track, self.index)
+    _insert_clip(self.track, self.clip, self.index,
+                 self.clip.clip_in, self.clip.clip_out - self.delta)
+
+    _ripple_trim_blanks_undo(self)
+
+def _ripple_trim_end_redo(self):
+    _remove_clip(self.track, self.index)
+    _insert_clip(self.track, self.clip, self.index,
+                 self.clip.clip_in, self.clip.clip_out + self.edit_delta)
+
+    _ripple_trim_blanks_redo(self)
+
+    # Reinit one roll trim
+    if self.first_do == True:
+        self.first_do = False
+        self.undo_done_callback(self.track, self.index + 1, False)
+
+#-------------------------------------------- RIPPLE TRIM START
+# "track","clip","index","edit_delta","first_do","multi_data"
+# self.multi_data is trimmodes.RippleData
+def ripple_trim_start_action(data):
+    action = EditAction(_ripple_trim_start_undo,_ripple_trim_start_redo, data)
+    action.exit_active_trimmode_on_edit = False
+    action.update_hidden_track_blank = False
+    return action
+
+def _ripple_trim_start_undo(self):
+    _remove_clip(self.track, self.index)
+    _insert_clip(self.track, self.clip, self.index,
+                 self.clip.clip_in - self.edit_delta, self.clip.clip_out)
+
+    _ripple_trim_blanks_undo(self)
+
+def _ripple_trim_start_redo(self):
+    _remove_clip(self.track, self.index)
+    _insert_clip(self.track, self.clip, self.index,
+                 self.clip.clip_in + self.edit_delta, self.clip.clip_out)
+
+    _ripple_trim_blanks_redo(self)
+
+    # Reinit one roll trim, when used with clip start drag this is not needed
+    if  hasattr(self, "first_do") and self.first_do == True:
+        self.first_do = False
+        self.undo_done_callback(self.track, self.index, True)
+
+#------------------ RIPPLE TRIM LAST CLIP END
+# "track","clip","index","edit_delta","first_do","multi_data"
+# self.multi_data is trimmodes.RippleData
+def ripple_trim_last_clip_end_action(data): 
+    action = EditAction(_ripple_trim_last_clip_end_undo,_ripple_trim_last_clip_end_redo, data)
+    action.exit_active_trimmode_on_edit = False
+    action.update_hidden_track_blank = False
+    return action
+
+def _ripple_trim_last_clip_end_undo(self):
+    _remove_clip(self.track, self.index)
+    _insert_clip(self.track, self.clip, self.index,
+                 self.clip.clip_in, self.clip.clip_out - self.edit_delta)
+
+    _ripple_trim_blanks_undo(self)
+
+def _ripple_trim_last_clip_end_redo(self):
+    print self.__dict__
+    _remove_clip(self.track, self.index)
+    _insert_clip(self.track, self.clip, self.index,
+                 self.clip.clip_in, self.clip.clip_out + self.edit_delta)
+
+    _ripple_trim_blanks_redo(self)
+
+    # Reinit one roll trim for continued trim mode, whenused with clip end drag this is not needed
+    if hasattr(self, "first_do") and self.first_do == True:
+        self.first_do = False
+        self.undo_done_callback(self.track)
+
+# ----------------------------- RIPPLE TRIM BLANK UPDATE METHODS
+def _ripple_trim_blanks_undo(self):
+    track_moved = self.multi_data.track_affected    
+    tracks = current_sequence().tracks
+    for i in range(1, len(tracks) - 1):
+        if not track_moved[i - 1]:
+            continue
+        if self.track.id == i:
+            continue
+
+        track = tracks[i]
+        edit_op = self.multi_data.track_edit_ops[i - 1]        
+        trim_blank_index = self.multi_data.trim_blank_indexes[i - 1]
+
+        if edit_op == appconsts.MULTI_NOOP:
+            continue
+        elif edit_op == appconsts.MULTI_TRIM:
+            blank_length = track.clips[trim_blank_index].clip_length()
+            _remove_clip(track, trim_blank_index) 
+            _insert_blank(track, trim_blank_index, blank_length - self.edit_delta)
+        elif edit_op == appconsts.MULTI_ADD_TRIM:
+            _remove_clip(track, trim_blank_index) 
+        elif edit_op == appconsts.MULTI_TRIM_REMOVE:
+            if self.edit_delta != -self.multi_data.max_backwards:
+                _remove_clip(track, trim_blank_index) 
+
+            _insert_blank(track, trim_blank_index, self.orig_length)
+
+    tracks_compositors = _get_tracks_compositors_list()
+    for i in range(1, len(tracks) - 1):
+        if not track_moved[i - 1]:
+            continue
+        track_comp = tracks_compositors[i - 1]
+        for comp in track_comp:
+            if comp.clip_in >= self.multi_data.first_moved_frame + self.edit_delta:
+                comp.move(-self.edit_delta)
+
+def _ripple_trim_blanks_redo(self):
+    tracks = current_sequence().tracks
+    track_moved = self.multi_data.track_affected
+
+    # Move clips          
+    for i in range(1, len(tracks) - 1):
+        if not track_moved[i - 1]:
+            continue
+        if self.track.id == i:
+            continue
+
+        track = tracks[i]
+        edit_op = self.multi_data.track_edit_ops[i - 1]        
+        trim_blank_index = self.multi_data.trim_blank_indexes[i - 1]
+
+        if edit_op == appconsts.MULTI_NOOP:
+            continue
+        elif edit_op == appconsts.MULTI_TRIM:
+            blank_length = track.clips[trim_blank_index].clip_length()
+            _remove_clip(track, trim_blank_index) 
+            _insert_blank(track, trim_blank_index, blank_length + self.edit_delta)
+        elif edit_op == appconsts.MULTI_ADD_TRIM:
+            _insert_blank(track, trim_blank_index, self.edit_delta)
+        elif edit_op == appconsts.MULTI_TRIM_REMOVE:
+            self.orig_length = track.clips[trim_blank_index].clip_length()
+            _remove_clip(track, trim_blank_index) 
+            if self.edit_delta != -self.multi_data.max_backwards:
+                _insert_blank(track, trim_blank_index, self.orig_length + self.edit_delta)
+
+    # Move compositors
+    tracks_compositors = _get_tracks_compositors_list()
+    for i in range(1, len(tracks) - 1):
+        if not track_moved[i - 1]:
+            continue
+        track_comp = tracks_compositors[i - 1]
+        for comp in track_comp:
+            if comp.clip_in >= self.multi_data.first_moved_frame:
+                comp.move(self.edit_delta)
+
+
 #------------------ TRIM CLIP START
 # "track","clip","index","delta","first_do"
 # "undo_done_callback" <- THIS IS REALLY BADLY NAMED, IT SHOULD BE FIRST DO CALLBACK

flowblade-trunk/Flowblade/sequence.py

@@ -130,7 +130,7 @@ def init_mlt_objects(self):
         if self.master_audio_pan != NO_PAN:
             self.add_track_pan_filter(self.tractor, self.master_audio_pan)
 
-        # Create and ad gain filter
+        # Create and add gain filter
         gain_filter = mlt.Filter(self.profile, "volume")
         mltrefhold.hold_ref(gain_filter)
         gain_filter.set("gain", str(self.master_audio_gain))

flowblade-trunk/Flowblade/tlinewidgets.py

@@ -1214,7 +1214,7 @@ def draw_track(self, cr, track, y, width):
         # Get clip indexes for clips overlapping first and last displayed frame.
         start = track.get_clip_index_at(int(pos))
         end = track.get_clip_index_at(int(pos + width / pix_per_frame))
-
+        print start, end
         width_frames = float(width) / pix_per_frame
 
         # Add 1 to end because range() last index exclusive 
@@ -1242,7 +1242,7 @@ def draw_track(self, cr, track, y, width):
 
         # Draw clips in draw range
         for i in range(start, end):
-
+            print "track :", track.id, "index:", i
             clip = track.clips[i]
 
             # Get clip frame values

flowblade-trunk/Flowblade/trimmodes.py

@@ -45,6 +45,7 @@
 
 # Data/state for ongoing edit.
 edit_data = None
+ripple_data = None
 
 # Flag for disabling mouse event
 mouse_disabled = False
@@ -413,6 +414,7 @@ def set_oneroll_mode(track, current_frame=-1, editing_to_clip=None):
     _set_edit_data(track, edit_frame, True)
 
     # Init ripple data if needed
+    global ripple_data
     ripple_data = None
     if editorstate.trim_mode_ripple == True:
         ripple_data = RippleData( track, edit_frame)
@@ -425,7 +427,7 @@ def set_oneroll_mode(track, current_frame=-1, editing_to_clip=None):
     # Set side being edited to default to-side
     edit_data["to_side_being_edited"] = to_side_being_edited
 
-    # Set start fframe bound for ripple mode edit
+    # Set start frame bound for ripple mode edits
     if editorstate.trim_mode_ripple == True:
         ripple_start_bound = edit_frame - ripple_data.max_backwards
 
@@ -585,39 +587,73 @@ def _do_one_roll_trim_edit(frame):
     # case: editing from-side of last clip
     global last_from_trimmed
     if last_from_trimmed:
-        data = {"track":edit_data["track_object"],
-                "index":edit_data["index"],
-                "clip":edit_data["from_clip"],
-                "delta":delta,
-                "undo_done_callback":clip_end_first_do_done,
-                "first_do":True}
-        action = edit.trim_last_clip_end_action(data)
         last_from_trimmed = False
-        action.do_edit()
+        if editorstate.trim_mode_ripple == False:
+            data = {"track":edit_data["track_object"],
+                    "index":edit_data["index"],
+                    "clip":edit_data["from_clip"],
+                    "delta":delta,
+                    "undo_done_callback":clip_end_first_do_done,
+                    "first_do":True}
+            action = edit.trim_last_clip_end_action(data)
+            last_from_trimmed = False
+            action.do_edit()
+        else:
+            data = {"track":edit_data["track_object"],
+                    "index":edit_data["index"],
+                    "clip":edit_data["from_clip"],
+                    "edit_delta":delta,
+                    "undo_done_callback":clip_end_first_do_done,
+                    "first_do":True,
+                    "multi_data":ripple_data}
+            action = edit.ripple_trim_last_clip_end_action(data)
+            action.do_edit()
         # Edit is reinitialized in callback from edit action one_roll_trim_undo_done
     # case: editing to-side of cut
     elif edit_data["to_side_being_edited"]:
-        data = {"track":edit_data["track_object"],
-                "index":edit_data["index"],
-                "clip":edit_data["to_clip"],
-                "delta":delta,
-                "undo_done_callback":one_roll_trim_undo_done,
-                "first_do":True}
-        action = edit.trim_start_action(data)
-        action.do_edit()
-        # Edit is reinitialized in callback from edit action one_roll_trim_undo_done
+        if editorstate.trim_mode_ripple == False:
+            data = {"track":edit_data["track_object"],
+                    "index":edit_data["index"],
+                    "clip":edit_data["to_clip"],
+                    "delta":delta,
+                    "undo_done_callback":one_roll_trim_undo_done,
+                    "first_do":True}
+            action = edit.trim_start_action(data)
+            action.do_edit()
+            # Edit is reinitialized in callback from edit action one_roll_trim_undo_done
+        else:
+            data = {"track":edit_data["track_object"],
+                    "index":edit_data["index"],
+                    "clip":edit_data["from_clip"],
+                    "edit_delta":delta,
+                    "undo_done_callback":one_roll_trim_undo_done,
+                    "first_do":True,
+                    "multi_data":ripple_data}
+            action = edit.ripple_trim_start_action(data)
+            action.do_edit()
     # case: editing from-side of cut
     else:
-        data = {"track":edit_data["track_object"],
-                "index":edit_data["index"] - 1,
-                "clip":edit_data["from_clip"],
-                "delta":delta,
-                "undo_done_callback":one_roll_trim_undo_done,
-                "first_do":True}
-        action = edit.trim_end_action(data)
-        action.do_edit()
-        # Edit is reinitialized in callback from edit action one_roll_trim_undo_done
-
+        if editorstate.trim_mode_ripple == False:
+            data = {"track":edit_data["track_object"],
+                    "index":edit_data["index"] - 1,
+                    "clip":edit_data["from_clip"],
+                    "delta":delta,
+                    "undo_done_callback":one_roll_trim_undo_done,
+                    "first_do":True}
+            action = edit.trim_end_action(data)
+            action.do_edit()
+            # Edit is reinitialized in callback from edit action one_roll_trim_undo_done
+        else:
+            data = {"track":edit_data["track_object"],
+                    "index":edit_data["index"] - 1,
+                    "clip":edit_data["from_clip"],
+                    "edit_delta":delta,
+                    "undo_done_callback":one_roll_trim_undo_done,
+                    "first_do":True,
+                    "multi_data":ripple_data}
+            action = edit.ripple_trim_end_action(data)
+            action.do_edit()
+
 def oneroll_play_pressed():
     # Start trim preview playback loop
     current_sequence().hide_hidden_clips()