~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

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

Tags: upstream-2.50~alpha~0~svn24834
ImportĀ upstreamĀ versionĀ 2.50~alpha~0~svn24834

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/**
2
 
 * header_action.c oct-2003
3
 
 *
4
 
 * Functions to draw the "Action Editor" window header
5
 
 * and handle user events sent to it.
6
 
 * 
7
 
 * $Id: header_action.c 16931 2008-10-05 11:49:09Z aligorith $
8
 
 *
9
 
 * ***** BEGIN GPL LICENSE BLOCK *****
10
 
 *
11
 
 * This program is free software; you can redistribute it and/or
12
 
 * modify it under the terms of the GNU General Public License
13
 
 * as published by the Free Software Foundation; either version 2
14
 
 * of the License, or (at your option) any later version.
15
 
 *
16
 
 * This program is distributed in the hope that it will be useful,
17
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
 
 * GNU General Public License for more details.
20
 
 *
21
 
 * You should have received a copy of the GNU General Public License
22
 
 * along with this program; if not, write to the Free Software Foundation,
23
 
 * Inc., 59 Temple Place - Suite 330, Boston, MA        02111-1307, USA.
24
 
 *
25
 
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
26
 
 * All rights reserved.
27
 
 *
28
 
 * The Original Code is: all of this file.
29
 
 *
30
 
 * Contributor(s): 2007, Joshua Leung (Action Editor recode) 
31
 
 *
32
 
 * ***** END GPL LICENSE BLOCK *****
33
 
 */
34
 
 
35
 
#include <stdlib.h>
36
 
#include <string.h>
37
 
#include <stdio.h>
38
 
 
39
 
#ifdef HAVE_CONFIG_H
40
 
#include <config.h>
41
 
#endif
42
 
 
43
 
#include "DNA_action_types.h"
44
 
#include "DNA_curve_types.h"
45
 
#include "DNA_ID.h"
46
 
#include "DNA_ipo_types.h"
47
 
#include "DNA_key_types.h"
48
 
#include "DNA_object_types.h"
49
 
#include "DNA_scene_types.h"
50
 
#include "DNA_screen_types.h"
51
 
#include "DNA_space_types.h"
52
 
 
53
 
#include "BIF_gl.h"
54
 
#include "BIF_glutil.h"
55
 
#include "BIF_editaction.h"
56
 
#include "BIF_interface.h"
57
 
#include "BIF_language.h"
58
 
#include "BIF_poseobject.h"
59
 
#include "BIF_resources.h"
60
 
#include "BIF_screen.h"
61
 
#include "BIF_space.h"
62
 
#include "BIF_toolbox.h"
63
 
 
64
 
#include "BKE_action.h"
65
 
#include "BKE_armature.h"
66
 
#include "BKE_constraint.h"
67
 
#include "BKE_depsgraph.h"
68
 
#include "BKE_global.h"
69
 
#include "BKE_main.h"
70
 
#include "BKE_utildefines.h"
71
 
 
72
 
#include "BDR_drawaction.h"
73
 
#include "BSE_drawipo.h"
74
 
#include "BSE_headerbuttons.h"
75
 
#include "BSE_time.h"
76
 
 
77
 
#include "nla.h"
78
 
 
79
 
#include "blendef.h"
80
 
#include "mydevice.h"
81
 
 
82
 
/* ------------------------------- */
83
 
/* enums declaring constants that are used as menu event codes  */
84
 
 
85
 
enum {
86
 
        ACTMENU_VIEW_CENTERVIEW= 0,
87
 
        ACTMENU_VIEW_AUTOUPDATE,
88
 
        ACTMENU_VIEW_PLAY3D,
89
 
        ACTMENU_VIEW_PLAYALL,
90
 
        ACTMENU_VIEW_ALL,
91
 
        ACTMENU_VIEW_MAXIMIZE,
92
 
        ACTMENU_VIEW_LOCK,
93
 
        ACTMENU_VIEW_SLIDERS,
94
 
        ACTMENU_VIEW_NEXTMARKER,
95
 
        ACTMENU_VIEW_PREVMARKER,
96
 
        ACTMENU_VIEW_NEXTKEYFRAME,
97
 
        ACTMENU_VIEW_PREVKEYFRAME,
98
 
        ACTMENU_VIEW_TIME,
99
 
        ACTMENU_VIEW_NOHIDE,
100
 
        ACTMENU_VIEW_TRANSDELDUPS,
101
 
        ACTMENU_VIEW_HORIZOPTIMISE,
102
 
        ACTMENU_VIEW_GCOLORS,
103
 
        ACTMENU_VIEW_PREVRANGESET,
104
 
        ACTMENU_VIEW_PREVRANGECLEAR,
105
 
        ACTMENU_VIEW_PREVRANGEAUTO
106
 
};
107
 
 
108
 
enum {
109
 
        ACTMENU_SEL_BORDER = 0,
110
 
        ACTMENU_SEL_BORDERC,
111
 
        ACTMENU_SEL_BORDERM,
112
 
        ACTMENU_SEL_ALL_KEYS,
113
 
        ACTMENU_SEL_ALL_CHAN,
114
 
        ACTMENU_SEL_ALL_MARKERS,
115
 
        ACTMENU_SEL_INVERSE_KEYS,
116
 
        ACTMENU_SEL_INVERSE_MARKERS,
117
 
        ACTMENU_SEL_INVERSE_CHANNELS,
118
 
        ACTMENU_SEL_LEFTKEYS,
119
 
        ACTMENU_SEL_RIGHTKEYS
120
 
};
121
 
 
122
 
enum {
123
 
        ACTMENU_SEL_COLUMN_KEYS = 1,
124
 
        ACTMENU_SEL_COLUMN_CFRA,
125
 
        ACTMENU_SEL_COLUMN_MARKERSCOLUMN,
126
 
        ACTMENU_SEL_COLUMN_MARKERSBETWEEN 
127
 
};
128
 
 
129
 
enum {
130
 
        ACTMENU_CHANNELS_OPENLEVELS = 0,
131
 
        ACTMENU_CHANNELS_CLOSELEVELS,
132
 
        ACTMENU_CHANNELS_EXPANDALL,
133
 
        ACTMENU_CHANNELS_SHOWACHANS,
134
 
        ACTMENU_CHANNELS_DELETE
135
 
};
136
 
 
137
 
enum {
138
 
        ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_UP        = 0,
139
 
        ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_DOWN,
140
 
        ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_TOP,
141
 
        ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_BOTTOM
142
 
};
143
 
 
144
 
enum {
145
 
        ACTMENU_CHANNELS_GROUP_ADD_TOACTIVE     = 0,
146
 
        ACTMENU_CHANNELS_GROUP_ADD_TONEW,
147
 
        ACTMENU_CHANNELS_GROUP_REMOVE,
148
 
        ACTMENU_CHANNELS_GROUP_SYNCPOSE
149
 
};
150
 
 
151
 
enum {
152
 
        ACTMENU_CHANNELS_SETTINGS_TOGGLE = 0,
153
 
        ACTMENU_CHANNELS_SETTINGS_ENABLE,
154
 
        ACTMENU_CHANNELS_SETTINGS_DISABLE,
155
 
};
156
 
 
157
 
enum {
158
 
        ACTMENU_KEY_DUPLICATE = 0,
159
 
        ACTMENU_KEY_DELETE,
160
 
        ACTMENU_KEY_CLEAN,
161
 
        ACTMENU_KEY_SAMPLEKEYS,
162
 
        ACTMENU_KEY_INSERTKEY
163
 
};
164
 
 
165
 
enum {
166
 
        ACTMENU_KEY_TRANSFORM_MOVE  = 0,
167
 
        ACTMENU_KEY_TRANSFORM_SCALE,
168
 
        ACTMENU_KEY_TRANSFORM_SLIDE,
169
 
        ACTMENU_KEY_TRANSFORM_EXTEND
170
 
};
171
 
 
172
 
enum {
173
 
        ACTMENU_KEY_HANDLE_AUTO = 0,
174
 
        ACTMENU_KEY_HANDLE_ALIGN,
175
 
        ACTMENU_KEY_HANDLE_FREE,
176
 
        ACTMENU_KEY_HANDLE_VECTOR
177
 
};
178
 
 
179
 
enum {
180
 
        ACTMENU_KEY_INTERP_CONST = 0,
181
 
        ACTMENU_KEY_INTERP_LINEAR,
182
 
        ACTMENU_KEY_INTERP_BEZIER
183
 
};
184
 
 
185
 
enum {
186
 
        ACTMENU_KEY_EXTEND_CONST = 0,
187
 
        ACTMENU_KEY_EXTEND_EXTRAPOLATION,
188
 
        ACTMENU_KEY_EXTEND_CYCLIC,
189
 
        ACTMENU_KEY_EXTEND_CYCLICEXTRAPOLATION
190
 
};
191
 
 
192
 
enum {
193
 
        ACTMENU_KEY_SNAP_NEARFRAME = 1,
194
 
        ACTMENU_KEY_SNAP_CURFRAME,
195
 
        ACTMENU_KEY_SNAP_NEARMARK,
196
 
        ACTMENU_KEY_SNAP_NEARTIME,
197
 
        ACTMENU_KEY_SNAP_CFRA2KEY,
198
 
};
199
 
 
200
 
enum {
201
 
        ACTMENU_KEY_MIRROR_CURFRAME = 1,
202
 
        ACTMENU_KEY_MIRROR_YAXIS,
203
 
        ACTMENU_KEY_MIRROR_XAXIS,
204
 
        ACTMENU_KEY_MIRROR_MARKER
205
 
};
206
 
 
207
 
enum {
208
 
        ACTMENU_MARKERS_ADD = 0,
209
 
        ACTMENU_MARKERS_DUPLICATE,
210
 
        ACTMENU_MARKERS_DELETE,
211
 
        ACTMENU_MARKERS_NAME,
212
 
        ACTMENU_MARKERS_MOVE,
213
 
        ACTMENU_MARKERS_LOCALADD,
214
 
        ACTMENU_MARKERS_LOCALRENAME,
215
 
        ACTMENU_MARKERS_LOCALDELETE,
216
 
        ACTMENU_MARKERS_LOCALMOVE
217
 
};
218
 
 
219
 
/* ------------------------------- */
220
 
