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