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