/* macros for easier state testing (only for use here) */
221
 
 
222
 
/* test if active action editor is showing any markers */
223
 
#define G_SACTION_HASMARKERS \
224
 
        ((G.saction->action && G.saction->action->markers.first) \
225
 
         || (G.scene->markers.first))
226
 
 
227
 
/* ------------------------------- */
228
 
 
229
 
void do_action_buttons(unsigned short event)
230
 
{
231
 
        Object *ob= OBACT;
232
 
 
233
 
        switch(event) {
234
 
                case B_ACTHOME: /* HOMEKEY in Action Editor */
235
 
                        /*      Find X extents */
236
 
                        G.v2d->cur.xmin = 0;
237
 
                        G.v2d->cur.ymin=-SCROLLB;
238
 
                        
239
 
                        if (G.saction->action) {
240
 
                                float extra;
241
 
                                
242
 
                                calc_action_range(G.saction->action, &G.v2d->cur.xmin, &G.v2d->cur.xmax, 0);
243
 
                                if (G.saction->pin==0 && ob) {
244
 
                                        G.v2d->cur.xmin= get_action_frame_inv(ob, G.v2d->cur.xmin);
245
 
                                        G.v2d->cur.xmax= get_action_frame_inv(ob, G.v2d->cur.xmax);
246
 
                                }                               
247
 
                                extra= 0.05*(G.v2d->cur.xmax - G.v2d->cur.xmin);
248
 
                                G.v2d->cur.xmin-= extra;
249
 
                                G.v2d->cur.xmax+= extra;
250
 
 
251
 
                                if (G.v2d->cur.xmin==G.v2d->cur.xmax) {
252
 
                                        G.v2d->cur.xmax= -5;
253
 
                                        G.v2d->cur.xmax= 100;
254
 
                                }
255
 
                        }
256
 
                        else { /* shapekeys and/or no action */
257
 
                                G.v2d->cur.xmin= -5.0;
258
 
                                G.v2d->cur.xmax= 65.0;
259
 
                        }
260
 
                        
261
 
                        G.v2d->cur.ymin= -75.0;
262
 
                        G.v2d->cur.ymax= 5.0;
263
 
                        
264
 
                        G.v2d->tot= G.v2d->cur;
265
 
                        test_view2d(G.v2d, curarea->winx, curarea->winy);
266
 
                        view2d_do_locks(curarea, V2D_LOCK_COPY);
267
 
                        
268
 
                        addqueue (curarea->win, REDRAW, 1);
269
 
                        
270
 
                        break;
271
 
                        
272
 
                /* copy/paste/paste-flip buttons in 3d-view header in PoseMode */
273
 
                case B_ACTCOPY:
274
 
                        copy_posebuf();
275
 
                        allqueue(REDRAWVIEW3D, 1);
276
 
                        break;
277
 
                case B_ACTPASTE:
278
 
                        paste_posebuf(0);
279
 
                        allqueue(REDRAWVIEW3D, 1);
280
 
                        break;
281
 
                case B_ACTPASTEFLIP:
282
 
                        paste_posebuf(1);
283
 
                        allqueue(REDRAWVIEW3D, 1);
284
 
                        break;
285
 
                        
286
 
                /* copy/paste buttons in Action Editor header */
287
 
                case B_ACTCOPYKEYS:
288
 
                        if (G.saction->mode == SACTCONT_GPENCIL)
289
 
                                copy_gpdata();
290
 
                        else
291
 
                                copy_actdata();
292
 
                        break;
293
 
                case B_ACTPASTEKEYS:
294
 
                        if (G.saction->mode == SACTCONT_GPENCIL)
295
 
                                paste_gpdata();
296
 
                        else
297
 
                                paste_actdata();
298
 
                        break;
299
 
 
300
 
                case B_ACTPIN:  /* __PINFAKE */
301
 
/*              if (G.saction->flag & SACTION_PIN) {
302
 
                        if (G.saction->action)
303
 
                                G.saction->action->id.us ++;
304
 
                }
305
 
                else {
306
 
                        if (G.saction->action)
307
 
                                G.saction->action->id.us --;
308
 
                }
309
 
*/              /* end PINFAKE */
310
 
                        allqueue(REDRAWACTION, 1);
311
 
                        break;
312
 
        }
313
 
}
314
 
 
315
 
static void do_action_viewmenu(void *arg, int event)
316
 
{
317
 
        extern int play_anim(int mode);
318
 
 
319
 
        switch(event) {
320
 
                case ACTMENU_VIEW_CENTERVIEW: /* Center View to Current Frame */
321
 
                        center_currframe();
322
 
                        break;
323
 
                case ACTMENU_VIEW_AUTOUPDATE: /* Update Automatically */
324
 
                        if (BTST(G.saction->lock, 0)) 
325
 
                                G.saction->lock = BCLR(G.saction->lock, 0);
326
 
                        else 
327
 
                                G.saction->lock = BSET(G.saction->lock, 0);
328
 
                        break;
329
 
                case ACTMENU_VIEW_PLAY3D: /* Play Back Animation */
330
 
                        play_anim(0);
331
 
                        break;
332
 
                case ACTMENU_VIEW_PLAYALL: /* Play Back Animation in All */
333
 
                        play_anim(1);
334
 
                        break;  
335
 
                case ACTMENU_VIEW_ALL: /* View All */
336
 
                        do_action_buttons(B_ACTHOME);
337
 
                        break;
338
 
                case ACTMENU_VIEW_LOCK:
339
 
                        G.v2d->flag ^= V2D_VIEWLOCK;
340
 
                        if (G.v2d->flag & V2D_VIEWLOCK)
341
 
                                view2d_do_locks(curarea, 0);
342
 
                        break;
343
 
                case ACTMENU_VIEW_SLIDERS:       /* Show sliders (when applicable) */
344
 
                        G.saction->flag ^= SACTION_SLIDERS;
345
 
                        break;
346
 
                case ACTMENU_VIEW_MAXIMIZE: /* Maximize Window */
347
 
                        /* using event B_FULL */
348
 
                        break;
349
 
                case ACTMENU_VIEW_NEXTMARKER: /* Jump to next marker */
350
 
                        nextprev_marker(1);
351
 
                        break;
352
 
                case ACTMENU_VIEW_PREVMARKER: /* Jump to previous marker */
353
 
                        nextprev_marker(-1);
354
 
                        break;
355
 
                case ACTMENU_VIEW_TIME: /* switch between frames and seconds display */
356
 
                        G.saction->flag ^= SACTION_DRAWTIME;
357
 
                        break;
358
 
                case ACTMENU_VIEW_NOHIDE: /* Show hidden channels */
359
 
                        G.saction->flag ^= SACTION_NOHIDE;
360
 
                        break;
361
 
                case ACTMENU_VIEW_NEXTKEYFRAME: /* Jump to next keyframe */
362
 
                        nextprev_action_keyframe(1);
363
 
                        break;
364
 
                case ACTMENU_VIEW_PREVKEYFRAME: /* Jump to previous keyframe */
365
 
                        nextprev_action_keyframe(-1);
366
 
                        break;
367
 
                case ACTMENU_VIEW_TRANSDELDUPS: /* Don't delete duplicate/overlapping keyframes after transform */
368
 
                        G.saction->flag ^= SACTION_NOTRANSKEYCULL;
369
 
                        break;
370
 
                case ACTMENU_VIEW_HORIZOPTIMISE: /* Include keyframes not in view (horizontally) when preparing to draw */
371
 
                        G.saction->flag ^= SACTION_HORIZOPTIMISEON;
372
 
                        break;
373
 
                case ACTMENU_VIEW_GCOLORS: /* Draw grouped-action channels using its group's color */
374
 
                        G.saction->flag ^= SACTION_NODRAWGCOLORS;
375
 
                        break;
376
 
                case ACTMENU_VIEW_PREVRANGESET: /* Set preview range */
377
 
                        anim_previewrange_set();
378
 
                        break;
379
 
                case ACTMENU_VIEW_PREVRANGECLEAR: /* Clear preview range */
380
 
                        anim_previewrange_clear();
381
 
                        break;
382
 
                case ACTMENU_VIEW_PREVRANGEAUTO: /* Auto preview-range length */
383
 
                        action_previewrange_set(G.saction->action);
384
 
                        break;
385
 
        }
386
 
        allqueue(REDRAWVIEW3D, 0);
387
 
}
388
 
 
389
 
static uiBlock *action_viewmenu(void *arg_unused)
390
 
{
391
 
        uiBlock *block;
392
 
        short yco= 0, menuwidth=120;
393
 
        
394
 
        block= uiNewBlock(&curarea->uiblocks, "action_viewmenu", 
395
 
                                          UI_EMBOSSP, UI_HELV, curarea->headwin);
396
 
        uiBlockSetButmFunc(block, do_action_viewmenu, NULL);
397
 
        
398
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
399
 
                                         "Center View to Current Frame|C", 0, yco-=20, 
400
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
401
 
                                         ACTMENU_VIEW_CENTERVIEW, "");
402
 
                
403
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
404
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
405
 
                         
406
 
        if (G.saction->flag & SACTION_DRAWTIME) {
407
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
408
 
                                                "Show Frames|Ctrl T", 0, yco-=20, 
409
 
                                                menuwidth, 19, NULL, 0.0, 0.0, 1, 
410
 
                                                ACTMENU_VIEW_TIME, "");
411
 
        }
412
 
        else {
413
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
414
 
                                                "Show Seconds|Ctrl T", 0, yco-=20, 
415
 
                                                menuwidth, 19, NULL, 0.0, 0.0, 1, 
416
 
                                                ACTMENU_VIEW_TIME, "");
417
 
        }
418
 
        
419
 
        uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
420
 
        
421
 
        if (G.saction->mode == SACTCONT_GPENCIL) {
422
 
                        // this option may get removed in future
423
 
                uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_HORIZOPTIMISEON)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
424
 
                                                 "Cull Out-of-View Keys (Time)|", 0, yco-=20, 
425
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, 
426
 
                                                 ACTMENU_VIEW_HORIZOPTIMISE, "");
427
 
        }
428
 
        else {
429
 
                uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_SLIDERS)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
430
 
                                                 "Show Sliders|", 0, yco-=20, 
431
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, 
432
 
                                                 ACTMENU_VIEW_SLIDERS, "");
