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