← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/blender/intrepid-updates

« back to all changes in this revision

Viewing changes to source/blender/src/edittime.c

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2008-08-08 02:45:40 UTC
  • mfrom: (12.1.14 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080808024540-kkjp7ekfivzhuw3l
Tags: 2.46+dfsg-4
http://bugs.debian.org/492280
* Fix python syntax warning in import_dxf.py, which led to nasty output
  in installation/upgrade logs during byte-compilation, using a patch
  provided by the script author (Closes: #492280):
   - debian/patches/45_fix_python_syntax_warning

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/src/edittime.c
1
1
/**
2
 
 * $Id:
 
2
 * $Id: BIF_edittime.c
3
3
 *
4
4
 * ***** BEGIN GPL LICENSE BLOCK *****
5
5
 *
63
63
#include "BIF_interface.h"
64
64
#include "BIF_toolbox.h"
65
65
#include "BIF_mywindow.h"
 
66
#include "BIF_editaction.h"
66
67
 
67
68
#include "BSE_drawipo.h"
 
69
#include "BSE_edit.h"
68
70
#include "BSE_headerbuttons.h"
69
71
#include "BSE_time.h"
70
72
 
79
81
/* declarations */
80
82
void winqreadtimespace(ScrArea *, void *, BWinEvent *);
81
83
 
82
 
/* ************* Timeline marker code **************** */
 
84
/* ************* Marker API **************** */
83
85
 
84
86
/* add TimeMarker at curent frame */
85
 
void add_timeline_marker(int frame)
 
87
void add_marker(int frame)
86
88
{
87
89
        TimeMarker *marker;
88
90
        
98
100
        marker->frame= frame;
99
101
        BLI_addtail(&(G.scene->markers), marker);
100
102
        
101
 
        BIF_undo_push("Add Timeline Marker");
 
103
        BIF_undo_push("Add Marker");
102
104
}
103
105
 
104
 
/* remove TimeMarker */
105
 
void remove_timeline_marker(void)
 
106
 
 
107
 
 
108
/* remove selected TimeMarkers */
 
109
void remove_marker(void)
106
110
{
107
 
        TimeMarker *marker;
108
 
        
109
 
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
110
 
                if(marker->flag & SELECT){
111
 
                        BLI_freelinkN(&G.scene->markers, marker);
 
111
        TimeMarker *marker, *nmarker;
 
112
        short changed= 0;
 
113
                
 
114
        for(marker= G.scene->markers.first; marker; marker= nmarker) {
 
115
                nmarker= marker->next;
 
116
                if(marker->flag & SELECT) {
 
117
                        BLI_freelinkN(&(G.scene->markers), marker);
 
118
                        changed= 1;
112
119
                }
113
120
        }
114
121
        
115
 
        BIF_undo_push("Remove Timeline Marker");
 
122
        if (changed)
 
123
                BIF_undo_push("Remove Marker");
116
124
}
117
125
 
118
126
/* rename first selected TimeMarker */
119
 
void rename_timeline_marker(void)
 
127
void rename_marker(void)
120
128
{
121
129
        TimeMarker *marker;
122
130
        char name[64];
123
 
        
 
131
                        
124
132
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
125
133
                if(marker->flag & SELECT) {
126
 
                        sprintf(name, marker->name);
 
134
                        strcpy(name, marker->name);
127
135
                        if (sbutton(name, 0, sizeof(name)-1, "Name: "))
128
136
                                BLI_strncpy(marker->name, name, sizeof(marker->name));
129
137
                        break;
130
138
                }
131
139
        }
132
140
        
133
 
        BIF_undo_push("Rename Timeline Marker");
 
141
//      BIF_undo_push("Rename Marker");
134
142
}
135
143
 
136
144
/* duplicate selected TimeMarkers */
137
 
void duplicate_timeline_marker(void)
 
145
void duplicate_marker(void)
138
146
{
139
147
        TimeMarker *marker, *newmarker;
140
 
 
 
148
        
141
149
        /* go through the list of markers, duplicate selected markers and add duplicated copies
142
150
         * to the begining of the list (unselect original markers) */
143
151
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
154
162
                }
155
163
        }
156
164
        
157
 
        timeline_grab('g', 0);
158
 
}
159
 
 
160
 
 
161
 
 
162
 
static int find_nearest_marker(float dx)
 
165
        transform_markers('g', 0);
 
166
}
 
167
 
 
168
void transform_markers(int mode, int smode)     // mode and smode unused here, for callback
 
