Bassam Feature Request: "Auto Clamped" handles can now be set per
[blender-staging.git] / source / blender / editors / animation / drivers.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Joshua Leung (full recode)
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 /** \file blender/editors/animation/drivers.c
31  *  \ingroup edanimation
32  */
33
34  
35 #include <stdio.h>
36 #include <string.h>
37
38 #include "MEM_guardedalloc.h"
39
40 #include "BLI_blenlib.h"
41 #include "BLI_utildefines.h"
42
43 #include "DNA_anim_types.h"
44 #include "DNA_object_types.h"
45 #include "DNA_material_types.h"
46 #include "DNA_texture_types.h"
47 #include "DNA_screen_types.h"
48 #include "DNA_space_types.h"
49
50 #include "BKE_animsys.h"
51 #include "BKE_depsgraph.h"
52 #include "BKE_fcurve.h"
53 #include "BKE_context.h"
54 #include "BKE_report.h"
55 #include "BKE_material.h"
56 #include "BKE_texture.h"
57
58 #include "ED_keyframing.h"
59
60 #include "UI_interface.h"
61
62 #include "WM_api.h"
63 #include "WM_types.h"
64
65 #include "RNA_access.h"
66 #include "RNA_define.h"
67
68 #include "anim_intern.h"
69
70 /* called by WM */
71 void free_anim_drivers_copybuf (void);
72
73 /* ************************************************** */
74 /* Animation Data Validation */
75
76 /* Get (or add relevant data to be able to do so) F-Curve from the driver stack, 
77  * for the given Animation Data block. This assumes that all the destinations are valid.
78  *      
79  *      - add:  0 - don't add anything if not found, 
80  *                      1 - add new Driver FCurve, 
81  *                      -1 - add new Driver FCurve without driver stuff (for pasting)
82  */
83 FCurve *verify_driver_fcurve (ID *id, const char rna_path[], const int array_index, short add)
84 {
85         AnimData *adt;
86         FCurve *fcu;
87         
88         /* sanity checks */
89         if ELEM(NULL, id, rna_path)
90                 return NULL;
91         
92         /* init animdata if none available yet */
93         adt= BKE_animdata_from_id(id);
94         if ((adt == NULL) && (add))
95                 adt= BKE_id_add_animdata(id);
96         if (adt == NULL) { 
97                 /* if still none (as not allowed to add, or ID doesn't have animdata for some reason) */
98                 return NULL;
99         }
100                 
101         /* try to find f-curve matching for this setting 
102          *      - add if not found and allowed to add one
103          *              TODO: add auto-grouping support? how this works will need to be resolved
104          */
105         fcu= list_find_fcurve(&adt->drivers, rna_path, array_index);
106         
107         if ((fcu == NULL) && (add)) {
108                 /* use default settings to make a F-Curve */
109                 fcu= MEM_callocN(sizeof(FCurve), "FCurve");
110                 
111                 fcu->flag = (FCURVE_VISIBLE|FCURVE_SELECTED);
112                 
113                 /* store path - make copy, and store that */
114                 fcu->rna_path= BLI_strdupn(rna_path, strlen(rna_path));
115                 fcu->array_index= array_index;
116                 
117                 /* if add is negative, don't init this data yet, since it will be filled in by the pasted driver */
118                 if (add > 0) {
119                         /* add some new driver data */
120                         fcu->driver= MEM_callocN(sizeof(ChannelDriver), "ChannelDriver");
121                         
122                         /* add simple generator modifier for driver so that there is some visible representation */
123                         add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_GENERATOR);
124                 }
125                 
126                 /* just add F-Curve to end of driver list */
127                 BLI_addtail(&adt->drivers, fcu);
128         }
129         
130         /* return the F-Curve */
131         return fcu;
132 }
133
134 /* ************************************************** */
135 /* Driver Management API */
136
137 /* Main Driver Management API calls:
138  *      Add a new driver for the specified property on the given ID block
139  */
140 short ANIM_add_driver (ReportList *reports, ID *id, const char rna_path[], int array_index, short flag, int type)
141 {       
142         PointerRNA id_ptr, ptr;
143         PropertyRNA *prop;
144         FCurve *fcu;
145         int array_index_max;
146         int done = 0;
147         
148         /* validate pointer first - exit if failure */
149         RNA_id_pointer_create(id, &id_ptr);
150         if ((RNA_path_resolve(&id_ptr, rna_path, &ptr, &prop) == 0) || (prop == NULL)) {
151                 BKE_reportf(reports, RPT_ERROR, 
152                         "Could not add Driver, as RNA Path is invalid for the given ID (ID = %s, Path = %s)", 
153                         id->name, rna_path);
154                 return 0;
155         }
156         
157         /* key entire array convenience method */
158         if (array_index == -1) {
159                 array_index_max= RNA_property_array_length(&ptr, prop);
160                 array_index= 0;
161         }
162         else
163                 array_index_max= array_index;
164         
165         /* maximum index should be greater than the start index */
166         if (array_index == array_index_max)
167                 array_index_max += 1;
168         
169         /* will only loop once unless the array index was -1 */
170         for (; array_index < array_index_max; array_index++) {
171                 /* create F-Curve with Driver */
172                 fcu= verify_driver_fcurve(id, rna_path, array_index, 1);
173                 
174                 if (fcu && fcu->driver) {
175                         ChannelDriver *driver= fcu->driver;
176                         
177                         /* set the type of the driver */
178                         driver->type= type;
179                         
180                         /* creating drivers for buttons will create the driver(s) with type 
181                          * "scripted expression" so that their values won't be lost immediately,
182                          * so here we copy those values over to the driver's expression
183                          */
184                         if (type == DRIVER_TYPE_PYTHON) {
185                                 PropertyType proptype= RNA_property_type(prop);
186                                 int array= RNA_property_array_length(&ptr, prop);
187                                 char *expression= driver->expression;
188                                 int val, maxlen= sizeof(driver->expression);
189                                 float fval;
190                                 
191                                 if (proptype == PROP_BOOLEAN) {
192                                         if (!array) val= RNA_property_boolean_get(&ptr, prop);
193                                         else val= RNA_property_boolean_get_index(&ptr, prop, array_index);
194                                         
195                                         BLI_strncpy(expression, (val)? "True": "False", maxlen);
196                                 }
197                                 else if (proptype == PROP_INT) {
198                                         if (!array) val= RNA_property_int_get(&ptr, prop);
199                                         else val= RNA_property_int_get_index(&ptr, prop, array_index);
200                                         
201                                         BLI_snprintf(expression, maxlen, "%d", val);
202                                 }
203                                 else if (proptype == PROP_FLOAT) {
204                                         if (!array) fval= RNA_property_float_get(&ptr, prop);
205                                         else fval= RNA_property_float_get_index(&ptr, prop, array_index);
206                                         
207                                         BLI_snprintf(expression, maxlen, "%.3f", fval);
208                                 }
209                         }
210                         
211                         /* for easier setup of drivers from UI, a driver variable should be 
212                          * added if flag is set (UI calls only)
213                          */
214                         if (flag & CREATEDRIVER_WITH_DEFAULT_DVAR) {
215                                 /* assume that users will mostly want this to be of type "Transform Channel" too,
216                                  * since this allows the easiest setting up of common rig components
217                                  */
218                                 DriverVar *dvar = driver_add_new_variable(driver);
219                                 driver_change_variable_type(dvar, DVAR_TYPE_TRANSFORM_CHAN);
220                         }
221                 }
222                 
223                 /* set the done status */
224                 done += (fcu != NULL);
225         }
226         
227         /* done */
228         return done;
229 }
230
231 /* Main Driver Management API calls:
232  *      Remove the driver for the specified property on the given ID block (if available)
233  */
234 short ANIM_remove_driver (ReportList *UNUSED(reports), ID *id, const char rna_path[], int array_index, short UNUSED(flag))
235 {
236         AnimData *adt;
237         FCurve *fcu;
238         int success= 0;
239         
240         /* we don't check the validity of the path here yet, but it should be ok... */
241         adt= BKE_animdata_from_id(id);
242         
243         if (adt) {
244                 if (array_index == -1) {
245                         /* step through all drivers, removing all of those with the same base path */
246                         FCurve *fcu_iter= adt->drivers.first;
247                         
248                         while ((fcu = iter_step_fcurve(fcu_iter, rna_path)) != NULL) {
249                                 /* store the next fcurve for looping  */
250                                 fcu_iter= fcu->next;
251                                 
252                                 /* remove F-Curve from driver stack, then free it */
253                                 BLI_remlink(&adt->drivers, fcu);
254                                 free_fcurve(fcu);
255                                 
256                                 /* done successfully */
257                                 success |= 1;
258                         }
259                 }
260                 else {
261                         /* find the matching driver and remove it only 
262                          * Note: here is one of the places where we don't want new F-Curve + Driver added!
263                          *              so 'add' var must be 0
264                          */
265                         fcu= verify_driver_fcurve(id, rna_path, array_index, 0);
266                         if (fcu) {
267                                 BLI_remlink(&adt->drivers, fcu);
268                                 free_fcurve(fcu);
269                                 
270                                 success = 1;
271                         }
272                 }
273         }
274
275         return success;
276 }
277
278 /* ************************************************** */
279 /* Driver Management API - Copy/Paste Drivers */
280
281 /* Copy/Paste Buffer for Driver Data... */
282 static FCurve *channeldriver_copypaste_buf = NULL;
283
284 /* This function frees any MEM_calloc'ed copy/paste buffer data */
285 // XXX find some header to put this in!
286 void free_anim_drivers_copybuf (void)
287 {
288         /* free the buffer F-Curve if it exists, as if it were just another F-Curve */
289         if (channeldriver_copypaste_buf)
290                 free_fcurve(channeldriver_copypaste_buf);
291         channeldriver_copypaste_buf= NULL;
292 }
293
294 /* Checks if there is a driver in the copy/paste buffer */
295 short ANIM_driver_can_paste (void)
296 {
297         return (channeldriver_copypaste_buf != NULL);
298 }
299
300 /* ------------------- */
301
302 /* Main Driver Management API calls:
303  *      Make a copy of the driver for the specified property on the given ID block
304  */
305 short ANIM_copy_driver (ReportList *reports, ID *id, const char rna_path[], int array_index, short UNUSED(flag))
306 {
307         PointerRNA id_ptr, ptr;
308         PropertyRNA *prop;
309         FCurve *fcu;
310         
311         /* validate pointer first - exit if failure */
312         RNA_id_pointer_create(id, &id_ptr);
313         if ((RNA_path_resolve(&id_ptr, rna_path, &ptr, &prop) == 0) || (prop == NULL)) {
314                 BKE_reportf(reports, RPT_ERROR,
315                         "Could not find Driver to copy, as RNA Path is invalid for the given ID (ID = %s, Path = %s)", 
316                         id->name, rna_path);
317                 return 0;
318         }
319         
320         /* try to get F-Curve with Driver */
321         fcu= verify_driver_fcurve(id, rna_path, array_index, 0);
322         
323         /* clear copy/paste buffer first (for consistency with other copy/paste buffers) */
324         free_anim_drivers_copybuf();
325         
326         /* copy this to the copy/paste buf if it exists */
327         if (fcu && fcu->driver) {
328                 /* make copies of some info such as the rna_path, then clear this info from the F-Curve temporarily
329                  * so that we don't end up wasting memory storing the path which won't get used ever...
330                  */
331                 char *tmp_path = fcu->rna_path;
332                 fcu->rna_path= NULL;
333                 
334                 /* make a copy of the F-Curve with */
335                 channeldriver_copypaste_buf= copy_fcurve(fcu);
336                 
337                 /* restore the path */
338                 fcu->rna_path= tmp_path;
339                 
340                 /* copied... */
341                 return 1;
342         }
343         
344         /* done */
345         return 0;
346 }
347
348 /* Main Driver Management API calls:
349  *      Add a new driver for the specified property on the given ID block or replace an existing one
350  *      with the driver + driver-curve data from the buffer 
351  */
352 short ANIM_paste_driver (ReportList *reports, ID *id, const char rna_path[], int array_index, short UNUSED(flag))
353 {       
354         PointerRNA id_ptr, ptr;
355         PropertyRNA *prop;
356         FCurve *fcu;
357         
358         /* validate pointer first - exit if failure */
359         RNA_id_pointer_create(id, &id_ptr);
360         if ((RNA_path_resolve(&id_ptr, rna_path, &ptr, &prop) == 0) || (prop == NULL)) {
361                 BKE_reportf(reports, RPT_ERROR,
362                         "Could not paste Driver, as RNA Path is invalid for the given ID (ID = %s, Path = %s)", 
363                         id->name, rna_path);
364                 return 0;
365         }
366         
367         /* if the buffer is empty, cannot paste... */
368         if (channeldriver_copypaste_buf == NULL) {
369                 BKE_report(reports, RPT_ERROR, "Paste Driver: No Driver to paste.");
370                 return 0;
371         }
372         
373         /* create Driver F-Curve, but without data which will be copied across... */
374         fcu= verify_driver_fcurve(id, rna_path, array_index, -1);
375
376         if (fcu) {
377                 /* copy across the curve data from the buffer curve 
378                  * NOTE: this step needs care to not miss new settings
379                  */
380                         /* keyframes/samples */
381                 fcu->bezt= MEM_dupallocN(channeldriver_copypaste_buf->bezt);
382                 fcu->fpt= MEM_dupallocN(channeldriver_copypaste_buf->fpt);
383                 fcu->totvert= channeldriver_copypaste_buf->totvert;
384                 
385                         /* modifiers */
386                 copy_fmodifiers(&fcu->modifiers, &channeldriver_copypaste_buf->modifiers);
387                 
388                         /* flags - on a per-relevant-flag basis */
389                         /* extrapolation mode */
390                 fcu->extend= channeldriver_copypaste_buf->extend;
391                         
392                         /* the 'juicy' stuff - the driver */
393                 fcu->driver= fcurve_copy_driver(channeldriver_copypaste_buf->driver);
394         }
395         
396         /* done */
397         return (fcu != NULL);
398 }
399
400 /* ************************************************** */
401 /* UI-Button Interface */
402
403 /* Temporary wrapper for driver operators for buttons to make it easier to create
404  * such drivers by rerouting all paths through the active object instead so that
405  * they will get picked up by the dependency system.
406  *
407  * < C: context pointer - for getting active data 
408  * <> ptr: RNA pointer for property's datablock. May be modified as result of path remapping.
409  * < prop: RNA definition of property to add for
410  *
411  * > returns: MEM_alloc'd string representing the path to the property from the given PointerRNA
412  */
413 static char *get_driver_path_hack (bContext *C, PointerRNA *ptr, PropertyRNA *prop)
414 {
415         ID *id = (ID *)ptr->id.data;
416         ScrArea *sa = CTX_wm_area(C);
417         
418         /* get standard path which may be extended */
419         char *basepath = RNA_path_from_ID_to_property(ptr, prop);
420         char *path = basepath; /* in case no remapping is needed */
421         
422         /* Remapping will only be performed in the Properties Editor, as only this 
423          * restricts the subspace of options to the 'active' data (a manageable state)
424          */
425         // TODO: watch out for pinned context?
426         if ((sa) && (sa->spacetype == SPACE_BUTS)) {
427                 Object *ob = CTX_data_active_object(C);
428                 
429                 if (ob && id) {
430                         /* only id-types which can be remapped to go through objects should be considered */
431                         switch (GS(id->name)) {
432                                 case ID_MA: /* materials */
433                                 {
434                                         Material *ma = give_current_material(ob, ob->actcol);
435                                         
436                                         /* assumes: material will only be shown if it is active objects's active material it's ok */
437                                         if ((ID*)ma == id) {
438                                                 /* create new path */
439                                                 // TODO: use RNA path functions to construct instead?
440                                                 path = BLI_sprintfN("material_slots[\"%s\"].material.%s",
441                                                         ma->id.name+2, basepath);
442                                                         
443                                                 /* free old one */
444                                                 MEM_freeN(basepath);
445                                         }
446                                 }
447                                         break;
448                                         
449                                 case ID_TE: /* textures */
450                                 {
451                                         Material *ma = give_current_material(ob, ob->actcol);
452                                         Tex *tex = give_current_material_texture(ma);
453                                         
454                                         /* assumes: texture will only be shown if it is active material's active texture it's ok */
455                                         if ((ID*)tex == id) {
456                                                 /* create new path */
457                                                 // TODO: use RNA path functions to construct step by step instead?
458                                                 path = BLI_sprintfN("material_slots[\"%s\"].material.texture_slots[\"%s\"].texture.%s", 
459                                                         ma->id.name+2, tex->id.name+2, basepath);
460                                                         
461                                                 /* free old one */
462                                                 MEM_freeN(basepath);
463                                         }
464                                 }
465                                         break;
466                         }
467                         
468                         /* fix RNA pointer, as we've now changed the ID root by changing the paths */
469                         if (basepath != path) {
470                                 /* rebase provided pointer so that it starts from object... */
471                                 RNA_pointer_create(&ob->id, ptr->type, ptr->data, ptr);
472                         }
473                 }
474         }
475         
476         /* the path should now have been corrected for use */
477         return path;
478 }
479
480 /* Add Driver Button Operator ------------------------ */
481
482 static int add_driver_button_exec (bContext *C, wmOperator *op)
483 {
484         PointerRNA ptr= {{NULL}};
485         PropertyRNA *prop= NULL;
486         short success= 0;
487         int index, all= RNA_boolean_get(op->ptr, "all");
488         
489         /* try to create driver using property retrieved from UI */
490         uiContextActiveProperty(C, &ptr, &prop, &index);
491         
492         if (all)
493                 index= -1;
494         
495         if (ptr.id.data && ptr.data && prop && RNA_property_animateable(&ptr, prop)) {
496                 char *path= get_driver_path_hack(C, &ptr, prop);
497                 short flags = CREATEDRIVER_WITH_DEFAULT_DVAR;
498                 
499                 if (path) {                     
500                         success+= ANIM_add_driver(op->reports, ptr.id.data, path, index, flags, DRIVER_TYPE_PYTHON);
501                         
502                         MEM_freeN(path);
503                 }
504         }
505         
506         if (success) {
507                 /* send updates */
508                 uiContextAnimUpdate(C);
509                 
510                 DAG_ids_flush_update(CTX_data_main(C), 0);
511                 
512                 WM_event_add_notifier(C, NC_ANIMATION|ND_FCURVES_ORDER, NULL); // XXX
513         }
514         
515         return (success)? OPERATOR_FINISHED: OPERATOR_CANCELLED;
516 }
517
518 void ANIM_OT_driver_button_add (wmOperatorType *ot)
519 {
520         /* identifiers */
521         ot->name= "Add Driver";
522         ot->idname= "ANIM_OT_driver_button_add";
523         ot->description= "Add driver(s) for the property(s) connected represented by the highlighted button";
524         
525         /* callbacks */
526         ot->exec= add_driver_button_exec; 
527         //op->poll= ??? // TODO: need to have some animateable property to do this
528         
529         /* flags */
530         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
531
532         /* properties */
533         RNA_def_boolean(ot->srna, "all", 1, "All", "Create drivers for all elements of the array.");
534 }
535
536 /* Remove Driver Button Operator ------------------------ */
537
538 static int remove_driver_button_exec (bContext *C, wmOperator *op)
539 {
540         PointerRNA ptr= {{NULL}};
541         PropertyRNA *prop= NULL;
542         short success= 0;
543         int index, all= RNA_boolean_get(op->ptr, "all");
544         
545         /* try to find driver using property retrieved from UI */
546         uiContextActiveProperty(C, &ptr, &prop, &index);
547         
548         if (all)
549                 index= -1;
550         
551         if (ptr.id.data && ptr.data && prop) {
552                 char *path= get_driver_path_hack(C, &ptr, prop);
553                 
554                 success= ANIM_remove_driver(op->reports, ptr.id.data, path, index, 0);
555                 MEM_freeN(path);
556         }
557         
558         if (success) {
559                 /* send updates */
560                 uiContextAnimUpdate(C);
561                 
562                 DAG_ids_flush_update(CTX_data_main(C), 0);
563                 
564                 WM_event_add_notifier(C, NC_ANIMATION|ND_FCURVES_ORDER, NULL);  // XXX
565         }
566         
567         return (success)? OPERATOR_FINISHED: OPERATOR_CANCELLED;
568 }
569
570 void ANIM_OT_driver_button_remove (wmOperatorType *ot)
571 {
572         /* identifiers */
573         ot->name= "Remove Driver";
574         ot->idname= "ANIM_OT_driver_button_remove";
575         ot->description= "Remove the driver(s) for the property(s) connected represented by the highlighted button";
576         
577         /* callbacks */
578         ot->exec= remove_driver_button_exec; 
579         //op->poll= ??? // TODO: need to have some driver to be able to do this...
580         
581         /* flags */
582         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
583
584         /* properties */
585         RNA_def_boolean(ot->srna, "all", 1, "All", "Delete drivers for all elements of the array.");
586 }
587
588 /* Copy Driver Button Operator ------------------------ */
589
590 static int copy_driver_button_exec (bContext *C, wmOperator *op)
591 {
592         PointerRNA ptr= {{NULL}};
593         PropertyRNA *prop= NULL;
594         short success= 0;
595         int index;
596         
597         /* try to create driver using property retrieved from UI */
598         uiContextActiveProperty(C, &ptr, &prop, &index);
599         
600         if (ptr.id.data && ptr.data && prop && RNA_property_animateable(&ptr, prop)) {
601                 char *path= get_driver_path_hack(C, &ptr, prop);
602                 
603                 if (path) {
604                         /* only copy the driver for the button that this was involved for */
605                         success= ANIM_copy_driver(op->reports, ptr.id.data, path, index, 0);
606                         
607                         uiContextAnimUpdate(C);
608                         
609                         MEM_freeN(path);
610                 }
611         }
612         
613         /* since we're just copying, we don't really need to do anything else...*/
614         return (success)? OPERATOR_FINISHED: OPERATOR_CANCELLED;
615 }
616
617 void ANIM_OT_copy_driver_button (wmOperatorType *ot)
618 {
619         /* identifiers */
620         ot->name= "Copy Driver";
621         ot->idname= "ANIM_OT_copy_driver_button";
622         ot->description= "Copy the driver for the highlighted button";
623         
624         /* callbacks */
625         ot->exec= copy_driver_button_exec; 
626         //op->poll= ??? // TODO: need to have some driver to be able to do this...
627         
628         /* flags */
629         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
630 }
631
632 /* Paste Driver Button Operator ------------------------ */
633
634 static int paste_driver_button_exec (bContext *C, wmOperator *op)
635 {
636         PointerRNA ptr= {{NULL}};
637         PropertyRNA *prop= NULL;
638         short success= 0;
639         int index;
640         
641         /* try to create driver using property retrieved from UI */
642         uiContextActiveProperty(C, &ptr, &prop, &index);
643         
644         if (ptr.id.data && ptr.data && prop && RNA_property_animateable(&ptr, prop)) {
645                 char *path= get_driver_path_hack(C, &ptr, prop);
646                 
647                 if (path) {
648                         /* only copy the driver for the button that this was involved for */
649                         success= ANIM_paste_driver(op->reports, ptr.id.data, path, index, 0);
650                         
651                         uiContextAnimUpdate(C);
652                         
653                         MEM_freeN(path);
654                 }
655         }
656         
657         /* since we're just copying, we don't really need to do anything else...*/
658         return (success)? OPERATOR_FINISHED: OPERATOR_CANCELLED;
659 }
660
661 void ANIM_OT_paste_driver_button (wmOperatorType *ot)
662 {
663         /* identifiers */
664         ot->name= "Paste Driver";
665         ot->idname= "ANIM_OT_paste_driver_button";
666         ot->description= "Paste the driver in the copy/paste buffer for the highlighted button";
667         
668         /* callbacks */
669         ot->exec= paste_driver_button_exec; 
670         //op->poll= ??? // TODO: need to have some driver to be able to do this...
671         
672         /* flags */
673         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
674 }
675
676 /* ************************************************** */