fb06e2e17d3d828436eca5509ed30249d8c916b2
[blender.git] / source / blender / makesrna / intern / rna_gpencil.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 (2009), Joshua Leung, Antonio Vazquez
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_gpencil.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28
29 #include "DNA_gpencil_types.h"
30 #include "DNA_scene_types.h"
31
32 #include "MEM_guardedalloc.h"
33
34 #include "BLI_string_utils.h"
35 #include "BLI_utildefines.h"
36
37 #include "BLT_translation.h"
38
39 #include "RNA_access.h"
40 #include "RNA_define.h"
41
42 #include "rna_internal.h"
43
44 #include "WM_types.h"
45 #include "DNA_object_types.h"
46 #include "ED_gpencil.h"
47
48 /* parent type */
49 static const EnumPropertyItem parent_type_items[] = {
50         {PAROBJECT, "OBJECT", 0, "Object", "The layer is parented to an object"},
51         {PARSKEL, "ARMATURE", 0, "Armature", ""},
52         {PARBONE, "BONE", 0, "Bone", "The layer is parented to a bone"},
53         {0, NULL, 0, NULL, NULL}
54 };
55
56
57 #ifdef RNA_RUNTIME
58
59 #include "BLI_math.h"
60
61 #include "WM_api.h"
62
63 #include "BKE_animsys.h"
64 #include "BKE_gpencil.h"
65 #include "BKE_action.h"
66
67
68 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *UNUSED(ptr))
69 {
70         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
71 }
72
73 static void rna_GPencil_editmode_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *UNUSED(ptr))
74 {
75         /* Notify all places where GPencil data lives that the editing state is different */
76         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
77         WM_main_add_notifier(NC_SCENE | ND_MODE | NC_MOVIECLIP, NULL);
78 }
79
80 static void rna_GPencil_onion_skinning_update(Main *bmain, Scene *scene, PointerRNA *ptr)
81 {
82         bGPdata *gpd = (bGPdata *)ptr->id.data;
83         bGPDlayer *gpl;
84         bool enabled = false;
85
86         /* Ensure that the datablock's onionskinning toggle flag
87          * stays in sync with the status of the actual layers
88          */
89         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
90                 if (gpl->flag & GP_LAYER_ONIONSKIN) {
91                         enabled = true;
92                 }
93         }
94
95         if (enabled)
96                 gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
97         else
98                 gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
99
100
101         /* Now do standard updates... */
102         rna_GPencil_update(bmain, scene, ptr);
103 }
104
105 static void rna_GPencil_stroke_colorname_update(Main *bmain, Scene *scene, PointerRNA *ptr)
106 {
107         bGPDstroke *gps = (bGPDstroke *)ptr->data;
108         gps->flag |= GP_STROKE_RECALC_COLOR;
109         gps->palcolor = NULL;
110
111         /* Now do standard updates... */
112         rna_GPencil_update(bmain, scene, ptr);
113 }
114
115 static char *rna_GPencilLayer_path(PointerRNA *ptr)
116 {
117         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
118         char name_esc[sizeof(gpl->info) * 2];
119
120         BLI_strescape(name_esc, gpl->info, sizeof(name_esc));
121
122         return BLI_sprintfN("layers[\"%s\"]", name_esc);
123 }
124
125 static int rna_GPencilLayer_active_frame_editable(PointerRNA *ptr, const char **UNUSED(r_info))
126 {
127         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
128
129         /* surely there must be other criteria too... */
130         if (gpl->flag & GP_LAYER_LOCKED)
131                 return 0;
132         else
133                 return PROP_EDITABLE;
134 }
135
136 static void rna_GPencilLayer_line_width_range(PointerRNA *ptr, int *min, int *max,
137                                               int *softmin, int *softmax)
138 {
139         bGPDlayer *gpl = ptr->data;
140
141         /* The restrictions on max width here are due to OpenGL on Windows not supporting
142          * any widths greater than 10 (for driver-drawn) strokes/points.
143          *
144          * Although most of our 2D strokes also don't suffer from this restriction,
145          * it's relatively hard to test for that. So, for now, only volumetric strokes
146          * get to be larger...
147          */
148
149         /* From GP v2 this value is used to increase or decrease the thickness of the stroke */
150         if (gpl->flag & GP_LAYER_VOLUMETRIC) {
151                 *min = -300;
152                 *max = 300;
153
154                 *softmin = -100;
155                 *softmax = 100;
156         }
157         else {
158                 *min = -10;
159                 *max = 10;
160
161                 *softmin = -10;
162                 *softmax = 10;
163         }
164 }
165
166 /* set parent */
167 static void set_parent(bGPDlayer *gpl, Object *par, const int type, const char *substr)
168 {
169         if (type == PAROBJECT) {
170                 invert_m4_m4(gpl->inverse, par->obmat);
171                 gpl->parent = par;
172                 gpl->partype |= PAROBJECT;
173                 gpl->parsubstr[0] = 0;
174         }
175         else if (type == PARSKEL) {
176                 invert_m4_m4(gpl->inverse, par->obmat);
177                 gpl->parent = par;
178                 gpl->partype |= PARSKEL;
179                 gpl->parsubstr[0] = 0;
180         }
181         else if (type == PARBONE) {
182                 bPoseChannel *pchan = BKE_pose_channel_find_name(par->pose, substr);
183                 if (pchan) {
184                         float tmp_mat[4][4];
185                         mul_m4_m4m4(tmp_mat, par->obmat, pchan->pose_mat);
186
187                         invert_m4_m4(gpl->inverse, tmp_mat);
188                         gpl->parent = par;
189                         gpl->partype |= PARBONE;
190                         BLI_strncpy(gpl->parsubstr, substr, sizeof(gpl->parsubstr));
191                 }
192         }
193 }
194
195 /* set parent object and inverse matrix */
196 static void rna_GPencilLayer_parent_set(PointerRNA *ptr, PointerRNA value)
197 {
198         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
199         Object *par = (Object *)value.data;
200
201         if (par != NULL) {
202                 set_parent(gpl, par, gpl->partype, gpl->parsubstr);
203         }
204         else {
205                 /* keep strokes in the same place, so apply current transformation */
206                 if (gpl->parent != NULL) {
207                         bGPDspoint *pt;
208                         int i;
209                         float diff_mat[4][4];
210                         /* calculate difference matrix */
211                         ED_gpencil_parent_location(gpl, diff_mat);
212                         for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
213                                 for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
214                                         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
215                                                 mul_m4_v3(diff_mat, &pt->x);
216                                         }
217                                 }
218                         }
219                 }
220                 /* clear parent */
221                 gpl->parent = NULL;
222         }
223 }
224
225 /* set parent type */
226 static void rna_GPencilLayer_parent_type_set(PointerRNA *ptr, int value)
227 {
228         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
229         Object *par = gpl->parent;
230         gpl->partype = value;
231
232         if (par != NULL) {
233                 set_parent(gpl, par, value, gpl->parsubstr);
234         }
235 }
236
237 /* set parent bone */
238 static void rna_GPencilLayer_parent_bone_set(PointerRNA *ptr, const char *value)
239 {
240         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
241
242         Object *par = gpl->parent;
243         gpl->partype = PARBONE;
244
245         if (par != NULL) {
246                 set_parent(gpl, par, gpl->partype, value);
247         }
248 }
249
250
251 /* parent types enum */
252 static const EnumPropertyItem *rna_Object_parent_type_itemf(
253         bContext *UNUSED(C), PointerRNA *ptr,
254         PropertyRNA *UNUSED(prop), bool *r_free)
255 {
256         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
257         EnumPropertyItem *item = NULL;
258         int totitem = 0;
259
260         RNA_enum_items_add_value(&item, &totitem, parent_type_items, PAROBJECT);
261
262         if (gpl->parent) {
263                 Object *par = gpl->parent;
264
265                 if (par->type == OB_ARMATURE) {
266                         /* special hack: prevents this being overrided */
267                         RNA_enum_items_add_value(&item, &totitem, &parent_type_items[1], PARSKEL);
268                         RNA_enum_items_add_value(&item, &totitem, parent_type_items, PARBONE);
269                 }
270         }
271
272         RNA_enum_item_end(&item, &totitem);
273         *r_free = true;
274
275         return item;
276 }
277
278 static int rna_GPencilLayer_is_parented_get(PointerRNA *ptr)
279 {
280         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
281         return (gpl->parent != NULL);
282 }
283
284 static PointerRNA rna_GPencil_active_layer_get(PointerRNA *ptr)
285 {
286         bGPdata *gpd = ptr->id.data;
287
288         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
289                 bGPDlayer *gl;
290
291                 for (gl = gpd->layers.first; gl; gl = gl->next) {
292                         if (gl->flag & GP_LAYER_ACTIVE) {
293                                 break;
294                         }
295                 }
296
297                 if (gl) {
298                         return rna_pointer_inherit_refine(ptr, &RNA_GPencilLayer, gl);
299                 }
300         }
301
302         return rna_pointer_inherit_refine(ptr, NULL, NULL);
303 }
304
305 static void rna_GPencil_active_layer_set(PointerRNA *ptr, PointerRNA value)
306 {
307         bGPdata *gpd = ptr->id.data;
308
309         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
310                 bGPDlayer *gl;
311
312                 for (gl = gpd->layers.first; gl; gl = gl->next) {
313                         if (gl == value.data) {
314                                 gl->flag |= GP_LAYER_ACTIVE;
315                         }
316                         else {
317                                 gl->flag &= ~GP_LAYER_ACTIVE;
318                         }
319                 }
320
321                 WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
322         }
323 }
324
325 static int rna_GPencil_active_layer_index_get(PointerRNA *ptr)
326 {
327         bGPdata *gpd = (bGPdata *)ptr->id.data;
328         bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
329
330         return BLI_findindex(&gpd->layers, gpl);
331 }
332
333 static void rna_GPencil_active_layer_index_set(PointerRNA *ptr, int value)
334 {
335         bGPdata *gpd   = (bGPdata *)ptr->id.data;
336         bGPDlayer *gpl = BLI_findlink(&gpd->layers, value);
337
338         BKE_gpencil_layer_setactive(gpd, gpl);
339 }
340
341 static void rna_GPencil_active_layer_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
342 {
343         bGPdata *gpd = (bGPdata *)ptr->id.data;
344
345         *min = 0;
346         *max = max_ii(0, BLI_listbase_count(&gpd->layers) - 1);
347
348         *softmin = *min;
349         *softmax = *max;
350 }
351
352 static void rna_GPencilLayer_info_set(PointerRNA *ptr, const char *value)
353 {
354         bGPdata *gpd = ptr->id.data;
355         bGPDlayer *gpl = ptr->data;
356
357         char oldname[128] = "";
358         BLI_strncpy(oldname, gpl->info, sizeof(oldname));
359
360         /* copy the new name into the name slot */
361         BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));
362
363         BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
364
365         /* now fix animation paths */
366         BKE_animdata_fix_paths_rename_all(&gpd->id, "layers", oldname, gpl->info);
367 }
368
369 static void rna_GPencil_use_onion_skinning_set(PointerRNA *ptr, const int value)
370 {
371         bGPdata *gpd = ptr->id.data;
372         bGPDlayer *gpl;
373
374         /* set new value */
375         if (value) {
376                 /* enable on active layer (it's the one that's most likely to be of interest right now) */
377                 gpl = BKE_gpencil_layer_getactive(gpd);
378                 if (gpl) {
379                         gpl->flag |= GP_LAYER_ONIONSKIN;
380                 }
381
382                 gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
383         }
384         else {
385                 /* disable on all layers - allowa quickly turning them all off, without having to check */
386                 for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
387                         gpl->flag &= ~GP_LAYER_ONIONSKIN;
388                 }
389
390                 gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
391         }
392 }
393
394 static bGPDstroke *rna_GPencil_stroke_point_find_stroke(const bGPdata *gpd, const bGPDspoint *pt, bGPDlayer **r_gpl, bGPDframe **r_gpf)
395 {
396         bGPDlayer *gpl;
397         bGPDstroke *gps;
398
399         /* sanity checks */
400         if (ELEM(NULL, gpd, pt)) {
401                 return NULL;
402         }
403
404         if (r_gpl) *r_gpl = NULL;
405         if (r_gpf) *r_gpf = NULL;
406
407         /* there's no faster alternative than just looping over everything... */
408         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
409                 if (gpl->actframe) {
410                         for (gps = gpl->actframe->strokes.first; gps; gps = gps->next) {
411                                 if ((pt >= gps->points) && (pt < &gps->points[gps->totpoints])) {
412                                         /* found it */
413                                         if (r_gpl) *r_gpl = gpl;
414                                         if (r_gpf) *r_gpf = gpl->actframe;
415
416                                         return gps;
417                                 }
418                         }
419                 }
420         }
421
422         /* didn't find it */
423         return NULL;
424 }
425
426 static void rna_GPencil_stroke_point_select_set(PointerRNA *ptr, const int value)
427 {
428         bGPdata *gpd = ptr->id.data;
429         bGPDspoint *pt = ptr->data;
430         bGPDstroke *gps = NULL;
431
432         /* Ensure that corresponding stroke is set
433          * - Since we don't have direct access, we're going to have to search
434          * - We don't apply selection value unless we can find the corresponding
435          *   stroke, so that they don't get out of sync
436          */
437         gps = rna_GPencil_stroke_point_find_stroke(gpd, pt, NULL, NULL);
438         if (gps) {
439                 /* Set the new selection state for the point */
440                 if (value)
441                         pt->flag |= GP_SPOINT_SELECT;
442                 else
443                         pt->flag &= ~GP_SPOINT_SELECT;
444
445                 /* Check if the stroke should be selected or not... */
446                 BKE_gpencil_stroke_sync_selection(gps);
447         }
448 }
449
450 static void rna_GPencil_stroke_point_add(bGPDstroke *stroke, int count, float pressure, float strength)
451 {
452         if (count > 0) {
453                 /* create space at the end of the array for extra points */
454                 stroke->points = MEM_recallocN_id(stroke->points,
455                                                   sizeof(bGPDspoint) * (stroke->totpoints + count),
456                                                   "gp_stroke_points");
457
458                 /* init the pressure and strength values so that old scripts won't need to
459                  * be modified to give these initial values...
460                  */
461                 for (int i = 0; i < count; i++) {
462                         bGPDspoint *pt = stroke->points + (stroke->totpoints + i);
463                         pt->pressure = pressure;
464                         pt->strength = strength;
465                 }
466
467                 stroke->totpoints += count;
468         }
469 }
470
471 static void rna_GPencil_stroke_point_pop(bGPDstroke *stroke, ReportList *reports, int index)
472 {
473         bGPDspoint *pt_tmp = stroke->points;
474
475         /* python style negative indexing */
476         if (index < 0) {
477                 index += stroke->totpoints;
478         }
479
480         if (stroke->totpoints <= index || index < 0) {
481                 BKE_report(reports, RPT_ERROR, "GPencilStrokePoints.pop: index out of range");
482                 return;
483         }
484
485         stroke->totpoints--;
486
487         stroke->points = MEM_callocN(sizeof(bGPDspoint) * stroke->totpoints, "gp_stroke_points");
488
489         if (index > 0)
490                 memcpy(stroke->points, pt_tmp, sizeof(bGPDspoint) * index);
491
492         if (index < stroke->totpoints)
493                 memcpy(&stroke->points[index], &pt_tmp[index + 1], sizeof(bGPDspoint) * (stroke->totpoints - index));
494
495         /* free temp buffer */
496         MEM_freeN(pt_tmp);
497
498         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
499 }
500
501 static bGPDstroke *rna_GPencil_stroke_new(bGPDframe *frame, const char *colorname)
502 {
503         bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
504         if (colorname) {
505                 BLI_strncpy(stroke->colorname, colorname, sizeof(stroke->colorname));
506         }
507         stroke->palcolor = NULL;
508         stroke->flag |= GP_STROKE_RECALC_COLOR;
509         BLI_addtail(&frame->strokes, stroke);
510
511         return stroke;
512 }
513
514 static void rna_GPencil_stroke_remove(bGPDframe *frame, ReportList *reports, PointerRNA *stroke_ptr)
515 {
516         bGPDstroke *stroke = stroke_ptr->data;
517         if (BLI_findindex(&frame->strokes, stroke) == -1) {
518                 BKE_report(reports, RPT_ERROR, "Stroke not found in grease pencil frame");
519                 return;
520         }
521
522         BLI_freelinkN(&frame->strokes, stroke);
523         RNA_POINTER_INVALIDATE(stroke_ptr);
524
525         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
526 }
527
528 static void rna_GPencil_stroke_select_set(PointerRNA *ptr, const int value)
529 {
530         bGPDstroke *gps = ptr->data;
531         bGPDspoint *pt;
532         int i;
533
534         /* set new value */
535         if (value)
536                 gps->flag |= GP_STROKE_SELECT;
537         else
538                 gps->flag &= ~GP_STROKE_SELECT;
539
540         /* ensure that the stroke's points are selected in the same way */
541         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
542                 if (value)
543                         pt->flag |= GP_SPOINT_SELECT;
544                 else
545                         pt->flag &= ~GP_SPOINT_SELECT;
546         }
547 }
548
549 static bGPDframe *rna_GPencil_frame_new(bGPDlayer *layer, ReportList *reports, int frame_number)
550 {
551         bGPDframe *frame;
552
553         if (BKE_gpencil_layer_find_frame(layer, frame_number)) {
554                 BKE_reportf(reports, RPT_ERROR, "Frame already exists on this frame number %d", frame_number);
555                 return NULL;
556         }
557
558         frame = BKE_gpencil_frame_addnew(layer, frame_number);
559
560         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
561
562         return frame;
563 }
564
565 static void rna_GPencil_frame_remove(bGPDlayer *layer, ReportList *reports, PointerRNA *frame_ptr)
566 {
567         bGPDframe *frame = frame_ptr->data;
568         if (BLI_findindex(&layer->frames, frame) == -1) {
569                 BKE_report(reports, RPT_ERROR, "Frame not found in grease pencil layer");
570                 return;
571         }
572
573         BKE_gpencil_layer_delframe(layer, frame);
574         RNA_POINTER_INVALIDATE(frame_ptr);
575
576         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
577 }
578
579 static bGPDframe *rna_GPencil_frame_copy(bGPDlayer *layer, bGPDframe *src)
580 {
581         bGPDframe *frame = BKE_gpencil_frame_duplicate(src);
582
583         while (BKE_gpencil_layer_find_frame(layer, frame->framenum)) {
584                 frame->framenum++;
585         }
586
587         BLI_addtail(&layer->frames, frame);
588
589         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
590
591         return frame;
592 }
593
594 static bGPDlayer *rna_GPencil_layer_new(bGPdata *gpd, const char *name, bool setactive)
595 {
596         bGPDlayer *gpl = BKE_gpencil_layer_addnew(gpd, name, setactive != 0);
597
598         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
599
600         return gpl;
601 }
602
603 static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, PointerRNA *layer_ptr)
604 {
605         bGPDlayer *layer = layer_ptr->data;
606         if (BLI_findindex(&gpd->layers, layer) == -1) {
607                 BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
608                 return;
609         }
610
611         BKE_gpencil_layer_delete(gpd, layer);
612         RNA_POINTER_INVALIDATE(layer_ptr);
613
614         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
615 }
616
617 static void rna_GPencil_frame_clear(bGPDframe *frame)
618 {
619         BKE_gpencil_free_strokes(frame);
620
621         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
622 }
623
624 static void rna_GPencil_layer_clear(bGPDlayer *layer)
625 {
626         BKE_gpencil_free_frames(layer);
627
628         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
629 }
630
631 static void rna_GPencil_clear(bGPdata *gpd)
632 {
633         BKE_gpencil_free_layers(&gpd->layers);
634
635         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
636 }
637
638 /* Palettes */
639 static bGPDpalette *rna_GPencil_palette_new(bGPdata *gpd, const char *name, bool setactive)
640 {
641         bGPDpalette *palette = BKE_gpencil_palette_addnew(gpd, name, setactive != 0);
642
643         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
644
645         return palette;
646 }
647
648 static void rna_GPencil_palette_remove(bGPdata *gpd, ReportList *reports, PointerRNA *palette_ptr)
649 {
650         bGPDpalette *palette = palette_ptr->data;
651         if (BLI_findindex(&gpd->palettes, palette) == -1) {
652                 BKE_report(reports, RPT_ERROR, "Palette not found in grease pencil data");
653                 return;
654         }
655
656         BKE_gpencil_palette_delete(gpd, palette);
657         RNA_POINTER_INVALIDATE(palette_ptr);
658
659         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
660 }
661
662 static PointerRNA rna_GPencil_active_palette_get(PointerRNA *ptr)
663 {
664         bGPdata *gpd = ptr->id.data;
665
666         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
667                 bGPDpalette *palette;
668
669                 for (palette = gpd->palettes.first; palette; palette = palette->next) {
670                         if (palette->flag & PL_PALETTE_ACTIVE) {
671                                 break;
672                         }
673                 }
674
675                 if (palette) {
676                         return rna_pointer_inherit_refine(ptr, &RNA_GPencilPalette, palette);
677                 }
678         }
679
680         return rna_pointer_inherit_refine(ptr, NULL, NULL);
681 }
682
683 static void rna_GPencil_active_palette_set(PointerRNA *ptr, PointerRNA value)
684 {
685         bGPdata *gpd = ptr->id.data;
686
687         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
688                 bGPDpalette *palette;
689
690                 for (palette = gpd->palettes.first; palette; palette = palette->next) {
691                         if (palette == value.data) {
692                                 palette->flag |= PL_PALETTE_ACTIVE;
693                         }
694                         else {
695                                 palette->flag &= ~PL_PALETTE_ACTIVE;
696                         }
697                 }
698                 /* force color recalc */
699                 BKE_gpencil_palette_change_strokes(gpd);
700
701                 WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
702         }
703 }
704
705 static int rna_GPencilPalette_index_get(PointerRNA *ptr)
706 {
707         bGPdata *gpd = (bGPdata *)ptr->id.data;
708         bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
709
710         return BLI_findindex(&gpd->palettes, palette);
711 }
712
713 static void rna_GPencilPalette_index_set(PointerRNA *ptr, int value)
714 {
715         bGPdata *gpd   = (bGPdata *)ptr->id.data;
716         bGPDpalette *palette = BLI_findlink(&gpd->palettes, value);
717
718         BKE_gpencil_palette_setactive(gpd, palette);
719         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
720 }
721
722 static void rna_GPencilPalette_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
723 {
724         bGPdata *gpd = (bGPdata *)ptr->id.data;
725
726         *min = 0;
727         *max = max_ii(0, BLI_listbase_count(&gpd->palettes) - 1);
728
729         *softmin = *min;
730         *softmax = *max;
731 }
732
733 /* Palette colors */
734 static bGPDpalettecolor *rna_GPencilPalette_color_new(bGPDpalette *palette)
735 {
736         bGPDpalettecolor *color = BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
737
738         return color;
739 }
740
741 static void rna_GPencilPalette_color_remove(bGPDpalette *palette, ReportList *reports, PointerRNA *color_ptr)
742 {
743         bGPDpalettecolor *color = color_ptr->data;
744
745         if (BLI_findindex(&palette->colors, color) == -1) {
746                 BKE_reportf(reports, RPT_ERROR, "Palette '%s' does not contain color given", palette->info + 2);
747                 return;
748         }
749
750         BKE_gpencil_palettecolor_delete(palette, color);
751         RNA_POINTER_INVALIDATE(color_ptr);
752
753         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
754 }
755
756 static PointerRNA rna_GPencilPalette_active_color_get(PointerRNA *ptr)
757 {
758         bGPDpalette *palette = (bGPDpalette *)ptr->data;
759         bGPDpalettecolor *color;
760
761         for (color = palette->colors.first; color; color = color->next) {
762                 if (color->flag & PC_COLOR_ACTIVE) {
763                         break;
764                 }
765         }
766
767         if (color) {
768                 return rna_pointer_inherit_refine(ptr, &RNA_GPencilPaletteColor, color);
769         }
770
771         return rna_pointer_inherit_refine(ptr, NULL, NULL);
772 }
773
774 static void rna_GPencilPalette_active_color_set(PointerRNA *ptr, PointerRNA value)
775 {
776         bGPDpalette *palette = (bGPDpalette *)ptr->data;
777         bGPDpalettecolor *color = value.data;
778
779         BKE_gpencil_palettecolor_setactive(palette, color);
780 }
781
782 static void rna_GPencilPalette_info_set(PointerRNA *ptr, const char *value)
783 {
784         bGPdata *gpd = ptr->id.data;
785         bGPDpalette *palette = ptr->data;
786
787         char oldname[64] = "";
788         BLI_strncpy(oldname, palette->info, sizeof(oldname));
789
790         /* copy the new name into the name slot */
791         BLI_strncpy_utf8(palette->info, value, sizeof(palette->info));
792
793         BLI_uniquename(&gpd->palettes, palette, DATA_("GP_Palette"), '.', offsetof(bGPDpalette, info),
794                        sizeof(palette->info));
795         /* now fix animation paths */
796         BKE_animdata_fix_paths_rename_all(&gpd->id, "palettes", oldname, palette->info);
797 }
798
799 static char *rna_GPencilPalette_path(PointerRNA *ptr)
800 {
801         bGPDpalette *palette = ptr->data;
802         char name_esc[sizeof(palette->info) * 2];
803
804         BLI_strescape(name_esc, palette->info, sizeof(name_esc));
805
806         return BLI_sprintfN("palettes[\"%s\"]", name_esc);
807 }
808
809 static char *rna_GPencilPalette_color_path(PointerRNA *ptr)
810 {
811         bGPdata *gpd = ptr->id.data;
812         bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
813         bGPDpalettecolor *palcolor = ptr->data;
814
815         char name_palette[sizeof(palette->info) * 2];
816         char name_color[sizeof(palcolor->info) * 2];
817
818         BLI_strescape(name_palette, palette->info, sizeof(name_palette));
819         BLI_strescape(name_color, palcolor->info, sizeof(name_color));
820
821         return BLI_sprintfN("palettes[\"%s\"].colors[\"%s\"]", name_palette, name_color);
822 }
823
824 static void rna_GPencilPaletteColor_info_set(PointerRNA *ptr, const char *value)
825 {
826         bGPdata *gpd = ptr->id.data;
827         bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
828         bGPDpalettecolor *palcolor = ptr->data;
829
830         char oldname[64] = "";
831         BLI_strncpy(oldname, palcolor->info, sizeof(oldname));
832
833         /* copy the new name into the name slot */
834         BLI_strncpy_utf8(palcolor->info, value, sizeof(palcolor->info));
835         BLI_uniquename(&palette->colors, palcolor, DATA_("Color"), '.', offsetof(bGPDpalettecolor, info),
836                        sizeof(palcolor->info));
837
838         /* rename all strokes */
839         BKE_gpencil_palettecolor_changename(gpd, oldname, palcolor->info);
840
841         /* now fix animation paths */
842         BKE_animdata_fix_paths_rename_all(&gpd->id, "colors", oldname, palcolor->info);
843 }
844
845 static void rna_GPencilStrokeColor_info_set(PointerRNA *ptr, const char *value)
846 {
847         bGPDstroke *gps = ptr->data;
848
849         /* copy the new name into the name slot */
850         BLI_strncpy_utf8(gps->colorname, value, sizeof(gps->colorname));
851 }
852
853
854 static int rna_GPencilPaletteColor_is_stroke_visible_get(PointerRNA *ptr)
855 {
856         bGPDpalettecolor *pcolor = (bGPDpalettecolor *)ptr->data;
857         return (pcolor->color[3] > GPENCIL_ALPHA_OPACITY_THRESH);
858 }
859
860 static int rna_GPencilPaletteColor_is_fill_visible_get(PointerRNA *ptr)
861 {
862         bGPDpalettecolor *pcolor = (bGPDpalettecolor *)ptr->data;
863         return (pcolor->fill[3] > GPENCIL_ALPHA_OPACITY_THRESH);
864 }
865
866 static int rna_GPencilPaletteColor_index_get(PointerRNA *ptr)
867 {
868         bGPDpalette *palette = (bGPDpalette *)ptr->data;
869         bGPDpalettecolor *pcolor = BKE_gpencil_palettecolor_getactive(palette);
870
871         return BLI_findindex(&palette->colors, pcolor);
872 }
873
874 static void rna_GPencilPaletteColor_index_set(PointerRNA *ptr, int value)
875 {
876         bGPDpalette *palette = (bGPDpalette *)ptr->data;
877         bGPDpalettecolor *pcolor = BLI_findlink(&palette->colors, value);
878         BKE_gpencil_palettecolor_setactive(palette, pcolor);
879 }
880
881 static void rna_GPencilPaletteColor_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
882 {
883         bGPDpalette *palette = (bGPDpalette *)ptr->data;
884
885         *min = 0;
886         *max = max_ii(0, BLI_listbase_count(&palette->colors) - 1);
887
888         *softmin = *min;
889         *softmax = *max;
890 }
891
892 #else
893
894 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
895 {
896         StructRNA *srna;
897         PropertyRNA *prop;
898
899         srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);
900         RNA_def_struct_sdna(srna, "bGPDspoint");
901         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Point", "Data point for freehand stroke curve");
902
903         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
904         RNA_def_property_float_sdna(prop, NULL, "x");
905         RNA_def_property_array(prop, 3);
906         RNA_def_property_ui_text(prop, "Coordinates", "");
907         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
908
909         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
910         RNA_def_property_float_sdna(prop, NULL, "pressure");
911         RNA_def_property_range(prop, 0.0f, 1.0f);
912         RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
913         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
914
915         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
916         RNA_def_property_float_sdna(prop, NULL, "strength");
917         RNA_def_property_range(prop, 0.0f, 1.0f);
918         RNA_def_property_ui_text(prop, "Strength", "Color intensity (alpha factor)");
919         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
920
921         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
922         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SPOINT_SELECT);
923         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_point_select_set");
924         RNA_def_property_ui_text(prop, "Select", "Point is selected for viewport editing");
925         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
926 }
927
928 static void rna_def_gpencil_stroke_points_api(BlenderRNA *brna, PropertyRNA *cprop)
929 {
930         StructRNA *srna;
931         FunctionRNA *func;
932
933         RNA_def_property_srna(cprop, "GPencilStrokePoints");
934         srna = RNA_def_struct(brna, "GPencilStrokePoints", NULL);
935         RNA_def_struct_sdna(srna, "bGPDstroke");
936         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Points", "Collection of grease pencil stroke points");
937
938         func = RNA_def_function(srna, "add", "rna_GPencil_stroke_point_add");
939         RNA_def_function_ui_description(func, "Add a new grease pencil stroke point");
940         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the stroke", 0, INT_MAX);
941         RNA_def_float(func, "pressure", 1.0f, 0.0f, 1.0f, "Pressure", "Pressure for newly created points", 0.0f, 1.0f);
942         RNA_def_float(func, "strength", 1.0f, 0.0f, 1.0f, "Strength", "Color intensity (alpha factor) for newly created points", 0.0f, 1.0f);
943
944         func = RNA_def_function(srna, "pop", "rna_GPencil_stroke_point_pop");
945         RNA_def_function_ui_description(func, "Remove a grease pencil stroke point");
946         RNA_def_function_flag(func, FUNC_USE_REPORTS);
947         RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "Index", "point index", INT_MIN, INT_MAX);
948 }
949
950 /* This information is read only and it can be used by add-ons */
951 static void rna_def_gpencil_triangle(BlenderRNA *brna)
952 {
953         StructRNA *srna;
954         PropertyRNA *prop;
955
956         srna = RNA_def_struct(brna, "GPencilTriangle", NULL);
957         RNA_def_struct_sdna(srna, "bGPDtriangle");
958         RNA_def_struct_ui_text(srna, "Triangle", "Triangulation data for HQ fill");
959
960         /* point v1 */
961         prop = RNA_def_property(srna, "v1", PROP_INT, PROP_NONE);
962         RNA_def_property_int_sdna(prop, NULL, "verts[0]");
963         RNA_def_property_ui_text(prop, "v1", "First triangle vertex index");
964         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
965
966         /* point v2 */
967         prop = RNA_def_property(srna, "v2", PROP_INT, PROP_NONE);
968         RNA_def_property_int_sdna(prop, NULL, "verts[1]");
969         RNA_def_property_ui_text(prop, "v2", "Second triangle vertex index");
970         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
971
972         /* point v3 */
973         prop = RNA_def_property(srna, "v3", PROP_INT, PROP_NONE);
974         RNA_def_property_int_sdna(prop, NULL, "verts[2]");
975         RNA_def_property_ui_text(prop, "v3", "Third triangle vertex index");
976         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
977 }
978
979 static void rna_def_gpencil_stroke(BlenderRNA *brna)
980 {
981         StructRNA *srna;
982         PropertyRNA *prop;
983
984         static const EnumPropertyItem stroke_draw_mode_items[] = {
985                 {0, "SCREEN", 0, "Screen", "Stroke is in screen-space"},
986                 {GP_STROKE_3DSPACE, "3DSPACE", 0, "3D Space", "Stroke is in 3D-space"},
987                 {GP_STROKE_2DSPACE, "2DSPACE", 0, "2D Space", "Stroke is in 2D-space"},
988                 {GP_STROKE_2DIMAGE, "2DIMAGE", 0, "2D Image", "Stroke is in 2D-space (but with special 'image' scaling)"},
989                 {0, NULL, 0, NULL, NULL}
990         };
991
992         srna = RNA_def_struct(brna, "GPencilStroke", NULL);
993         RNA_def_struct_sdna(srna, "bGPDstroke");
994         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke", "Freehand curve defining part of a sketch");
995
996         /* Points */
997         prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
998         RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
999         RNA_def_property_struct_type(prop, "GPencilStrokePoint");
1000         RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
1001         rna_def_gpencil_stroke_points_api(brna, prop);
1002
1003         /* Triangles */
1004         prop = RNA_def_property(srna, "triangles", PROP_COLLECTION, PROP_NONE);
1005         RNA_def_property_collection_sdna(prop, NULL, "triangles", "tot_triangles");
1006         RNA_def_property_struct_type(prop, "GPencilTriangle");
1007         RNA_def_property_ui_text(prop, "Triangles", "Triangulation data for HQ fill");
1008
1009         /* Color */
1010         prop = RNA_def_property(srna, "color", PROP_POINTER, PROP_NONE);
1011         RNA_def_property_struct_type(prop, "GPencilPaletteColor");
1012         RNA_def_property_pointer_sdna(prop, NULL, "palcolor");
1013         RNA_def_property_ui_text(prop, "Palette Color", "Color from palette used in Stroke");
1014         RNA_def_property_update(prop, 0, "rna_GPencil_update");
1015
1016         /* Settings */
1017         prop = RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);
1018         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1019         RNA_def_property_enum_items(prop, stroke_draw_mode_items);
1020         RNA_def_property_ui_text(prop, "Draw Mode", "");
1021         RNA_def_property_update(prop, 0, "rna_GPencil_update");
1022
1023         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1024         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_SELECT);
1025         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_select_set");
1026         RNA_def_property_ui_text(prop, "Select", "Stroke is selected for viewport editing");
1027         RNA_def_property_update(prop, 0, "rna_GPencil_update");
1028
1029         /* Color Name */
1030         prop = RNA_def_property(srna, "colorname", PROP_STRING, PROP_NONE);
1031         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilStrokeColor_info_set");
1032         RNA_def_property_ui_text(prop, "Color Name", "Palette color name");
1033         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_stroke_colorname_update");
1034
1035         /* Cyclic: Draw a line from end to start point */
1036         prop = RNA_def_property(srna, "draw_cyclic", PROP_BOOLEAN, PROP_NONE);
1037         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_CYCLIC);
1038         RNA_def_property_ui_text(prop, "Cyclic", "Enable cyclic drawing, closing the stroke");
1039         RNA_def_property_update(prop, 0, "rna_GPencil_update");
1040
1041         /* Line Thickness */
1042         prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
1043         RNA_def_property_int_sdna(prop, NULL, "thickness");
1044         RNA_def_property_range(prop, 1, 300);
1045         RNA_def_property_ui_range(prop, 1, 10, 1, 0);
1046         RNA_def_property_ui_text(prop, "Thickness", "Thickness of stroke (in pixels)");
1047         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1048
1049 }
1050
1051 static void rna_def_gpencil_strokes_api(BlenderRNA *brna, PropertyRNA *cprop)
1052 {
1053         StructRNA *srna;
1054
1055         FunctionRNA *func;
1056         PropertyRNA *parm;
1057
1058         RNA_def_property_srna(cprop, "GPencilStrokes");
1059         srna = RNA_def_struct(brna, "GPencilStrokes", NULL);
1060         RNA_def_struct_sdna(srna, "bGPDframe");
1061         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil stroke");
1062
1063         func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");
1064         RNA_def_function_ui_description(func, "Add a new grease pencil stroke");
1065         parm = RNA_def_string(func, "colorname", 0, MAX_NAME, "Color", "Name of the color");
1066         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");
1067         RNA_def_function_return(func, parm);
1068
1069         func = RNA_def_function(srna, "remove", "rna_GPencil_stroke_remove");
1070         RNA_def_function_ui_description(func, "Remove a grease pencil stroke");
1071         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1072         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");
1073         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1074         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1075 }
1076
1077 static void rna_def_gpencil_frame(BlenderRNA *brna)
1078 {
1079         StructRNA *srna;
1080         PropertyRNA *prop;
1081
1082         FunctionRNA *func;
1083
1084         srna = RNA_def_struct(brna, "GPencilFrame", NULL);
1085         RNA_def_struct_sdna(srna, "bGPDframe");
1086         RNA_def_struct_ui_text(srna, "Grease Pencil Frame", "Collection of related sketches on a particular frame");
1087
1088         /* Strokes */
1089         prop = RNA_def_property(srna, "strokes", PROP_COLLECTION, PROP_NONE);
1090         RNA_def_property_collection_sdna(prop, NULL, "strokes", NULL);
1091         RNA_def_property_struct_type(prop, "GPencilStroke");
1092         RNA_def_property_ui_text(prop, "Strokes", "Freehand curves defining the sketch on this frame");
1093         rna_def_gpencil_strokes_api(brna, prop);
1094
1095         /* Frame Number */
1096         prop = RNA_def_property(srna, "frame_number", PROP_INT, PROP_NONE);
1097         RNA_def_property_int_sdna(prop, NULL, "framenum");
1098         /* XXX note: this cannot occur on the same frame as another sketch */
1099         RNA_def_property_range(prop, -MAXFRAME, MAXFRAME);
1100         RNA_def_property_ui_text(prop, "Frame Number", "The frame on which this sketch appears");
1101
1102         /* Flags */
1103         prop = RNA_def_property(srna, "is_edited", PROP_BOOLEAN, PROP_NONE);
1104         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_PAINT); /* XXX should it be editable? */
1105         RNA_def_property_ui_text(prop, "Paint Lock", "Frame is being edited (painted on)");
1106
1107         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1108         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_SELECT);
1109         RNA_def_property_ui_text(prop, "Select", "Frame is selected for editing in the Dope Sheet");
1110
1111
1112         /* API */
1113         func = RNA_def_function(srna, "clear", "rna_GPencil_frame_clear");
1114         RNA_def_function_ui_description(func, "Remove all the grease pencil frame data");
1115 }
1116
1117 static void rna_def_gpencil_frames_api(BlenderRNA *brna, PropertyRNA *cprop)
1118 {
1119         StructRNA *srna;
1120
1121         FunctionRNA *func;
1122         PropertyRNA *parm;
1123
1124         RNA_def_property_srna(cprop, "GPencilFrames");
1125         srna = RNA_def_struct(brna, "GPencilFrames", NULL);
1126         RNA_def_struct_sdna(srna, "bGPDlayer");
1127         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil frames");
1128
1129         func = RNA_def_function(srna, "new", "rna_GPencil_frame_new");
1130         RNA_def_function_ui_description(func, "Add a new grease pencil frame");
1131         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1132         parm = RNA_def_int(func, "frame_number", 1, MINAFRAME, MAXFRAME, "Frame Number",
1133                            "The frame on which this sketch appears", MINAFRAME, MAXFRAME);
1134         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1135         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "", "The newly created frame");
1136         RNA_def_function_return(func, parm);
1137
1138         func = RNA_def_function(srna, "remove", "rna_GPencil_frame_remove");
1139         RNA_def_function_ui_description(func, "Remove a grease pencil frame");
1140         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1141         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "Frame", "The frame to remove");
1142         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1143         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1144
1145         func = RNA_def_function(srna, "copy", "rna_GPencil_frame_copy");
1146         RNA_def_function_ui_description(func, "Copy a grease pencil frame");
1147         parm = RNA_def_pointer(func, "source", "GPencilFrame", "Source", "The source frame");
1148         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1149         parm = RNA_def_pointer(func, "copy", "GPencilFrame", "", "The newly copied frame");
1150         RNA_def_function_return(func, parm);
1151 }
1152
1153 static void rna_def_gpencil_layer(BlenderRNA *brna)
1154 {
1155         StructRNA *srna;
1156         PropertyRNA *prop;
1157
1158         FunctionRNA *func;
1159
1160         srna = RNA_def_struct(brna, "GPencilLayer", NULL);
1161         RNA_def_struct_sdna(srna, "bGPDlayer");
1162         RNA_def_struct_ui_text(srna, "Grease Pencil Layer", "Collection of related sketches");
1163         RNA_def_struct_path_func(srna, "rna_GPencilLayer_path");
1164
1165         /* Name */
1166         prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
1167         RNA_def_property_ui_text(prop, "Info", "Layer name");
1168         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_info_set");
1169         RNA_def_struct_name_property(srna, prop);
1170         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_RENAME, NULL);
1171
1172         /* Frames */
1173         prop = RNA_def_property(srna, "frames", PROP_COLLECTION, PROP_NONE);
1174         RNA_def_property_collection_sdna(prop, NULL, "frames", NULL);
1175         RNA_def_property_struct_type(prop, "GPencilFrame");
1176         RNA_def_property_ui_text(prop, "Frames", "Sketches for this layer on different frames");
1177         rna_def_gpencil_frames_api(brna, prop);
1178
1179         /* Active Frame */
1180         prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
1181         RNA_def_property_pointer_sdna(prop, NULL, "actframe");
1182         RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
1183         RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
1184         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1185
1186         /* Draw Style */
1187         // TODO: replace these with a "draw type" combo (i.e. strokes only, filled strokes, strokes + fills, volumetric)?
1188         prop = RNA_def_property(srna, "use_volumetric_strokes", PROP_BOOLEAN, PROP_NONE);
1189         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_VOLUMETRIC);
1190         RNA_def_property_ui_text(prop, "Volumetric Strokes",
1191                                  "Draw strokes as a series of circular blobs, resulting in a volumetric effect");
1192         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1193
1194         prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
1195         RNA_def_property_float_sdna(prop, NULL, "opacity");
1196         RNA_def_property_range(prop, 0.0, 1.0f);
1197         RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
1198         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1199
1200         /* Tint Color */
1201         prop = RNA_def_property(srna, "tint_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1202         RNA_def_property_float_sdna(prop, NULL, "tintcolor");
1203         RNA_def_property_array(prop, 3);
1204         RNA_def_property_range(prop, 0.0f, 1.0f);
1205         RNA_def_property_ui_text(prop, "Tint Color", "Color for tinting stroke colors");
1206         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1207
1208         /* Tint factor */
1209         prop = RNA_def_property(srna, "tint_factor", PROP_FLOAT, PROP_NONE);
1210         RNA_def_property_float_sdna(prop, NULL, "tintcolor[3]");
1211         RNA_def_property_range(prop, 0.0, 1.0f);
1212         RNA_def_property_ui_text(prop, "Tint Factor", "Factor of tinting color");
1213         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1214
1215         /* Line Thickness change */
1216         prop = RNA_def_property(srna, "line_change", PROP_INT, PROP_PIXEL);
1217         RNA_def_property_int_sdna(prop, NULL, "thickness");
1218         //RNA_def_property_range(prop, 1, 10); /* 10 px limit comes from Windows OpenGL limits for natively-drawn strokes */
1219         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_GPencilLayer_line_width_range");
1220         RNA_def_property_ui_text(prop, "Thickness", "Thickness change to apply to current strokes (in pixels)");
1221         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1222
1223         /* Onion-Skinning */
1224         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1225         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ONIONSKIN);
1226         RNA_def_property_ui_text(prop, "Onion Skinning", "Ghost frames on either side of frame");
1227         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_onion_skinning_update");
1228
1229         prop = RNA_def_property(srna, "ghost_before_range", PROP_INT, PROP_NONE);
1230         RNA_def_property_int_sdna(prop, NULL, "gstep");
1231         RNA_def_property_range(prop, -1, 120);
1232         RNA_def_property_ui_text(prop, "Frames Before",
1233                                  "Maximum number of frames to show before current frame "
1234                                  "(0 = show only the previous sketch, -1 = don't show any frames before current)");
1235         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1236
1237         prop = RNA_def_property(srna, "ghost_after_range", PROP_INT, PROP_NONE);
1238         RNA_def_property_int_sdna(prop, NULL, "gstep_next");
1239         RNA_def_property_range(prop, -1, 120);
1240         RNA_def_property_ui_text(prop, "Frames After",
1241                                  "Maximum number of frames to show after current frame "
1242                                  "(0 = show only the next sketch, -1 = don't show any frames after current)");
1243         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1244
1245         prop = RNA_def_property(srna, "use_ghost_custom_colors", PROP_BOOLEAN, PROP_NONE);
1246         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_GHOST_PREVCOL | GP_LAYER_GHOST_NEXTCOL);
1247         RNA_def_property_ui_text(prop, "Use Custom Ghost Colors", "Use custom colors for ghost frames");
1248         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1249
1250         prop = RNA_def_property(srna, "before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1251         RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
1252         RNA_def_property_array(prop, 3);
1253         RNA_def_property_range(prop, 0.0f, 1.0f);
1254         RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
1255         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1256
1257         prop = RNA_def_property(srna, "after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1258         RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
1259         RNA_def_property_array(prop, 3);
1260         RNA_def_property_range(prop, 0.0f, 1.0f);
1261         RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
1262         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1263
1264         prop = RNA_def_property(srna, "use_ghosts_always", PROP_BOOLEAN, PROP_NONE);
1265         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_GHOST_ALWAYS);
1266         RNA_def_property_ui_text(prop, "Always Show Ghosts",
1267                                  "Ghosts are shown in renders and animation playback. Useful for special effects (e.g. motion blur)");
1268         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1269
1270
1271         /* Flags */
1272         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1273         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
1274         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
1275         RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
1276         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1277
1278         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1279         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_LOCKED);
1280         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1281         RNA_def_property_ui_text(prop, "Locked", "Protect layer from further editing and/or frame changes");
1282         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1283
1284         prop = RNA_def_property(srna, "lock_frame", PROP_BOOLEAN, PROP_NONE);
1285         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_FRAMELOCK);
1286         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1287         RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
1288         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1289
1290         /* Unlock colors */
1291         prop = RNA_def_property(srna, "unlock_color", PROP_BOOLEAN, PROP_NONE);
1292         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_UNLOCK_COLOR);
1293         RNA_def_property_ui_icon(prop, ICON_RESTRICT_COLOR_OFF, 1);
1294         RNA_def_property_ui_text(prop, "Unlock Color",
1295                                  "Unprotect selected colors from further editing and/or frame changes");
1296         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1297
1298
1299         /* expose as layers.active */
1300 #if 0
1301         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1302         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
1303         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
1304         RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
1305         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1306 #endif
1307
1308         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1309         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
1310         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the Dope Sheet");
1311         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, "rna_GPencil_update");
1312
1313         /* XXX keep this option? */
1314         prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
1315         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
1316         RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
1317         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1318
1319         /* X-Ray */
1320         prop = RNA_def_property(srna, "show_x_ray", PROP_BOOLEAN, PROP_NONE);
1321         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
1322         RNA_def_property_ui_text(prop, "X Ray", "Make the layer draw in front of objects");
1323         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1324
1325         /* Parent object */
1326         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
1327         RNA_def_property_pointer_funcs(prop, NULL, "rna_GPencilLayer_parent_set", NULL, NULL);
1328         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1329         RNA_def_property_ui_text(prop, "Parent", "Parent Object");
1330         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1331
1332         /* parent type */
1333         prop = RNA_def_property(srna, "parent_type", PROP_ENUM, PROP_NONE);
1334         RNA_def_property_enum_bitflag_sdna(prop, NULL, "partype");
1335         RNA_def_property_enum_items(prop, parent_type_items);
1336         RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilLayer_parent_type_set", "rna_Object_parent_type_itemf");
1337         RNA_def_property_ui_text(prop, "Parent Type", "Type of parent relation");
1338         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1339
1340         /* parent bone */
1341         prop = RNA_def_property(srna, "parent_bone", PROP_STRING, PROP_NONE);
1342         RNA_def_property_string_sdna(prop, NULL, "parsubstr");
1343         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_parent_bone_set");
1344         RNA_def_property_ui_text(prop, "Parent Bone", "Name of parent bone in case of a bone parenting relation");
1345         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1346
1347         /* matrix */
1348         prop = RNA_def_property(srna, "matrix_inverse", PROP_FLOAT, PROP_MATRIX);
1349         RNA_def_property_float_sdna(prop, NULL, "inverse");
1350         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1351         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1352         RNA_def_property_ui_text(prop, "Inverse Matrix", "Parent inverse transformation matrix");
1353         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1354
1355         /* read only parented flag */
1356         prop = RNA_def_property(srna, "is_parented", PROP_BOOLEAN, PROP_NONE);
1357         RNA_def_property_boolean_funcs(prop, "rna_GPencilLayer_is_parented_get", NULL);
1358         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1359         RNA_def_property_ui_text(prop, "Is Parented", "True when the layer parent object is set");
1360
1361         /* Layers API */
1362         func = RNA_def_function(srna, "clear", "rna_GPencil_layer_clear");
1363         RNA_def_function_ui_description(func, "Remove all the grease pencil layer data");
1364 }
1365
1366 static void rna_def_gpencil_layers_api(BlenderRNA *brna, PropertyRNA *cprop)
1367 {
1368         StructRNA *srna;
1369         PropertyRNA *prop;
1370
1371         FunctionRNA *func;
1372         PropertyRNA *parm;
1373
1374         RNA_def_property_srna(cprop, "GreasePencilLayers");
1375         srna = RNA_def_struct(brna, "GreasePencilLayers", NULL);
1376         RNA_def_struct_sdna(srna, "bGPdata");
1377         RNA_def_struct_ui_text(srna, "Grease Pencil Layers", "Collection of grease pencil layers");
1378
1379         func = RNA_def_function(srna, "new", "rna_GPencil_layer_new");
1380         RNA_def_function_ui_description(func, "Add a new grease pencil layer");
1381         parm = RNA_def_string(func, "name", "GPencilLayer", MAX_NAME, "Name", "Name of the layer");
1382         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1383         RNA_def_boolean(func, "set_active", true, "Set Active", "Set the newly created layer to the active layer");
1384         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The newly created layer");
1385         RNA_def_function_return(func, parm);
1386
1387         func = RNA_def_function(srna, "remove", "rna_GPencil_layer_remove");
1388         RNA_def_function_ui_description(func, "Remove a grease pencil layer");
1389         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1390         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to remove");
1391         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1392         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1393
1394         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1395         RNA_def_property_struct_type(prop, "GPencilLayer");
1396         RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_layer_get", "rna_GPencil_active_layer_set", NULL, NULL);
1397         RNA_def_property_flag(prop, PROP_EDITABLE);
1398         RNA_def_property_ui_text(prop, "Active Layer", "Active grease pencil layer");
1399         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1400
1401         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1402         RNA_def_property_int_funcs(prop,
1403                                    "rna_GPencil_active_layer_index_get",
1404                                    "rna_GPencil_active_layer_index_set",
1405                                    "rna_GPencil_active_layer_index_range");
1406         RNA_def_property_ui_text(prop, "Active Layer Index", "Index of active grease pencil layer");
1407         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1408 }
1409
1410 static void rna_def_gpencil_palettecolor(BlenderRNA *brna)
1411 {
1412         StructRNA *srna;
1413         PropertyRNA *prop;
1414
1415         srna = RNA_def_struct(brna, "GPencilPaletteColor", NULL);
1416         RNA_def_struct_sdna(srna, "bGPDpalettecolor");
1417         RNA_def_struct_ui_text(srna, "Grease Pencil Palette color", "Collection of related colors");
1418         RNA_def_struct_path_func(srna, "rna_GPencilPalette_color_path");
1419
1420         /* Stroke Drawing Color */
1421         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1422         RNA_def_property_float_sdna(prop, NULL, "color");
1423         RNA_def_property_array(prop, 3);
1424         RNA_def_property_range(prop, 0.0f, 1.0f);
1425         RNA_def_property_ui_text(prop, "Color", "Color for strokes");
1426         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1427
1428         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
1429         RNA_def_property_float_sdna(prop, NULL, "color[3]");
1430         RNA_def_property_range(prop, 0.0, 1.0f);
1431         RNA_def_property_ui_text(prop, "Opacity", "Color Opacity");
1432         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1433
1434         /* Name */
1435         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1436         RNA_def_property_string_sdna(prop, NULL, "info");
1437         RNA_def_property_ui_text(prop, "Name", "Color name");
1438         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilPaletteColor_info_set");
1439         RNA_def_struct_name_property(srna, prop);
1440         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1441
1442         /* Fill Drawing Color */
1443         prop = RNA_def_property(srna, "fill_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1444         RNA_def_property_float_sdna(prop, NULL, "fill");
1445         RNA_def_property_array(prop, 3);
1446         RNA_def_property_range(prop, 0.0f, 1.0f);
1447         RNA_def_property_ui_text(prop, "Fill Color", "Color for filling region bounded by each stroke");
1448         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1449
1450         /* Fill alpha */
1451         prop = RNA_def_property(srna, "fill_alpha", PROP_FLOAT, PROP_NONE);
1452         RNA_def_property_float_sdna(prop, NULL, "fill[3]");
1453         RNA_def_property_range(prop, 0.0, 1.0f);
1454         RNA_def_property_ui_text(prop, "Fill Opacity", "Opacity for filling region bounded by each stroke");
1455         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1456
1457         /* Flags */
1458         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1459         RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_HIDE);
1460         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
1461         RNA_def_property_ui_text(prop, "Hide", "Set color Visibility");
1462         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1463
1464         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1465         RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_LOCKED);
1466         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1467         RNA_def_property_ui_text(prop, "Locked", "Protect color from further editing and/or frame changes");
1468         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1469
1470         prop = RNA_def_property(srna, "ghost", PROP_BOOLEAN, PROP_NONE);
1471         RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_ONIONSKIN);
1472         RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
1473         RNA_def_property_ui_text(prop, "Show in Ghosts", "Display strokes using this color when showing onion skins");
1474         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1475
1476         /* Draw Style */
1477         prop = RNA_def_property(srna, "use_volumetric_strokes", PROP_BOOLEAN, PROP_NONE);
1478         RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_VOLUMETRIC);
1479         RNA_def_property_ui_text(prop, "Volumetric Strokes", "Draw strokes as a series of circular blobs, resulting in "
1480                                  "a volumetric effect");
1481         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1482
1483         /* Use High quality fill */
1484         prop = RNA_def_property(srna, "use_hq_fill", PROP_BOOLEAN, PROP_NONE);
1485         RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_HQ_FILL);
1486         RNA_def_property_ui_text(prop, "High Quality Fill", "Fill strokes using high quality to avoid glitches "
1487                                  "(slower fps during animation play)");
1488         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1489
1490         /* Read-only state props (for simpler UI code) */
1491         prop = RNA_def_property(srna, "is_stroke_visible", PROP_BOOLEAN, PROP_NONE);
1492         RNA_def_property_boolean_funcs(prop, "rna_GPencilPaletteColor_is_stroke_visible_get", NULL);
1493         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1494         RNA_def_property_ui_text(prop, "Is Stroke Visible", "True when opacity of stroke is set high enough to be visible");
1495
1496         prop = RNA_def_property(srna, "is_fill_visible", PROP_BOOLEAN, PROP_NONE);
1497         RNA_def_property_boolean_funcs(prop, "rna_GPencilPaletteColor_is_fill_visible_get", NULL);
1498         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1499         RNA_def_property_ui_text(prop, "Is Fill Visible", "True when opacity of fill is set high enough to be visible");
1500 }
1501
1502 /* palette colors api */
1503 static void rna_def_gpencil_palettecolors_api(BlenderRNA *brna, PropertyRNA *cprop)
1504 {
1505         StructRNA *srna;
1506         PropertyRNA *prop;
1507
1508         FunctionRNA *func;
1509         PropertyRNA *parm;
1510
1511         RNA_def_property_srna(cprop, "GPencilPaletteColors");
1512         srna = RNA_def_struct(brna, "GPencilPaletteColors", NULL);
1513         RNA_def_struct_sdna(srna, "bGPDpalette");
1514         RNA_def_struct_ui_text(srna, "Palette colors", "Collection of palette colors");
1515
1516         func = RNA_def_function(srna, "new", "rna_GPencilPalette_color_new");
1517         RNA_def_function_ui_description(func, "Add a new color to the palette");
1518         parm = RNA_def_pointer(func, "color", "GPencilPaletteColor", "", "The newly created color");
1519         RNA_def_function_return(func, parm);
1520
1521         func = RNA_def_function(srna, "remove", "rna_GPencilPalette_color_remove");
1522         RNA_def_function_ui_description(func, "Remove a color from the palette");
1523         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1524         parm = RNA_def_pointer(func, "color", "GPencilPaletteColor", "", "The color to remove");
1525         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1526         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1527
1528         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1529         RNA_def_property_struct_type(prop, "GPencilPaletteColor");
1530         RNA_def_property_pointer_funcs(prop, "rna_GPencilPalette_active_color_get", "rna_GPencilPalette_active_color_set", NULL, NULL);
1531         RNA_def_property_flag(prop, PROP_EDITABLE);
1532         RNA_def_property_ui_text(prop, "Active Palette Color", "Current active color");
1533
1534         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1535         RNA_def_property_int_funcs(prop,
1536                 "rna_GPencilPaletteColor_index_get",
1537                 "rna_GPencilPaletteColor_index_set",
1538                 "rna_GPencilPaletteColor_index_range");
1539         RNA_def_property_ui_text(prop, "Active color Index", "Index of active palette color");
1540 }
1541
1542 static void rna_def_gpencil_palette(BlenderRNA *brna)
1543 {
1544         StructRNA *srna;
1545         PropertyRNA *prop;
1546
1547         srna = RNA_def_struct(brna, "GPencilPalette", NULL);
1548         RNA_def_struct_sdna(srna, "bGPDpalette");
1549         RNA_def_struct_ui_text(srna, "Grease Pencil Palette", "Collection of related palettes");
1550         RNA_def_struct_path_func(srna, "rna_GPencilPalette_path");
1551         RNA_def_struct_ui_icon(srna, ICON_COLOR);
1552
1553         /* Name */
1554         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1555         RNA_def_property_string_sdna(prop, NULL, "info");
1556         RNA_def_property_ui_text(prop, "Name", "Palette name");
1557         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilPalette_info_set");
1558         RNA_def_struct_name_property(srna, prop);
1559         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1560
1561         /* Colors */
1562         prop = RNA_def_property(srna, "colors", PROP_COLLECTION, PROP_NONE);
1563         RNA_def_property_collection_sdna(prop, NULL, "colors", NULL);
1564         RNA_def_property_struct_type(prop, "GPencilPaletteColor");
1565         RNA_def_property_ui_text(prop, "Colors", "Colors of the palette");
1566         rna_def_gpencil_palettecolors_api(brna, prop);
1567
1568 }
1569
1570 static void rna_def_gpencil_palettes_api(BlenderRNA *brna, PropertyRNA *cprop)
1571 {
1572         StructRNA *srna;
1573         PropertyRNA *prop;
1574
1575         FunctionRNA *func;
1576         PropertyRNA *parm;
1577
1578         RNA_def_property_srna(cprop, "GreasePencilPalettes");
1579         srna = RNA_def_struct(brna, "GreasePencilPalettes", NULL);
1580         RNA_def_struct_sdna(srna, "bGPdata");
1581         RNA_def_struct_ui_text(srna, "Grease Pencil Palettes", "Collection of grease pencil palettes");
1582
1583         func = RNA_def_function(srna, "new", "rna_GPencil_palette_new");
1584         RNA_def_function_ui_description(func, "Add a new grease pencil palette");
1585         parm = RNA_def_string(func, "name", "GPencilPalette", MAX_NAME, "Name", "Name of the palette");
1586         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1587         RNA_def_boolean(func, "set_active", true, "Set Active", "Activate the newly created palette");
1588         parm = RNA_def_pointer(func, "palette", "GPencilPalette", "", "The newly created palette");
1589         RNA_def_function_return(func, parm);
1590
1591         func = RNA_def_function(srna, "remove", "rna_GPencil_palette_remove");
1592         RNA_def_function_ui_description(func, "Remove a grease pencil palette");
1593         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1594         parm = RNA_def_pointer(func, "palette", "GPencilPalette", "", "The palette to remove");
1595         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1596         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1597
1598         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1599         RNA_def_property_struct_type(prop, "GPencilPalette");
1600         RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_palette_get", "rna_GPencil_active_palette_set",
1601                                        NULL, NULL);
1602         RNA_def_property_flag(prop, PROP_EDITABLE);
1603         RNA_def_property_ui_text(prop, "Active Palette", "Current active palette");
1604
1605         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1606         RNA_def_property_int_funcs(prop,
1607                 "rna_GPencilPalette_index_get",
1608                 "rna_GPencilPalette_index_set",
1609                 "rna_GPencilPalette_index_range");
1610         RNA_def_property_ui_text(prop, "Active Palette Index", "Index of active palette");
1611 }
1612
1613 static void rna_def_gpencil_data(BlenderRNA *brna)
1614 {
1615         StructRNA *srna;
1616         PropertyRNA *prop;
1617         FunctionRNA *func;
1618
1619         srna = RNA_def_struct(brna, "GreasePencil", "ID");
1620         RNA_def_struct_sdna(srna, "bGPdata");
1621         RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
1622         RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);
1623
1624         /* Layers */
1625         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
1626         RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
1627         RNA_def_property_struct_type(prop, "GPencilLayer");
1628         RNA_def_property_ui_text(prop, "Layers", "");
1629         rna_def_gpencil_layers_api(brna, prop);
1630
1631         /* Palettes */
1632         prop = RNA_def_property(srna, "palettes", PROP_COLLECTION, PROP_NONE);
1633         RNA_def_property_collection_sdna(prop, NULL, "palettes", NULL);
1634         RNA_def_property_struct_type(prop, "GPencilPalette");
1635         RNA_def_property_ui_text(prop, "Palettes", "");
1636         rna_def_gpencil_palettes_api(brna, prop);
1637
1638         /* Animation Data */
1639         rna_def_animdata_common(srna);
1640
1641         /* Flags */
1642         prop = RNA_def_property(srna, "use_stroke_edit_mode", PROP_BOOLEAN, PROP_NONE);
1643         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_EDITMODE);
1644         RNA_def_property_ui_text(prop, "Stroke Edit Mode", "Edit Grease Pencil strokes instead of viewport data");
1645         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1646
1647         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1648         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_ONIONSKINS);
1649         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_use_onion_skinning_set");
1650         RNA_def_property_ui_text(prop, "Onion Skins",
1651                                  "Show ghosts of the frames before and after the current frame, toggle to enable on active layer or disable all");
1652         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1653
1654         prop = RNA_def_property(srna, "show_stroke_direction", PROP_BOOLEAN, PROP_NONE);
1655         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_DIRECTION);
1656         RNA_def_property_ui_text(prop, "Show Direction", "Show stroke drawing direction with a bigger green dot (start) "
1657                                  "and smaller red dot (end) points");
1658         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1659
1660         /* API Functions */
1661         func = RNA_def_function(srna, "clear", "rna_GPencil_clear");
1662         RNA_def_function_ui_description(func, "Remove all the grease pencil data");
1663 }
1664
1665 /* --- */
1666
1667 void RNA_def_gpencil(BlenderRNA *brna)
1668 {
1669         rna_def_gpencil_data(brna);
1670
1671         rna_def_gpencil_layer(brna);
1672         rna_def_gpencil_frame(brna);
1673         rna_def_gpencil_triangle(brna);
1674         rna_def_gpencil_stroke(brna);
1675         rna_def_gpencil_stroke_point(brna);
1676
1677         rna_def_gpencil_palette(brna);
1678         rna_def_gpencil_palettecolor(brna);
1679 }
1680
1681 #endif