169
{
 
170
        SpaceLink *slink= curarea->spacedata.first;
 
171
        SpaceTime *stime= curarea->spacedata.first;
 
172
        SpaceAction *saction = curarea->spacedata.first;
 
173
        ListBase *markers;
 
174
        TimeMarker *marker, *selmarker=NULL;
 
175
        float dx, fac;
 
176
        int a, ret_val= 0, totmark=0, *oldframe, offs, firsttime=1;
 
177
        unsigned short event;
 
178
        short val, pmval[2], mval[2], mvalo[2];
 
179
        char str[32];
 
180
        
 
181
        /* hack for pose-markers in action editor */
 
182
        if ((slink->spacetype == SPACE_ACTION) && (saction->flag & SACTION_POSEMARKERS_MOVE)) {
 
183
                if (saction->action)
 
184
                        markers= &saction->action->markers;
 
185
                else
 
186
                        markers= NULL;
 
187
        }
 
188
        else
 
189
                markers= &G.scene->markers;
 
190
        
 
191
        for (marker= markers->first; marker; marker= marker->next) {
 
192
                if (marker->flag & SELECT) totmark++;
 
193
        }
 
194
        if (totmark==0) return;
 
195
        
 
196
        oldframe= MEM_mallocN(totmark*sizeof(int), "marker array");
 
197
        for (a=0, marker= markers->first; marker; marker= marker->next) {
 
198
                if (marker->flag & SELECT) {
 
199
                        oldframe[a]= marker->frame;
 
200
                        selmarker= marker;      // used for headerprint
 
201
                        a++;
 
202
                }
 
203
        }
 
204
        
 
205
        dx= G.v2d->mask.xmax-G.v2d->mask.xmin;
 
206
        dx= (G.v2d->cur.xmax-G.v2d->cur.xmin)/dx;
 
207
        
 
208
        getmouseco_areawin(pmval);
 
209
        mvalo[0]= pmval[0];
 
210
        
 
211
        while (ret_val == 0) {
 
212
                getmouseco_areawin(mval);
 
213
                
 
214
                if (mval[0] != mvalo[0] || firsttime) {
 
215
                        mvalo[0]= mval[0];
 
216
                        firsttime= 0;
 
217
                        
 
218
                        fac= (((float)(mval[0] - pmval[0]))*dx);
 
219
                        
 
220
                        if (ELEM(slink->spacetype, SPACE_TIME, SPACE_SOUND)) 
 
221
                                apply_keyb_grid(&fac, 0.0, FPS, 0.1*FPS, 0);
 
222
                        else
 
223
                                apply_keyb_grid(&fac, 0.0, 1.0, 0.1, U.flag & USER_AUTOGRABGRID);
 
224
                        offs= (int)fac;
 
225
                        
 
226
                        for (a=0, marker= markers->first; marker; marker= marker->next) {
 
227
                                if (marker->flag & SELECT) {
 
228
                                        marker->frame= oldframe[a] + offs;
 
229
                                        a++;
 
230
                                }
 
231
                        }
 
232
                        
 
233
                        if (totmark==1) {       
 
234
                                /* we print current marker value */
 
235
                                if (ELEM(slink->spacetype, SPACE_TIME, SPACE_SOUND)) {
 
236
                                        if (stime->flag & TIME_DRAWFRAMES) 
 
237
                                                sprintf(str, "Marker %d offset %d", selmarker->frame, offs);
 
238
                                        else 
 
239
                                                sprintf(str, "Marker %.2f offset %.2f", FRA2TIME(selmarker->frame), FRA2TIME(offs));
 
240
                                }
 
241
                                else if (slink->spacetype == SPACE_ACTION) {
 
242
                                        if (saction->flag & SACTION_DRAWTIME)
 
243
                                                sprintf(str, "Marker %.2f offset %.2f", FRA2TIME(selmarker->frame), FRA2TIME(offs));
 
244
                                        else
 
245
                                                sprintf(str, "Marker %.2f offset %.2f", (double)(selmarker->frame), (double)(offs));
 
246
                                }
 
247
                                else {
 
248
                                        sprintf(str, "Marker %.2f offset %.2f", (double)(selmarker->frame), (double)(offs));
 
249
                                }
 
250
                        }
 
251
                        else {
 
252
                                /* we only print the offset */
 
253
                                if (ELEM(slink->spacetype, SPACE_TIME, SPACE_SOUND)) { 
 
254
                                        if (stime->flag & TIME_DRAWFRAMES) 
 
255
                                                sprintf(str, "Marker offset %d ", offs);
 
256
                                        else 
 
257
                                                sprintf(str, "Marker offset %.2f ", FRA2TIME(offs));
 
258
                                }
 
259
                                else if (slink->spacetype == SPACE_ACTION) {
 
260
                                        if (saction->flag & SACTION_DRAWTIME)
 
261
                                                sprintf(str, "Marker offset %.2f ", FRA2TIME(offs));
 
262
                                        else
 
263
                                                sprintf(str, "Marker offset %.2f ", (double)(offs));
 
264
                                }
 
265
                                else {
 
266
                                        sprintf(str, "Marker offset %.2f ", (double)(offs));
 
267
                                }
 
268
                        }
 
269
                        headerprint(str);
 
270
                        
 
271
                        force_draw(0);  // areas identical to this, 0 = no header
 
272
                }
 
273
                else PIL_sleep_ms(10);  // idle
 
274
                
 
275
                /* emptying queue and reading events */
 
276
                while ( qtest() ) {
 
277
                        event= extern_qread(&val);
 
278
                        
 
279
                        if (val) {
 
280
                                if (ELEM(event, ESCKEY, RIGHTMOUSE)) ret_val= 2;
 
281
                                else if (ELEM3(event, LEFTMOUSE, RETKEY, SPACEKEY)) ret_val= 1;
 
282
                        }
 
283
                }
 
284
        }
 
285
        
 
286
        /* restore? */
 
287
        if (ret_val==2) {
 
288
                for (a=0, marker= markers->first; marker; marker= marker->next) {
 
289
                        if (marker->flag & SELECT) {
 
290
                                marker->frame= oldframe[a];
 
291
                                a++;
 
292
                        }
 
293
                }
 
294
        }
 
295
        else {
 
296
                BIF_undo_push("Move Markers");
 
297
        }
 
298
        MEM_freeN(oldframe);
 
299
        allqueue(REDRAWMARKER, 0);
 
300
}
 