433
 
                                                 
434
 
                uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NOHIDE)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
435
 
                                                 "Show Hidden Channels|", 0, yco-=20, 
436
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, 
437
 
                                                 ACTMENU_VIEW_NOHIDE, "");
438
 
                                                 
439
 
                uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NODRAWGCOLORS)?ICON_CHECKBOX_DEHLT:ICON_CHECKBOX_HLT, 
440
 
                                                 "Use Group Colors|", 0, yco-=20, 
441
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, 
442
 
                                                 ACTMENU_VIEW_GCOLORS, "");
443
 
                                                 
444
 
                        // this option may get removed in future
445
 
                uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_HORIZOPTIMISEON)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
446
 
                                                 "Cull Out-of-View Keys (Time)|", 0, yco-=20, 
447
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, 
448
 
                                                 ACTMENU_VIEW_HORIZOPTIMISE, "");
449
 
                
450
 
                uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NOTRANSKEYCULL)?ICON_CHECKBOX_DEHLT:ICON_CHECKBOX_HLT, 
451
 
                                                 "AutoMerge Keyframes|", 0, yco-=20, 
452
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, 
453
 
                                                 ACTMENU_VIEW_TRANSDELDUPS, "");
454
 
        }       
455
 
        
456
 
                
457
 
        uiDefIconTextBut(block, BUTM, 1, (G.v2d->flag & V2D_VIEWLOCK)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
458
 
                                         "Lock Time to Other Windows|", 0, yco-=20, 
459
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
460
 
                                         ACTMENU_VIEW_LOCK, "");
461
 
                                         
462
 
        uiDefIconTextBut(block, BUTM, 1, BTST(G.saction->lock, 0)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
463
 
                                         "Update Automatically|", 0, yco-=20, 
464
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
465
 
                                         ACTMENU_VIEW_AUTOUPDATE, "");
466
 
 
467
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
468
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
469
 
                
470
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
471
 
                                "Jump To Next Marker|PageUp", 0, yco-=20,
472
 
                                menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_VIEW_NEXTMARKER, "");
473
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
474
 
                                "Jump To Prev Marker|PageDown", 0, yco-=20, 
475
 
                                menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_VIEW_PREVMARKER, "");
476
 
                                
477
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
478
 
                                "Jump To Next Keyframe|Ctrl PageUp", 0, yco-=20,
479
 
                                menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_VIEW_NEXTKEYFRAME, "");
480
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
481
 
                                "Jump To Prev Keyframe|Ctrl PageDown", 0, yco-=20, 
482
 
                                menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_VIEW_PREVKEYFRAME, "");
483
 
                                         
484
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
485
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
486
 
                        
487
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
488
 
                                         "Play Back Animation|Alt A", 0, yco-=20, 
489
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
490
 
                                         ACTMENU_VIEW_PLAY3D, "");
491
 
        //uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
492
 
        //                               "Play Back Animation in 3D View|Alt Shift A", 0, yco-=20,
493
 
        //                               menuwidth, 19, NULL, 0.0, 0.0, 1, 
494
 
        //                               ACTMENU_VIEW_PLAYALL, "");
495
 
        
496
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
497
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
498
 
                
499
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
500
 
                                         "Set Preview Range|Ctrl P", 0, yco-=20, 
501
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
502
 
                                         ACTMENU_VIEW_PREVRANGESET, "");
503
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
504
 
                                         "Clear Preview Range|Alt P", 0, yco-=20,
505
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
506
 
                                         ACTMENU_VIEW_PREVRANGECLEAR, "");
507
 
                
508
 
        if ((G.saction->mode == SACTCONT_ACTION) && (G.saction->action)) {
509
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
510
 
                                         "Preview Range from Action Length|Ctrl Alt P", 0, yco-=20, 
511
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
512
 
                                         ACTMENU_VIEW_PREVRANGEAUTO, "");
513
 
        }
514
 
                
515
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
516
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
517
 
        
518
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
519
 
                                         "View All|Home", 0, yco-=20, 
520
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, 
521
 
                                         ACTMENU_VIEW_ALL, "");
522
 
        
523
 
        if (!curarea->full) 
524
 
                uiDefIconTextBut(block, BUTM, B_FULL, ICON_BLANK1, 
525
 
                                                 "Maximize Window|Ctrl UpArrow", 0, yco-=20, 
526
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
527
 
                                                 ACTMENU_VIEW_MAXIMIZE, "");
528
 
        else 
529
 
                uiDefIconTextBut(block, BUTM, B_FULL, ICON_BLANK1, 
530
 
                                                 "Tile Window|Ctrl DownArrow", 0, yco-=20, 
531
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
532
 
                                                 ACTMENU_VIEW_MAXIMIZE, "");
533
 
        
534
 
        if(curarea->headertype==HEADERTOP) {
535
 
                uiBlockSetDirection(block, UI_DOWN);
536
 
        }
537
 
        else {
538
 
                uiBlockSetDirection(block, UI_TOP);
539
 
                uiBlockFlipOrder(block);
540
 
        }
541
 
 
542
 
        uiTextBoundsBlock(block, 50);
543
 
        
544
 
        return block;
545
 
}
546
 
 
547
 
static void do_action_selectmenu_columnmenu(void *arg, int event)
548
 
{
549
 
        switch (event) {
550
 
                case ACTMENU_SEL_COLUMN_MARKERSBETWEEN:
551
 
                        markers_selectkeys_between();
552
 
                        break;
553
 
                case ACTMENU_SEL_COLUMN_KEYS:
554
 
                        column_select_action_keys(1);
555
 
                        break;
556
 
                case ACTMENU_SEL_COLUMN_MARKERSCOLUMN:
557
 
                        column_select_action_keys(2);
558
 
                        break;
559
 
                case ACTMENU_SEL_COLUMN_CFRA:
560
 
                        column_select_action_keys(3);
561
 
                        break;
562
 
        }
563
 
                
564
 
        allqueue(REDRAWMARKER, 0);
565
 
}
566
 
 
567
 
static uiBlock *action_selectmenu_columnmenu(void *arg_unused)
568
 
{
569
 
        uiBlock *block;
570
 
        short yco= 0, menuwidth=120;
571
 
 
572
 
        block= uiNewBlock(&curarea->uiblocks, "action_selectmenu_columnmenu", 
573
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
574
 
        uiBlockSetButmFunc(block, do_action_selectmenu_columnmenu, NULL);
575
 
 
576
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
577
 
                                         "On Selected Keys|K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0,  
578
 
                                         ACTMENU_SEL_COLUMN_KEYS, "");
579
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
580
 
                                         "On Current Frame|Ctrl K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0,  
581
 
                                         ACTMENU_SEL_COLUMN_CFRA, "");
582
 
        
583
 
        if (G_SACTION_HASMARKERS) {
584
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
585
 
                                                 "On Selected Markers|Shift K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
586
 
                                                 ACTMENU_SEL_COLUMN_MARKERSCOLUMN, "");
587
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
588
 
                                                 "Between Selected Markers|Alt K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
589
 
                                                 ACTMENU_SEL_COLUMN_MARKERSBETWEEN, "");
590
 
        }
591
 
        
592
 
        uiBlockSetDirection(block, UI_RIGHT);
593
 
        uiTextBoundsBlock(block, 60);
594
 
 
595
 
        return block;
596
 
}
597
 
 
598
 
static void do_action_selectmenu(void *arg, int event)
599
 
{       
600
 
        SpaceAction *saction;
601
 
        bAction *act;
602
 
        Key *key;
603
 
        
604
 
        saction = curarea->spacedata.first;
605
 
        if (saction == NULL) return;
606
 
 
607
 
        act = saction->action;
608
 
        key = get_action_mesh_key();
609
 
        
610
 
        switch(event)
611
 
        {
612
 
                case ACTMENU_SEL_BORDER: /* Border Select */
613
 
                        borderselect_action();
614
 
                        break;
615
 
                        
616
 
                case ACTMENU_SEL_BORDERC: /* Border Select */
617
 
                        borderselect_actionchannels();
618
 
                        break;
619
 
                        
620
 
                case ACTMENU_SEL_BORDERM: /* Border Select */
621
 
                        borderselect_markers();
622
 
                        break;
623
 
                        
624
 
                case ACTMENU_SEL_ALL_KEYS: /* Select/Deselect All Keys */
625
 
                        deselect_action_keys(1, 1);
626
 
                        BIF_undo_push("(De)Select Keys");
627
 
                        allqueue(REDRAWACTION, 0);
628
 
                        allqueue(REDRAWNLA, 0);
629
 
                        allqueue(REDRAWIPO, 0);
630
 
                        break;
631
 
                        
632
 
                case ACTMENU_SEL_ALL_CHAN: /* Select/Deselect All Channels */
633
 
                        deselect_action_channels(1);
634
 
                        BIF_undo_push("(De)Select Action Channels");
635
 
                        allqueue(REDRAWVIEW3D, 0);
636
 
                        allqueue(REDRAWACTION, 0);
637
 
                        allqueue(REDRAWNLA, 0);
638
 
                        allqueue(REDRAWIPO, 0);
639
 
                        break;
640
 
                        
641
 
                case ACTMENU_SEL_ALL_MARKERS: /* select/deselect all markers */
642
 
                        deselect_markers(1, 0);
643
 
                        BIF_undo_push("(De)Select Markers");
644
 
                        allqueue(REDRAWMARKER, 0);
645
 
                        break;
646
 
                        
647
 
                case ACTMENU_SEL_INVERSE_KEYS: /* invert selection status of keys */
648
 
                        deselect_action_keys(0, 2);
649
 
                        BIF_undo_push("Inverse Keys");
650
 
                        allqueue(REDRAWACTION, 0);
651
 
                        allqueue(REDRAWNLA, 0);
652
 
                        allqueue(REDRAWIPO, 0);
653
 
                        break;
654
 
                        
655
 
                case ACTMENU_SEL_INVERSE_CHANNELS: /* invert selection status of channels */
656
 
                        deselect_action_channels(2);
657
 
                        BIF_undo_push("Inverse Action Channels");
658
 
                        allqueue(REDRAWVIEW3D, 0);
659
 
                        allqueue(REDRAWACTION, 0);
660
 
                        allqueue(REDRAWNLA, 0);
661
 
                        allqueue(REDRAWIPO, 0);
662
 
                        break;
663
 
                        
664
 
                case ACTMENU_SEL_INVERSE_MARKERS: /* invert selection of markers */
665
 
                        deselect_markers(0, 2);
666
 
                        BIF_undo_push("Inverse Action Channels");
667
 
                        allqueue(REDRAWMARKER, 0);
668
 
                        break;
669
 
                        
670
 
                case ACTMENU_SEL_LEFTKEYS:
671
 
                        selectkeys_leftright(1, SELECT_REPLACE);
672
 
                        break;
673
 
                        
674
 
                case ACTMENU_SEL_RIGHTKEYS:
675
 
                        selectkeys_leftright(0, SELECT_REPLACE);
676
 
                        break;
677
 
        }
678
 
}
679
 
 
680
 
