Cleanup: use `rna_enum_` prefix for RNA enums
[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 "DNA_mask_types.h"
35 #include "DNA_object_types.h"   /* SELECT */
36 #include "DNA_scene_types.h"
37
38 #include "BLT_translation.h"
39
40 #include "BKE_movieclip.h"
41 #include "BKE_tracking.h"
42
43 #include "RNA_define.h"
44 #include "RNA_enum_types.h"
45
46 #include "rna_internal.h"
47
48 #include "WM_types.h"
49
50 #include "IMB_imbuf_types.h"
51 #include "IMB_imbuf.h"
52
53 #ifdef RNA_RUNTIME
54
55 #include "DNA_movieclip_types.h"
56
57 #include "BKE_depsgraph.h"
58 #include "BKE_mask.h"
59
60 #include "BLI_math.h"
61
62 #include "RNA_access.h"
63
64 #include "WM_api.h"
65
66 static void rna_Mask_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
67 {
68         Mask *mask = ptr->id.data;
69
70         WM_main_add_notifier(NC_MASK | ND_DATA, mask);
71         DAG_id_tag_update( &mask->id, 0);
72 }
73
74 static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr)
75 {
76         MaskParent *parent = ptr->data;
77
78         if (parent->id) {
79                 if (GS(parent->id->name) == ID_MC) {
80                         MovieClip *clip = (MovieClip *) parent->id;
81                         MovieTracking *tracking = &clip->tracking;
82                         MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, parent->parent);
83
84                         if (object) {
85                                 int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra);
86
87                                 if (parent->type == MASK_PARENT_POINT_TRACK) {
88                                         MovieTrackingTrack *track = BKE_tracking_track_get_named(tracking, object, parent->sub_parent);
89
90                                         if (track) {
91                                                 MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_framenr);
92                                                 float marker_pos_ofs[2], parmask_pos[2];
93                                                 MovieClipUser user = {0};
94
95                                                 BKE_movieclip_user_set_frame(&user, scene->r.cfra);
96
97                                                 add_v2_v2v2(marker_pos_ofs, marker->pos, track->offset);
98
99                                                 BKE_mask_coord_from_movieclip(clip, &user, parmask_pos, marker_pos_ofs);
100
101                                                 copy_v2_v2(parent->parent_orig, parmask_pos);
102                                         }
103                                 }
104                                 else /* if (parent->type == MASK_PARENT_PLANE_TRACK) */ {
105                                         MovieTrackingPlaneTrack *plane_track = BKE_tracking_plane_track_get_named(tracking, object, parent->sub_parent);
106                                         if (plane_track) {
107                                                 MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, clip_framenr);
108
109                                                 memcpy(parent->parent_corners_orig, plane_marker->corners, sizeof(parent->parent_corners_orig));
110                                                 zero_v2(parent->parent_orig);
111                                         }
112                                 }
113                         }
114                 }
115         }
116
117         rna_Mask_update_data(bmain, scene, ptr);
118 }
119
120 /* note: this function exists only to avoid id refcounting */
121 static void rna_MaskParent_id_set(PointerRNA *ptr, PointerRNA value)
122 {
123         MaskParent *mpar = (MaskParent *) ptr->data;
124
125         mpar->id = value.data;
126 }
127
128 static StructRNA *rna_MaskParent_id_typef(PointerRNA *ptr)
129 {
130         MaskParent *mpar = (MaskParent *) ptr->data;
131
132         return ID_code_to_RNA_type(mpar->id_type);
133 }
134
135 static void rna_MaskParent_id_type_set(PointerRNA *ptr, int value)
136 {
137         MaskParent *mpar = (MaskParent *) ptr->data;
138
139         /* change ID-type to the new type */
140         mpar->id_type = value;
141
142         /* clear the id-block if the type is invalid */
143         if ((mpar->id) && (GS(mpar->id->name) != mpar->id_type))
144                 mpar->id = NULL;
145 }
146
147 static void rna_Mask_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
148 {
149         Mask *mask = (Mask *)ptr->id.data;
150
151         rna_iterator_listbase_begin(iter, &mask->masklayers, NULL);
152 }
153
154 static int rna_Mask_layer_active_index_get(PointerRNA *ptr)
155 {
156         Mask *mask = (Mask *)ptr->id.data;
157
158         return mask->masklay_act;
159 }
160
161 static void rna_Mask_layer_active_index_set(PointerRNA *ptr, int value)
162 {
163         Mask *mask = (Mask *)ptr->id.data;
164
165         mask->masklay_act = value;
166 }
167
168 static void rna_Mask_layer_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
169 {
170         Mask *mask = (Mask *)ptr->id.data;
171
172         *min = 0;
173         *max = max_ii(0, mask->masklay_tot - 1);
174
175         *softmin = *min;
176         *softmax = *max;
177 }
178
179 static char *rna_MaskLayer_path(PointerRNA *ptr)
180 {
181         MaskLayer *masklay = (MaskLayer *)ptr->data;
182         char name_esc[sizeof(masklay->name) * 2];
183         BLI_strescape(name_esc, masklay->name, sizeof(name_esc));
184         return BLI_sprintfN("layers[\"%s\"]", name_esc);
185 }
186
187 static PointerRNA rna_Mask_layer_active_get(PointerRNA *ptr)
188 {
189         Mask *mask = (Mask *)ptr->id.data;
190         MaskLayer *masklay = BKE_mask_layer_active(mask);
191
192         return rna_pointer_inherit_refine(ptr, &RNA_MaskLayer, masklay);
193 }
194
195 static void rna_Mask_layer_active_set(PointerRNA *ptr, PointerRNA value)
196 {
197         Mask *mask = (Mask *)ptr->id.data;
198         MaskLayer *masklay = (MaskLayer *)value.data;
199
200         BKE_mask_layer_active_set(mask, masklay);
201 }
202
203 static void rna_MaskLayer_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
204 {
205         MaskLayer *masklay = (MaskLayer *)ptr->data;
206
207         rna_iterator_listbase_begin(iter, &masklay->splines, NULL);
208 }
209
210 static void rna_MaskLayer_name_set(PointerRNA *ptr, const char *value)
211 {
212         Mask *mask = (Mask *)ptr->id.data;
213         MaskLayer *masklay = (MaskLayer *)ptr->data;
214         char oldname[sizeof(masklay->name)], newname[sizeof(masklay->name)];
215
216         /* need to be on the stack */
217         BLI_strncpy(oldname, masklay->name, sizeof(masklay->name));
218         BLI_strncpy_utf8(newname, value, sizeof(masklay->name));
219
220         BKE_mask_layer_rename(mask, masklay, oldname, newname);
221 }
222
223 static PointerRNA rna_MaskLayer_active_spline_get(PointerRNA *ptr)
224 {
225         MaskLayer *masklay = (MaskLayer *)ptr->data;
226
227         return rna_pointer_inherit_refine(ptr, &RNA_MaskSpline, masklay->act_spline);
228 }
229
230 static void rna_MaskLayer_active_spline_set(PointerRNA *ptr, PointerRNA value)
231 {
232         MaskLayer *masklay = (MaskLayer *)ptr->data;
233         MaskSpline *spline = (MaskSpline *)value.data;
234         int index = BLI_findindex(&masklay->splines, spline);
235
236         if (index != -1)
237                 masklay->act_spline = spline;
238         else
239                 masklay->act_spline = NULL;
240 }
241
242 static PointerRNA rna_MaskLayer_active_spline_point_get(PointerRNA *ptr)
243 {
244         MaskLayer *masklay = (MaskLayer *)ptr->data;
245
246         return rna_pointer_inherit_refine(ptr, &RNA_MaskSplinePoint, masklay->act_point);
247 }
248
249 static void rna_MaskLayer_active_spline_point_set(PointerRNA *ptr, PointerRNA value)
250 {
251         MaskLayer *masklay = (MaskLayer *)ptr->data;
252         MaskSpline *spline;
253         MaskSplinePoint *point = (MaskSplinePoint *)value.data;
254
255         masklay->act_point = NULL;
256
257         for (spline = masklay->splines.first; spline; spline = spline->next) {
258                 if (point >= spline->points && point < spline->points + spline->tot_point) {
259                         masklay->act_point = point;
260
261                         break;
262                 }
263         }
264 }
265
266 static void rna_MaskSplinePoint_handle1_get(PointerRNA *ptr, float *values)
267 {
268         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
269         BezTriple *bezt = &point->bezt;
270         copy_v2_v2(values, bezt->vec[0]);
271 }
272
273 static void rna_MaskSplinePoint_handle1_set(PointerRNA *ptr, const float *values)
274 {
275         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
276         BezTriple *bezt = &point->bezt;
277         copy_v2_v2(bezt->vec[0], values);
278 }
279
280 static void rna_MaskSplinePoint_handle2_get(PointerRNA *ptr, float *values)
281 {
282         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
283         BezTriple *bezt = &point->bezt;
284         copy_v2_v2(values, bezt->vec[2]);
285 }
286
287 static void rna_MaskSplinePoint_handle2_set(PointerRNA *ptr, const float *values)
288 {
289         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
290         BezTriple *bezt = &point->bezt;
291         copy_v2_v2(bezt->vec[2], values);
292 }
293
294 static void rna_MaskSplinePoint_ctrlpoint_get(PointerRNA *ptr, float *values)
295 {
296         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
297         BezTriple *bezt = &point->bezt;
298         copy_v2_v2(values, bezt->vec[1]);
299 }
300
301 static void rna_MaskSplinePoint_ctrlpoint_set(PointerRNA *ptr, const float *values)
302 {
303         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
304         BezTriple *bezt = &point->bezt;
305         copy_v2_v2(bezt->vec[1], values);
306 }
307
308 static int rna_MaskSplinePoint_handle_type_get(PointerRNA *ptr)
309 {
310         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
311         BezTriple *bezt = &point->bezt;
312
313         return bezt->h1;
314 }
315
316 static MaskSpline *mask_spline_from_point(Mask *mask, MaskSplinePoint *point)
317 {
318         MaskLayer *mask_layer;
319         for (mask_layer = mask->masklayers.first;
320              mask_layer;
321              mask_layer = mask_layer->next)
322         {
323                 MaskSpline *spline;
324                 for (spline = mask_layer->splines.first;
325                      spline;
326                      spline = spline->next)
327                 {
328                         if (point >= spline->points && point < spline->points + spline->tot_point) {
329                                 return spline;
330                         }
331                 }
332         }
333         return NULL;
334 }
335
336 static void mask_point_check_stick(MaskSplinePoint *point)
337 {
338         BezTriple *bezt = &point->bezt;
339         if (bezt->h1 == HD_ALIGN && bezt->h2 == HD_ALIGN) {
340                 float vec[3];
341                 sub_v3_v3v3(vec, bezt->vec[0], bezt->vec[1]);
342                 add_v3_v3v3(bezt->vec[2], bezt->vec[1], vec);
343         }
344 }
345
346 static void rna_MaskSplinePoint_handle_type_set(PointerRNA *ptr, int value)
347 {
348         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
349         BezTriple *bezt = &point->bezt;
350         MaskSpline *spline = mask_spline_from_point((Mask *) ptr->id.data, point);
351
352         bezt->h1 = bezt->h2 = value;
353         mask_point_check_stick(point);
354         BKE_mask_calc_handle_point(spline, point);
355 }
356
357 static int rna_MaskSplinePoint_handle_left_type_get(PointerRNA *ptr)
358 {
359         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
360         BezTriple *bezt = &point->bezt;
361
362         return bezt->h1;
363 }
364
365 static void rna_MaskSplinePoint_handle_left_type_set(PointerRNA *ptr, int value)
366 {
367         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
368         BezTriple *bezt = &point->bezt;
369         MaskSpline *spline = mask_spline_from_point((Mask *) ptr->id.data, point);
370
371         bezt->h1 = value;
372         mask_point_check_stick(point);
373         BKE_mask_calc_handle_point(spline, point);
374 }
375
376 static int rna_MaskSplinePoint_handle_right_type_get(PointerRNA *ptr)
377 {
378         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
379         BezTriple *bezt = &point->bezt;
380
381         return bezt->h2;
382 }
383
384 static void rna_MaskSplinePoint_handle_right_type_set(PointerRNA *ptr, int value)
385 {
386         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
387         BezTriple *bezt = &point->bezt;
388         MaskSpline *spline = mask_spline_from_point((Mask *) ptr->id.data, point);
389
390         bezt->h2 = value;
391         mask_point_check_stick(point);
392         BKE_mask_calc_handle_point(spline, point);
393 }
394
395 /* ** API **  */
396
397 static MaskLayer *rna_Mask_layers_new(Mask *mask, const char *name)
398 {
399         MaskLayer *masklay = BKE_mask_layer_new(mask, name);
400
401         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
402
403         return masklay;
404 }
405
406 static void rna_Mask_layers_remove(Mask *mask, ReportList *reports, PointerRNA *masklay_ptr)
407 {
408         MaskLayer *masklay = masklay_ptr->data;
409         if (BLI_findindex(&mask->masklayers, masklay) == -1) {
410                 BKE_reportf(reports, RPT_ERROR, "Mask layer '%s' not found in mask '%s'", masklay->name, mask->id.name + 2);
411                 return;
412         }
413
414         BKE_mask_layer_remove(mask, masklay);
415         RNA_POINTER_INVALIDATE(masklay_ptr);
416
417         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
418 }
419
420 static void rna_Mask_layers_clear(Mask *mask)
421 {
422         BKE_mask_layer_free_list(&mask->masklayers);
423
424         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
425 }
426
427 static MaskSpline *rna_MaskLayer_spline_new(ID *id, MaskLayer *mask_layer)
428 {
429         Mask *mask = (Mask *) id;
430         MaskSpline *new_spline;
431
432         new_spline = BKE_mask_spline_add(mask_layer);
433
434         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
435
436         return new_spline;
437 }
438
439 static void rna_MaskLayer_spline_remove(ID *id, MaskLayer *mask_layer, ReportList *reports, PointerRNA *spline_ptr)
440 {
441         Mask *mask = (Mask *) id;
442         MaskSpline *spline = spline_ptr->data;
443
444         if (BKE_mask_spline_remove(mask_layer, spline) == false) {
445                 BKE_reportf(reports, RPT_ERROR, "Mask layer '%s' does not contain spline given", mask_layer->name);
446                 return;
447         }
448
449         RNA_POINTER_INVALIDATE(spline_ptr);
450
451         DAG_id_tag_update(&mask->id, OB_RECALC_DATA);
452 }
453
454 static void rna_Mask_start_frame_set(PointerRNA *ptr, int value)
455 {
456         Mask *data = (Mask *)ptr->data;
457         /* MINFRAME not MINAFRAME, since some output formats can't taken negative frames */
458         CLAMP(value, MINFRAME, MAXFRAME);
459         data->sfra = value;
460
461         if (data->sfra >= data->efra) {
462                 data->efra = MIN2(data->sfra, MAXFRAME);
463         }
464 }
465
466 static void rna_Mask_end_frame_set(PointerRNA *ptr, int value)
467 {
468         Mask *data = (Mask *)ptr->data;
469         CLAMP(value, MINFRAME, MAXFRAME);
470         data->efra = value;
471
472         if (data->sfra >= data->efra) {
473                 data->sfra = MAX2(data->efra, MINFRAME);
474         }
475 }
476
477 static void rna_MaskSpline_points_add(ID *id, MaskSpline *spline, int count)
478 {
479         Mask *mask = (Mask *) id;
480         MaskLayer *layer;
481         int active_point_index = -1;
482         int i, spline_shape_index;
483
484         if (count <= 0) {
485                 return;
486         }
487
488         for (layer = mask->masklayers.first; layer; layer = layer->next) {
489                 if (BLI_findindex(&layer->splines, spline) != -1) {
490                         break;
491                 }
492         }
493
494         if (!layer) {
495                 /* Shall not happen actually */
496                 BLI_assert(!"No layer found for the spline");
497                 return;
498         }
499
500         if (layer->act_spline == spline) {
501                 active_point_index = layer->act_point - spline->points;
502         }
503
504         spline->points = MEM_recallocN(spline->points, sizeof(MaskSplinePoint) * (spline->tot_point + count));
505         spline->tot_point += count;
506
507         if (active_point_index >= 0) {
508                 layer->act_point = spline->points + active_point_index;
509         }
510
511         spline_shape_index = BKE_mask_layer_shape_spline_to_index(layer, spline);
512
513         for (i = 0; i < count; i++) {
514                 int point_index = spline->tot_point - count + i;
515                 MaskSplinePoint *new_point = spline->points + point_index;
516                 new_point->bezt.h1 = new_point->bezt.h2 = HD_ALIGN;
517                 BKE_mask_calc_handle_point_auto(spline, new_point, true);
518                 BKE_mask_parent_init(&new_point->parent);
519
520                 /* Not efficient, but there's no other way for now */
521                 BKE_mask_layer_shape_changed_add(layer, spline_shape_index + point_index, true, true);
522         }
523
524         WM_main_add_notifier(NC_MASK | ND_DATA, mask);
525         DAG_id_tag_update(&mask->id, 0);
526 }
527
528 static void rna_MaskSpline_point_remove(ID *id, MaskSpline *spline, ReportList *reports, PointerRNA *point_ptr)
529 {
530         Mask *mask = (Mask *) id;
531         MaskSplinePoint *point = point_ptr->data;
532         MaskSplinePoint *new_point_array;
533         MaskLayer *layer;
534         int active_point_index = -1;
535         int point_index;
536
537         for (layer = mask->masklayers.first; layer; layer = layer->next) {
538                 if (BLI_findindex(&layer->splines, spline) != -1) {
539                         break;
540                 }
541         }
542
543         if (!layer) {
544                 /* Shall not happen actually */
545                 BKE_report(reports, RPT_ERROR, "Mask layer not found for given spline");
546                 return;
547         }
548
549         if (point < spline->points || point >= spline->points + spline->tot_point) {
550                 BKE_report(reports, RPT_ERROR, "Point is not found in given spline");
551                 return;
552         }
553
554         if (layer->act_spline == spline) {
555                 active_point_index = layer->act_point - spline->points;
556         }
557
558         point_index = point - spline->points;
559
560         new_point_array = MEM_mallocN(sizeof(MaskSplinePoint) * (spline->tot_point - 1), "remove mask point");
561
562         memcpy(new_point_array, spline->points, sizeof(MaskSplinePoint) * point_index);
563         memcpy(new_point_array + point_index, spline->points + point_index + 1,
564                sizeof(MaskSplinePoint) * (spline->tot_point - point_index - 1));
565
566         MEM_freeN(spline->points);
567         spline->points = new_point_array;
568         spline->tot_point--;
569
570         if (active_point_index >= 0) {
571                 if (active_point_index == point_index) {
572                         layer->act_point = NULL;
573                 }
574                 else if (active_point_index < point_index) {
575                         layer->act_point = spline->points + active_point_index;
576                 }
577                 else {
578                         layer->act_point = spline->points + active_point_index - 1;
579                 }
580         }
581
582         BKE_mask_layer_shape_changed_remove(layer, BKE_mask_layer_shape_spline_to_index(layer, spline) + point_index, 1);
583
584         WM_main_add_notifier(NC_MASK | ND_DATA, mask);
585         DAG_id_tag_update(&mask->id, 0);
586
587         RNA_POINTER_INVALIDATE(point_ptr);
588 }
589
590 #else
591 static void rna_def_maskParent(BlenderRNA *brna)
592 {
593         StructRNA *srna;
594         PropertyRNA *prop;
595
596         static EnumPropertyItem mask_id_type_items[] = {
597                 {ID_MC, "MOVIECLIP", ICON_SEQUENCE, "Movie Clip", ""},
598                 {0, NULL, 0, NULL, NULL}};
599
600         static EnumPropertyItem parent_type_items[] = {
601                 {MASK_PARENT_POINT_TRACK, "POINT_TRACK", 0, "Point Track", ""},
602                 {MASK_PARENT_PLANE_TRACK, "PLANE_TRACK", 0, "Plane Track", ""},
603                 {0, NULL, 0, NULL, NULL}};
604
605         srna = RNA_def_struct(brna, "MaskParent", NULL);
606         RNA_def_struct_ui_text(srna, "Mask Parent", "Parenting settings for masking element");
607
608         /* Target Properties - ID-block to Drive */
609         prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
610         RNA_def_property_struct_type(prop, "ID");
611         RNA_def_property_flag(prop, PROP_EDITABLE);
612         // RNA_def_property_editable_func(prop, "rna_maskSpline_id_editable");
613         /* note: custom set function is ONLY to avoid rna setting a user for this. */
614         RNA_def_property_pointer_funcs(prop, NULL, "rna_MaskParent_id_set", "rna_MaskParent_id_typef", NULL);
615         RNA_def_property_ui_text(prop, "ID", "ID-block to which masking element would be parented to or to it's property");
616         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
617
618         prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
619         RNA_def_property_enum_sdna(prop, NULL, "id_type");
620         RNA_def_property_enum_items(prop, mask_id_type_items);
621         RNA_def_property_enum_default(prop, ID_MC);
622         RNA_def_property_enum_funcs(prop, NULL, "rna_MaskParent_id_type_set", NULL);
623         //RNA_def_property_editable_func(prop, "rna_MaskParent_id_type_editable");
624         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
625         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
626
627         /* type */
628         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
629         RNA_def_property_enum_items(prop, parent_type_items);
630         RNA_def_property_ui_text(prop, "Parent Type", "Parent Type");
631         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
632
633         /* parent */
634         prop = RNA_def_property(srna, "parent", PROP_STRING, PROP_NONE);
635         RNA_def_property_ui_text(prop, "Parent", "Name of parent object in specified data block to which parenting happens");
636         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
637         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
638
639         /* sub_parent */
640         prop = RNA_def_property(srna, "sub_parent", PROP_STRING, PROP_NONE);
641         RNA_def_property_ui_text(prop, "Sub Parent", "Name of parent sub-object in specified data block to which parenting happens");
642         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
643         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
644 }
645
646 static void rna_def_maskSplinePointUW(BlenderRNA *brna)
647 {
648         StructRNA *srna;
649         PropertyRNA *prop;
650
651         srna = RNA_def_struct(brna, "MaskSplinePointUW", NULL);
652         RNA_def_struct_ui_text(srna, "Mask Spline UW Point", "Single point in spline segment defining feather");
653
654         /* u */
655         prop = RNA_def_property(srna, "u", PROP_FLOAT, PROP_NONE);
656         RNA_def_property_float_sdna(prop, NULL, "u");
657         RNA_def_property_range(prop, 0.0, 1.0);
658         RNA_def_property_ui_text(prop, "U", "U coordinate of point along spline segment");
659         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
660
661         /* weight */
662         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
663         RNA_def_property_float_sdna(prop, NULL, "w");
664         RNA_def_property_range(prop, 0.0, 1.0);
665         RNA_def_property_ui_text(prop, "Weight", "Weight of feather point");
666         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
667
668         /* select */
669         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
670         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
671         RNA_def_property_ui_text(prop, "Select", "Selection status");
672         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
673 }
674
675 static void rna_def_maskSplinePoint(BlenderRNA *brna)
676 {
677         StructRNA *srna;
678         PropertyRNA *prop;
679
680         static EnumPropertyItem handle_type_items[] = {
681                 {HD_AUTO, "AUTO", 0, "Auto", ""},
682                 {HD_VECT, "VECTOR", 0, "Vector", ""},
683                 {HD_ALIGN, "ALIGNED", 0, "Aligned Single", ""},
684                 {HD_ALIGN_DOUBLESIDE, "ALIGNED_DOUBLESIDE", 0, "Aligned", ""},
685                 {HD_FREE, "FREE", 0, "Free", ""},
686                 {0, NULL, 0, NULL, NULL}};
687
688         rna_def_maskSplinePointUW(brna);
689
690         srna = RNA_def_struct(brna, "MaskSplinePoint", NULL);
691         RNA_def_struct_ui_text(srna, "Mask Spline Point", "Single point in spline used for defining mask");
692
693         /* Vector values */
694         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
695         RNA_def_property_array(prop, 2);
696         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle1_get", "rna_MaskSplinePoint_handle1_set", NULL);
697         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
698         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
699
700         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
701         RNA_def_property_array(prop, 2);
702         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_ctrlpoint_get", "rna_MaskSplinePoint_ctrlpoint_set", NULL);
703         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
704         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
705
706         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
707         RNA_def_property_array(prop, 2);
708         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle2_get", "rna_MaskSplinePoint_handle2_set", NULL);
709         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
710         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
711
712         /* handle_type */
713         prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
714         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_type_get", "rna_MaskSplinePoint_handle_type_set", NULL);
715         RNA_def_property_enum_items(prop, handle_type_items);
716         RNA_def_property_ui_text(prop, "Handle Type", "Handle type");
717         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
718
719         /* handle_type */
720         prop = RNA_def_property(srna, "handle_left_type", PROP_ENUM, PROP_NONE);
721         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_left_type_get", "rna_MaskSplinePoint_handle_left_type_set", NULL);
722         RNA_def_property_enum_items(prop, handle_type_items);
723         RNA_def_property_ui_text(prop, "Handle 1 Type", "Handle type");
724         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
725
726         /* handle_right */
727         prop = RNA_def_property(srna, "handle_right_type", PROP_ENUM, PROP_NONE);
728         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_right_type_get", "rna_MaskSplinePoint_handle_right_type_set", NULL);
729         RNA_def_property_enum_items(prop, handle_type_items);
730         RNA_def_property_ui_text(prop, "Handle 2 Type", "Handle type");
731         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
732
733         /* weight */
734         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
735         RNA_def_property_float_sdna(prop, NULL, "bezt.weight");
736         RNA_def_property_range(prop, 0.0, 1.0);
737         RNA_def_property_ui_text(prop, "Weight", "Weight of the point");
738         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
739
740         /* select */
741         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
742         RNA_def_property_boolean_sdna(prop, NULL, "bezt.f1", SELECT);
743         RNA_def_property_ui_text(prop, "Select", "Selection status");
744         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
745
746         /* parent */
747         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
748         RNA_def_property_struct_type(prop, "MaskParent");
749
750         /* feather points */
751         prop = RNA_def_property(srna, "feather_points", PROP_COLLECTION, PROP_NONE);
752         RNA_def_property_struct_type(prop, "MaskSplinePointUW");
753         RNA_def_property_collection_sdna(prop, NULL, "uw", "tot_uw");
754         RNA_def_property_ui_text(prop, "Feather Points", "Points defining feather");
755 }
756
757 static void rna_def_mask_splines(BlenderRNA *brna)
758 {
759         StructRNA *srna;
760         FunctionRNA *func;
761         PropertyRNA *prop;
762         PropertyRNA *parm;
763
764         srna = RNA_def_struct(brna, "MaskSplines", NULL);
765         RNA_def_struct_sdna(srna, "MaskLayer");
766         RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
767
768         /* Create new spline */
769         func = RNA_def_function(srna, "new", "rna_MaskLayer_spline_new");
770         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
771         RNA_def_function_ui_description(func, "Add a new spline to the layer");
772         parm = RNA_def_pointer(func, "spline", "MaskSpline", "", "The newly created spline");
773         RNA_def_function_return(func, parm);
774
775         /* Remove the spline */
776         func = RNA_def_function(srna, "remove", "rna_MaskLayer_spline_remove");
777         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
778         RNA_def_function_ui_description(func, "Remove a spline from a layer");
779         RNA_def_function_flag(func, FUNC_USE_REPORTS);
780         parm = RNA_def_pointer(func, "spline", "MaskSpline", "", "The spline to remove");
781         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
782         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
783
784         /* active spline */
785         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
786         RNA_def_property_struct_type(prop, "MaskSpline");
787         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_get", "rna_MaskLayer_active_spline_set", NULL, NULL);
788         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
789         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
790
791         /* active point */
792         prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
793         RNA_def_property_struct_type(prop, "MaskSplinePoint");
794         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_point_get", "rna_MaskLayer_active_spline_point_set", NULL, NULL);
795         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
796         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
797 }
798
799 static void rna_def_maskSplinePoints(BlenderRNA *brna)
800 {
801         StructRNA *srna;
802         FunctionRNA *func;
803         PropertyRNA *parm;
804
805         srna = RNA_def_struct(brna, "MaskSplinePoints", NULL);
806         RNA_def_struct_sdna(srna, "MaskSpline");
807         RNA_def_struct_ui_text(srna, "Mask Spline Points", "Collection of masking spline points");
808
809         /* Create new point */
810         func = RNA_def_function(srna, "add", "rna_MaskSpline_points_add");
811         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
812         RNA_def_function_ui_description(func, "Add a number of point to this spline");
813         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the spline", 0, INT_MAX);
814
815         /* Remove the point */
816         func = RNA_def_function(srna, "remove", "rna_MaskSpline_point_remove");
817         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
818         RNA_def_function_ui_description(func, "Remove a point from a spline");
819         RNA_def_function_flag(func, FUNC_USE_REPORTS);
820         parm = RNA_def_pointer(func, "point", "MaskSplinePoint", "", "The point to remove");
821         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
822         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
823 }
824
825 static void rna_def_maskSpline(BlenderRNA *brna)
826 {
827         static EnumPropertyItem spline_interpolation_items[] = {
828                 {MASK_SPLINE_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
829                 {MASK_SPLINE_INTERP_EASE, "EASE", 0, "Ease", ""},
830                 {0, NULL, 0, NULL, NULL}
831         };
832
833         static EnumPropertyItem spline_offset_mode_items[] = {
834                 {MASK_SPLINE_OFFSET_EVEN, "EVEN", 0, "Even", "Calculate even feather offset"},
835                 {MASK_SPLINE_OFFSET_SMOOTH, "SMOOTH", 0, "Smooth", "Calculate feather offset as a second curve"},
836                 {0, NULL, 0, NULL, NULL}
837         };
838
839         StructRNA *srna;
840         PropertyRNA *prop;
841
842         rna_def_maskSplinePoint(brna);
843
844         srna = RNA_def_struct(brna, "MaskSpline", NULL);
845         RNA_def_struct_ui_text(srna, "Mask spline", "Single spline used for defining mask shape");
846
847         /* offset mode */
848         prop = RNA_def_property(srna, "offset_mode", PROP_ENUM, PROP_NONE);
849         RNA_def_property_enum_sdna(prop, NULL, "offset_mode");
850         RNA_def_property_enum_items(prop, spline_offset_mode_items);
851         RNA_def_property_ui_text(prop, "Feather Offset", "The method used for calculating the feather offset");
852         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
853
854         /* weight interpolation */
855         prop = RNA_def_property(srna, "weight_interpolation", PROP_ENUM, PROP_NONE);
856         RNA_def_property_enum_sdna(prop, NULL, "weight_interp");
857         RNA_def_property_enum_items(prop, spline_interpolation_items);
858         RNA_def_property_ui_text(prop, "Weight Interpolation", "The type of weight interpolation for spline");
859         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
860
861         /* cyclic */
862         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
863         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
864         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_CYCLIC);
865         RNA_def_property_ui_text(prop, "Cyclic", "Make this spline a closed loop");
866         RNA_def_property_update(prop, NC_MASK | NA_EDITED, "rna_Mask_update_data");
867
868         /* fill */
869         prop = RNA_def_property(srna, "use_fill", PROP_BOOLEAN, PROP_NONE);
870         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
871         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", MASK_SPLINE_NOFILL);
872         RNA_def_property_ui_text(prop, "Fill", "Make this spline filled");
873         RNA_def_property_update(prop, NC_MASK | NA_EDITED, "rna_Mask_update_data");
874
875         /* self-intersection check */
876         prop = RNA_def_property(srna, "use_self_intersection_check", PROP_BOOLEAN, PROP_NONE);
877         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
878         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_NOINTERSECT);
879         RNA_def_property_ui_text(prop, "Self Intersection Check", "Prevent feather from self-intersections");
880         RNA_def_property_update(prop, NC_MASK | NA_EDITED, "rna_Mask_update_data");
881
882         prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
883         RNA_def_property_struct_type(prop, "MaskSplinePoint");
884         RNA_def_property_collection_sdna(prop, NULL, "points", "tot_point");
885         RNA_def_property_ui_text(prop, "Points", "Collection of points");
886         RNA_def_property_srna(prop, "MaskSplinePoints");
887 }
888
889 static void rna_def_mask_layer(BlenderRNA *brna)
890 {
891         static EnumPropertyItem masklay_blend_mode_items[] = {
892                 {MASK_BLEND_MERGE_ADD, "MERGE_ADD", 0, "Merge Add", ""},
893                 {MASK_BLEND_MERGE_SUBTRACT, "MERGE_SUBTRACT", 0, "Merge Subtract", ""},
894                 {MASK_BLEND_ADD, "ADD", 0, "Add", ""},
895                 {MASK_BLEND_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
896                 {MASK_BLEND_LIGHTEN, "LIGHTEN", 0, "Lighten", ""},
897                 {MASK_BLEND_DARKEN, "DARKEN", 0, "Darken", ""},
898                 {MASK_BLEND_MUL, "MUL", 0, "Multiply", ""},
899                 {MASK_BLEND_REPLACE, "REPLACE", 0, "Replace", ""},
900                 {MASK_BLEND_DIFFERENCE, "DIFFERENCE", 0, "Difference", ""},
901                 {0, NULL, 0, NULL, NULL}
902         };
903
904         StructRNA *srna;
905         PropertyRNA *prop;
906
907         rna_def_maskSpline(brna);
908         rna_def_mask_splines(brna);
909         rna_def_maskSplinePoints(brna);
910
911         srna = RNA_def_struct(brna, "MaskLayer", NULL);
912         RNA_def_struct_ui_text(srna, "Mask Layer", "Single layer used for masking pixels");
913         RNA_def_struct_path_func(srna, "rna_MaskLayer_path");
914
915         /* name */
916         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
917         RNA_def_property_ui_text(prop, "Name", "Unique name of layer");
918         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskLayer_name_set");
919         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
920         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
921         RNA_def_struct_name_property(srna, prop);
922
923         /* splines */
924         prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
925         RNA_def_property_collection_funcs(prop, "rna_MaskLayer_splines_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", NULL, NULL, NULL, NULL);
926         RNA_def_property_struct_type(prop, "MaskSpline");
927         RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this layer");
928         RNA_def_property_srna(prop, "MaskSplines");
929
930         /* restrict */
931         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
932         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_VIEW);
933         RNA_def_property_ui_text(prop, "Restrict View", "Restrict visibility in the viewport");
934         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
935         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
936
937         prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
938         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_SELECT);
939         RNA_def_property_ui_text(prop, "Restrict Select", "Restrict selection in the viewport");
940         RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 1);
941         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
942
943         prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
944         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_RENDER);
945         RNA_def_property_ui_text(prop, "Restrict Render", "Restrict renderability");
946         RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
947         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
948
949         /* select (for dopesheet)*/
950         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
951         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_LAYERFLAG_SELECT);
952         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the Dope Sheet");
953 //      RNA_def_property_update(prop, NC_SCREEN | ND_MASK, NULL);
954
955         /* render settings */
956         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
957         RNA_def_property_float_sdna(prop, NULL, "alpha");
958         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
959         RNA_def_property_ui_text(prop, "Opacity", "Render Opacity");
960         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
961
962         /* weight interpolation */
963         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
964         RNA_def_property_enum_sdna(prop, NULL, "blend");
965         RNA_def_property_enum_items(prop, masklay_blend_mode_items);
966         RNA_def_property_ui_text(prop, "Blend", "Method of blending mask layers");
967         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
968         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
969
970         prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
971         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MASK_BLENDFLAG_INVERT);
972         RNA_def_property_ui_text(prop, "Restrict View", "Invert the mask black/white");
973         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
974
975         prop = RNA_def_property(srna, "falloff", PROP_ENUM, PROP_NONE);
976         RNA_def_property_enum_sdna(prop, NULL, "falloff");
977         RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_curve_only_items);
978         RNA_def_property_ui_text(prop, "Falloff", "Falloff type the feather");
979         RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
980         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
981
982         /* filling options */
983         prop = RNA_def_property(srna, "use_fill_holes", PROP_BOOLEAN, PROP_NONE);
984         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", MASK_LAYERFLAG_FILL_DISCRETE);
985         RNA_def_property_ui_text(prop, "Calculate Holes", "Calculate holes when filling overlapping curves");
986         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
987
988         prop = RNA_def_property(srna, "use_fill_overlap", PROP_BOOLEAN, PROP_NONE);
989         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_LAYERFLAG_FILL_OVERLAP);
990         RNA_def_property_ui_text(prop, "Calculate Overlap", "Calculate self intersections and overlap before filling");
991         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
992 }
993
994 static void rna_def_masklayers(BlenderRNA *brna, PropertyRNA *cprop)
995 {
996         StructRNA *srna;
997         PropertyRNA *prop;
998
999         FunctionRNA *func;
1000         PropertyRNA *parm;
1001
1002         RNA_def_property_srna(cprop, "MaskLayers");
1003         srna = RNA_def_struct(brna, "MaskLayers", NULL);
1004         RNA_def_struct_sdna(srna, "Mask");
1005         RNA_def_struct_ui_text(srna, "Mask Layers", "Collection of layers used by mask");
1006
1007         func = RNA_def_function(srna, "new", "rna_Mask_layers_new");
1008         RNA_def_function_ui_description(func, "Add layer to this mask");
1009         RNA_def_string(func, "name", NULL, 0, "Name", "Name of new layer");
1010         parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "New mask layer");
1011         RNA_def_function_return(func, parm);
1012
1013         func = RNA_def_function(srna, "remove", "rna_Mask_layers_remove");
1014         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1015         RNA_def_function_ui_description(func, "Remove layer from this mask");
1016         parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "Shape to be removed");
1017         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1018         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1019
1020         /* clear all layers */
1021         func = RNA_def_function(srna, "clear", "rna_Mask_layers_clear");
1022         RNA_def_function_ui_description(func, "Remove all mask layers");
1023
1024         /* active layer */
1025         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1026         RNA_def_property_struct_type(prop, "MaskLayer");
1027         RNA_def_property_pointer_funcs(prop, "rna_Mask_layer_active_get", "rna_Mask_layer_active_set", NULL, NULL);
1028         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
1029         RNA_def_property_ui_text(prop, "Active Shape", "Active layer in this mask");
1030 }
1031
1032 static void rna_def_mask(BlenderRNA *brna)
1033 {
1034         StructRNA *srna;
1035         PropertyRNA *prop;
1036
1037         rna_def_mask_layer(brna);
1038
1039         srna = RNA_def_struct(brna, "Mask", "ID");
1040         RNA_def_struct_ui_text(srna, "Mask", "Mask data-block defining mask for compositing");
1041         RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
1042
1043         /* mask layers */
1044         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
1045         RNA_def_property_collection_funcs(prop, "rna_Mask_layers_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", NULL, NULL, NULL, NULL);
1046         RNA_def_property_struct_type(prop, "MaskLayer");
1047         RNA_def_property_ui_text(prop, "Layers", "Collection of layers which defines this mask");
1048         rna_def_masklayers(brna, prop);
1049
1050         /* active masklay index */
1051         prop = RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
1052         RNA_def_property_int_sdna(prop, NULL, "masklay_act");
1053         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1054         RNA_def_property_int_funcs(prop, "rna_Mask_layer_active_index_get", "rna_Mask_layer_active_index_set", "rna_Mask_layer_active_index_range");
1055         RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active layer in list of all mask's layers");
1056         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
1057
1058         /* frame range */
1059         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
1060         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1061         RNA_def_property_int_sdna(prop, NULL, "sfra");
1062         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_start_frame_set", NULL);
1063         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
1064         RNA_def_property_ui_text(prop, "Start Frame", "First frame of the mask (used for sequencer)");
1065         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
1066
1067         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_TIME);
1068         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1069         RNA_def_property_int_sdna(prop, NULL, "efra");
1070         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_end_frame_set", NULL);
1071         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
1072         RNA_def_property_ui_text(prop, "End Frame", "Final frame of the mask (used for sequencer)");
1073         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
1074
1075         /* pointers */
1076         rna_def_animdata_common(srna);
1077 }
1078
1079 void RNA_def_mask(BlenderRNA *brna)
1080 {
1081         rna_def_maskParent(brna);
1082         rna_def_mask(brna);
1083 }
1084
1085 #endif