301
 
 
302
/* select/deselect all TimeMarkers
 
303
 *      test - based on current selections?
 
304
 *      sel - selection status to set all markers to if blanket apply status
 
305
 */
 
306
void deselect_markers(short test, short sel)
 
307
{
 
308
        TimeMarker *marker;
 
309
                
 
310
        /* check if need to find out whether to how to select markers */
 
311
        if (test) {
 
312
                /* dependant on existing selection */
 
313
                /* determine if select all or deselect all */
 
314
                sel = 1;
 
315
                for (marker= G.scene->markers.first; marker; marker= marker->next) {
 
316
                        if (marker->flag & SELECT) {
 
317
                                sel = 0;
 
318
                                break;
 
319
                        }
 
320
                }
 
321
                
 
322
                /* do selection */
 
323
                for (marker= G.scene->markers.first; marker; marker= marker->next) {
 
324
                        if (sel == 2) {
 
325
                                marker->flag ^= SELECT;
 
326
                        }
 
327
                        else if (sel == 1) {
 
328
                                if ((marker->flag & SELECT)==0) 
 
329
                                        marker->flag |= SELECT;
 
330
                        }
 
331
                        else {
 
332
                                if (marker->flag & SELECT)
 
333
                                        marker->flag &= ~SELECT;
 
334
                        }
 
335
                }
 
336
        }
 
337
        else {
 
338
                /* not dependant on existing selection */
 
339
                for (marker= G.scene->markers.first; marker; marker= marker->next) {
 
340
                                if (sel==2) {
 
341
                                        marker->flag ^= SELECT;
 
342
                                }
 
343
                                else if (sel==1) {
 
344
                                        if ((marker->flag & SELECT)==0)
 
345
                                                marker->flag |= SELECT;
 
346
                                }
 
347
                                else {
 
348
                                        if (marker->flag & SELECT)
 
349
                                                marker->flag &= ~SELECT;
 
350
                                }
 
351
                }
 
352
        }
 
353
}
 
354
 
 
355
static void borderselect_markers_func(float xmin, float xmax, int selectmode)
 
356
{
 
357
        TimeMarker *marker;
 
358
                
 
359
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
 
360
                if ((marker->frame > xmin) && (marker->frame <= xmax)) {
 
361
                        switch (selectmode) {
 
362
                                case SELECT_ADD:
 
363
                                        if ((marker->flag & SELECT) == 0) 
 
364
                                                marker->flag |= SELECT;
 
365
                                        break;
 
366
                                case SELECT_SUBTRACT:
 
367
                                        if (marker->flag & SELECT) 
 
368
                                                marker->flag &= ~SELECT;
 
369
                                        break;
 
370
                        }
 
371
                }
 
372
        }
 
373
}
 
374
 
 
375
/* border-select markers */
 
376
void borderselect_markers(void) 
 