static uiBlock *action_selectmenu(void *arg_unused)
681
 
{
682
 
        uiBlock *block;
683
 
        short yco= 0, menuwidth=120;
684
 
 
685
 
        block= uiNewBlock(&curarea->uiblocks, "action_selectmenu", 
686
 
                                          UI_EMBOSSP, UI_HELV, curarea->headwin);
687
 
        uiBlockSetButmFunc(block, do_action_selectmenu, NULL);
688
 
 
689
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
690
 
                                         "Border Select Keys|B", 0, yco-=20, 
691
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
692
 
                                         ACTMENU_SEL_BORDER, "");
693
 
        if (G_SACTION_HASMARKERS) {
694
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
695
 
                                                 "Border Select Markers|Ctrl B", 0, yco-=20, 
696
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
697
 
                                                 ACTMENU_SEL_BORDERM, "");
698
 
        }
699
 
        if (G.saction->mode != SACTCONT_SHAPEKEY) {
700
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
701
 
                                                 "Border Select Channels|B", 0, yco-=20, 
702
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
703
 
                                                 ACTMENU_SEL_BORDERC, "");
704
 
        }
705
 
                                         
706
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
707
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
708
 
                         
709
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
710
 
                                         "Select/Deselect All Keys|A", 0, yco-=20, 
711
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
712
 
                                         ACTMENU_SEL_ALL_KEYS, "");
713
 
        if (G_SACTION_HASMARKERS) {
714
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
715
 
                                                 "Select/Deselect All Markers|Ctrl A", 0, yco-=20, 
716
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
717
 
                                                 ACTMENU_SEL_ALL_MARKERS, "");
718
 
        }
719
 
        if (G.saction->mode != SACTCONT_SHAPEKEY) {
720
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
721
 
                                                 "Select/Deselect All Channels|A", 0, yco-=20, 
722
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
723
 
                                                 ACTMENU_SEL_ALL_CHAN, "");
724
 
        }
725
 
                                         
726
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
727
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
728
 
 
729
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
730
 
                                         "Inverse Keys|Ctrl I", 0, yco-=20, 
731
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
732
 
                                         ACTMENU_SEL_INVERSE_KEYS, "");
733
 
        if (G_SACTION_HASMARKERS) {
734
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
735
 
                                                 "Inverse Markers|Ctrl Shift I", 0, yco-=20, 
736
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
737
 
                                                 ACTMENU_SEL_INVERSE_MARKERS, "");
738
 
        }
739
 
        if (G.saction->mode != SACTCONT_SHAPEKEY) {
740
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
741
 
                                                 "Inverse All Channels|Ctrl I", 0, yco-=20, 
742
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
743
 
                                                 ACTMENU_SEL_INVERSE_CHANNELS, "");
744
 
        }
745
 
                
746
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
747
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
748
 
                         
749
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
750
 
                                         "Back In Time|Alt RMB", 0, yco-=20, 
751
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
752
 
                                         ACTMENU_SEL_LEFTKEYS, "");
753
 
                                                                 
754
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
755
 
                                         "Ahead In Time|Alt RMB", 0, yco-=20, 
756
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
757
 
                                         ACTMENU_SEL_RIGHTKEYS, "");             
758
 
                         
759
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
760
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
761
 
                         
762
 
        uiDefIconTextBlockBut(block, action_selectmenu_columnmenu, 
763
 
                                                  NULL, ICON_RIGHTARROW_THIN, "Column Select Keys", 0, yco-=20, 120, 20, "");
764
 
        
765
 
        if (curarea->headertype==HEADERTOP) {
766
 
                uiBlockSetDirection(block, UI_DOWN);
767
 
        }
768
 
        else {
769
 
                uiBlockSetDirection(block, UI_TOP);
770
 
                uiBlockFlipOrder(block);
771
 
        }
772
 
 
773
 
        uiTextBoundsBlock(block, 50);
774
 
 
775
 
        return block;
776
 
}
777
 
 
778
 
 
779
 
static void do_action_channelmenu_posmenu(void *arg, int event)
780
 
{
781
 
        switch(event)
782
 
        {
783
 
                case ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_DOWN:
784
 
                        rearrange_action_channels(REARRANGE_ACTCHAN_DOWN);
785
 
                        break;
786
 
                case ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_UP:
787
 
                        rearrange_action_channels(REARRANGE_ACTCHAN_UP);
788
 
                        break;
789
 
                case ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_TOP:
790
 
                        rearrange_action_channels(REARRANGE_ACTCHAN_TOP);
791
 
                        break;
792
 
                case ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_BOTTOM:
793
 
                        rearrange_action_channels(REARRANGE_ACTCHAN_BOTTOM);
794
 
                        break;
795
 
        }
796
 
 
797
 
        scrarea_queue_winredraw(curarea);
798
 
}
799
 
 
800
 
static uiBlock *action_channelmenu_posmenu(void *arg_unused)
801
 
{
802
 
        uiBlock *block;
803
 
        short yco= 0, menuwidth=120;
804
 
 
805
 
        block= uiNewBlock(&curarea->uiblocks, "action_channelmenu_posmenu", 
806
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
807
 
        uiBlockSetButmFunc(block, do_action_channelmenu_posmenu, NULL);
808
 
 
809
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
810
 
                                         "Move Up|Shift Page Up", 0, yco-=20, 
811
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
812
 
                                         ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_UP, "");
813
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
814
 
                                         "Move Down|Shift Page Down", 0, yco-=20, 
815
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
816
 
                                         ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_DOWN, "");
817
 
        
818
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
819
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
820
 
                                        
821
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
822
 
                                         "Move to Top|Ctrl Shift Page Up", 0, yco-=20, 
823
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
824
 
                                         ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_TOP, "");
825
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
826
 
                                         "Move to Bottom|Ctrl Shift Page Down", 0, yco-=20, 
827
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
828
 
                                         ACTMENU_CHANNELS_CHANPOS_MOVE_CHANNEL_BOTTOM, "");
829
 
 
830
 
        uiBlockSetDirection(block, UI_RIGHT);
831
 
        uiTextBoundsBlock(block, 60);
832
 
 
833
 
        return block;
834
 
}
835
 
 
836
 
static void do_action_channelmenu_groupmenu(void *arg, int event)
837
 
{
838
 
        switch(event)
839
 
        {
840
 
                case ACTMENU_CHANNELS_GROUP_ADD_TOACTIVE:
841
 
                        action_groups_group(0);
842
 
                        break;
843
 
                case ACTMENU_CHANNELS_GROUP_ADD_TONEW:
844
 
                        action_groups_group(1);
845
 
                        break;
846
 
                case ACTMENU_CHANNELS_GROUP_REMOVE:
847
 
                        action_groups_ungroup();
848
 
                        break;
849
 
                case ACTMENU_CHANNELS_GROUP_SYNCPOSE: /* Syncronise Pose-data and Action-data */
850
 
                        sync_pchan2achan_grouping();
851
 
                        break;
852
 
        }
853
 
}
854
 
 
855
 
static uiBlock *action_channelmenu_groupmenu(void *arg_unused)
856
 
{
857
 
        uiBlock *block;
858
 
        short yco= 0, menuwidth=120;
859
 
 
860
 
        block= uiNewBlock(&curarea->uiblocks, "action_channelmenu_groupmenu", 
861
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
862
 
        uiBlockSetButmFunc(block, do_action_channelmenu_groupmenu, NULL);
863
 
 
864
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
865
 
                                         "Add to Active Group|Shift G", 0, yco-=20, 
866
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
867
 
                                         ACTMENU_CHANNELS_GROUP_ADD_TOACTIVE, "");
868
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
869
 
                                         "Add to New Group|Ctrl Shift G", 0, yco-=20, 
870
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
871
 
                                         ACTMENU_CHANNELS_GROUP_ADD_TONEW, "");
872
 
                
873
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
874
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
875
 
                                        
876
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
877
 
                                         "Remove From Group|Alt G", 0, yco-=20, 
878
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
879
 
                                         ACTMENU_CHANNELS_GROUP_REMOVE, "");
880
 
                                         
881
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
882
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
883
 
                                        
884
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
885
 
                                         "Synchronise with Armature", 0, yco-=20, 
886
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
887
 
                                         ACTMENU_CHANNELS_GROUP_SYNCPOSE, "");
888
 
 
889
 
        uiBlockSetDirection(block, UI_RIGHT);
890
 
        uiTextBoundsBlock(block, 60);
891
 
 
892
 
        return block;
893
 
}
894
 
 
895
 
static void do_action_channelmenu_settingsmenu(void *arg, int event)
896
 
{
897
 
        setflag_action_channels(event);
898
 
}
899
 
 
900
 
static uiBlock *action_channelmenu_settingsmenu(void *arg_unused)
901
 
{
902
 
        uiBlock *block;
903
 
        short yco= 0, menuwidth=120;
904
 
 
905
 
        block= uiNewBlock(&curarea->uiblocks, "action_channelmenu_settingsmenu", 
906
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
907
 
        uiBlockSetButmFunc(block, do_action_channelmenu_settingsmenu, NULL);
908
 
 
909
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
910
 
                                         "Toggle a Setting|Shift W", 0, yco-=20, 
911
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
912
 
                                         ACTMENU_CHANNELS_SETTINGS_TOGGLE, "");
913
 
                                         
914
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
915
 
                                         "Enable a Setting|Ctrl Shift W", 0, yco-=20, 
916
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
917
 
                                         ACTMENU_CHANNELS_SETTINGS_ENABLE, "");
