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