mask editing
[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_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
97 {
98         Mask *mask = (Mask *)ptr->id.data;
99
100         rna_iterator_listbase_begin(iter, &mask->masklayers, NULL);
101 }
102
103 static int rna_Mask_layer_active_index_get(PointerRNA *ptr)
104 {
105         Mask *mask = (Mask *)ptr->id.data;
106
107         return mask->masklay_act;
108 }
109
110 static void rna_Mask_layer_active_index_set(PointerRNA *ptr, int value)
111 {
112         Mask *mask = (Mask *)ptr->id.data;
113
114         mask->masklay_act = value;
115 }
116
117 static void rna_Mask_layer_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->masklay_tot - 1;
123         *max = MAX2(0, *max);
124
125         *softmin = *min;
126         *softmax = *max;
127 }
128
129 static char *rna_MaskLayer_path(PointerRNA *ptr)
130 {
131         return BLI_sprintfN("layers[\"%s\"]", ((MaskLayer *)ptr->data)->name);
132 }
133
134 static PointerRNA rna_Mask_layer_active_get(PointerRNA *ptr)
135 {
136         Mask *mask = (Mask *)ptr->id.data;
137         MaskLayer *masklay = BKE_mask_layer_active(mask);
138
139         return rna_pointer_inherit_refine(ptr, &RNA_MaskLayer, masklay);
140 }
141
142 static void rna_Mask_layer_active_set(PointerRNA *ptr, PointerRNA value)
143 {
144         Mask *mask = (Mask *)ptr->id.data;
145         MaskLayer *masklay = (MaskLayer *)value.data;
146
147         BKE_mask_layer_active_set(mask, masklay);
148 }
149
150 static void rna_MaskLayer_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
151 {
152         MaskLayer *masklay = (MaskLayer *)ptr->data;
153
154         rna_iterator_listbase_begin(iter, &masklay->splines, NULL);
155 }
156
157 void rna_MaskLayer_name_set(PointerRNA *ptr, const char *value)
158 {
159         Mask *mask = (Mask *)ptr->id.data;
160         MaskLayer *masklay = (MaskLayer *)ptr->data;
161
162         BLI_strncpy(masklay->name, value, sizeof(masklay->name));
163
164         BKE_mask_layer_unique_name(mask, masklay);
165 }
166
167 static PointerRNA rna_MaskLayer_active_spline_get(PointerRNA *ptr)
168 {
169         MaskLayer *masklay = (MaskLayer *)ptr->data;
170
171         return rna_pointer_inherit_refine(ptr, &RNA_MaskSpline, masklay->act_spline);
172 }
173
174 static void rna_MaskLayer_active_spline_set(PointerRNA *ptr, PointerRNA value)
175 {
176         MaskLayer *masklay = (MaskLayer *)ptr->data;
177         MaskSpline *spline = (MaskSpline *)value.data;
178         int index = BLI_findindex(&masklay->splines, spline);
179
180         if (index >= 0)
181                 masklay->act_spline = spline;
182         else
183                 masklay->act_spline = NULL;
184 }
185
186 static PointerRNA rna_MaskLayer_active_spline_point_get(PointerRNA *ptr)
187 {
188         MaskLayer *masklay = (MaskLayer *)ptr->data;
189
190         return rna_pointer_inherit_refine(ptr, &RNA_MaskSplinePoint, masklay->act_point);
191 }
192
193 static void rna_MaskLayer_active_spline_point_set(PointerRNA *ptr, PointerRNA value)
194 {
195         MaskLayer *masklay = (MaskLayer *)ptr->data;
196         MaskSpline *spline;
197         MaskSplinePoint *point = (MaskSplinePoint *)value.data;
198
199         masklay->act_point = NULL;
200
201         for (spline = masklay->splines.first; spline; spline = spline->next) {
202                 if (point >= spline->points && point < spline->points + spline->tot_point) {
203                         masklay->act_point = point;
204
205                         break;
206                 }
207         }
208 }
209
210 static void rna_MaskSplinePoint_handle1_get(PointerRNA *ptr, float *values)
211 {
212         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
213         BezTriple *bezt = &point->bezt;
214
215         values[0] = bezt->vec[0][0];
216         values[1] = bezt->vec[0][1];
217         values[2] = bezt->vec[0][2];
218 }
219
220 static void rna_MaskSplinePoint_handle1_set(PointerRNA *ptr, const float *values)
221 {
222         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
223         BezTriple *bezt = &point->bezt;
224
225         bezt->vec[0][0] = values[0];
226         bezt->vec[0][1] = values[1];
227         bezt->vec[0][2] = values[2];
228 }
229
230 static void rna_MaskSplinePoint_handle2_get(PointerRNA *ptr, float *values)
231 {
232         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
233         BezTriple *bezt = &point->bezt;
234
235         values[0] = bezt->vec[2][0];
236         values[1] = bezt->vec[2][1];
237         values[2] = bezt->vec[2][2];
238 }
239
240 static void rna_MaskSplinePoint_handle2_set(PointerRNA *ptr, const float *values)
241 {
242         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
243         BezTriple *bezt = &point->bezt;
244
245         bezt->vec[2][0] = values[0];
246         bezt->vec[2][1] = values[1];
247         bezt->vec[2][2] = values[2];
248 }
249
250 static void rna_MaskSplinePoint_ctrlpoint_get(PointerRNA *ptr, float *values)
251 {
252         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
253         BezTriple *bezt = &point->bezt;
254
255         values[0] = bezt->vec[1][0];
256         values[1] = bezt->vec[1][1];
257         values[2] = bezt->vec[1][2];
258 }
259
260 static void rna_MaskSplinePoint_ctrlpoint_set(PointerRNA *ptr, const float *values)
261 {
262         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
263         BezTriple *bezt = &point->bezt;
264
265         bezt->vec[1][0] = values[0];
266         bezt->vec[1][1] = values[1];
267         bezt->vec[1][2] = values[2];
268 }
269
270 static int rna_MaskSplinePoint_handle_type_get(PointerRNA *ptr)
271 {
272         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
273         BezTriple *bezt = &point->bezt;
274
275         return bezt->h1;
276 }
277
278 static void rna_MaskSplinePoint_handle_type_set(PointerRNA *ptr, int value)
279 {
280         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
281         BezTriple *bezt = &point->bezt;
282
283         bezt->h1 = bezt->h2 = value;
284 }
285
286 /* ** API **  */
287
288 static MaskLayer *rna_Mask_layer_new(Mask *mask, const char *name)
289 {
290         MaskLayer *masklay = BKE_mask_layer_new(mask, name);
291
292         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
293
294         return masklay;
295 }
296
297 void rna_Mask_layer_remove(Mask *mask, MaskLayer *masklay)
298 {
299         BKE_mask_layer_remove(mask, masklay);
300
301         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
302 }
303
304 static void rna_MaskLayer_spline_add(ID *id, MaskLayer *masklay, int number)
305 {
306         Mask *mask = (Mask*) id;
307         int i;
308
309         for (i = 0; i < number; i++)
310                 BKE_mask_spline_add(masklay);
311
312         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
313 }
314
315 #else
316
317 static void rna_def_maskParent(BlenderRNA *brna)
318 {
319         StructRNA *srna;
320         PropertyRNA *prop;
321
322         static EnumPropertyItem mask_id_type_items[] = {
323                 {ID_MC, "MOVIECLIP", ICON_SEQUENCE, "Movie Clip", ""},
324                 {0, NULL, 0, NULL, NULL}};
325
326         srna = RNA_def_struct(brna, "MaskParent", NULL);
327         RNA_def_struct_ui_text(srna, "Mask Parent", "Parenting settings for masking element");
328
329         /* use_parent */
330         prop = RNA_def_property(srna, "use_parent", PROP_BOOLEAN, PROP_NONE);
331         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
332         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_PARENT_ACTIVE);
333         RNA_def_property_ui_text(prop, "Use Parent", "Use parenting for this layer");
334         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
335
336         /* Target Properties - ID-block to Drive */
337         prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
338         RNA_def_property_struct_type(prop, "ID");
339         RNA_def_property_flag(prop, PROP_EDITABLE);
340         // RNA_def_property_editable_func(prop, "rna_maskSpline_id_editable");
341         /* note: custom set function is ONLY to avoid rna setting a user for this. */
342         RNA_def_property_pointer_funcs(prop, NULL, "rna_MaskParent_id_set", "rna_MaskParent_id_typef", NULL);
343         RNA_def_property_ui_text(prop, "ID", "ID-block to which masking element would be parented to or to it's property");
344         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
345
346         prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
347         RNA_def_property_enum_sdna(prop, NULL, "id_type");
348         RNA_def_property_enum_items(prop, mask_id_type_items);
349         RNA_def_property_enum_default(prop, ID_MC);
350         RNA_def_property_enum_funcs(prop, NULL, "rna_MaskParent_id_type_set", NULL);
351         //RNA_def_property_editable_func(prop, "rna_MaskParent_id_type_editable");
352         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
353         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
354
355         /* parent */
356         prop = RNA_def_property(srna, "parent", PROP_STRING, PROP_NONE);
357         RNA_def_property_ui_text(prop, "Parent", "Name of parent object in specified data block to which parenting happens");
358         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
359         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
360
361         /* sub_parent */
362         prop = RNA_def_property(srna, "sub_parent", PROP_STRING, PROP_NONE);
363         RNA_def_property_ui_text(prop, "Sub Parent", "Name of parent sub-object in specified data block to which parenting happens");
364         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
365         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
366 }
367
368 static void rna_def_maskSplinePointUW(BlenderRNA *brna)
369 {
370         StructRNA *srna;
371         PropertyRNA *prop;
372
373         srna = RNA_def_struct(brna, "MaskSplinePointUW", NULL);
374         RNA_def_struct_ui_text(srna, "Mask Spline UW Point", "Single point in spline segment defining feather");
375
376         /* u */
377         prop = RNA_def_property(srna, "u", PROP_FLOAT, PROP_NONE);
378         RNA_def_property_float_sdna(prop, NULL, "u");
379         RNA_def_property_range(prop, 0.0, 1.0);
380         RNA_def_property_ui_text(prop, "U", "U coordinate of point along spline segment");
381         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
382
383         /* weight */
384         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
385         RNA_def_property_float_sdna(prop, NULL, "w");
386         RNA_def_property_range(prop, 0.0, 1.0);
387         RNA_def_property_ui_text(prop, "Weight", "Weight of feather point");
388         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
389
390         /* select */
391         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
392         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
393         RNA_def_property_ui_text(prop, "Select", "Selection status");
394         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
395 }
396
397 static void rna_def_maskSplinePoint(BlenderRNA *brna)
398 {
399         StructRNA *srna;
400         PropertyRNA *prop;
401
402         static EnumPropertyItem handle_type_items[] = {
403                 {HD_AUTO, "AUTO", 0, "Auto", ""},
404                 {HD_VECT, "VECTOR", 0, "Vector", ""},
405                 {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
406                 {0, NULL, 0, NULL, NULL}};
407
408         rna_def_maskSplinePointUW(brna);
409
410         srna = RNA_def_struct(brna, "MaskSplinePoint", NULL);
411         RNA_def_struct_ui_text(srna, "Mask Spline Point", "Single point in spline used for defining mask");
412
413         /* Vector values */
414         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
415         RNA_def_property_array(prop, 3);
416         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle1_get", "rna_MaskSplinePoint_handle1_set", NULL);
417         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
418         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
419
420         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
421         RNA_def_property_array(prop, 3);
422         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_ctrlpoint_get", "rna_MaskSplinePoint_ctrlpoint_set", NULL);
423         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
424         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
425
426         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
427         RNA_def_property_array(prop, 3);
428         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle2_get", "rna_MaskSplinePoint_handle2_set", NULL);
429         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
430         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
431
432         /* handle_type */
433         prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
434         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_type_get", "rna_MaskSplinePoint_handle_type_set", NULL);
435         RNA_def_property_enum_items(prop, handle_type_items);
436         RNA_def_property_ui_text(prop, "Handle Type", "Handle type");
437         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
438
439         /* select */
440         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
441         RNA_def_property_boolean_sdna(prop, NULL, "bezt.f1", SELECT);
442         RNA_def_property_ui_text(prop, "Select", "Selection status");
443         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
444
445         /* parent */
446         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
447         RNA_def_property_struct_type(prop, "MaskParent");
448
449         /* feather points */
450         prop = RNA_def_property(srna, "feather_points", PROP_COLLECTION, PROP_NONE);
451         RNA_def_property_struct_type(prop, "MaskSplinePointUW");
452         RNA_def_property_collection_sdna(prop, NULL, "uw", "tot_uw");
453         RNA_def_property_ui_text(prop, "Feather Points", "Points defining feather");
454 }
455
456 static void rna_def_mask_splines(BlenderRNA *brna)
457 {
458         StructRNA *srna;
459         FunctionRNA *func;
460         PropertyRNA *prop;
461
462         srna = RNA_def_struct(brna, "MaskSplines", NULL);
463         RNA_def_struct_sdna(srna, "MaskLayer");
464         RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
465
466         func = RNA_def_function(srna, "add", "rna_MaskLayer_spline_add");
467         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
468         RNA_def_function_ui_description(func, "Add a number of splines to mask layer");
469         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the layer", 0, INT_MAX);
470
471         /* active spline */
472         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
473         RNA_def_property_struct_type(prop, "MaskSpline");
474         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_get", "rna_MaskLayer_active_spline_set", NULL, NULL);
475         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
476         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
477
478         /* active point */
479         prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
480         RNA_def_property_struct_type(prop, "MaskSplinePoint");
481         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_point_get", "rna_MaskLayer_active_spline_point_set", NULL, NULL);
482         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
483         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
484 }
485
486 static void rna_def_maskSpline(BlenderRNA *brna)
487 {
488         static EnumPropertyItem spline_interpolation_items[] = {
489                 {MASK_SPLINE_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
490                 {MASK_SPLINE_INTERP_EASE, "EASE", 0, "Ease", ""},
491                 {0, NULL, 0, NULL, NULL}
492         };
493
494         StructRNA *srna;
495         PropertyRNA *prop;
496
497         rna_def_maskSplinePoint(brna);
498
499         srna = RNA_def_struct(brna, "MaskSpline", NULL);
500         RNA_def_struct_ui_text(srna, "Mask spline", "Single spline used for defining mask shape");
501
502         /* weight interpolation */
503         prop = RNA_def_property(srna, "weight_interpolation", PROP_ENUM, PROP_NONE);
504         RNA_def_property_enum_sdna(prop, NULL, "weight_interp");
505         RNA_def_property_enum_items(prop, spline_interpolation_items);
506         RNA_def_property_ui_text(prop, "Weight Interpolation", "The type of weight interpolation for spline");
507         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
508
509         /* cyclic */
510         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
511         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
512         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_CYCLIC);
513         RNA_def_property_ui_text(prop, "Cyclic", "Make this spline a closed loop");
514         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
515 }
516
517 static void rna_def_mask_layer(BlenderRNA *brna)
518 {
519         static EnumPropertyItem masklay_blend_mode_items[] = {
520                 {MASK_BLEND_ADD, "ADD", 0, "Add", ""},
521                 {MASK_BLEND_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
522                 {0, NULL, 0, NULL, NULL}
523         };
524
525         StructRNA *srna;
526         PropertyRNA *prop;
527
528         rna_def_maskSpline(brna);
529         rna_def_mask_splines(brna);
530
531         srna = RNA_def_struct(brna, "MaskLayer", NULL);
532         RNA_def_struct_ui_text(srna, "Mask Layer", "Single layer used for masking pixels");
533         RNA_def_struct_path_func(srna, "rna_MaskLayer_path");
534
535         /* name */
536         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
537         RNA_def_property_ui_text(prop, "Name", "Unique name of layer");
538         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskLayer_name_set");
539         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
540         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
541         RNA_def_struct_name_property(srna, prop);
542
543         /* splines */
544         prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
545         RNA_def_property_collection_funcs(prop, "rna_MaskLayer_splines_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
546         RNA_def_property_struct_type(prop, "MaskSpline");
547         RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this layer");
548         RNA_def_property_srna(prop, "MaskSplines");
549
550         /* restrict */
551         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
552         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_VIEW);
553         RNA_def_property_ui_text(prop, "Restrict View", "Restrict visibility in the viewport");
554         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
555         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
556
557         prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
558         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_SELECT);
559         RNA_def_property_ui_text(prop, "Restrict Select", "Restrict selection in the viewport");
560         RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 1);
561         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
562
563         prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
564         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_RENDER);
565         RNA_def_property_ui_text(prop, "Restrict Render", "Restrict renderability");
566         RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
567         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
568
569         /* render settings */
570         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
571         RNA_def_property_float_sdna(prop, NULL, "alpha");
572         RNA_def_property_range(prop, 0.0, 1.0f);
573         RNA_def_property_ui_text(prop, "Opacity", "Render Opacity");
574         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
575
576         /* weight interpolation */
577         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
578         RNA_def_property_enum_sdna(prop, NULL, "blend");
579         RNA_def_property_enum_items(prop, masklay_blend_mode_items);
580         RNA_def_property_ui_text(prop, "Blend", "Method of blending mask layers");
581         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
582         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
583
584         prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
585         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MASK_BLENDFLAG_INVERT);
586         RNA_def_property_ui_text(prop, "Restrict View", "Invert the mask black/white");
587         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
588
589 }
590
591 static void rna_def_masklayers(BlenderRNA *brna, PropertyRNA *cprop)
592 {
593         StructRNA *srna;
594         PropertyRNA *prop;
595
596         FunctionRNA *func;
597         PropertyRNA *parm;
598
599         RNA_def_property_srna(cprop, "MaskLayers");
600         srna = RNA_def_struct(brna, "MaskLayers", NULL);
601         RNA_def_struct_sdna(srna, "Mask");
602         RNA_def_struct_ui_text(srna, "Mask Layers", "Collection of layers used by mask");
603
604         func = RNA_def_function(srna, "new", "rna_Mask_layer_new");
605         RNA_def_function_ui_description(func, "Add layer to this mask");
606         RNA_def_string(func, "name", "", 0, "Name", "Name of new layer");
607         parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "New mask layer");
608         RNA_def_function_return(func, parm);
609
610         func = RNA_def_function(srna, "remove", "rna_Mask_layer_remove");
611         RNA_def_function_ui_description(func, "Remove layer from this mask");
612         RNA_def_pointer(func, "layer", "MaskLayer", "", "Shape to be removed");
613
614         /* active layer */
615         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
616         RNA_def_property_struct_type(prop, "MaskLayer");
617         RNA_def_property_pointer_funcs(prop, "rna_Mask_layer_active_get", "rna_Mask_layer_active_set", NULL, NULL);
618         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
619         RNA_def_property_ui_text(prop, "Active Shape", "Active layer in this mask");
620 }
621
622 static void rna_def_mask(BlenderRNA *brna)
623 {
624         StructRNA *srna;
625         PropertyRNA *prop;
626
627         rna_def_mask_layer(brna);
628
629         srna = RNA_def_struct(brna, "Mask", "ID");
630         RNA_def_struct_ui_text(srna, "Mask", "Mask datablock defining mask for compositing");
631         RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
632
633         /* mask layers */
634         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
635         RNA_def_property_collection_funcs(prop, "rna_Mask_layers_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
636         RNA_def_property_struct_type(prop, "MaskLayer");
637         RNA_def_property_ui_text(prop, "Layers", "Collection of layers which defines this mask");
638         rna_def_masklayers(brna, prop);
639
640         /* active masklay index */
641         prop = RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
642         RNA_def_property_int_sdna(prop, NULL, "masklay_act");
643         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
644         RNA_def_property_int_funcs(prop, "rna_Mask_layer_active_index_get", "rna_Mask_layer_active_index_set", "rna_Mask_layer_active_index_range");
645         RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active layer in list of all mask's layers");
646
647         /* pointers */
648         rna_def_animdata_common(srna);
649 }
650
651 void RNA_def_mask(BlenderRNA *brna)
652 {
653         rna_def_maskParent(brna);
654         rna_def_mask(brna);
655 }
656
657 #endif