918
 
                                        
919
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
920
 
                                         "Disable a Setting|Alt W", 0, yco-=20, 
921
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
922
 
                                         ACTMENU_CHANNELS_SETTINGS_DISABLE, "");
923
 
 
924
 
        uiBlockSetDirection(block, UI_RIGHT);
925
 
        uiTextBoundsBlock(block, 60);
926
 
 
927
 
        return block;
928
 
}
929
 
 
930
 
static void do_action_channelmenu(void *arg, int event)
931
 
{       
932
 
        SpaceAction *saction;
933
 
        
934
 
        saction = curarea->spacedata.first;
935
 
        if (saction == NULL) return;
936
 
        
937
 
        switch(event)
938
 
        {
939
 
                case ACTMENU_CHANNELS_OPENLEVELS: /* Unfold selected channels one step */
940
 
                        openclose_level_action(1);
941
 
                        break;
942
 
                case ACTMENU_CHANNELS_CLOSELEVELS: /* Fold selected channels one step */
943
 
                        openclose_level_action(-1);
944
 
                        break;
945
 
                case ACTMENU_CHANNELS_EXPANDALL: /* Expands all channels */
946
 
                        expand_all_action();
947
 
                        break;
948
 
                case ACTMENU_CHANNELS_SHOWACHANS: /* Unfold groups that are hiding selected achans */
949
 
                        expand_obscuregroups_action();
950
 
                        break;
951
 
                case ACTMENU_CHANNELS_DELETE: /* Deletes selected channels */
952
 
                        delete_action_channels();
953
 
                        break;
954
 
        }
955
 
}
956
 
 
957
 
static uiBlock *action_channelmenu(void *arg_unused)
958
 
{
959
 
        uiBlock *block;
960
 
        short yco= 0, menuwidth=120;
961
 
 
962
 
        block= uiNewBlock(&curarea->uiblocks, "action_channelmenu", 
963
 
                                          UI_EMBOSSP, UI_HELV, curarea->headwin);
964
 
        uiBlockSetButmFunc(block, do_action_channelmenu, NULL);
965
 
        
966
 
        uiDefIconTextBlockBut(block, action_channelmenu_groupmenu, 
967
 
                                                  NULL, ICON_RIGHTARROW_THIN, 
968
 
                                                  "Grouping", 0, yco-=20, 120, 20, "");  
969
 
                                                  
970
 
        uiDefIconTextBlockBut(block, action_channelmenu_posmenu, 
971
 
                                                  NULL, ICON_RIGHTARROW_THIN, 
972
 
                                                  "Ordering", 0, yco-=20, 120, 20, "");
973
 
        
974
 
        uiDefIconTextBlockBut(block, action_channelmenu_settingsmenu, 
975
 
                                                  NULL, ICON_RIGHTARROW_THIN, 
976
 
                                                  "Settings", 0, yco-=20, 120, 20, ""); 
977
 
        
978
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
979
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
980
 
        
981
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
982
 
                        "Delete|X", 0, yco-=20,
983
 
                        menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_CHANNELS_DELETE, "");
984
 
        
985
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
986
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
987
 
                
988
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
989
 
                        "Toggle Show Hierachy|~", 0, yco-=20,
990
 
                        menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_CHANNELS_EXPANDALL, "");
991
 
                        
992
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
993
 
                        "Show Group-Hidden Channels|Shift ~", 0, yco-=20,
994
 
                        menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_CHANNELS_SHOWACHANS, "");
995
 
                        
996
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
997
 
                        "Expand One Level|Ctrl NumPad+", 0, yco-=20,
998
 
                        menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_CHANNELS_OPENLEVELS, "");
999
 
                        
1000
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1001
 
                        "Collapse One Level|Ctrl NumPad-", 0, yco-=20,
1002
 
                        menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_CHANNELS_CLOSELEVELS, "");
1003
 
        
1004
 
        if (curarea->headertype==HEADERTOP) {
1005
 
                uiBlockSetDirection(block, UI_DOWN);
1006
 
        }
1007
 
        else {
1008
 
                uiBlockSetDirection(block, UI_TOP);
1009
 
                uiBlockFlipOrder(block);
1010
 
        }
1011
 
 
1012
 
        uiTextBoundsBlock(block, 50);
1013
 
 
1014
 
        return block;
1015
 
}
1016
 
 
1017
 
/* note: uses do_action_channelmenu too... */
1018
 
static uiBlock *action_gplayermenu(void *arg_unused)
1019
 
{
1020
 
        uiBlock *block;
1021
 
        short yco= 0, menuwidth=120;
1022
 
 
1023
 
        block= uiNewBlock(&curarea->uiblocks, "action_gplayermenu", 
1024
 
                                          UI_EMBOSSP, UI_HELV, curarea->headwin);
1025
 
        uiBlockSetButmFunc(block, do_action_channelmenu, NULL);
1026
 
        
1027
 
        uiDefIconTextBlockBut(block, action_channelmenu_settingsmenu, 
1028
 
                                                  NULL, ICON_RIGHTARROW_THIN, 
1029
 
                                                  "Settings", 0, yco-=20, 120, 20, ""); 
1030
 
        
1031
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1032
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1033
 
        
1034
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1035
 
                        "Delete|X", 0, yco-=20,
1036
 
                        menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_CHANNELS_DELETE, "");
1037
 
        
1038
 
        if (curarea->headertype==HEADERTOP) {
1039
 
                uiBlockSetDirection(block, UI_DOWN);
1040
 
        }
1041
 
        else {
1042
 
                uiBlockSetDirection(block, UI_TOP);
1043
 
                uiBlockFlipOrder(block);
1044
 
        }
1045
 
 
1046
 
        uiTextBoundsBlock(block, 50);
1047
 
 
1048
 
        return block;
1049
 
}
1050
 
 
1051
 
static void do_action_keymenu_transformmenu(void *arg, int event)
1052
 
{       
1053
 
        switch (event)
1054
 
        {
1055
 
                case ACTMENU_KEY_TRANSFORM_MOVE:
1056
 
                        transform_action_keys('g', 0);
1057
 
                        break;
1058
 
                case ACTMENU_KEY_TRANSFORM_SCALE:
1059
 
                        transform_action_keys('s', 0);
1060
 
                        break;
1061
 
                case ACTMENU_KEY_TRANSFORM_SLIDE:
1062
 
                        transform_action_keys('t', 0);
1063
 
                        break;
1064
 
                case ACTMENU_KEY_TRANSFORM_EXTEND:
1065
 
                        transform_action_keys('e', 0);
1066
 
                        break;
1067
 
        }
1068
 
 
1069
 
        scrarea_queue_winredraw(curarea);
1070
 
}
1071
 
 
1072
 
static uiBlock *action_keymenu_transformmenu(void *arg_unused)
1073
 
{
1074
 
        uiBlock *block;
1075
 
        short yco= 0, menuwidth=120;
1076
 
 
1077
 
        block= uiNewBlock(&curarea->uiblocks, "action_keymenu_transformmenu", 
1078
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
1079
 
        uiBlockSetButmFunc(block, do_action_keymenu_transformmenu, NULL);
1080
 
 
1081
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1082
 
                                         "Grab/Move|G", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0,  
1083
 
                                         ACTMENU_KEY_TRANSFORM_MOVE, "");
1084
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1085
 
                                         "Grab/Extend from Frame|E", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
1086
 
                                         ACTMENU_KEY_TRANSFORM_EXTEND, "");
1087
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1088
 
                                         "Scale|S", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
1089
 
                                         ACTMENU_KEY_TRANSFORM_SCALE, "");
1090
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1091
 
                                         "Time Slide|T", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
1092
 
                                         ACTMENU_KEY_TRANSFORM_SLIDE, "");
1093
 
        
1094
 
        
1095
 
        uiBlockSetDirection(block, UI_RIGHT);
1096
 
        uiTextBoundsBlock(block, 60);
1097
 
 
1098
 
        return block;
1099
 
}
1100
 
 
1101
 
static void do_action_keymenu_handlemenu(void *arg, int event)
1102
 
{
1103
 
        switch (event) {
1104
 
                case ACTMENU_KEY_HANDLE_AUTO:
1105
 
                        sethandles_action_keys(HD_AUTO);
1106
 
                        break;
1107
 
 
1108
 
                case ACTMENU_KEY_HANDLE_ALIGN:
1109
 
                case ACTMENU_KEY_HANDLE_FREE:
1110
 
                        /* OK, this is kinda dumb, need to fix the
1111
 
                         * toggle crap in sethandles_ipo_keys() 
1112
 
                         */
1113
 
                        sethandles_action_keys(HD_ALIGN);
1114
 
                        break;
1115
 
 
1116
 
                case ACTMENU_KEY_HANDLE_VECTOR:
1117
 
                        sethandles_action_keys(HD_VECT);        
1118
 
                        break;
1119
 
        }
1120
 
}
1121
 
 
1122
 
static uiBlock *action_keymenu_handlemenu(void *arg_unused)
1123
 
{
1124
 
        uiBlock *block;
1125
 
        short yco= 0, menuwidth=120;
1126
 
 
1127
 
        block= uiNewBlock(&curarea->uiblocks, "action_keymenu_handlemenu", UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
1128
 
        uiBlockSetButmFunc(block, do_action_keymenu_handlemenu, NULL);
1129
 
 
1130
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1131
 
                                         "Auto|Shift H", 0, yco-=20, 
1132
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1133
 
                                         ACTMENU_KEY_HANDLE_AUTO, "");
1134
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1135
 
                                         "Aligned|H", 0, yco-=20, 
1136
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1137
 
                                         ACTMENU_KEY_HANDLE_ALIGN, "");
1138
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1139
 
                                         "Free|H", 0, yco-=20, menuwidth, 
1140
 
                                         19, NULL, 0.0, 0.0, 0, 
1141
 
                                         ACTMENU_KEY_HANDLE_FREE, "");
1142
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1143
 
                                         "Vector|V", 0, yco-=20, 
1144
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1145
 
                                         ACTMENU_KEY_HANDLE_VECTOR, "");
1146
 
 
1147
 
        uiBlockSetDirection(block, UI_RIGHT);
1148
 
        uiTextBoundsBlock(block, 60);
1149
 
 
1150
 
        return block;