377
{
 
378
        rcti rect;
 
379
        rctf rectf;
 
380
        int val, selectmode;            
 
381
        short   mval[2];
 
382
 
 
383
        if ( (val = get_border(&rect, 3)) ){
 
384
                if (val == LEFTMOUSE)
 
385
                        selectmode = SELECT_ADD;
 
386
                else
 
387
                        selectmode = SELECT_SUBTRACT;
 
388
 
 
389
                mval[0]= rect.xmin;
 
390
                mval[1]= rect.ymin+2;
 
391
                areamouseco_to_ipoco(G.v2d, mval, &rectf.xmin, &rectf.ymin);
 
392
                mval[0]= rect.xmax;
 
393
                mval[1]= rect.ymax-2;
 
394
                areamouseco_to_ipoco(G.v2d, mval, &rectf.xmax, &rectf.ymax);
 
395
                        
 
396
                /* do markers */
 
397
                borderselect_markers_func(rectf.xmin, rectf.xmax, selectmode);
 
398
                
 
399
                BIF_undo_push("Border Select Markers");
 
400
                allqueue(REDRAWMARKER, 0);
 
401
        }
 
402
}
 
403
 
 
404
void nextprev_marker(short dir)
 
405
{
 
406
        TimeMarker *marker, *cur=NULL, *first, *last;
 
407
        int mindist= MAXFRAME, dist;
 
408
                
 
409
        first= last= G.scene->markers.first; 
 
410
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
 
411
                /* find closest to current frame first */
 
412
                dist= (marker->frame/G.scene->r.framelen) - CFRA;
 
413
                if(dir==1 && dist>0 && dist<mindist) {
 
414
                        mindist= dist;
 
415
                        cur= marker;
 
416
                }
 
417
                else if(dir==-1 && dist<0 && -dist<mindist) {
 
418
                        mindist= -dist;
 
419
                        cur= marker;
 
420
                }
 
421
                /* find first/last */
 
422
                if(marker->frame > last->frame) last= marker;
 
423
                if(marker->frame < first->frame) first= marker;
 
424
        }
 
425
        
 
426
        if(cur==NULL) {
 
427
                if(dir==1) cur= first;
 
428
                else cur= last;
 
429
        }
 
430
        if(cur) {
 
431
                CFRA= cur->frame/G.scene->r.framelen;
 
432
                update_for_newframe();
 
433
                allqueue(REDRAWALL, 0);
 
434
        }
 
435
}
 
436
 
 
437
void get_minmax_markers(short sel, float *first, float *last)
 
438
{
 
439
        TimeMarker *marker;
 
440
        ListBase *markers;
 
441
        float min, max;
 
442
        int selcount = 0;
 
443
        
 
444
        markers= &(G.scene->markers);
 
445
        
 
446
        if (sel)
 
447
                for (marker= markers->first; marker; marker= marker->next) {
 
448
                        if (marker->flag & SELECT)
 
449
                                selcount++;
 
450
                }
 
451
        else {
 
452
                selcount= BLI_countlist(markers);
 
453
        }
 
454
        
 
455
        if (markers->first && markers->last) {
 
456
                min= ((TimeMarker *)markers->first)->frame;
 
457
                max= ((TimeMarker *)markers->last)->frame;
 
458
        }
 
459
        else {
 
460
                *first = 0.0f;
 
461
                *last = 0.0f;
 
462
                return;
 
463
        }
 
464
        
 
465
        if (selcount > 1) {
 
466
                for (marker= markers->first; marker; marker= marker->next) {
 
467
                        if (sel) {
 
468
                                if (marker->flag & SELECT) {
 
469
                                        if (marker->frame < min)
 
470
                                                min= marker->frame;
 
471
                                        else if (marker->frame > max)
 
472
                                                max= marker->frame;
 
473
                                }
 
474
                        }
 
475
                        else {
 
476
                                if (marker->frame < min)
 
477
                                        min= marker->frame;
 
478
                                else if (marker->frame > max)
 
479
                                        max= marker->frame;
 
480
                        }       
 
481
                }
 
482
        }
 
483
        
 
484
        *first= min;
 
485
        *last= max;
 
486
}
 
487
 
 
488
TimeMarker *find_nearest_marker(ListBase *markers, int clip_y)
 
489
{
 
490
        TimeMarker *marker;
 
491
        float xmin, xmax;
 
492
        rctf    rectf;
 
493
        short mval[2];
 
494
        
 
495
        getmouseco_areawin (mval);
 
496
        
 
497
        /* first clip selection in Y */
 
498
        if ((clip_y) && (mval[1] > 30))
 
499
                return NULL;
 
500
        
 
501
        mval[0]-=7;
 
502
        areamouseco_to_ipoco(G.v2d, mval, &rectf.xmin, &rectf.ymin);
 
503
        mval[0]+=14;
 
504
        areamouseco_to_ipoco(G.v2d, mval, &rectf.xmax, &rectf.ymax);
 
505
        
 
506
        xmin= rectf.xmin;
 
507
        xmax= rectf.xmax;
 
508
        
 
509
        for (marker= markers->first; marker; marker= marker->next) {
 
510
                if ((marker->frame > xmin) && (marker->frame <= xmax)) {
 
511
                        return marker;
 
512
                }
 
513
        }
 
514
        
 
515
        return NULL;
 
516
}
 
