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