1151
 
}
1152
 
 
1153
 
static void do_action_keymenu_intpolmenu(void *arg, int event)
1154
 
{
1155
 
        switch(event)
1156
 
        {
1157
 
                case ACTMENU_KEY_INTERP_CONST:
1158
 
                        action_set_ipo_flags(SET_IPO_MENU, SET_IPO_CONSTANT);
1159
 
                        break;
1160
 
                case ACTMENU_KEY_INTERP_LINEAR:
1161
 
                        action_set_ipo_flags(SET_IPO_MENU, SET_IPO_LINEAR);
1162
 
                        break;
1163
 
                case ACTMENU_KEY_INTERP_BEZIER:
1164
 
                        action_set_ipo_flags(SET_IPO_MENU, SET_IPO_BEZIER);
1165
 
                        break;
1166
 
        }
1167
 
 
1168
 
        scrarea_queue_winredraw(curarea);
1169
 
}
1170
 
 
1171
 
static uiBlock *action_keymenu_intpolmenu(void *arg_unused)
1172
 
{
1173
 
        uiBlock *block;
1174
 
        short yco= 0, menuwidth=120;
1175
 
 
1176
 
        block= uiNewBlock(&curarea->uiblocks, "action_keymenu_intpolmenu", 
1177
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
1178
 
        uiBlockSetButmFunc(block, do_action_keymenu_intpolmenu, NULL);
1179
 
 
1180
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1181
 
                                         "Constant|Shift T, 1", 0, yco-=20, 
1182
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1183
 
                                         ACTMENU_KEY_INTERP_CONST, "");
1184
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1185
 
                                         "Linear|Shift T, 2", 0, yco-=20, 
1186
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1187
 
                                         ACTMENU_KEY_INTERP_LINEAR, "");
1188
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1189
 
                                         "Bezier|Shift T, 3", 0, yco-=20, 
1190
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1191
 
                                         ACTMENU_KEY_INTERP_BEZIER, "");
1192
 
 
1193
 
        uiBlockSetDirection(block, UI_RIGHT);
1194
 
        uiTextBoundsBlock(block, 60);
1195
 
 
1196
 
        return block;
1197
 
}
1198
 
 
1199
 
static void do_action_keymenu_extendmenu(void *arg, int event)
1200
 
{
1201
 
        switch(event)
1202
 
        {
1203
 
                case ACTMENU_KEY_EXTEND_CONST:
1204
 
                        action_set_ipo_flags(SET_EXTEND_MENU, SET_EXTEND_CONSTANT);
1205
 
                        break;
1206
 
                case ACTMENU_KEY_EXTEND_EXTRAPOLATION:
1207
 
                        action_set_ipo_flags(SET_EXTEND_MENU, SET_EXTEND_EXTRAPOLATION);
1208
 
                        break;
1209
 
                case ACTMENU_KEY_EXTEND_CYCLIC:
1210
 
                        action_set_ipo_flags(SET_EXTEND_MENU, SET_EXTEND_CYCLIC);
1211
 
                        break;
1212
 
                case ACTMENU_KEY_EXTEND_CYCLICEXTRAPOLATION:
1213
 
                        action_set_ipo_flags(SET_EXTEND_MENU, SET_EXTEND_CYCLICEXTRAPOLATION);
1214
 
                        break;
1215
 
        }
1216
 
 
1217
 
        scrarea_queue_winredraw(curarea);
1218
 
}
1219
 
 
1220
 
static uiBlock *action_keymenu_extendmenu(void *arg_unused)
1221
 
{
1222
 
        uiBlock *block;
1223
 
        short yco= 0, menuwidth=120;
1224
 
 
1225
 
        block= uiNewBlock(&curarea->uiblocks, "action_keymenu_extendmenu", 
1226
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
1227
 
        uiBlockSetButmFunc(block, do_action_keymenu_extendmenu, NULL);
1228
 
 
1229
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1230
 
                                         "Constant", 0, yco-=20, 
1231
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1232
 
                                         ACTMENU_KEY_EXTEND_CONST, "");
1233
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1234
 
                                         "Extrapolation", 0, yco-=20, 
1235
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1236
 
                                         ACTMENU_KEY_EXTEND_EXTRAPOLATION, "");
1237
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1238
 
                                         "Cyclic", 0, yco-=20, 
1239
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1240
 
                                         ACTMENU_KEY_EXTEND_CYCLIC, "");
1241
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1242
 
                                         "Cyclic Extrapolation", 0, yco-=20, 
1243
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1244
 
                                         ACTMENU_KEY_EXTEND_CYCLICEXTRAPOLATION, "");
1245
 
 
1246
 
        uiBlockSetDirection(block, UI_RIGHT);
1247
 
        uiTextBoundsBlock(block, 60);
1248
 
 
1249
 
        return block;
1250
 
}
1251
 
 
1252
 
static void do_action_keymenu_snapmenu(void *arg, int event)
1253
 
{
1254
 
        switch(event)
1255
 
        {
1256
 
                case ACTMENU_KEY_SNAP_NEARFRAME:
1257
 
                case ACTMENU_KEY_SNAP_CURFRAME:
1258
 
                case ACTMENU_KEY_SNAP_NEARMARK:
1259
 
                case ACTMENU_KEY_SNAP_NEARTIME:
1260
 
                        snap_action_keys(event);
1261
 
                        break;
1262
 
                        
1263
 
                case ACTMENU_KEY_SNAP_CFRA2KEY:
1264
 
                        snap_cfra_action();
1265
 
                        break;
1266
 
        }
1267
 
 
1268
 
        scrarea_queue_winredraw(curarea);
1269
 
}
1270
 
 
1271
 
static uiBlock *action_keymenu_snapmenu(void *arg_unused)
1272
 
{
1273
 
        uiBlock *block;
1274
 
        short yco= 0, menuwidth=120;
1275
 
 
1276
 
        block= uiNewBlock(&curarea->uiblocks, "action_keymenu_snapmenu", 
1277
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
1278
 
        uiBlockSetButmFunc(block, do_action_keymenu_snapmenu, NULL);
1279
 
 
1280
 
        if (G.saction->flag & SACTION_DRAWTIME) {
1281
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1282
 
                                                 "Key -> Nearest Second|Shift S, 1", 0, yco-=20, 
1283
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
1284
 
                                                 ACTMENU_KEY_SNAP_NEARTIME, "");
1285
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1286
 
                                                 "Key -> Current Time|Shift S, 2", 0, yco-=20, 
1287
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
1288
 
                                                 ACTMENU_KEY_SNAP_CURFRAME, "");
1289
 
 
1290
 
        }
1291
 
        else {
1292
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1293
 
                                                 "Key -> Nearest Frame|Shift S, 1", 0, yco-=20, 
1294
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
1295
 
                                                 ACTMENU_KEY_SNAP_NEARFRAME, "");
1296
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1297
 
                                                 "Key -> Current Frame|Shift S, 2", 0, yco-=20, 
1298
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 0, 
1299
 
                                                 ACTMENU_KEY_SNAP_CURFRAME, "");
1300
 
        }
1301
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1302
 
                                         "Key -> Nearest Marker|Shift S, 3", 0, yco-=20, 
1303
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1304
 
                                         ACTMENU_KEY_SNAP_NEARMARK, "");
1305
 
                                         
1306
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1307
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1308
 
                         
1309
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1310
 
                                         "Current Frame -> Key|Ctrl Shift S", 0, yco-=20, 
1311
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1312
 
                                         ACTMENU_KEY_SNAP_NEARMARK, "");
1313
 
 
1314
 
        uiBlockSetDirection(block, UI_RIGHT);
1315
 
        uiTextBoundsBlock(block, 60);
1316
 
 
1317
 
        return block;
1318
 
}
1319
 
 
1320
 
static void do_action_keymenu_mirrormenu(void *arg, int event)
1321
 
{
1322
 
        switch(event)
1323
 
        {
1324
 
                case ACTMENU_KEY_MIRROR_CURFRAME:
1325
 
                case ACTMENU_KEY_MIRROR_YAXIS:
1326
 
                        mirror_action_keys(event);
1327
 
                        break;
1328
 
        }
1329
 
 
1330
 
        scrarea_queue_winredraw(curarea);
1331
 
}
1332
 
 
1333
 
static uiBlock *action_keymenu_mirrormenu(void *arg_unused)
1334
 
{
1335
 
        uiBlock *block;
1336
 
        short yco= 0, menuwidth=120;
1337
 
 
1338
 
        block= uiNewBlock(&curarea->uiblocks, "action_keymenu_mirrormenu", 
1339
 
                                          UI_EMBOSSP, UI_HELV, G.curscreen->mainwin);
1340
 
        uiBlockSetButmFunc(block, do_action_keymenu_mirrormenu, NULL);
1341
 
 
1342
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1343
 
                                         "Current Frame|Shift M, 1", 0, yco-=20, 
1344
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1345
 
                                         ACTMENU_KEY_MIRROR_CURFRAME, "");
1346
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1347
 
                                         "Vertical Axis|Shift M, 2", 0, yco-=20, 
1348
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1349
 
                                         ACTMENU_KEY_MIRROR_YAXIS, "");
1350
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1351
 
                                         "Horizontal Axis|Shift M, 3", 0, yco-=20, 
1352
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1353
 
                                         ACTMENU_KEY_MIRROR_XAXIS, "");
1354
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1355
 
                                         "Selected Marker|Shift M, 4", 0, yco-=20, 
1356
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1357
 
                                         ACTMENU_KEY_MIRROR_MARKER, "");
1358
 
 
1359
 
        uiBlockSetDirection(block, UI_RIGHT);
1360
 
        uiTextBoundsBlock(block, 60);
1361
 
 
1362
 
        return block;
1363
 
}
1364
 
 
1365
 
static void do_action_keymenu(void *arg, int event)
1366
 
