Cleanup: duplicate includes
[blender-staging.git] / source / blender / makesrna / intern / rna_key.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_key.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28
29 #include "DNA_ID.h"
30 #include "DNA_scene_types.h"
31 #include "DNA_curve_types.h"
32 #include "DNA_key_types.h"
33 #include "DNA_lattice_types.h"
34 #include "DNA_mesh_types.h"
35
36 #include "BLI_utildefines.h"
37
38 #include "BLF_translation.h"
39
40 #include "RNA_access.h"
41 #include "RNA_define.h"
42 #include "RNA_enum_types.h"
43
44 #include "rna_internal.h"
45
46 #ifdef RNA_RUNTIME
47
48 #include <stddef.h>
49
50 #include "DNA_object_types.h"
51
52 #include "BKE_animsys.h"
53 #include "BKE_depsgraph.h"
54 #include "BKE_key.h"
55 #include "BKE_main.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 static Key *rna_ShapeKey_find_key(ID *id)
61 {
62         switch (GS(id->name)) {
63                 case ID_CU: return ((Curve *)id)->key;
64                 case ID_KE: return (Key *)id;
65                 case ID_LT: return ((Lattice *)id)->key;
66                 case ID_ME: return ((Mesh *)id)->key;
67                 case ID_OB: return BKE_key_from_object((Object *)id);
68                 default: return NULL;
69         }
70 }
71
72 static void rna_ShapeKey_name_set(PointerRNA *ptr, const char *value)
73 {
74         KeyBlock *kb = ptr->data;
75         char oldname[sizeof(kb->name)];
76         
77         /* make a copy of the old name first */
78         BLI_strncpy(oldname, kb->name, sizeof(kb->name));
79         
80         /* copy the new name into the name slot */
81         BLI_strncpy_utf8(kb->name, value, sizeof(kb->name));
82         
83         /* make sure the name is truly unique */
84         if (ptr->id.data) {
85                 Key *key = rna_ShapeKey_find_key(ptr->id.data);
86                 BLI_uniquename(&key->block, kb, CTX_DATA_(BLF_I18NCONTEXT_ID_SHAPEKEY, "Key"), '.',
87                                offsetof(KeyBlock, name), sizeof(kb->name));
88         }
89         
90         /* fix all the animation data which may link to this */
91         BKE_animdata_fix_paths_rename_all(NULL, "key_blocks", oldname, kb->name);
92 }
93
94 static float rna_ShapeKey_frame_get(PointerRNA *ptr)
95 {
96         KeyBlock *kb = (KeyBlock *)ptr->data;
97         return kb->pos * 100.0f;  /* Because pos is ctime/100... */
98 }
99
100 static void rna_ShapeKey_value_set(PointerRNA *ptr, float value)
101 {
102         KeyBlock *data = (KeyBlock *)ptr->data;
103         CLAMP(value, data->slidermin, data->slidermax);
104         data->curval = value;
105 }
106
107 static void rna_ShapeKey_value_range(PointerRNA *ptr, float *min, float *max,
108                                      float *UNUSED(softmin), float *UNUSED(softmax))
109 {
110         KeyBlock *data = (KeyBlock *)ptr->data;
111
112         *min = data->slidermin;
113         *max = data->slidermax;
114 }
115
116 /* epsilon for how close one end of shapekey range can get to the other */
117 #define SHAPEKEY_SLIDER_TOL 0.001f
118
119 static void rna_ShapeKey_slider_min_range(PointerRNA *ptr, float *min, float *max,
120                                           float *UNUSED(softmin), float *UNUSED(softmax))
121 {
122         KeyBlock *data = (KeyBlock *)ptr->data;
123
124         *min = -10.0f;
125         *max = data->slidermax - SHAPEKEY_SLIDER_TOL;
126 }
127
128 static void rna_ShapeKey_slider_min_set(PointerRNA *ptr, float value)
129 {
130         KeyBlock *data = (KeyBlock *)ptr->data;
131         float min, max, softmin, softmax;
132         
133         rna_ShapeKey_slider_min_range(ptr, &min, &max, &softmin, &softmax);
134         CLAMP(value, min, max);
135         data->slidermin = value;
136 }
137
138 static void rna_ShapeKey_slider_max_range(PointerRNA *ptr, float *min, float *max,
139                                           float *UNUSED(softmin), float *UNUSED(softmax))
140 {
141         KeyBlock *data = (KeyBlock *)ptr->data;
142
143         *min = data->slidermin + SHAPEKEY_SLIDER_TOL;
144         *max = 10.0f;
145 }
146
147 static void rna_ShapeKey_slider_max_set(PointerRNA *ptr, float value)
148 {
149         KeyBlock *data = (KeyBlock *)ptr->data;
150         float min, max, softmin, softmax;
151         
152         rna_ShapeKey_slider_max_range(ptr, &min, &max, &softmin, &softmax);
153         CLAMP(value, min, max);
154         data->slidermax = value;
155 }
156
157 #undef SHAPEKEY_SLIDER_TOL
158
159 PointerRNA rna_object_shapekey_index_get(ID *id, int value)
160 {
161         Key *key = rna_ShapeKey_find_key(id);
162         KeyBlock *kb = NULL;
163         PointerRNA ptr;
164
165         if (key && value < key->totkey)
166                 kb = BLI_findlink(&key->block, value);
167         
168         RNA_pointer_create(id, &RNA_ShapeKey, kb, &ptr);
169
170         return ptr;
171 }
172
173 int rna_object_shapekey_index_set(ID *id, PointerRNA value, int current)
174 {
175         Key *key = rna_ShapeKey_find_key(id);
176
177         if (key) {
178                 int a = BLI_findindex(&key->block, value.data);
179                 if (a != -1) return a;
180         }
181         
182         return current;
183 }
184
185 static PointerRNA rna_ShapeKey_relative_key_get(PointerRNA *ptr)
186 {
187         KeyBlock *kb = (KeyBlock *)ptr->data;
188
189         return rna_object_shapekey_index_get(ptr->id.data, kb->relative);
190 }
191
192 static void rna_ShapeKey_relative_key_set(PointerRNA *ptr, PointerRNA value)
193 {
194         KeyBlock *kb = (KeyBlock *)ptr->data;
195
196         kb->relative = rna_object_shapekey_index_set(ptr->id.data, value, kb->relative);
197 }
198
199 static void rna_ShapeKeyPoint_co_get(PointerRNA *ptr, float *values)
200 {
201         float *vec = (float *)ptr->data;
202
203         values[0] = vec[0];
204         values[1] = vec[1];
205         values[2] = vec[2];
206 }
207
208 static void rna_ShapeKeyPoint_co_set(PointerRNA *ptr, const float *values)
209 {
210         float *vec = (float *)ptr->data;
211
212         vec[0] = values[0];
213         vec[1] = values[1];
214         vec[2] = values[2];
215 }
216
217 static float rna_ShapeKeyCurvePoint_tilt_get(PointerRNA *ptr)
218 {
219         float *vec = (float *)ptr->data;
220         return vec[3];
221 }
222
223 static void rna_ShapeKeyCurvePoint_tilt_set(PointerRNA *ptr, float value)
224 {
225         float *vec = (float *)ptr->data;
226         vec[3] = value;
227 }
228
229 static void rna_ShapeKeyBezierPoint_co_get(PointerRNA *ptr, float *values)
230 {
231         float *vec = (float *)ptr->data;
232
233         values[0] = vec[0 + 3];
234         values[1] = vec[1 + 3];
235         values[2] = vec[2 + 3];
236 }
237
238 static void rna_ShapeKeyBezierPoint_co_set(PointerRNA *ptr, const float *values)
239 {
240         float *vec = (float *)ptr->data;
241
242         vec[0 + 3] = values[0];
243         vec[1 + 3] = values[1];
244         vec[2 + 3] = values[2];
245 }
246
247 static void rna_ShapeKeyBezierPoint_handle_1_co_get(PointerRNA *ptr, float *values)
248 {
249         float *vec = (float *)ptr->data;
250
251         values[0] = vec[0];
252         values[1] = vec[1];
253         values[2] = vec[2];
254 }
255
256 static void rna_ShapeKeyBezierPoint_handle_1_co_set(PointerRNA *ptr, const float *values)
257 {
258         float *vec = (float *)ptr->data;
259
260         vec[0] = values[0];
261         vec[1] = values[1];
262         vec[2] = values[2];
263 }
264
265 static void rna_ShapeKeyBezierPoint_handle_2_co_get(PointerRNA *ptr, float *values)
266 {
267         float *vec = (float *)ptr->data;
268
269         values[0] = vec[6 + 0];
270         values[1] = vec[6 + 1];
271         values[2] = vec[6 + 2];
272 }
273
274 static void rna_ShapeKeyBezierPoint_handle_2_co_set(PointerRNA *ptr, const float *values)
275 {
276         float *vec = (float *)ptr->data;
277
278         vec[6 + 0] = values[0];
279         vec[6 + 1] = values[1];
280         vec[6 + 2] = values[2];
281 }
282
283 #if 0
284 static float rna_ShapeKeyBezierPoint_tilt_get(PointerRNA *ptr)
285 {
286         float *vec = (float *)ptr->data;
287         return vec[10];
288 }
289
290 static void rna_ShapeKeyBezierPoint_tilt_set(PointerRNA *ptr, float value)
291 {
292         float *vec = (float *)ptr->data;
293         vec[10] = value;
294 }
295 #endif
296
297 static void rna_ShapeKey_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
298 {
299         Key *key = rna_ShapeKey_find_key(ptr->id.data);
300         KeyBlock *kb = (KeyBlock *)ptr->data;
301         Curve *cu;
302         Nurb *nu;
303         int tot = kb->totelem, size = key->elemsize;
304         
305         if (GS(key->from->name) == ID_CU) {
306                 cu = (Curve *)key->from;
307                 nu = cu->nurb.first;
308                 
309                 if (nu->bezt) {
310                         tot /= 3;
311                         size *= 3;
312                 }
313         }
314         
315         rna_iterator_array_begin(iter, (void *)kb->data, size, tot, 0, NULL);
316 }
317
318 static int rna_ShapeKey_data_length(PointerRNA *ptr)
319 {
320         Key *key = rna_ShapeKey_find_key(ptr->id.data);
321         KeyBlock *kb = (KeyBlock *)ptr->data;
322         Curve *cu;
323         Nurb *nu;
324         int tot = kb->totelem;
325         
326         if (GS(key->from->name) == ID_CU) {
327                 cu = (Curve *)key->from;
328                 nu = cu->nurb.first;
329                 
330                 if (nu->bezt)
331                         tot /= 3;
332         }
333         
334         return tot;
335 }
336
337 static PointerRNA rna_ShapeKey_data_get(CollectionPropertyIterator *iter)
338 {
339         Key *key = rna_ShapeKey_find_key(iter->parent.id.data);
340         StructRNA *type;
341         Curve *cu;
342         Nurb *nu;
343         
344         if (GS(key->from->name) == ID_CU) {
345                 cu = (Curve *)key->from;
346                 nu = cu->nurb.first;
347                 
348                 if (nu->bezt)
349                         type = &RNA_ShapeKeyBezierPoint;
350                 else
351                         type = &RNA_ShapeKeyCurvePoint;
352         }
353         else
354                 type = &RNA_ShapeKeyPoint;
355         
356         return rna_pointer_inherit_refine(&iter->parent, type, rna_iterator_array_get(iter));
357 }
358
359 static char *rna_ShapeKey_path(PointerRNA *ptr)
360 {
361         KeyBlock *kb = (KeyBlock *)ptr->data;
362         ID *id = ptr->id.data;
363         char name_esc[sizeof(kb->name) * 2];
364
365         BLI_strescape(name_esc, kb->name, sizeof(name_esc));
366
367         if ((id) && (GS(id->name) != ID_KE))
368                 return BLI_sprintfN("shape_keys.key_blocks[\"%s\"]", name_esc);
369         else
370                 return BLI_sprintfN("key_blocks[\"%s\"]", name_esc);
371 }
372
373 static void rna_Key_update_data(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
374 {
375         Key *key = ptr->id.data;
376         Object *ob;
377
378         for (ob = bmain->object.first; ob; ob = ob->id.next) {
379                 if (BKE_key_from_object(ob) == key) {
380                         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
381                         WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
382                 }
383         }
384 }
385
386 static KeyBlock *rna_ShapeKeyData_find_keyblock(Key *key, float *point)
387 {
388         KeyBlock *kb;
389         
390         /* sanity checks */
391         if (ELEM(NULL, key, point))
392                 return NULL;
393         
394         /* we'll need to manually search through the keyblocks and check
395          * if the point is somewhere in the middle of each block's data
396          */
397         for (kb = key->block.first; kb; kb = kb->next) {
398                 if (kb->data) {
399                         float *start = (float *)kb->data;
400                         float *end;
401                         
402                         /* easy cases first */
403                         if ((start == NULL) || (start > point)) {
404                                 /* there's no chance point is in array */
405                                 continue;
406                         }
407                         else if (start == point) {
408                                 /* exact match - point is first in array */
409                                 return kb;
410                         }
411                         
412                         /* determine where end of array is
413                          *      - elemsize is in bytes, so use (char *) cast to get array in terms of bytes
414                          */
415                         end = (float *)((char *)start + (key->elemsize * kb->totelem));
416                         
417                         /* if point's address is less than the end, then it is somewhere between start and end, so in array */
418                         if (end > point) {
419                                 /* we've found the owner of the point data */
420                                 return kb;
421                         }
422                 }
423         }
424         
425         return NULL;
426 }
427
428 static int rna_ShapeKeyPoint_get_index(Key *key, KeyBlock *kb, float *point)
429 {
430         /* if we frame the data array and point pointers as (char *), then the difference between
431          * them will be in bytes. Thus, dividing through by key->elemsize (number of bytes per point)
432          * gives us the offset of point from start of array.
433          */
434         char *start = (char *)kb->data;
435         char *pt = (char *)point;
436         
437         return (int)(pt - start) / key->elemsize;
438 }
439
440 static int rna_ShapeKeyBezierPoint_get_index(KeyBlock *kb, float *point)
441 {
442         float *start = (float *)kb->data;
443         
444         /* Unlike with rna_ShapeKeyPoint_get_index(), we cannot use key->elemsize here
445          * since the default value for curves (16) is actually designed for BPoints
446          * (i.e. NURBS Surfaces). The magic number "12" here was found by empirical
447          * testing on a 64-bit system, and is similar to what's used for meshes and 
448          * lattices. For more details, see T38013
449          */
450         return (int)(point - start) / 12;
451 }
452
453 static char *rna_ShapeKeyPoint_path(PointerRNA *ptr)
454 {
455         ID *id = (ID *)ptr->id.data;
456         Key *key = rna_ShapeKey_find_key(ptr->id.data);
457         KeyBlock *kb;
458         float *point = (float *)ptr->data;
459         
460         /* if we can get a key block, we can construct a path */
461         kb = rna_ShapeKeyData_find_keyblock(key, point);
462         
463         if (kb) {
464                 char name_esc_kb[sizeof(kb->name) * 2];
465                 int index;
466                 
467                 if (ptr->type == &RNA_ShapeKeyBezierPoint)
468                         index = rna_ShapeKeyBezierPoint_get_index(kb, point);
469                 else
470                         index = rna_ShapeKeyPoint_get_index(key, kb, point);
471
472                 BLI_strescape(name_esc_kb, kb->name, sizeof(name_esc_kb));
473                 
474                 if (GS(id->name) == ID_KE)
475                         return BLI_sprintfN("key_blocks[\"%s\"].data[%d]", name_esc_kb, index);
476                 else
477                         return BLI_sprintfN("shape_keys.key_blocks[\"%s\"].data[%d]", name_esc_kb, index);
478         }
479         else
480                 return NULL;  /* XXX: there's really no way to resolve this... */
481 }
482
483 #else
484
485 EnumPropertyItem keyblock_type_items[] = {
486         {KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
487         {KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
488         {KEY_CATMULL_ROM, "KEY_CATMULL_ROM", 0, "Catmull-Rom", ""},
489         {KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
490         {0, NULL, 0, NULL, NULL}
491 };
492
493 static void rna_def_keydata(BlenderRNA *brna)
494 {
495         StructRNA *srna;
496         PropertyRNA *prop;
497
498         srna = RNA_def_struct(brna, "ShapeKeyPoint", NULL);
499         RNA_def_struct_ui_text(srna, "Shape Key Point", "Point in a shape key");
500         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
501
502         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
503         RNA_def_property_array(prop, 3);
504         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
505         RNA_def_property_ui_text(prop, "Location", "");
506         RNA_def_property_update(prop, 0, "rna_Key_update_data");
507
508         srna = RNA_def_struct(brna, "ShapeKeyCurvePoint", NULL);
509         RNA_def_struct_ui_text(srna, "Shape Key Curve Point", "Point in a shape key for curves");
510         /* there's nothing type specific here, so this is fine for now */
511         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
512
513         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
514         RNA_def_property_array(prop, 3);
515         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
516         RNA_def_property_ui_text(prop, "Location", "");
517         RNA_def_property_update(prop, 0, "rna_Key_update_data");
518
519         prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
520         RNA_def_property_float_funcs(prop, "rna_ShapeKeyCurvePoint_tilt_get", "rna_ShapeKeyCurvePoint_tilt_set", NULL);
521         RNA_def_property_ui_text(prop, "Tilt", "");
522         RNA_def_property_update(prop, 0, "rna_Key_update_data");
523
524         srna = RNA_def_struct(brna, "ShapeKeyBezierPoint", NULL);
525         RNA_def_struct_ui_text(srna, "Shape Key Bezier Point", "Point in a shape key for Bezier curves");
526         /* there's nothing type specific here, so this is fine for now */
527         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
528
529         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
530         RNA_def_property_array(prop, 3);
531         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_co_get", "rna_ShapeKeyBezierPoint_co_set", NULL);
532         RNA_def_property_ui_text(prop, "Location", "");
533         RNA_def_property_update(prop, 0, "rna_Key_update_data");
534
535         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
536         RNA_def_property_array(prop, 3);
537         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_1_co_get",
538                                      "rna_ShapeKeyBezierPoint_handle_1_co_set", NULL);
539         RNA_def_property_ui_text(prop, "Handle 1 Location", "");
540         RNA_def_property_update(prop, 0, "rna_Key_update_data");
541
542         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
543         RNA_def_property_array(prop, 3);
544         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_2_co_get",
545                                      "rna_ShapeKeyBezierPoint_handle_2_co_set", NULL);
546         RNA_def_property_ui_text(prop, "Handle 2 Location", "");
547         RNA_def_property_update(prop, 0, "rna_Key_update_data");
548
549         /* appears to be unused currently */
550 #if 0
551         prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
552         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_tilt_get", "rna_ShapeKeyBezierPoint_tilt_set", NULL);
553         RNA_def_property_ui_text(prop, "Tilt", "");
554         RNA_def_property_update(prop, 0, "rna_Key_update_data");
555 #endif
556 }
557
558 static void rna_def_keyblock(BlenderRNA *brna)
559 {
560         StructRNA *srna;
561         PropertyRNA *prop;
562
563         srna = RNA_def_struct(brna, "ShapeKey", NULL);
564         RNA_def_struct_ui_text(srna, "Shape Key", "Shape key in a shape keys datablock");
565         RNA_def_struct_sdna(srna, "KeyBlock");
566         RNA_def_struct_path_func(srna, "rna_ShapeKey_path");
567         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
568
569         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
570         RNA_def_property_ui_text(prop, "Name", "Name of Shape Key");
571         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ShapeKey_name_set");
572         RNA_def_property_update(prop, 0, "rna_Key_update_data");
573         RNA_def_struct_name_property(srna, prop);
574
575         /* keys need to be sorted to edit this */
576         prop = RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
577         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
578         RNA_def_property_float_sdna(prop, NULL, "pos");
579         RNA_def_property_float_funcs(prop, "rna_ShapeKey_frame_get", NULL, NULL);
580         RNA_def_property_ui_text(prop, "Frame", "Frame for absolute keys");
581         RNA_def_property_update(prop, 0, "rna_Key_update_data");
582         
583         /* for now, this is editable directly, as users can set this even if they're not animating them
584          * (to test results) */
585         prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_FACTOR);
586         RNA_def_property_float_sdna(prop, NULL, "curval");
587         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_value_set", "rna_ShapeKey_value_range");
588         RNA_def_property_ui_range(prop, -10.0f, 10.0f, 10, 3);
589         RNA_def_property_ui_text(prop, "Value", "Value of shape key at the current frame");
590         RNA_def_property_update(prop, 0, "rna_Key_update_data");
591
592         prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
593         RNA_def_property_enum_sdna(prop, NULL, "type");
594         RNA_def_property_enum_items(prop, keyblock_type_items);
595         RNA_def_property_ui_text(prop, "Interpolation", "Interpolation type for absolute shape keys");
596         RNA_def_property_update(prop, 0, "rna_Key_update_data");
597
598         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
599         RNA_def_property_string_sdna(prop, NULL, "vgroup");
600         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex weight group, to blend with basis shape");
601         RNA_def_property_update(prop, 0, "rna_Key_update_data");
602
603         prop = RNA_def_property(srna, "relative_key", PROP_POINTER, PROP_NONE);
604         RNA_def_property_struct_type(prop, "ShapeKey");
605         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
606         RNA_def_property_pointer_funcs(prop, "rna_ShapeKey_relative_key_get",
607                                        "rna_ShapeKey_relative_key_set", NULL, NULL);
608         RNA_def_property_ui_text(prop, "Relative Key", "Shape used as a relative key");
609         RNA_def_property_update(prop, 0, "rna_Key_update_data");
610
611         prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
612         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYBLOCK_MUTE);
613         RNA_def_property_ui_text(prop, "Mute", "Mute this shape key");
614         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
615         RNA_def_property_update(prop, 0, "rna_Key_update_data");
616
617         prop = RNA_def_property(srna, "slider_min", PROP_FLOAT, PROP_NONE);
618         RNA_def_property_float_sdna(prop, NULL, "slidermin");
619         RNA_def_property_range(prop, -10.0f, 10.0f);
620         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_slider_min_set", "rna_ShapeKey_slider_min_range");
621         RNA_def_property_ui_text(prop, "Slider Min", "Minimum for slider");
622
623         prop = RNA_def_property(srna, "slider_max", PROP_FLOAT, PROP_NONE);
624         RNA_def_property_float_sdna(prop, NULL, "slidermax");
625         RNA_def_property_range(prop, -10.0f, 10.0f);
626         RNA_def_property_float_default(prop, 1.0f);
627         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_slider_max_set", "rna_ShapeKey_slider_max_range");
628         RNA_def_property_ui_text(prop, "Slider Max", "Maximum for slider");
629
630         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
631         RNA_def_property_collection_sdna(prop, NULL, "data", "totelem");
632         RNA_def_property_struct_type(prop, "UnknownType");
633         RNA_def_property_ui_text(prop, "Data", "");
634         RNA_def_property_collection_funcs(prop, "rna_ShapeKey_data_begin", NULL, NULL, "rna_ShapeKey_data_get",
635                                           "rna_ShapeKey_data_length", NULL, NULL, NULL);
636 }
637
638 static void rna_def_key(BlenderRNA *brna)
639 {
640         StructRNA *srna;
641         PropertyRNA *prop;
642
643         srna = RNA_def_struct(brna, "Key", "ID");
644         RNA_def_struct_ui_text(srna, "Key", "Shape keys datablock containing different shapes of geometric datablocks");
645         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
646
647         prop = RNA_def_property(srna, "reference_key", PROP_POINTER, PROP_NONE);
648         RNA_def_property_flag(prop, PROP_NEVER_NULL);
649         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
650         RNA_def_property_pointer_sdna(prop, NULL, "refkey");
651         RNA_def_property_ui_text(prop, "Reference Key", "");
652
653         prop = RNA_def_property(srna, "key_blocks", PROP_COLLECTION, PROP_NONE);
654         RNA_def_property_collection_sdna(prop, NULL, "block", NULL);
655         RNA_def_property_struct_type(prop, "ShapeKey");
656         RNA_def_property_ui_text(prop, "Key Blocks", "Shape keys");
657
658         rna_def_animdata_common(srna);
659
660         prop = RNA_def_property(srna, "user", PROP_POINTER, PROP_NONE);
661         RNA_def_property_flag(prop, PROP_NEVER_NULL);
662         RNA_def_property_pointer_sdna(prop, NULL, "from");
663         RNA_def_property_ui_text(prop, "User", "Datablock using these shape keys");
664
665         prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
666         RNA_def_property_boolean_sdna(prop, NULL, "type", KEY_RELATIVE);
667         RNA_def_property_ui_text(prop, "Relative",
668                                  "Make shape keys relative, "
669                                  "otherwise play through shapes as a sequence using the evaluation time");
670         RNA_def_property_update(prop, 0, "rna_Key_update_data");
671
672         prop = RNA_def_property(srna, "eval_time", PROP_FLOAT, PROP_NONE);
673         RNA_def_property_float_sdna(prop, NULL, "ctime");
674         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
675         RNA_def_property_ui_text(prop, "Evaluation Time", "Evaluation time for absolute shape keys");
676         RNA_def_property_update(prop, 0, "rna_Key_update_data");
677 }
678
679 void RNA_def_key(BlenderRNA *brna)
680 {
681         rna_def_key(brna);
682         rna_def_keyblock(brna);
683         rna_def_keydata(brna);
684 }
685
686 #endif