← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2007-05-17 11:47:59 UTC
  • mfrom: (1.2.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20070517114759-yp4ybrnhp2u7pk66
Tags: 2.44-1
* New upstream release.
* Drop debian/patches/01_64bits_stupidity, not needed anymore: as of this
  version blender is 64 bits safe again. Adjust README.Debian accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/src/header_action.c
4
4
 * Functions to draw the "Action Editor" window header
5
5
 * and handle user events sent to it.
6
6
 * 
7
 
 * $Id: header_action.c,v 1.59 2007/02/05 23:29:10 aligorith Exp $
 
7
 * $Id: header_action.c,v 1.62 2007/05/10 06:51:08 aligorith Exp $
8
8
 *
9
9
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
10
10
 *
150
150
 
151
151
        switch(event){
152
152
                case B_ACTBAKE:
153
 
                        bake_action_with_client (G.saction->action, ob, 0.01);
154
 
                        break;
155
 
                case B_ACTCONT:
156
 
                        set_exprap_action(IPO_HORIZ);
157
 
                        break;
158
 
//      case B_ACTEXTRAP:
159
 
//              set_exprap_ipo(IPO_DIR);
160
 
//              break;
161
 
                case B_ACTCYCLIC:
162
 
                        set_exprap_action(IPO_CYCL);
163
 
                        break;
164
 
//      case B_ACTCYCLICX:
165
 
//              set_exprap_ipo(IPO_CYCLX);
166
 
//              break;
 
153
                        bake_action_with_client(G.saction->action, ob, 0.01);
 
154
                        break;
167
155
                case B_ACTHOME:
168
 
                        //      Find X extents
169
 
                        //v2d= &(G.saction->v2d);
170
 
 
 
156
                        /*      Find X extents */
171
157
                        G.v2d->cur.xmin = 0;
172
158
                        G.v2d->cur.ymin=-SCROLLB;
173
159
 
174
 
                        if (!G.saction->action){        // here the mesh rvk?
175
 
                                G.v2d->cur.xmax= -5;
176
 
                                G.v2d->cur.xmax= 100;
177
 
                        }
178
 
                        else {
 
160
                        if (G.saction->action) {
179
161
                                float extra;
180
162
                                
181
163
                                calc_action_range(G.saction->action, &G.v2d->cur.xmin, &G.v2d->cur.xmax, 0);
182
 
                                if(G.saction->pin==0 && ob) {
 
164
                                if (G.saction->pin==0 && ob) {
183
165
                                        G.v2d->cur.xmin= get_action_frame_inv(ob, G.v2d->cur.xmin);
184
166
                                        G.v2d->cur.xmax= get_action_frame_inv(ob, G.v2d->cur.xmax);
185
167
                                }                               
187
169
                                G.v2d->cur.xmin-= extra;
188
170
                                G.v2d->cur.xmax+= extra;
189
171
 
190
 
                                if(G.v2d->cur.xmin==G.v2d->cur.xmax) {
 
172
                                if (G.v2d->cur.xmin==G.v2d->cur.xmax) {
191
173
                                        G.v2d->cur.xmax= -5;
192
174
                                        G.v2d->cur.xmax= 100;
193
175
                                }
194
176
                        }
 
177
                        else { /* shapekeys and/or no action */
 
178
                                G.v2d->cur.xmax= -5;
 
179
                                G.v2d->cur.xmax= 100;
 
180
                        }
195
181
                        G.v2d->cur.ymin= 0.0f;
196
182
                        G.v2d->cur.ymax= 1000.0f;
197
183
                        
216
202
                        break;
217
203
 
218
204
                case B_ACTPIN:  /* __PINFAKE */
219
 
/*              if (G.saction->flag & SACTION_PIN){
220
 
                if (G.saction->action)
221
 
                G.saction->action->id.us ++;
222
 
                
 
205
/*              if (G.saction->flag & SACTION_PIN) {
 
206
                        if (G.saction->action)
 
207
                                G.saction->action->id.us ++;
223
208
                }
224
209
                else {
225
210
                        if (G.saction->action)
226
211
                                G.saction->action->id.us --;
227
 
                                }
 
212
                }
228
213
*/              /* end PINFAKE */
229
214
                        allqueue(REDRAWACTION, 1);
230
215
                        break;
231
 
 
232
216
        }
233
217
}
234
218
 
368
352
        bAction *act;
369
353
        Key *key;
370
354
        
371
 
        saction= curarea->spacedata.first;
372
 
        act=saction->action;
 
355
        saction = curarea->spacedata.first;
 
356
        if (!saction) return;
 
357
 
 
358
        act = saction->action;
373
359
        key = get_action_mesh_key();
374
360
        
375
361
        if (event == ACTMENU_SEL_COLUMN_MARKERSBETWEEN) {
376
362
                markers_selectkeys_between();
377
363
        }
378
364
        else if (ELEM(event, ACTMENU_SEL_COLUMN_KEYS, ACTMENU_SEL_COLUMN_MARKERSCOLUMN)) {
379
 
                if (key)
 
365
                if (act)
 
366
                        column_select_actionkeys(act, event);
 
367
                else if (key)
380
368
                        column_select_shapekeys(key, event);
381
 
                else if (act)
382
 
                        column_select_actionkeys(act, event);
383
369
        }
384
370
        else
385
371
                return;
424
410
        Key *key;
425
411
        
426
412
        saction = curarea->spacedata.first;
427
 
        if (!saction)
428
 
                return;
 
413
        if (!saction) return;
429
414
 
430
415
        act = saction->action;
431
416
        key = get_action_mesh_key();
433
418
        switch(event)
434
419
        {
435
420
                case ACTMENU_SEL_BORDER: /* Border Select */
436
 
                        if (key) {
 
421
                        if (act) {
 
422
                                borderselect_action();
 
423
                        }
 
424
                        else if (key) {
437
425
                                borderselect_mesh(key);
438
426
                        }
439
 
                        else {
440
 
                                borderselect_action();
441
 
                        }
442
427
                        break;
443
428
                        
444
429
                case ACTMENU_SEL_BORDERM: /* Border Select */
446
431
                        break;
447
432
 
448
433
                case ACTMENU_SEL_ALL_KEYS: /* Select/Deselect All Keys */
449
 
                        if (key) {
 
434
                        if (act) {
 
435
                                deselect_actionchannel_keys (act, 1, 1);
 
436
                                allqueue (REDRAWACTION, 0);
 
437
                                allqueue(REDRAWNLA, 0);
 
438
                                allqueue (REDRAWIPO, 0);
 
439
                        }
 
440
                        else if (key) {
450
441
                                deselect_meshchannel_keys(key, 1, 1);
451
442
                                allqueue (REDRAWACTION, 0);
452
443
                                allqueue(REDRAWNLA, 0);
453
444
                                allqueue (REDRAWIPO, 0);
454
445
                        }
455
 
                        else {
456
 
                                deselect_actionchannel_keys (act, 1, 1);
457
 
                                allqueue (REDRAWACTION, 0);
458
 
                                allqueue(REDRAWNLA, 0);
459
 
                                allqueue (REDRAWIPO, 0);
460
 
                        }
461
446
                        break;
462
447
 
463
448
                case ACTMENU_SEL_ALL_CHAN: /* Select/Deselect All Channels */
464
 
                        deselect_actionchannels (act, 1);
 
449
                        deselect_actionchannels(act, 1);
465
450
                        allqueue (REDRAWVIEW3D, 0);
466
451
                        allqueue (REDRAWACTION, 0);
467
452
                        allqueue(REDRAWNLA, 0);
478
463
                        break;
479
464
                        
480
465
                case ACTMENU_SEL_INVERSE_KEYS: /* invert selection status of keys */
481
 
                        if (key) {
 
466
                        if (act) {
 
467
                                deselect_actionchannel_keys(act, 0, 2);
 
468
                                allqueue (REDRAWACTION, 0);
 
469
                                allqueue(REDRAWNLA, 0);
 
470
                                allqueue (REDRAWIPO, 0);
 
471
                        }
 
472
                        else if (key) {
482
473
                                deselect_meshchannel_keys(key, 0, 2);
483
474
                                allqueue (REDRAWACTION, 0);
484
475
                                allqueue(REDRAWNLA, 0);
485
476
                                allqueue (REDRAWIPO, 0);
486
477
                        }
487
 
                        else {
488
 
                                deselect_actionchannel_keys (act, 0, 2);
489
 
                                allqueue (REDRAWACTION, 0);
490
 
                                allqueue(REDRAWNLA, 0);
491
 
                                allqueue (REDRAWIPO, 0);
492
 
                        }
493
478
                        break;
494
479
                        
495
480
                case ACTMENU_SEL_INVERSE_MARKERS: /* invert selection of markers */
574
559
        bAction *act;
575
560
        Key *key;
576
561
        
 
562
        saction = curarea->spacedata.first;
 
563
        if (!saction) return;
 
564
 
 
565
        act = saction->action;
577
566
        key = get_action_mesh_key();
578
 
        saction= curarea->spacedata.first;
579
 
        
580
 
        act=saction->action;
581
 
        
582
 
        switch(event)
 
567
        
 
568
        switch (event)
583
569
        {
584
570
                case ACTMENU_KEY_TRANSFORM_MOVE:
585
 
                        if (key) {
 
571
                        if (act) {      
 
572
                                transform_actionchannel_keys ('g', 0);
 
573
                        }
 
574
                        else if (key) {
586
575
                                transform_meshchannel_keys('g', key);
587
576
                        } 
588
 
                        else if (act) { 
589
 
                                transform_actionchannel_keys ('g', 0);
590
 
                        }
591
577
                        break;
592
578
                case ACTMENU_KEY_TRANSFORM_SCALE:
593
 
                        if (key) {
 
579
                        if (act) {
 
580
                                transform_actionchannel_keys ('s', 0);
 
581
                        }
 
582
                        else if (key) {
594
583
                                transform_meshchannel_keys('s', key);
595
584
                        } 
596
 
                        else if (act) {
597
 
                                transform_actionchannel_keys ('s', 0);
598
 
                        }
599
585
                        break;
600
586
                case ACTMENU_KEY_TRANSFORM_SLIDE:
601
 
                        if (key) {
 
587
                        if (act) {
 
588
                                transform_actionchannel_keys ('t', 0);
 
589
                        }
 
590
                        else if (key) {
602
591
                                //transform_meshchannel_keys('t', key);
603
592
                        } 
604
 
                        else if (act) {
605
 
                                transform_actionchannel_keys ('t', 0);
606
 
                        }
607
593
                        break;
608
594
        }
609
595
 
638
624
 
639
625
static void do_action_keymenu_handlemenu(void *arg, int event)
640
626
{
 
627
        SpaceAction *saction;
 
628
        bAction *act;
641
629
        Key *key;
642
630
        
 
631
        saction = curarea->spacedata.first;
 
632
        if (!saction) return;
 
633
 
 
634
        act = saction->action;
643
635
        key = get_action_mesh_key();
644
636
 
645
 
        switch (event){
 
637
        switch (event) {
646
638
                case ACTMENU_KEY_HANDLE_AUTO:
647
 
                        if (key) {
 
639
                        if (act) {
 
640
                                sethandles_actionchannel_keys(HD_AUTO);
 
641
                        }
 
642
                        else if (key) {
648
643
                                sethandles_meshchannel_keys(HD_AUTO, key);
649
 
                        } else {
650
 
                                sethandles_actionchannel_keys(HD_AUTO);
651
 
                        }
 
644
                        } 
652
645
                        break;
653
646
 
654
647
                case ACTMENU_KEY_HANDLE_ALIGN:
656
649
                        /* OK, this is kinda dumb, need to fix the
657
650
                         * toggle crap in sethandles_ipo_keys() 
658
651
                         */
659
 
                        if (key) {
 
652
                        if (act) {
 
653
                                sethandles_actionchannel_keys(HD_ALIGN);
 
654
                        }
 
655
                        else if (key) {
660
656
                                sethandles_meshchannel_keys(HD_ALIGN, key);
661
 
                        } else {
662
 
                                sethandles_actionchannel_keys(HD_ALIGN);
663
 
                        }
 
657
                        } 
664
658
                        break;
665
659
 
666
660
                case ACTMENU_KEY_HANDLE_VECTOR:
667
 
                        if (key) {
 
661
                        if (act) {
 
662
                                sethandles_actionchannel_keys(HD_VECT);
 
663
                        }
 
664
                        else if (key) {
668
665
                                sethandles_meshchannel_keys(HD_VECT, key);
669
 
                        } else {
670
 
                                sethandles_actionchannel_keys(HD_VECT);
671
 
                        }
 
666
                        }                       
672
667
                        break;
673
668
        }
674
669
}
706
701
 
707
702
static void do_action_keymenu_intpolmenu(void *arg, int event)
708
703
{
709
 
        Key *key;
 
704
        SpaceAction *saction;
 
705
        bAction *act;
 
706
        //Key *key;
 
707
        
 
708
        saction = curarea->spacedata.first;
 
709
        if (!saction) return;
710
710
 
711
 
        key = get_action_mesh_key();
 
711
        act = saction->action;
 
712
        //key = get_action_mesh_key();
712
713
 
713
714
        switch(event)
714
715
        {
715
716
                case ACTMENU_KEY_INTERP_CONST:
716
 
                        if (key) {
717
 
                                /* to do */
718
 
                        }
719
 
                        else {
 
717
                        if (act)
720
718
                                set_ipotype_actionchannels(SET_IPO_CONSTANT);
721
 
                        }
 
719
                        //else if (key) /* todo */
722
720
                        break;
723
721
                case ACTMENU_KEY_INTERP_LINEAR:
724
 
                        if (key) {
725
 
                                /* to do */
726
 
                        }
727
 
                        else {
 
722
                        if (act)
728
723
                                set_ipotype_actionchannels(SET_IPO_LINEAR);
729
 
                        }
 
724
                        //else if (key) /* todo */
730
725
                        break;
731
726
                case ACTMENU_KEY_INTERP_BEZIER:
732
 
                        if (key) {
733
 
                                /* to do */
734
 
                        }
735
 
                        else {
 
727
                        if (act)
736
728
                                set_ipotype_actionchannels(SET_IPO_BEZIER);
737
 
                        }
 
729
                        //else if (key) /* todo */
738
730
                        break;
739
731
        }
740
732
 
771
763
 
772
764
static void do_action_keymenu_extendmenu(void *arg, int event)
773
765
{
774
 
        Key *key;
 
766
        SpaceAction *saction;
 
767
        bAction *act;
 
768
        //Key *key;
 
769
        
 
770
        saction = curarea->spacedata.first;
 
771
        if (!saction) return;
775
772
 
776
 
        key = get_action_mesh_key();
 
773
        act = saction->action;
 
774
        //key = get_action_mesh_key();
777
775
 
778
776
        switch(event)
779
777
        {
780
778
                case ACTMENU_KEY_EXTEND_CONST:
781
 
                        if (key) {
782
 
                                /* to do */
783
 
                        }
784
 
                        else {
 
779
                        if (act)
785
780
                                set_extendtype_actionchannels(SET_EXTEND_CONSTANT);
786
 
                        }
 
781
                        //else if (key) /* todo */
787
782
                        break;
788
783
                case ACTMENU_KEY_EXTEND_EXTRAPOLATION:
789
 
                        if (key) {
790
 
                                /* to do */
791
 
                        }
792
 
                        else {
 
784
                        if (act)
793
785
                                set_extendtype_actionchannels(SET_EXTEND_EXTRAPOLATION);
794
 
                        }
 
786
                        //else if (key) /* todo */
795
787
                        break;
796
788
                case ACTMENU_KEY_EXTEND_CYCLIC:
797
 
                        if (key) {
798
 
                                /* to do */
799
 
                        }
800
 
                        else {
 
789
                        if (act)
801
790
                                set_extendtype_actionchannels(SET_EXTEND_CYCLIC);
802
 
                        }
 
791
                        //else if (key) /* todo */
803
792
                        break;
804
793
                case ACTMENU_KEY_EXTEND_CYCLICEXTRAPOLATION:
805
 
                        if (key) {
806
 
                                /* to do */
807
 
                        }
808
 
                        else {
 
794
                        if (act)
809
795
                                set_extendtype_actionchannels(SET_EXTEND_CYCLICEXTRAPOLATION);
810
 
                        }
 
796
                        //else if (key) /* todo */
811
797
                        break;
812
798
        }
813
799
 
996
982
        bAction *act;
997
983
        Key *key;
998
984
        
999
 
        saction= curarea->spacedata.first;
1000
 
        if (!saction)
1001
 
                return;
 
985
        saction = curarea->spacedata.first;
 
986
        if (!saction) return;
1002
987
 
1003
988
        act = saction->action;
1004
989
        key = get_action_mesh_key();
1006
991
        switch(event)
1007
992
        {
1008
993
                case ACTMENU_KEY_DUPLICATE:
1009
 
                        if (key) {
1010
 
                                duplicate_meshchannel_keys(key);
1011
 
                        }
1012
 
                        else if (act) {
 
994
                        if (act) {
1013
995
                                duplicate_actionchannel_keys();
1014
996
                                remake_action_ipos(act);
1015
997
                        }
 
998
                        else if (key) {
 
999
                                duplicate_meshchannel_keys(key);
 
1000
                        }
1016
1001
                        break;
1017
1002
 
1018
1003
                case ACTMENU_KEY_DELETE:
1019
 
                        if (okee("Erase selected keys")) {
1020
 
                                if (key) {
1021
 
                                        delete_meshchannel_keys(key);
1022
 
                                }
1023
 
                                else if (act) {
1024
 
                                        delete_actionchannel_keys ();
1025
 
                                }
 
1004
                        if (act) {
 
1005
                                delete_actionchannel_keys ();
 
1006
                        }
 
1007
                        else if (key) {
 
1008
                                delete_meshchannel_keys(key);
1026
1009
                        }
1027
1010
                        break;
1028
1011
                case ACTMENU_KEY_BAKE:
1029
 
                        bake_action_with_client (G.saction->action, OBACT, 0.01);
 
1012
                        bake_action_with_client(G.saction->action, OBACT, 0.01);
1030
1013
                        break;
1031
1014
                case ACTMENU_KEY_CLEAN:
1032
 
                        if (key) 
 
1015
                        if (act) 
 
1016
                                clean_actionchannels(act);
 
1017
                        else if (key) 
1033
1018
                                clean_shapekeys(key);
1034
 
                        else if (act) 
1035
 
                                clean_actionchannels(act);
1036
1019
                        break;
1037
1020
        }
1038
1021
}