Revision: 24054
          
http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=24054
Author:   campbellbarton
Date:     2009-10-22 16:40:32 +0200 (Thu, 22 Oct 2009)

Log Message:
-----------
after transform if strips overlap, move the frame rather then the channel to 
fix.
useful while snap isnt working. metastrips still need to be supported.

Modified Paths:
--------------
    trunk/blender/source/blender/blenkernel/BKE_sequence.h
    trunk/blender/source/blender/blenkernel/intern/sequence.c
    trunk/blender/source/blender/editors/transform/transform_conversions.c

Modified: trunk/blender/source/blender/blenkernel/BKE_sequence.h
===================================================================
--- trunk/blender/source/blender/blenkernel/BKE_sequence.h      2009-10-22 
12:59:14 UTC (rev 24053)
+++ trunk/blender/source/blender/blenkernel/BKE_sequence.h      2009-10-22 
14:40:32 UTC (rev 24054)
@@ -182,6 +182,7 @@
 void fix_single_seq(struct Sequence *seq);
 int seq_test_overlap(struct ListBase * seqbasep, struct Sequence *test);
 int shuffle_seq(struct ListBase * seqbasep, struct Sequence *test);
+int shuffle_seq_time(ListBase * seqbasep);
 void free_imbuf_seq(struct ListBase * seqbasep, int check_mem_usage);
 
 void seq_update_sound(struct Sequence *seq);

Modified: trunk/blender/source/blender/blenkernel/intern/sequence.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/sequence.c   2009-10-22 
12:59:14 UTC (rev 24053)
+++ trunk/blender/source/blender/blenkernel/intern/sequence.c   2009-10-22 
14:40:32 UTC (rev 24054)
@@ -3341,18 +3341,25 @@
        return (seq->type < SEQ_EFFECT) || 
(get_sequence_effect_num_inputs(seq->type) == 0);
 }
 
+static int seq_overlap(Sequence *seq1, Sequence *seq2)
+{
+       if(seq1 != seq2)
+               if(seq1->machine==seq2->machine)
+                       if(((seq1->enddisp <= seq2->startdisp) || 
(seq1->startdisp >= seq2->enddisp))==0)
+                               return 1;
+
+       return 0;
+}
+
 int seq_test_overlap(ListBase * seqbasep, Sequence *test)
 {
        Sequence *seq;
 
        seq= seqbasep->first;
        while(seq) {
-               if(seq!=test) {
-                       if(test->machine==seq->machine) {
-                               if( (test->enddisp <= seq->startdisp) || 
(test->startdisp >= seq->enddisp) );
-                               else return 1;
-                       }
-               }
+               if(seq_overlap(test, seq))
+                       return 1;
+
                seq= seq->next;
        }
        return 0;
@@ -3410,6 +3417,76 @@
        }
 }
 