517
 
 
518
/* Adds a marker to list of cfra elems */
 
519
void add_marker_to_cfra_elem(ListBase *lb, TimeMarker *marker, short only_sel)
 
520
{
 
521
        CfraElem *ce, *cen;
 
522
        
 
523
        /* should this one only be considered if it is selected? */
 
524
        if ((only_sel) && ((marker->flag & SELECT)==0))
 
525
                return;
 
526
        
 
527
        /* try to find a previous cfra elem */
 
528
        ce= lb->first;
 
529
        while(ce) {
 
530
                
 
531
                if( ce->cfra==marker->frame ) {
 
532
                        /* do because of double keys */
 
533
                        if(marker->flag & SELECT) ce->sel= marker->flag;
 
534
                        return;
 
535
                }
 
536
                else if(ce->cfra > marker->frame) break;
 
537
                
 
538
                ce= ce->next;
 
539
        }       
 
540
        
 
541
        cen= MEM_callocN(sizeof(CfraElem), "add_to_cfra_elem"); 
 
542
        if(ce) BLI_insertlinkbefore(lb, ce, cen);
 
543
        else BLI_addtail(lb, cen);
 
544
 
 
545
        cen->cfra= marker->frame;
 
546
        cen->sel= marker->flag;
 
547
}
 
548
 
 
549
/* This function makes a list of all the markers. The only_sel
 
550
 * argument is used to specify whether only the selected markers
 
551
 * are added.
 
552
 */
 
553
void make_marker_cfra_list(ListBase *lb, short only_sel)
 
554
{
 
555
        TimeMarker *marker;
 
556
        
 
557
        for (marker= G.scene->markers.first; marker; marker= marker->next) {
 
558
                add_marker_to_cfra_elem(lb, marker, only_sel);
 
559
        }
 
560
}
 
561
 
 
562
int find_nearest_marker_time(float dx)
163
563
{
164
564
        TimeMarker *marker, *nearest= NULL;
165
565
        float dist, min_dist= 1000000;
176
576
        else return (int)floor(dx);
177
577
}
178
578
 
 
579
/* *********** End Markers - Markers API *************** */
179
580
/* select/deselect TimeMarker at current frame */
180
581
static void select_timeline_marker_frame(int frame, unsigned char shift)
181
582
{
196
597
        }
197
598
}
198
599
 
199
 
/* select/deselect all TimeMarkers */
200
 
void select_timeline_markers(void)
201
 
{
202
 
        TimeMarker *marker;
203
 
        char any_selected= 0;
204
 
        
205
 
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
206
 
                if(marker->flag & SELECT) any_selected= 1;
207
 
                marker->flag &= ~SELECT;
208
 
        }
209
 
        
210
 
        /* no TimeMarker selected, then select all TimeMarkers */
211
 
        if(!any_selected){
212
 
                for(marker= G.scene->markers.first; marker; marker= marker->next) {
213
 
                        marker->flag |= SELECT;
214
 
                }
215
 
        }
216
 
}
217
 
 
218
 
void nextprev_timeline_marker(short dir)
219
 
{
220
 
        TimeMarker *marker, *cur=NULL, *first, *last;
221
 
        int mindist= MAXFRAME, dist;
222
 
        
223
 
        first= last= G.scene->markers.first; 
224
 
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
225
 
                /* find closest to current frame first */
226
 
                dist= (marker->frame/G.scene->r.framelen) - CFRA;
227
 
                if(dir==1 && dist>0 && dist<mindist) {
228
 
                        mindist= dist;
229
 
                        cur= marker;
230
 
                }
231
 
                else if(dir==-1 && dist<0 && -dist<mindist) {
232
 
                        mindist= -dist;
233
 
                        cur= marker;
234
 
                }
235
 
                /* find first/last */
236
 
                if(marker->frame > last->frame) last= marker;
237
 
                if(marker->frame < first->frame) first= marker;
238
 
        }
239
 
        
240
 
        if(cur==NULL) {
241
 
                if(dir==1) cur= first;
242
 
                else cur= last;
243
 
        }
244
 
        if(cur) {
245
 
                CFRA= cur->frame/G.scene->r.framelen;
246
 
                update_for_newframe();
247
 
                allqueue(REDRAWALL, 0);
248
 
        }
249
 
}
250
 
 
251
 
/* *********** end Markers *************** */
 
600
/* *********** end Markers - TimeLine *************** */
 
601
 
 
602
/* set the animation preview range of scene */
 