{       
1367
 
        SpaceAction *saction;
1368
 
        bAction *act;
1369
 
        Key *key;
1370
 
        
1371
 
        saction = curarea->spacedata.first;
1372
 
        if (!saction) return;
1373
 
 
1374
 
        act = saction->action;
1375
 
        key = get_action_mesh_key();
1376
 
 
1377
 
        switch(event)
1378
 
        {
1379
 
                case ACTMENU_KEY_DUPLICATE:
1380
 
                        duplicate_action_keys();
1381
 
                        break;
1382
 
                case ACTMENU_KEY_DELETE:
1383
 
                        delete_action_keys();
1384
 
                        break;
1385
 
                case ACTMENU_KEY_CLEAN:
1386
 
                        clean_action();
1387
 
                        break;
1388
 
                case ACTMENU_KEY_SAMPLEKEYS:
1389
 
                        sample_action_keys();
1390
 
                        break;
1391
 
                case ACTMENU_KEY_INSERTKEY:
1392
 
                        insertkey_action();
1393
 
                        break;
1394
 
        }
1395
 
}
1396
 
 
1397
 
static uiBlock *action_keymenu(void *arg_unused)
1398
 
{
1399
 
        uiBlock *block;
1400
 
        short yco= 0, menuwidth=120;
1401
 
 
1402
 
        block= uiNewBlock(&curarea->uiblocks, "action_keymenu", 
1403
 
                                          UI_EMBOSSP, UI_HELV, curarea->headwin);
1404
 
        uiBlockSetButmFunc(block, do_action_keymenu, NULL);
1405
 
        
1406
 
        uiDefIconTextBlockBut(block, action_keymenu_transformmenu, 
1407
 
                                                  NULL, ICON_RIGHTARROW_THIN, "Transform", 0, yco-=20, 120, 20, "");
1408
 
        
1409
 
        uiDefIconTextBlockBut(block, action_keymenu_snapmenu, 
1410
 
                                                  NULL, ICON_RIGHTARROW_THIN, "Snap", 0, yco-=20, 120, 20, "");
1411
 
        
1412
 
        uiDefIconTextBlockBut(block, action_keymenu_mirrormenu, 
1413
 
                                                  NULL, ICON_RIGHTARROW_THIN, "Mirror", 0, yco-=20, 120, 20, "");
1414
 
        
1415
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1416
 
                                        menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1417
 
        
1418
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1419
 
                                        "Insert Key|I", 0, yco-=20, 
1420
 
                                        menuwidth, 19, NULL, 0.0, 0.0, 0, 
1421
 
                                        ACTMENU_KEY_INSERTKEY, "");
1422
 
 
1423
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1424
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1425
 
                                        
1426
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1427
 
                                        "Duplicate|Shift D", 0, yco-=20, 
1428
 
                                        menuwidth, 19, NULL, 0.0, 0.0, 0, 
1429
 
                                        ACTMENU_KEY_DUPLICATE, "");
1430
 
        
1431
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1432
 
                                        "Delete|X", 0, yco-=20, 
1433
 
                                        menuwidth, 19, NULL, 0.0, 0.0, 0, 
1434
 
                                        ACTMENU_KEY_DELETE, "");
1435
 
 
1436
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1437
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1438
 
 
1439
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1440
 
                                         "Clean Action|O", 0, yco-=20, 
1441
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1442
 
                                         ACTMENU_KEY_CLEAN, "");
1443
 
                                         
1444
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1445
 
                                         "Sample Keys|Alt O", 0, yco-=20, 
1446
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 0, 
1447
 
                                         ACTMENU_KEY_SAMPLEKEYS, "");
1448
 
 
1449
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1450
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1451
 
 
1452
 
        uiDefIconTextBlockBut(block, action_keymenu_handlemenu, 
1453
 
                                                  NULL, ICON_RIGHTARROW_THIN, 
1454
 
                                                  "Handle Type", 0, yco-=20, 120, 20, "");
1455
 
        
1456
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1457
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1458
 
 
1459
 
        uiDefIconTextBlockBut(block, action_keymenu_extendmenu, 
1460
 
                                                  NULL, ICON_RIGHTARROW_THIN, 
1461
 
                                                  "Extend Mode", 0, yco-=20, 120, 20, "");
1462
 
        uiDefIconTextBlockBut(block, action_keymenu_intpolmenu, 
1463
 
                                                  NULL, ICON_RIGHTARROW_THIN, 
1464
 
                                                  "Interpolation Mode", 0, yco-=20, 120, 20, "");
1465
 
 
1466
 
        
1467
 
        if(curarea->headertype==HEADERTOP) {
1468
 
                uiBlockSetDirection(block, UI_DOWN);
1469
 
        }
1470
 
        else {
1471
 
                uiBlockSetDirection(block, UI_TOP);
1472
 
                uiBlockFlipOrder(block);
1473
 
        }
1474
 
 
1475
 
        uiTextBoundsBlock(block, 50);
1476
 
 
1477
 
        return block;
1478
 
}
1479
 
 
1480
 
/* note: uses do_action_keymenu too! */
1481
 
static uiBlock *action_framemenu(void *arg_unused)
1482
 
{
1483
 
        uiBlock *block;
1484
 
        short yco= 0, menuwidth=120;
1485
 
 
1486
 
        block= uiNewBlock(&curarea->uiblocks, "action_framemenu", 
1487
 
                                          UI_EMBOSSP, UI_HELV, curarea->headwin);
1488
 
        uiBlockSetButmFunc(block, do_action_keymenu, NULL);
1489
 
        
1490
 
        uiDefIconTextBlockBut(block, action_keymenu_transformmenu, 
1491
 
                                                  NULL, ICON_RIGHTARROW_THIN, "Transform", 0, yco-=20, 120, 20, "");
1492
 
        
1493
 
        uiDefIconTextBlockBut(block, action_keymenu_snapmenu, 
1494
 
                                                  NULL, ICON_RIGHTARROW_THIN, "Snap", 0, yco-=20, 120, 20, "");
1495
 
        
1496
 
        uiDefIconTextBlockBut(block, action_keymenu_mirrormenu, 
1497
 
                                                  NULL, ICON_RIGHTARROW_THIN, "Mirror", 0, yco-=20, 120, 20, "");
1498
 
        
1499
 
        uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
1500
 
                         menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1501
 
                                        
1502
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1503
 
                                        "Duplicate|Shift D", 0, yco-=20, 
1504
 
                                        menuwidth, 19, NULL, 0.0, 0.0, 0, 
1505
 
                                        ACTMENU_KEY_DUPLICATE, "");
1506
 
        
1507
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
1508
 
                                        "Delete|X", 0, yco-=20, 
1509
 
                                        menuwidth, 19, NULL, 0.0, 0.0, 0, 
1510
 
                                        ACTMENU_KEY_DELETE, "");
1511
 
        
1512
 
        if(curarea->headertype==HEADERTOP) {
1513
 
                uiBlockSetDirection(block, UI_DOWN);
1514
 
        }
1515
 
        else {
1516
 
                uiBlockSetDirection(block, UI_TOP);
1517
 
                uiBlockFlipOrder(block);
1518
 
        }
1519
 
 
1520
 
        uiTextBoundsBlock(block, 50);
1521
 
 
1522
 
        return block;
1523
 
}
1524
 
 
1525
 
static void do_action_markermenu(void *arg, int event)
1526
 
{       
1527
 
        switch(event)
1528
 
        {
1529
 
                case ACTMENU_MARKERS_ADD:
1530
 
                        add_marker(CFRA);
1531
 
                        break;
1532
 
                case ACTMENU_MARKERS_DUPLICATE:
1533
 
                        duplicate_marker();
1534
 
                        break;
1535
 
                case ACTMENU_MARKERS_DELETE:
1536
 
                        remove_marker();
1537
 
                        break;
1538
 
                case ACTMENU_MARKERS_NAME:
1539
 
                        rename_marker();
1540
 
                        break;
1541
 
                case ACTMENU_MARKERS_MOVE:
1542
 
                        transform_markers('g', 0);
1543
 
                        break;
1544
 
                        
1545
 
                case ACTMENU_MARKERS_LOCALADD:
1546
 
                        action_add_localmarker(G.saction->action, CFRA);
1547
 
                        break;
1548
 
                case ACTMENU_MARKERS_LOCALDELETE:
1549
 
                        action_remove_localmarkers(G.saction->action);
1550
 
                        break;
1551
 
                case ACTMENU_MARKERS_LOCALRENAME:
1552
 
                        action_rename_localmarker(G.saction->action);
1553
 
                        break;
1554
 
                case ACTMENU_MARKERS_LOCALMOVE:
1555
 
                        G.saction->flag |= SACTION_POSEMARKERS_MOVE;
1556
 
                        transform_markers('g', 0);
1557
 
                        G.saction->flag &= ~SACTION_POSEMARKERS_MOVE;
1558
 
                        break;
1559
 
        }
1560
 
        
1561
 
        allqueue(REDRAWMARKER, 0);
1562
 
}
1563
 
 
1564
 
static uiBlock *action_markermenu(void *arg_unused)
1565
 
{
1566
 
        uiBlock *block;
1567
 
        short yco= 0, menuwidth=120;
1568
 
 
1569
 
        block= uiNewBlock(&curarea->uiblocks, "action_markermenu", 
1570
 
                                          UI_EMBOSSP, UI_HELV, curarea->headwin);
1571
 
        uiBlockSetButmFunc(block, do_action_markermenu, NULL);
1572
 
 
1573
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Add Marker|M", 0, yco-=20, 
1574
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_ADD, "");
1575
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Duplicate Marker|Ctrl Shift D", 0, yco-=20, 
1576
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_DUPLICATE, "");
1577
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Delete Marker|Shift X", 0, yco-=20,
1578
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_DELETE, "");
1579
 
                                        
1580
 
        uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1581
 
                                        
1582
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "(Re)Name Marker|Ctrl M", 0, yco-=20,
1583
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_NAME, "");
1584
 
        uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Grab/Move Marker|Ctrl G", 0, yco-=20,
1585
 
                                         menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_MOVE, "");
1586
 
                
1587
 
        if (G.saction->mode == SACTCONT_ACTION) {
1588
 
                uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
1589
 
                
1590
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Add Pose Marker|Shift L", 0, yco-=20, 
1591
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALADD, "");
1592
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Rename Pose Marker|Ctrl Shift L", 0, yco-=20, 
1593
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALRENAME, "");
1594
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Delete Pose Marker|Alt L", 0, yco-=20,
1595
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALDELETE, "");
1596
 
                uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Grab/Move Pose Marker|Ctrl L", 0, yco-=20, 
1597
 
                                                 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALMOVE, "");
1598
 
        }