+static int shuffle_seq_time_offset_test(ListBase * seqbasep, char dir)
+{
+       int offset= 0;
+       Sequence *seq, *seq_other;
+
+       for(seq= seqbasep->first; seq; seq= seq->next) {
+               if(seq->tmp) {
+                       for(seq_other= seqbasep->first; seq_other; seq_other= 
seq_other->next) {
+                               if(seq_overlap(seq, seq_other)) {
+                                       if(dir=='L') {
+                                               offset= MIN2(offset, 
seq_other->startdisp - seq->enddisp);
+                                       }
+                                       else {
+                                               offset= MAX2(offset, 
seq_other->enddisp - seq->startdisp);
+                                       }
+                               }
+                       }
+               }
+       }
+       return offset;
+}
+
+static int shuffle_seq_time_offset(ListBase * seqbasep, char dir)
+{
+       int ofs= 0;
+       int tot_ofs= 0;
+       Sequence *seq;
+       while( (ofs= shuffle_seq_time_offset_test(seqbasep, dir)) ) {
+               for(seq= seqbasep->first; seq; seq= seq->next) {
+                       if(seq->tmp) {
+                               /* seq_test_overlap only tests display values */
+                               seq->startdisp +=       ofs;
+                               seq->enddisp +=         ofs;
+                       }
+               }
+
+               tot_ofs+= ofs;
+       }
+
+       for(seq= seqbasep->first; seq; seq= seq->next) {
+               if(seq->tmp)
+                       calc_sequence_disp(seq); /* corrects dummy 
startdisp/enddisp values */
+       }
+
+       return tot_ofs;
+}
+
+int shuffle_seq_time(ListBase * seqbasep)
+{
+       /* note: metastrinps untested */
+       /* note: seq->tmp is used to tag strips to move */
+
+       Sequence *seq;
+
+       int offset_l = shuffle_seq_time_offset(seqbasep, 'L');
+       int offset_r = shuffle_seq_time_offset(seqbasep, 'R');
+       int offset = (-offset_l < offset_r) ?  offset_l:offset_r;
+
+       if(offset) {
+               for(seq= seqbasep->first; seq; seq= seq->next) {
+                       if(seq->tmp) {
+                               seq->start += offset;
+                               seq->flag &= ~SEQ_OVERLAP;
+                               calc_sequence(seq);
+                       }
+               }
+       }
+}
+
+
 void seq_update_sound(struct Sequence *seq)
 {
        if(seq->type == SEQ_SOUND)

Modified: trunk/blender/source/blender/editors/transform/transform_conversions.c
===================================================================
--- trunk/blender/source/blender/editors/transform/transform_conversions.c      
2009-10-22 12:59:14 UTC (rev 24053)
+++ trunk/blender/source/blender/editors/transform/transform_conversions.c      
2009-10-22 14:40:32 UTC (rev 24054)
@@ -4039,7 +4039,6 @@
        return tot;
 }
 
-
 static void freeSeqData(TransInfo *t)
 {
        Editing *ed= seq_give_editing(t->scene, FALSE);
@@ -4058,16 +4057,49 @@
 
                if (!(t->state == TRANS_CANCEL)) {
 
+#if 0          // default 2.4 behavior
+
                        /* flush to 2d vector from internally used 3d vector */
                        for(a=0; a<t->total; a++, td++) {
+                               if ((seq != seq_prev) && (seq->depth==0) && 
(seq->flag & SEQ_OVERLAP)) {
                                seq= ((TransDataSeq *)td->extra)->seq;
-                               if ((seq != seq_prev) && (seq->depth==0) && 
(seq->flag & SEQ_OVERLAP)) {
                                        shuffle_seq(seqbasep, seq);
                                }
 
                                seq_prev= seq;
                        }
 
+#else          // durian hack
+                       {
+                               int overlap= 0;
+
+                               for(a=0; a<t->total; a++, td++) {
+                                       seq= ((TransDataSeq *)td->extra)->seq;
+                                       if ((seq != seq_prev) && 
(seq->depth==0) && (seq->flag & SEQ_OVERLAP)) {
+                                               overlap= 1;
+                                               break;
+                                       }
+                                       seq_prev= seq;
+                               }
+
+                               if(overlap) {
+                                       for(seq= seqbasep->first; seq; seq= 
seq->next)
+                                               seq->tmp= NULL;
+
+                                       td= t->data;
+
+                                       for(a=0; a<t->total; a++, td++) {
+                                               seq= ((TransDataSeq 
*)td->extra)->seq;
+                                               if ((seq != seq_prev)) {
+                                                       seq->tmp= 1;
+                                               }
+                                       }
+
+                                       shuffle_seq_time(seqbasep);
+                               }
+                       }
+#endif
+
                        for(seq= seqbasep->first; seq; seq= seq->next) {
                                /* We might want to build a list of effects 
that need to be updated during transform */
                                if(seq->type & SEQ_EFFECT) {


_______________________________________________
Bf-blender-cvs mailing list
[email protected]
http://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to