603
void anim_previewrange_set()
 
604
{
 
605
        rcti rect;
 
606
        rctf rectf;
 
607
        short val, mval[2];
 
608
        
 
609
        /* set range by drawing border-select rectangle */
 
610
        if ( (val = get_border(&rect, 5)) ) {   
 
611
                /* get frame numbers */
 
612
                mval[0]= rect.xmin;
 
613
                mval[1]= rect.ymin+2;
 
614
                areamouseco_to_ipoco(G.v2d, mval, &rectf.xmin, &rectf.ymin);
 
615
                mval[0]= rect.xmax;
 
616
                mval[1]= rect.ymax-2;
 
617
                areamouseco_to_ipoco(G.v2d, mval, &rectf.xmax, &rectf.ymax);
 
618
                        
 
619
                /* set preview-range */
 
620
                if (rectf.xmin < 1) rectf.xmin = 1.0f;
 
621
                if (rectf.xmax < 1) rectf.xmax = 1.0f;
 
622
                G.scene->r.psfra= rectf.xmin;
 
623
                G.scene->r.pefra= rectf.xmax;
 
624
                
 
625
                BIF_undo_push("Set anim-preview range");
 
626
                allqueue(REDRAWTIME, 0);
 
627
                allqueue(REDRAWACTION, 0);
 
628
                allqueue(REDRAWNLA, 0);
 
629
                allqueue(REDRAWIPO, 0);
 
630
                allqueue(REDRAWBUTSALL, 0);
 
631
        }
 
632
}
 
633
 
 
634
/* clear the animation preview range for scene */
 
635
void anim_previewrange_clear()
 
636
{
 
637
        G.scene->r.psfra = 0;
 
638
        G.scene->r.pefra = 0;
 
639
        
 
640
        BIF_undo_push("Clear anim-preview range");
 
641
        allqueue(REDRAWTIME, 0);
 
642
        allqueue(REDRAWACTION, 0);
 
643
        allqueue(REDRAWNLA, 0);
 
644
        allqueue(REDRAWBUTSALL, 0);
 
645
}
 
646
 
 
647
/* ************ end Animation Preview Range ********** */
 
648
 
252
649
 
253
650
static int float_to_frame(float frame) 
254
651
{
349
746
        }
350
747
}
351
748
 
 
749
/* return the current marker for this frame,
 
750
we can have more then 1 marker per frame, this just returns the first :/ */
 
751
TimeMarker *get_frame_marker(int frame)
 
752
{
 
753
        TimeMarker *marker, *best_marker = NULL;
 
754
        int best_frame = -MAXFRAME*2; 
 
755
        for (marker= G.scene->markers.first; marker; marker= marker->next) {
 
756
                if (marker->frame==frame) {
 
757
                        return marker;
 
758
                }
 
759
                
 
760
                if ( marker->frame > best_frame && marker->frame < frame) {
 
761
                        best_marker = marker;
 
762
                        best_frame = marker->frame;
 
763
                }
 
764
        }
 
765
        
 
766
        return best_marker;
 
767
}
 
768
 
 
769
 
352
770
void timeline_frame_to_center(void)
353
771
{
354
772
        float dtime;
359
777
        scrarea_queue_winredraw(curarea);
360
778
}
361
779
 
362
 
void timeline_grab(int mode, int smode) // mode and smode unused here, for callback
363
 
