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