1599
 
        
1600
 
        if(curarea->headertype==HEADERTOP) {
1601
 
                uiBlockSetDirection(block, UI_DOWN);
1602
 
        }
1603
 
        else {
1604
 
                uiBlockSetDirection(block, UI_TOP);
1605
 
                uiBlockFlipOrder(block);
1606
 
        }
1607
 
 
1608
 
        uiTextBoundsBlock(block, 50);
1609
 
 
1610
 
        return block;
1611
 
}
1612
 
 
1613
 
void action_buttons(void)
1614
 
{
1615
 
        uiBlock *block;
1616
 
        short xco, xmax;
1617
 
        char name[256];
1618
 
        Object *ob;
1619
 
        ID *from;
1620
 
 
1621
 
        if (G.saction == NULL)
1622
 
                return;
1623
 
 
1624
 
        /* copied from drawactionspace.... */
1625
 
        // FIXME: do for gpencil too?
1626
 
        if (!G.saction->pin) {
1627
 
                if (OBACT)
1628
 
                        G.saction->action = OBACT->action;
1629
 
                else
1630
 
                        G.saction->action= NULL;
1631
 
        }
1632
 
 
1633
 
        sprintf(name, "header %d", curarea->headwin);
1634
 
        block= uiNewBlock(&curarea->uiblocks, name, 
1635
 
                                          UI_EMBOSS, UI_HELV, curarea->headwin);
1636
 
 
1637
 
        if (area_is_active_area(curarea)) 
1638
 
                uiBlockSetCol(block, TH_HEADER);
1639
 
        else 
1640
 
                uiBlockSetCol(block, TH_HEADERDESEL);
1641
 
 
1642
 
        curarea->butspacetype= SPACE_ACTION;
1643
 
        
1644
 
        xco = 8;
1645
 
        
1646
 
        uiDefIconTextButC(block, ICONTEXTROW,B_NEWSPACE, ICON_VIEW3D, 
1647
 
                                          windowtype_pup(), xco, 0, XIC+10, YIC, 
1648
 
                                          &(curarea->butspacetype), 1.0, SPACEICONMAX, 0, 0, 
1649
 
                                          "Displays Current Window Type. "
1650
 
                                          "Click for menu of available types.");
1651
 
 
1652
 
        xco += XIC + 14;
1653
 
 
1654
 
        uiBlockSetEmboss(block, UI_EMBOSSN);
1655
 
        if (curarea->flag & HEADER_NO_PULLDOWN) {
1656
 
                uiDefIconButBitS(block, TOG, HEADER_NO_PULLDOWN, B_FLIPINFOMENU, 
1657
 
                                          ICON_DISCLOSURE_TRI_RIGHT,
1658
 
                                          xco,2,XIC,YIC-2,
1659
 
                                          &(curarea->flag), 0, 0, 0, 0, 
1660
 
                                          "Show pulldown menus");
1661
 
        }
1662
 
        else {
1663
 
                uiDefIconButBitS(block, TOG, HEADER_NO_PULLDOWN, B_FLIPINFOMENU, 
1664
 
                                          ICON_DISCLOSURE_TRI_DOWN,
1665
 
                                          xco,2,XIC,YIC-2,
1666
 
                                          &(curarea->flag), 0, 0, 0, 0, 
1667
 
                                          "Hide pulldown menus");
1668
 
        }
1669
 
        uiBlockSetEmboss(block, UI_EMBOSS);
1670
 
        xco+=XIC;
1671
 
 
1672
 
        if ((curarea->flag & HEADER_NO_PULLDOWN)==0) {
1673
 
                /* pull down menus */
1674
 
                uiBlockSetEmboss(block, UI_EMBOSSP);
1675
 
                
1676
 
                xmax= GetButStringLength("View");
1677
 
                uiDefPulldownBut(block, action_viewmenu, NULL, 
1678
 
                                          "View", xco, -2, xmax-3, 24, "");
1679
 
                xco+= xmax;
1680
 
                
1681
 
                xmax= GetButStringLength("Select");
1682
 
                uiDefPulldownBut(block, action_selectmenu, NULL, 
1683
 
                                          "Select", xco, -2, xmax-3, 24, "");
1684
 
                xco+= xmax;
1685
 
                
1686
 
                if ((G.saction->action) && (G.saction->mode==SACTCONT_ACTION)) {
1687
 
                        xmax= GetButStringLength("Channel");
1688
 
                        uiDefPulldownBut(block, action_channelmenu, NULL, 
1689
 
                                                  "Channel", xco, -2, xmax-3, 24, "");
1690
 
                        xco+= xmax;
1691
 
                }
1692
 
                else if (G.saction->mode==SACTCONT_GPENCIL) {
1693
 
                        xmax= GetButStringLength("Channel");
1694
 
                        uiDefPulldownBut(block, action_gplayermenu, NULL, 
1695
 
                                                  "Channel", xco, -2, xmax-3, 24, "");
1696
 
                        xco+= xmax;
1697
 
                }
1698
 
                
1699
 
                xmax= GetButStringLength("Marker");
1700
 
                uiDefPulldownBut(block, action_markermenu, NULL, 
1701
 
                                          "Marker", xco, -2, xmax-3, 24, "");
1702
 
                xco+= xmax;
1703
 
                
1704
 
                if (G.saction->mode == SACTCONT_GPENCIL) {
1705
 
                        xmax= GetButStringLength("Frame");
1706
 
                        uiDefPulldownBut(block, action_framemenu, NULL, 
1707
 
                                                  "Frame", xco, -2, xmax-3, 24, "");
1708
 
                        xco+= xmax;
1709
 
 
1710
 
                }
1711
 
                else {
1712
 
                        xmax= GetButStringLength("Key");
1713
 
                        uiDefPulldownBut(block, action_keymenu, NULL, 
1714
 
                                                  "Key", xco, -2, xmax-3, 24, "");
1715
 
                        xco+= xmax;
1716
 
                }
1717
 
        }
1718
 
 
1719
 
        uiBlockSetEmboss(block, UI_EMBOSS);
1720
 
        
1721
 
        /* MODE SELECTOR */
1722
 
        uiDefButC(block, MENU, B_REDR, 
1723
 
                        "Editor Mode %t|Action Editor %x0|ShapeKey Editor %x1|Grease Pencil %x2", 
1724
 
                        xco,0,90,YIC, &(G.saction->mode), 0, 1, 0, 0, 
1725
 
                        "Editing modes for this editor");
1726
 
 
1727
 
        
1728
 
        xco += (90 + 8);
1729
 
        
1730
 
        /* MODE-DEPENDENT DRAWING */
1731
 
        if (G.saction->mode != SACTCONT_GPENCIL) {
1732
 
                /* NAME ETC */
1733
 
                ob= OBACT;
1734
 
                from = (ID *)ob;
1735
 
                
1736
 
                xco= std_libbuttons(block, xco, 0, B_ACTPIN, &G.saction->pin, 
1737
 
                                                        B_ACTIONBROWSE, ID_AC, 0, (ID*)G.saction->action, 
1738
 
                                                        from, &(G.saction->actnr), B_ACTALONE, 
1739
 
                                                        B_ACTLOCAL, B_ACTIONDELETE, 0, B_KEEPDATA);     
1740
 
                
1741
 
                uiClearButLock();
1742
 
                
1743
 
                xco += 8;
1744
 
        }
1745
 
        
1746
 
        
1747
 
        /* COPY PASTE */
1748
 
        uiBlockBeginAlign(block);
1749
 
        if (curarea->headertype==HEADERTOP) {
1750
 
                uiDefIconBut(block, BUT, B_ACTCOPYKEYS, ICON_COPYUP,    xco,0,XIC,YIC, 0, 0, 0, 0, 0, "Copies the selected keyframes from the selected channel(s) to the buffer");
1751
 
                uiDefIconBut(block, BUT, B_ACTPASTEKEYS, ICON_PASTEUP,  xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Pastes the keyframes from the buffer");
1752
 
        }
1753
 
        else {
1754
 
                uiDefIconBut(block, BUT, B_ACTCOPYKEYS, ICON_COPYDOWN,  xco,0,XIC,YIC, 0, 0, 0, 0, 0, "Copies the selected keyframes from the selected channel(s) to the buffer");
1755
 
                uiDefIconBut(block, BUT, B_ACTPASTEKEYS, ICON_PASTEDOWN,        xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Pastes the keyframes from the buffer");
1756
 
        }
1757
 
        uiBlockEndAlign(block);
1758
 
        xco += (XIC + 8);
1759
 
        
1760
 
        
1761
 
        if (G.saction->mode != SACTCONT_GPENCIL) {
1762
 
                /* draw AUTOSNAP */
1763
 
                if (G.saction->flag & SACTION_DRAWTIME) {
1764
 
                        uiDefButC(block, MENU, B_REDR,
1765
 
                                        "Auto-Snap Keyframes %t|No Snap %x0|Second Step %x1|Nearest Second %x2|Nearest Marker %x3", 
1766
 
                                        xco,0,70,YIC, &(G.saction->autosnap), 0, 1, 0, 0, 
1767
 
                                        "Auto-snapping mode for keyframes when transforming");
1768
 
                }
1769
 
                else {
1770
 
                        uiDefButC(block, MENU, B_REDR, 
1771
 
                                        "Auto-Snap Keyframes %t|No Snap %x0|Frame Step %x1|Nearest Frame %x2|Nearest Marker %x3", 
1772
 
                                        xco,0,70,YIC, &(G.saction->autosnap), 0, 1, 0, 0, 
1773
 
                                        "Auto-snapping mode for keyframes when transforming");
1774
 
                }
1775
 
                
1776
 
                xco += (70 + 8);
1777
 
        }
1778
 
        
1779
 
        /* draw LOCK */
1780
 
        uiDefIconButS(block, ICONTOG, 1, ICON_UNLOCKED, xco, 0, XIC, YIC, 
1781
 
                                  &(G.saction->lock), 0, 0, 0, 0, 
1782
 
                                  "Updates other affected window spaces automatically "
1783
 
                                  "to reflect changes in real time");
1784
 
        
1785
 
        /* always as last  */
1786
 
        curarea->headbutlen = xco + 2*XIC;
1787
 
 
1788
 
        uiDrawBlock(block);
1789
 
}