{
364
 
        SpaceTime *stime= curarea->spacedata.first;
365
 
        TimeMarker *marker, *selmarker=NULL;
366
 
        float dx, fac;
367
 
        int a, ret_val= 0, totmark=0, *oldframe, offs, firsttime=1;
368
 
        unsigned short event;
369
 
        short val, pmval[2], mval[2], mvalo[2];
370
 
        char str[32];
371
 
        
372
 
        for(marker= G.scene->markers.first; marker; marker= marker->next) {
373
 
                if(marker->flag & SELECT) totmark++;
374
 
        }
375
 
        if(totmark==0) return;
376
 
        
377
 
        oldframe= MEM_mallocN(totmark*sizeof(int), "marker array");
378
 
        for(a=0, marker= G.scene->markers.first; marker; marker= marker->next) {
379
 
                if(marker->flag & SELECT) {
380
 
                        oldframe[a]= marker->frame;
381
 
                        selmarker= marker;      // used for hederprint
382
 
                        a++;
383
 
                }
384
 
        }
385
 
        
386
 
        dx= G.v2d->mask.xmax-G.v2d->mask.xmin;
387
 
        dx= (G.v2d->cur.xmax-G.v2d->cur.xmin)/dx;
388
 
        
389
 
        getmouseco_areawin(pmval);
390
 
        mvalo[0]= pmval[0];
391
 
        
392
 
        while(ret_val == 0) {
393
 
                
394
 
                getmouseco_areawin(mval);
395
 
                
396
 
                if (mval[0] != mvalo[0] || firsttime) {
397
 
                        mvalo[0]= mval[0];
398
 
                        firsttime= 0;
399
 
                        
400
 
                        fac= (((float)(mval[0] - pmval[0]))*dx);
401
 
                        
402
 
                        apply_keyb_grid(&fac, 0.0, (float)G.scene->r.frs_sec, 0.1*(float)G.scene->r.frs_sec, 0);
403
 
                        offs= (int)fac;
404
 
                        
405
 
                        for(a=0, marker= G.scene->markers.first; marker; marker= marker->next) {
406
 
                                if(marker->flag & SELECT) {
407
 
                                        marker->frame= oldframe[a] + offs;
408
 
                                        a++;
409
 
                                }
410
 
                        }
411
 
                        
412
 
                        if(totmark==1) {        // we print current marker value
413
 
                                if(stime->flag & TIME_DRAWFRAMES) 
414
 
                                        sprintf(str, "Marker %d offset %d", selmarker->frame, offs);
415
 
                                else 
416
 
                                        sprintf(str, "Marker %.2f offset %.2f", (selmarker->frame/(float)G.scene->r.frs_sec), (offs/(float)G.scene->r.frs_sec));
417
 
                        }
418
 
                        else {
419
 
                                if(stime->flag & TIME_DRAWFRAMES) 
420
 
                                        sprintf(str, "Marker offset %d ", offs);
421
 
                                else 
422
 
                                        sprintf(str, "Marker offset %.2f ", (offs/(float)G.scene->r.frs_sec));
423
 
                        }
424
 
                        headerprint(str);
425
 
                        
426
 
                        force_draw(0);  // areas identical to this, 0 = no header
427
 
                }
428
 
                else PIL_sleep_ms(10);  // idle
429
 
                
430
 
                /* emptying queue and reading events */
431
 
                while( qtest() ) {
432
 
                        event= extern_qread(&val);
433
 
                        
434
 
                        if(val) {
435
 
                                if(event==ESCKEY || event==RIGHTMOUSE) ret_val= 2;
436
 
                                else if(event==LEFTMOUSE || event==RETKEY || event==SPACEKEY) ret_val= 1;
437
 
                        }
438
 
                }
439
 
        }
440
 
        
441
 
        /* restore? */
442
 
        if(ret_val==2) {
443
 
                for(a=0, marker= G.scene->markers.first; marker; marker= marker->next) {
444
 
                        if(marker->flag & SELECT) {
445
 
                                marker->frame= oldframe[a];
446
 
                                a++;
447
 
                        }
448
 
                }
449
 
        }
450
 
        else {
451
 
                BIF_undo_push("Move Markers");
452
 
        }
453
 
        MEM_freeN(oldframe);
454
 
        allqueue(REDRAWTIME, 0);
455
 
}
456
 
 
457
780
/* copy of this is actually in editscreen.c, but event based */
458
781
static void timeline_force_draw(short val)
459
782
{
486
809
                else if(sa->spacetype==SPACE_BUTS) {
487
810
                        if(val & TIME_ALL_BUTS_WIN) dodraw= 1;
488
811
                }
 
812
                else if(sa->spacetype==SPACE_IMAGE) {
 
813
                        if (val & TIME_ALL_IMAGE_WIN) dodraw = 1;
 
814
                }
489
815
                else if(sa->spacetype==SPACE_SEQ) {
490
816
                        if (val & TIME_SEQ) dodraw = 1;
491
817
                }
521
847
 
522
848
        if(val) {
523
849
                
524
 
                if( uiDoBlocks(&sa->uiblocks, event)!=UI_NOTHING ) event= 0;
 
850
                if( uiDoBlocks(&sa->uiblocks, event, 1)!=UI_NOTHING ) event= 0;
525
851
 
526
852
                /* swap mouse buttons based on user preference */
527
853
                if (U.flag & USER_LMOUSESELECT) {
541
867
                                getmouseco_areawin(mval);
542
868
                                areamouseco_to_ipoco(G.v2d, mval, &dx, &dy);
543
869
                                
544
 
                                cfra = (int)dx;
 
870
                                cfra = (int)(dx+0.5f);
545
871
                                if(cfra< MINFRAME) cfra= MINFRAME;
546
872
                                
547
873
                                if( cfra!=CFRA || first )
562
888
                case RIGHTMOUSE: /* select/deselect marker */
563
889
                        getmouseco_areawin(mval);
564
890
                        areamouseco_to_ipoco(G.v2d, mval, &dx, &dy);
565
 
 
566
 
                        cfra= find_nearest_marker(dx);
567
 
 
 
891
                        
 
892
                        cfra= find_nearest_marker_time(dx);
 
893
                        
568
894
                        if (G.qual && LR_SHIFTKEY)
569
895
                                select_timeline_marker_frame(cfra, 1);
570
896
                        else
571
897
                                select_timeline_marker_frame(cfra, 0);
572
898
                        
573
899
                        force_draw(0);
574
 
                        std_rmouse_transform(timeline_grab);
 
900
                        std_rmouse_transform(transform_markers);
575
901
 
576
902
                        break;
577
903
                case MIDDLEMOUSE:
607
933
                        if(G.qual==LR_CTRLKEY)
608
934
                                nextprev_timeline_key(1);
609
935
                        else
610
 
                                nextprev_timeline_marker(1);
 
936
                                nextprev_marker(1);
611
937
                        break;
612
938
                case PAGEDOWNKEY: /* prev keyframe */
613
939
                        if(G.qual==LR_CTRLKEY)
614
940
                                nextprev_timeline_key(-1);
615
941
                        else
616
 
                                nextprev_timeline_marker(-1);
 
942
                                nextprev_marker(-1);
617
943
                        break;
618
944
                        
619
945
                case AKEY:
620
946
                        /* deselect all TimeMarkers */
621
 
                        select_timeline_markers();
622
 
                        doredraw= 1;
 
947
                        deselect_markers(1, 0);
 
948
                        allqueue(REDRAWMARKER, 0);
 
949
                        break;
 
950
                case BKEY:
 
951
                        /* borderselect markers */
 
952
                        borderselect_markers();
623
953
                        break;
624
954
                case DKEY:
625
955
                        if(G.qual==LR_SHIFTKEY)
626
 
                                duplicate_timeline_marker();
 
956
                                duplicate_marker();
627
957
                        break;
628
958
                case CKEY:
629
959
                        timeline_frame_to_center();
630
960
                        break;
631
961
                case GKEY: /* move marker */
632
 
                        timeline_grab('g', 0);
 
962
                        transform_markers('g', 0);
633
963
                        break;
634
964
                case EKEY: /* set end frame */
635
 
                        G.scene->r.efra = CFRA;
636
 
                        allqueue(REDRAWBUTSALL, 0);
637
 
                        allqueue(REDRAWTIME, 1);
 
965
                        if (G.scene->r.psfra) {
 
966
                                if (CFRA < G.scene->r.psfra)
 
967
                                        G.scene->r.psfra= CFRA;
 
968
                                G.scene->r.pefra= CFRA;
 
969
                        }                               
 
970
                        else
 
971
                                G.scene->r.efra = CFRA;
 
972
                        allqueue(REDRAWALL, 1);
638
973
                        break;
639
974
                case MKEY: /* add, rename marker */
640
975
                        if (G.qual & LR_CTRLKEY)
641
 
                                rename_timeline_marker();
 
976
                                rename_marker();
642
977
                        else
643
 
                                add_timeline_marker(CFRA);
644
 
                        allqueue(REDRAWTIME, 0);
 
978
                                add_marker(CFRA);
 
979
                        allqueue(REDRAWMARKER, 0);
 
980
                        break;
 
981
                case PKEY:      /* preview-range stuff */
 
982
                        if (G.qual & LR_CTRLKEY) /* set preview range */
 
983
                                anim_previewrange_set();
 
984
                        else if (G.qual & LR_ALTKEY) /* clear preview range */
 
985
                                anim_previewrange_clear();
645
986
                        break;
646
987
                case SKEY: /* set start frame */
647
 
                        G.scene->r.sfra = CFRA;
648
 
                        allqueue(REDRAWBUTSALL, 0);
649
 
                        allqueue(REDRAWTIME, 1);
 
988
                        if (G.scene->r.psfra) {
 
989
                                if (G.scene->r.pefra < CFRA)
 
990
                                        G.scene->r.pefra= CFRA;
 
991
                                G.scene->r.psfra= CFRA;
 
992
                        }                               
 
993
                        else
 
994
                                G.scene->r.sfra = CFRA;
 
995
                        allqueue(REDRAWALL, 1);
650
996
                        break;
651
997
                case TKEY: /* popup menu */
652
998
                        nr= pupmenu("Time value%t|Frames %x1|Seconds%x2");
660
1006
                case XKEY:
661
1007
                        if( okee("Erase selected")==0 ) break;
662
1008
 
663
 
                        remove_timeline_marker();
664
 
                        allqueue(REDRAWTIME, 0);
 
1009
                        remove_marker();
 
1010
                        allqueue(REDRAWMARKER, 0);
665
1011
                        break;
666
1012
                }
667
1013
        }