fix for incorrect range function args.
[blender.git] / source / blender / makesrna / intern / rna_mask.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,
19  *                 Sergey Sharybin
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/makesrna/intern/rna_mask.c
25  *  \ingroup RNA
26  */
27
28
29 #include <stdlib.h>
30 #include <limits.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "BKE_movieclip.h"
35 #include "BKE_tracking.h"
36
37 #include "RNA_define.h"
38
39 #include "rna_internal.h"
40
41 #include "DNA_mask_types.h"
42 #include "DNA_object_types.h"   /* SELECT */
43 #include "DNA_scene_types.h"
44
45 #include "WM_types.h"
46
47 #include "IMB_imbuf_types.h"
48 #include "IMB_imbuf.h"
49
50 #ifdef RNA_RUNTIME
51
52 #include "DNA_mask_types.h"
53
54 #include "BKE_depsgraph.h"
55 #include "BKE_mask.h"
56
57 #include "RNA_access.h"
58
59 #include "WM_api.h"
60
61 static void rna_Mask_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
62 {
63         Mask *mask = ptr->id.data;
64
65         WM_main_add_notifier(NC_MASK|ND_DATA, mask);
66         DAG_id_tag_update( &mask->id, 0);
67 }
68
69 /* note: this function exists only to avoid id refcounting */
70 static void rna_MaskParent_id_set(PointerRNA *ptr, PointerRNA value)
71 {
72         MaskParent *mpar = (MaskParent*) ptr->data;
73
74         mpar->id = value.data;
75 }
76
77 static StructRNA *rna_MaskParent_id_typef(PointerRNA *ptr)
78 {
79         MaskParent *mpar = (MaskParent*) ptr->data;
80
81         return ID_code_to_RNA_type(mpar->id_type);
82 }
83
84 static void rna_MaskParent_id_type_set(PointerRNA *ptr, int value)
85 {
86         MaskParent *mpar = (MaskParent*) ptr->data;
87
88         /* change ID-type to the new type */
89         mpar->id_type = value;
90
91         /* clear the id-block if the type is invalid */
92         if ((mpar->id) && (GS(mpar->id->name) != mpar->id_type))
93                 mpar->id = NULL;
94 }
95
96 static void rna_Mask_objects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
97 {
98         Mask *mask = (Mask *)ptr->id.data;
99
100         rna_iterator_listbase_begin(iter, &mask->maskobjs, NULL);
101 }
102
103 static int rna_Mask_object_active_index_get(PointerRNA *ptr)
104 {
105         Mask *mask = (Mask *)ptr->id.data;
106
107         return mask->act_maskobj;
108 }
109
110 static void rna_Mask_object_active_index_set(PointerRNA *ptr, int value)
111 {
112         Mask *mask = (Mask *)ptr->id.data;
113
114         mask->act_maskobj = value;
115 }
116
117 static void rna_Mask_object_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
118 {
119         Mask *mask = (Mask *)ptr->id.data;
120
121         *min = 0;
122         *max = mask->tot_maskobj - 1;
123         *max = MAX2(0, *max);
124
125         *softmin = *min;
126         *softmax = *max;
127 }
128
129 static PointerRNA rna_Mask_object_active_get(PointerRNA *ptr)
130 {
131         Mask *mask = (Mask *)ptr->id.data;
132         MaskObject *maskobj = BKE_mask_object_active(mask);
133
134         return rna_pointer_inherit_refine(ptr, &RNA_MaskObject, maskobj);
135 }
136
137 static void rna_Mask_object_active_set(PointerRNA *ptr, PointerRNA value)
138 {
139         Mask *mask = (Mask *)ptr->id.data;
140         MaskObject *maskobj = (MaskObject *)value.data;
141
142         BKE_mask_object_active_set(mask, maskobj);
143 }
144
145 static void rna_MaskObject_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
146 {
147         MaskObject *maskobj = (MaskObject *)ptr->data;
148
149         rna_iterator_listbase_begin(iter, &maskobj->splines, NULL);
150 }
151
152 void rna_MaskObject_name_set(PointerRNA *ptr, const char *value)
153 {
154         Mask *mask = (Mask *)ptr->id.data;
155         MaskObject *maskobj = (MaskObject *)ptr->data;
156
157         BLI_strncpy(maskobj->name, value, sizeof(maskobj->name));
158
159         BKE_mask_object_unique_name(mask, maskobj);
160 }
161
162 static PointerRNA rna_MaskObject_active_spline_get(PointerRNA *ptr)
163 {
164         MaskObject *maskobj = (MaskObject *)ptr->data;
165
166         return rna_pointer_inherit_refine(ptr, &RNA_MaskSpline, maskobj->act_spline);
167 }
168
169 static void rna_MaskObject_active_spline_set(PointerRNA *ptr, PointerRNA value)
170 {
171         MaskObject *maskobj = (MaskObject *)ptr->data;
172         MaskSpline *spline = (MaskSpline *)value.data;
173         int index = BLI_findindex(&maskobj->splines, spline);
174
175         if (index >= 0)
176                 maskobj->act_spline = spline;
177         else
178                 maskobj->act_spline = NULL;
179 }
180
181 static PointerRNA rna_MaskObject_active_spline_point_get(PointerRNA *ptr)
182 {
183         MaskObject *maskobj = (MaskObject *)ptr->data;
184
185         return rna_pointer_inherit_refine(ptr, &RNA_MaskSplinePoint, maskobj->act_point);
186 }
187
188 static void rna_MaskObject_active_spline_point_set(PointerRNA *ptr, PointerRNA value)
189 {
190         MaskObject *maskobj = (MaskObject *)ptr->data;
191         MaskSpline *spline;
192         MaskSplinePoint *point = (MaskSplinePoint *)value.data;
193
194         maskobj->act_point = NULL;
195
196         for (spline = maskobj->splines.first; spline; spline = spline->next) {
197                 if (point >= spline->points && point < spline->points + spline->tot_point) {
198                         maskobj->act_point = point;
199
200                         break;
201                 }
202         }
203 }
204
205 static void rna_MaskSplinePoint_handle1_get(PointerRNA *ptr, float *values)
206 {
207         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
208         BezTriple *bezt = &point->bezt;
209
210         values[0] = bezt->vec[0][0];
211         values[1] = bezt->vec[0][1];
212         values[2] = bezt->vec[0][2];
213 }
214
215 static void rna_MaskSplinePoint_handle1_set(PointerRNA *ptr, const float *values)
216 {
217         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
218         BezTriple *bezt = &point->bezt;
219
220         bezt->vec[0][0] = values[0];
221         bezt->vec[0][1] = values[1];
222         bezt->vec[0][2] = values[2];
223 }
224
225 static void rna_MaskSplinePoint_handle2_get(PointerRNA *ptr, float *values)
226 {
227         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
228         BezTriple *bezt = &point->bezt;
229
230         values[0] = bezt->vec[2][0];
231         values[1] = bezt->vec[2][1];
232         values[2] = bezt->vec[2][2];
233 }
234
235 static void rna_MaskSplinePoint_handle2_set(PointerRNA *ptr, const float *values)
236 {
237         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
238         BezTriple *bezt = &point->bezt;
239
240         bezt->vec[2][0] = values[0];
241         bezt->vec[2][1] = values[1];
242         bezt->vec[2][2] = values[2];
243 }
244
245 static void rna_MaskSplinePoint_ctrlpoint_get(PointerRNA *ptr, float *values)
246 {
247         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
248         BezTriple *bezt = &point->bezt;
249
250         values[0] = bezt->vec[1][0];
251         values[1] = bezt->vec[1][1];
252         values[2] = bezt->vec[1][2];
253 }
254
255 static void rna_MaskSplinePoint_ctrlpoint_set(PointerRNA *ptr, const float *values)
256 {
257         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
258         BezTriple *bezt = &point->bezt;
259
260         bezt->vec[1][0] = values[0];
261         bezt->vec[1][1] = values[1];
262         bezt->vec[1][2] = values[2];
263 }
264
265 static int rna_MaskSplinePoint_handle_type_get(PointerRNA *ptr)
266 {
267         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
268         BezTriple *bezt = &point->bezt;
269
270         return bezt->h1;
271 }
272
273 static void rna_MaskSplinePoint_handle_type_set(PointerRNA *ptr, int value)
274 {
275         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
276         BezTriple *bezt = &point->bezt;
277
278         bezt->h1 = bezt->h2 = value;
279 }
280
281 /* ** API **  */
282
283 static MaskObject *rna_Mask_object_new(Mask *mask, const char *name)
284 {
285         MaskObject *maskobj = BKE_mask_object_new(mask, name);
286
287         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
288
289         return maskobj;
290 }
291
292 void rna_Mask_object_remove(Mask *mask, MaskObject *maskobj)
293 {
294         BKE_mask_object_remove(mask, maskobj);
295
296         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
297 }
298
299 static void rna_MaskObject_spline_add(ID *id, MaskObject *maskobj, int number)
300 {
301         Mask *mask = (Mask*) id;
302         int i;
303
304         for (i = 0; i < number; i++)
305                 BKE_mask_spline_add(maskobj);
306
307         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
308 }
309
310 #else
311
312 static void rna_def_maskParent(BlenderRNA *brna)
313 {
314         StructRNA *srna;
315         PropertyRNA *prop;
316
317         static EnumPropertyItem mask_id_type_items[] = {
318                 {ID_MC, "MOVIECLIP", ICON_SEQUENCE, "Movie Clip", ""},
319                 {0, NULL, 0, NULL, NULL}};
320
321         srna = RNA_def_struct(brna, "MaskParent", NULL);
322         RNA_def_struct_ui_text(srna, "Mask Parent", "Parenting settings for maskign element");
323
324         /* use_parent */
325         prop = RNA_def_property(srna, "use_parent", PROP_BOOLEAN, PROP_NONE);
326         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
327         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_PARENT_ACTIVE);
328         RNA_def_property_ui_text(prop, "Use Parent", "Use parenting for this object");
329         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
330
331         /* Target Properties - ID-block to Drive */
332         prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
333         RNA_def_property_struct_type(prop, "ID");
334         RNA_def_property_flag(prop, PROP_EDITABLE);
335         // RNA_def_property_editable_func(prop, "rna_maskSpline_id_editable");
336         /* note: custom set function is ONLY to avoid rna setting a user for this. */
337         RNA_def_property_pointer_funcs(prop, NULL, "rna_MaskParent_id_set", "rna_MaskParent_id_typef", NULL);
338         RNA_def_property_ui_text(prop, "ID", "ID-block to which masking element would be parented to or to it's property");
339         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
340
341         prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
342         RNA_def_property_enum_sdna(prop, NULL, "id_type");
343         RNA_def_property_enum_items(prop, mask_id_type_items);
344         RNA_def_property_enum_default(prop, ID_MC);
345         RNA_def_property_enum_funcs(prop, NULL, "rna_MaskParent_id_type_set", NULL);
346         //RNA_def_property_editable_func(prop, "rna_MaskParent_id_type_editable");
347         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
348         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
349
350         /* parent */
351         prop = RNA_def_property(srna, "parent", PROP_STRING, PROP_NONE);
352         RNA_def_property_ui_text(prop, "Parent", "Name of parent object in specified data block to which parenting happens");
353         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
354         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
355
356         /* sub_parent */
357         prop = RNA_def_property(srna, "sub_parent", PROP_STRING, PROP_NONE);
358         RNA_def_property_ui_text(prop, "Sub Parent", "Name of parent sub-object in specified data block to which parenting happens");
359         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
360         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
361 }
362
363 static void rna_def_maskSplinePointUW(BlenderRNA *brna)
364 {
365         StructRNA *srna;
366         PropertyRNA *prop;
367
368         srna = RNA_def_struct(brna, "MaskSplinePointUW", NULL);
369         RNA_def_struct_ui_text(srna, "Mask Spline UW Point", "Single point in spline segment defining feather");
370
371         /* u */
372         prop = RNA_def_property(srna, "u", PROP_FLOAT, PROP_NONE);
373         RNA_def_property_float_sdna(prop, NULL, "u");
374         RNA_def_property_range(prop, 0.0, 1.0);
375         RNA_def_property_ui_text(prop, "U", "U coordinate of point along spline segment");
376         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
377
378         /* weight */
379         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
380         RNA_def_property_float_sdna(prop, NULL, "w");
381         RNA_def_property_range(prop, 0.0, 1.0);
382         RNA_def_property_ui_text(prop, "Weight", "Weight of feather point");
383         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
384
385         /* select */
386         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
387         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
388         RNA_def_property_ui_text(prop, "Select", "Selection status");
389         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
390 }
391
392 static void rna_def_maskSplinePoint(BlenderRNA *brna)
393 {
394         StructRNA *srna;
395         PropertyRNA *prop;
396
397         static EnumPropertyItem handle_type_items[] = {
398                 {HD_AUTO, "AUTO", 0, "Auto", ""},
399                 {HD_VECT, "VECTOR", 0, "Vector", ""},
400                 {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
401                 {0, NULL, 0, NULL, NULL}};
402
403         rna_def_maskSplinePointUW(brna);
404
405         srna = RNA_def_struct(brna, "MaskSplinePoint", NULL);
406         RNA_def_struct_ui_text(srna, "Mask Spline Point", "Single point in spline used for defining mask");
407
408         /* Vector values */
409         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
410         RNA_def_property_array(prop, 3);
411         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle1_get", "rna_MaskSplinePoint_handle1_set", NULL);
412         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
413         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
414
415         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
416         RNA_def_property_array(prop, 3);
417         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_ctrlpoint_get", "rna_MaskSplinePoint_ctrlpoint_set", NULL);
418         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
419         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
420
421         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
422         RNA_def_property_array(prop, 3);
423         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle2_get", "rna_MaskSplinePoint_handle2_set", NULL);
424         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
425         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
426
427         /* handle_type */
428         prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
429         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_type_get", "rna_MaskSplinePoint_handle_type_set", NULL);
430         RNA_def_property_enum_items(prop, handle_type_items);
431         RNA_def_property_ui_text(prop, "Handle Type", "Handle type");
432         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
433
434         /* select */
435         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
436         RNA_def_property_boolean_sdna(prop, NULL, "bezt.f1", SELECT);
437         RNA_def_property_ui_text(prop, "Select", "Selection status");
438         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
439
440         /* parent */
441         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
442         RNA_def_property_struct_type(prop, "MaskParent");
443
444         /* feather points */
445         prop = RNA_def_property(srna, "feather_points", PROP_COLLECTION, PROP_NONE);
446         RNA_def_property_struct_type(prop, "MaskSplinePointUW");
447         RNA_def_property_collection_sdna(prop, NULL, "uw", "tot_uw");
448         RNA_def_property_ui_text(prop, "Feather Points", "Points defining feather");
449 }
450
451 static void rna_def_mask_splines(BlenderRNA *brna)
452 {
453         StructRNA *srna;
454         FunctionRNA *func;
455         PropertyRNA *prop;
456
457         srna = RNA_def_struct(brna, "MaskSplines", NULL);
458         RNA_def_struct_sdna(srna, "MaskObject");
459         RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
460
461         func = RNA_def_function(srna, "add", "rna_MaskObject_spline_add");
462         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
463         RNA_def_function_ui_description(func, "Add a number of splines to mask object");
464         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the object", 0, INT_MAX);
465
466         /* active spline */
467         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
468         RNA_def_property_struct_type(prop, "MaskSpline");
469         RNA_def_property_pointer_funcs(prop, "rna_MaskObject_active_spline_get", "rna_MaskObject_active_spline_set", NULL, NULL);
470         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
471         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking object");
472
473         /* active point */
474         prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
475         RNA_def_property_struct_type(prop, "MaskSplinePoint");
476         RNA_def_property_pointer_funcs(prop, "rna_MaskObject_active_spline_point_get", "rna_MaskObject_active_spline_point_set", NULL, NULL);
477         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
478         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking object");
479 }
480
481 static void rna_def_maskSpline(BlenderRNA *brna)
482 {
483         static EnumPropertyItem spline_interpolation_items[] = {
484                 {MASK_SPLINE_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
485                 {MASK_SPLINE_INTERP_EASE, "EASE", 0, "Ease", ""},
486                 {0, NULL, 0, NULL, NULL}};
487
488         StructRNA *srna;
489         PropertyRNA *prop;
490
491         rna_def_maskSplinePoint(brna);
492
493         srna = RNA_def_struct(brna, "MaskSpline", NULL);
494         RNA_def_struct_ui_text(srna, "Mask spline", "Single spline used for defining mash shape");
495
496         /* weight interpolation */
497         prop = RNA_def_property(srna, "weight_interpolation", PROP_ENUM, PROP_NONE);
498         RNA_def_property_enum_sdna(prop, NULL, "weight_interp");
499         RNA_def_property_enum_items(prop, spline_interpolation_items);
500         RNA_def_property_ui_text(prop, "Weight Interpolation", "The type of weight interpolation for spline");
501         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
502
503         /* cyclic */
504         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
505         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
506         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_CYCLIC);
507         RNA_def_property_ui_text(prop, "Cyclic", "Make this spline a closed loop");
508         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
509 }
510
511 static void rna_def_mask_object(BlenderRNA *brna)
512 {
513         StructRNA *srna;
514         PropertyRNA *prop;
515
516         rna_def_maskSpline(brna);
517         rna_def_mask_splines(brna);
518
519         srna = RNA_def_struct(brna, "MaskObject", NULL);
520         RNA_def_struct_ui_text(srna, "Mask Object", "Single object used for masking pixels");
521
522         /* name */
523         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
524         RNA_def_property_ui_text(prop, "Name", "Unique name of object");
525         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskObject_name_set");
526         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
527         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
528         RNA_def_struct_name_property(srna, prop);
529
530         /* splines */
531         prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
532         RNA_def_property_collection_funcs(prop, "rna_MaskObject_splines_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
533         RNA_def_property_struct_type(prop, "MaskSpline");
534         RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this object");
535         RNA_def_property_srna(prop, "MaskSplines");
536 }
537
538 static void rna_def_maskobjects(BlenderRNA *brna, PropertyRNA *cprop)
539 {
540         StructRNA *srna;
541         PropertyRNA *prop;
542
543         FunctionRNA *func;
544         PropertyRNA *parm;
545
546         RNA_def_property_srna(cprop, "MaskObjects");
547         srna = RNA_def_struct(brna, "MaskObjects", NULL);
548         RNA_def_struct_sdna(srna, "Mask");
549         RNA_def_struct_ui_text(srna, "Mask Objects", "Collection of objects used by mask");
550
551         func = RNA_def_function(srna, "new", "rna_Mask_object_new");
552         RNA_def_function_ui_description(func, "Add object to this mask");
553         RNA_def_string(func, "name", "", 0, "Name", "Name of new object");
554         parm = RNA_def_pointer(func, "object", "MaskObject", "", "New mask object");
555         RNA_def_function_return(func, parm);
556
557         func = RNA_def_function(srna, "remove", "rna_Mask_object_remove");
558         RNA_def_function_ui_description(func, "Remove object from this mask");
559         RNA_def_pointer(func, "object", "MaskObject", "", "Shape to be removed");
560
561         /* active object */
562         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
563         RNA_def_property_struct_type(prop, "MaskObject");
564         RNA_def_property_pointer_funcs(prop, "rna_Mask_object_active_get", "rna_Mask_object_active_set", NULL, NULL);
565         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
566         RNA_def_property_ui_text(prop, "Active Shape", "Active object in this mask");
567 }
568
569 static void rna_def_mask(BlenderRNA *brna)
570 {
571         StructRNA *srna;
572         PropertyRNA *prop;
573
574         rna_def_mask_object(brna);
575
576         srna = RNA_def_struct(brna, "Mask", "ID");
577         RNA_def_struct_ui_text(srna, "Mask", "Mask datablock defining mask for compositing");
578         RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
579
580         /* mask objects */
581         prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
582         RNA_def_property_collection_funcs(prop, "rna_Mask_objects_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
583         RNA_def_property_struct_type(prop, "MaskObject");
584         RNA_def_property_ui_text(prop, "Objects", "Collection of objects which defines this mask");
585         rna_def_maskobjects(brna, prop);
586
587         /* active maskobj index */
588         prop = RNA_def_property(srna, "active_object_index", PROP_INT, PROP_NONE);
589         RNA_def_property_int_sdna(prop, NULL, "act_maskobj");
590         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
591         RNA_def_property_int_funcs(prop, "rna_Mask_object_active_index_get", "rna_Mask_object_active_index_set", "rna_Mask_object_active_index_range");
592         RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active object in list of all mask's objects");
593 }
594
595 void RNA_def_mask(BlenderRNA *brna)
596 {
597         rna_def_maskParent(brna);
598         rna_def_mask(brna);
599 }
600
601 #endif