Mask editing: remove use_parent property and use check if paren't id is set instead
[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 static void rna_Mask_start_frame_set(PointerRNA *ptr, int value)
316 {
317         Mask *data = (Mask *)ptr->data;
318         /* MINFRAME not MINAFRAME, since some output formats can't taken negative frames */
319         CLAMP(value, MINFRAME, MAXFRAME);
320         data->sfra = value;
321
322         if (data->sfra >= data->efra) {
323                 data->efra = MIN2(data->sfra, MAXFRAME);
324         }
325 }
326
327 static void rna_Mask_end_frame_set(PointerRNA *ptr, int value)
328 {
329         Mask *data = (Mask *)ptr->data;
330         CLAMP(value, MINFRAME, MAXFRAME);
331         data->efra = value;
332
333         if (data->sfra >= data->efra) {
334                 data->sfra = MAX2(data->efra, MINFRAME);
335         }
336 }
337
338 #else
339
340 static void rna_def_maskParent(BlenderRNA *brna)
341 {
342         StructRNA *srna;
343         PropertyRNA *prop;
344
345         static EnumPropertyItem mask_id_type_items[] = {
346                 {ID_MC, "MOVIECLIP", ICON_SEQUENCE, "Movie Clip", ""},
347                 {0, NULL, 0, NULL, NULL}};
348
349         srna = RNA_def_struct(brna, "MaskParent", NULL);
350         RNA_def_struct_ui_text(srna, "Mask Parent", "Parenting settings for masking element");
351
352         /* Target Properties - ID-block to Drive */
353         prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
354         RNA_def_property_struct_type(prop, "ID");
355         RNA_def_property_flag(prop, PROP_EDITABLE);
356         // RNA_def_property_editable_func(prop, "rna_maskSpline_id_editable");
357         /* note: custom set function is ONLY to avoid rna setting a user for this. */
358         RNA_def_property_pointer_funcs(prop, NULL, "rna_MaskParent_id_set", "rna_MaskParent_id_typef", NULL);
359         RNA_def_property_ui_text(prop, "ID", "ID-block to which masking element would be parented to or to it's property");
360         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
361
362         prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
363         RNA_def_property_enum_sdna(prop, NULL, "id_type");
364         RNA_def_property_enum_items(prop, mask_id_type_items);
365         RNA_def_property_enum_default(prop, ID_MC);
366         RNA_def_property_enum_funcs(prop, NULL, "rna_MaskParent_id_type_set", NULL);
367         //RNA_def_property_editable_func(prop, "rna_MaskParent_id_type_editable");
368         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
369         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
370
371         /* parent */
372         prop = RNA_def_property(srna, "parent", PROP_STRING, PROP_NONE);
373         RNA_def_property_ui_text(prop, "Parent", "Name of parent object in specified data block to which parenting happens");
374         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
375         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
376
377         /* sub_parent */
378         prop = RNA_def_property(srna, "sub_parent", PROP_STRING, PROP_NONE);
379         RNA_def_property_ui_text(prop, "Sub Parent", "Name of parent sub-object in specified data block to which parenting happens");
380         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
381         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
382 }
383
384 static void rna_def_maskSplinePointUW(BlenderRNA *brna)
385 {
386         StructRNA *srna;
387         PropertyRNA *prop;
388
389         srna = RNA_def_struct(brna, "MaskSplinePointUW", NULL);
390         RNA_def_struct_ui_text(srna, "Mask Spline UW Point", "Single point in spline segment defining feather");
391
392         /* u */
393         prop = RNA_def_property(srna, "u", PROP_FLOAT, PROP_NONE);
394         RNA_def_property_float_sdna(prop, NULL, "u");
395         RNA_def_property_range(prop, 0.0, 1.0);
396         RNA_def_property_ui_text(prop, "U", "U coordinate of point along spline segment");
397         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
398
399         /* weight */
400         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
401         RNA_def_property_float_sdna(prop, NULL, "w");
402         RNA_def_property_range(prop, 0.0, 1.0);
403         RNA_def_property_ui_text(prop, "Weight", "Weight of feather point");
404         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
405
406         /* select */
407         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
408         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
409         RNA_def_property_ui_text(prop, "Select", "Selection status");
410         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
411 }
412
413 static void rna_def_maskSplinePoint(BlenderRNA *brna)
414 {
415         StructRNA *srna;
416         PropertyRNA *prop;
417
418         static EnumPropertyItem handle_type_items[] = {
419                 {HD_AUTO, "AUTO", 0, "Auto", ""},
420                 {HD_VECT, "VECTOR", 0, "Vector", ""},
421                 {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
422                 {0, NULL, 0, NULL, NULL}};
423
424         rna_def_maskSplinePointUW(brna);
425
426         srna = RNA_def_struct(brna, "MaskSplinePoint", NULL);
427         RNA_def_struct_ui_text(srna, "Mask Spline Point", "Single point in spline used for defining mask");
428
429         /* Vector values */
430         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
431         RNA_def_property_array(prop, 3);
432         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle1_get", "rna_MaskSplinePoint_handle1_set", NULL);
433         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
434         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
435
436         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
437         RNA_def_property_array(prop, 3);
438         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_ctrlpoint_get", "rna_MaskSplinePoint_ctrlpoint_set", NULL);
439         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
440         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
441
442         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
443         RNA_def_property_array(prop, 3);
444         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle2_get", "rna_MaskSplinePoint_handle2_set", NULL);
445         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
446         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
447
448         /* handle_type */
449         prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
450         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_type_get", "rna_MaskSplinePoint_handle_type_set", NULL);
451         RNA_def_property_enum_items(prop, handle_type_items);
452         RNA_def_property_ui_text(prop, "Handle Type", "Handle type");
453         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
454
455         /* select */
456         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
457         RNA_def_property_boolean_sdna(prop, NULL, "bezt.f1", SELECT);
458         RNA_def_property_ui_text(prop, "Select", "Selection status");
459         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
460
461         /* parent */
462         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
463         RNA_def_property_struct_type(prop, "MaskParent");
464
465         /* feather points */
466         prop = RNA_def_property(srna, "feather_points", PROP_COLLECTION, PROP_NONE);
467         RNA_def_property_struct_type(prop, "MaskSplinePointUW");
468         RNA_def_property_collection_sdna(prop, NULL, "uw", "tot_uw");
469         RNA_def_property_ui_text(prop, "Feather Points", "Points defining feather");
470 }
471
472 static void rna_def_mask_splines(BlenderRNA *brna)
473 {
474         StructRNA *srna;
475         FunctionRNA *func;
476         PropertyRNA *prop;
477
478         srna = RNA_def_struct(brna, "MaskSplines", NULL);
479         RNA_def_struct_sdna(srna, "MaskLayer");
480         RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
481
482         func = RNA_def_function(srna, "add", "rna_MaskLayer_spline_add");
483         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
484         RNA_def_function_ui_description(func, "Add a number of splines to mask layer");
485         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the layer", 0, INT_MAX);
486
487         /* active spline */
488         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
489         RNA_def_property_struct_type(prop, "MaskSpline");
490         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_get", "rna_MaskLayer_active_spline_set", NULL, NULL);
491         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
492         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
493
494         /* active point */
495         prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
496         RNA_def_property_struct_type(prop, "MaskSplinePoint");
497         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_point_get", "rna_MaskLayer_active_spline_point_set", NULL, NULL);
498         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
499         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
500 }
501
502 static void rna_def_maskSpline(BlenderRNA *brna)
503 {
504         static EnumPropertyItem spline_interpolation_items[] = {
505                 {MASK_SPLINE_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
506                 {MASK_SPLINE_INTERP_EASE, "EASE", 0, "Ease", ""},
507                 {0, NULL, 0, NULL, NULL}
508         };
509
510         StructRNA *srna;
511         PropertyRNA *prop;
512
513         rna_def_maskSplinePoint(brna);
514
515         srna = RNA_def_struct(brna, "MaskSpline", NULL);
516         RNA_def_struct_ui_text(srna, "Mask spline", "Single spline used for defining mask shape");
517
518         /* weight interpolation */
519         prop = RNA_def_property(srna, "weight_interpolation", PROP_ENUM, PROP_NONE);
520         RNA_def_property_enum_sdna(prop, NULL, "weight_interp");
521         RNA_def_property_enum_items(prop, spline_interpolation_items);
522         RNA_def_property_ui_text(prop, "Weight Interpolation", "The type of weight interpolation for spline");
523         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
524
525         /* cyclic */
526         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
527         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
528         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_CYCLIC);
529         RNA_def_property_ui_text(prop, "Cyclic", "Make this spline a closed loop");
530         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
531 }
532
533 static void rna_def_mask_layer(BlenderRNA *brna)
534 {
535         static EnumPropertyItem masklay_blend_mode_items[] = {
536                 {MASK_BLEND_ADD, "ADD", 0, "Add", ""},
537                 {MASK_BLEND_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
538                 {0, NULL, 0, NULL, NULL}
539         };
540
541         StructRNA *srna;
542         PropertyRNA *prop;
543
544         rna_def_maskSpline(brna);
545         rna_def_mask_splines(brna);
546
547         srna = RNA_def_struct(brna, "MaskLayer", NULL);
548         RNA_def_struct_ui_text(srna, "Mask Layer", "Single layer used for masking pixels");
549         RNA_def_struct_path_func(srna, "rna_MaskLayer_path");
550
551         /* name */
552         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
553         RNA_def_property_ui_text(prop, "Name", "Unique name of layer");
554         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskLayer_name_set");
555         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
556         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
557         RNA_def_struct_name_property(srna, prop);
558
559         /* splines */
560         prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
561         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);
562         RNA_def_property_struct_type(prop, "MaskSpline");
563         RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this layer");
564         RNA_def_property_srna(prop, "MaskSplines");
565
566         /* restrict */
567         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
568         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_VIEW);
569         RNA_def_property_ui_text(prop, "Restrict View", "Restrict visibility in the viewport");
570         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
571         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
572
573         prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
574         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_SELECT);
575         RNA_def_property_ui_text(prop, "Restrict Select", "Restrict selection in the viewport");
576         RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 1);
577         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
578
579         prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
580         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_RENDER);
581         RNA_def_property_ui_text(prop, "Restrict Render", "Restrict renderability");
582         RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
583         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
584
585         /* render settings */
586         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
587         RNA_def_property_float_sdna(prop, NULL, "alpha");
588         RNA_def_property_range(prop, 0.0, 1.0f);
589         RNA_def_property_ui_text(prop, "Opacity", "Render Opacity");
590         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
591
592         /* weight interpolation */
593         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
594         RNA_def_property_enum_sdna(prop, NULL, "blend");
595         RNA_def_property_enum_items(prop, masklay_blend_mode_items);
596         RNA_def_property_ui_text(prop, "Blend", "Method of blending mask layers");
597         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
598         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
599
600         prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
601         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MASK_BLENDFLAG_INVERT);
602         RNA_def_property_ui_text(prop, "Restrict View", "Invert the mask black/white");
603         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
604
605 }
606
607 static void rna_def_masklayers(BlenderRNA *brna, PropertyRNA *cprop)
608 {
609         StructRNA *srna;
610         PropertyRNA *prop;
611
612         FunctionRNA *func;
613         PropertyRNA *parm;
614
615         RNA_def_property_srna(cprop, "MaskLayers");
616         srna = RNA_def_struct(brna, "MaskLayers", NULL);
617         RNA_def_struct_sdna(srna, "Mask");
618         RNA_def_struct_ui_text(srna, "Mask Layers", "Collection of layers used by mask");
619
620         func = RNA_def_function(srna, "new", "rna_Mask_layer_new");
621         RNA_def_function_ui_description(func, "Add layer to this mask");
622         RNA_def_string(func, "name", "", 0, "Name", "Name of new layer");
623         parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "New mask layer");
624         RNA_def_function_return(func, parm);
625
626         func = RNA_def_function(srna, "remove", "rna_Mask_layer_remove");
627         RNA_def_function_ui_description(func, "Remove layer from this mask");
628         RNA_def_pointer(func, "layer", "MaskLayer", "", "Shape to be removed");
629
630         /* active layer */
631         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
632         RNA_def_property_struct_type(prop, "MaskLayer");
633         RNA_def_property_pointer_funcs(prop, "rna_Mask_layer_active_get", "rna_Mask_layer_active_set", NULL, NULL);
634         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
635         RNA_def_property_ui_text(prop, "Active Shape", "Active layer in this mask");
636 }
637
638 static void rna_def_mask(BlenderRNA *brna)
639 {
640         StructRNA *srna;
641         PropertyRNA *prop;
642
643         rna_def_mask_layer(brna);
644
645         srna = RNA_def_struct(brna, "Mask", "ID");
646         RNA_def_struct_ui_text(srna, "Mask", "Mask datablock defining mask for compositing");
647         RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
648
649         /* mask layers */
650         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
651         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);
652         RNA_def_property_struct_type(prop, "MaskLayer");
653         RNA_def_property_ui_text(prop, "Layers", "Collection of layers which defines this mask");
654         rna_def_masklayers(brna, prop);
655
656         /* active masklay index */
657         prop = RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
658         RNA_def_property_int_sdna(prop, NULL, "masklay_act");
659         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
660         RNA_def_property_int_funcs(prop, "rna_Mask_layer_active_index_get", "rna_Mask_layer_active_index_set", "rna_Mask_layer_active_index_range");
661         RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active layer in list of all mask's layers");
662
663         /* frame range */
664         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
665         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
666         RNA_def_property_int_sdna(prop, NULL, "sfra");
667         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_start_frame_set", NULL);
668         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
669         RNA_def_property_ui_text(prop, "Start Frame", "First frame of the mask (used for sequencer)");
670         RNA_def_property_update(prop, NC_SCENE | ND_FRAME_RANGE, NULL);
671
672         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_TIME);
673         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
674         RNA_def_property_int_sdna(prop, NULL, "efra");
675         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_end_frame_set", NULL);
676         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
677         RNA_def_property_ui_text(prop, "End Frame", "Final frame of the mask (used for sequencer)");
678         RNA_def_property_update(prop, NC_SCENE | ND_FRAME_RANGE, NULL);
679
680         /* pointers */
681         rna_def_animdata_common(srna);
682 }
683
684 void RNA_def_mask(BlenderRNA *brna)
685 {
686         rna_def_maskParent(brna);
687         rna_def_mask(brna);
688 }
689
690 #endif