GPencil: Keep Options panels open by default
[blender.git] / source / blender / makesrna / intern / rna_gpencil.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22
23 #include "BLI_math.h"
24
25 #include "DNA_meshdata_types.h"
26 #include "DNA_gpencil_types.h"
27 #include "DNA_scene_types.h"
28 #include "DNA_brush_types.h"
29 #include "DNA_object_types.h"
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_utildefines.h"
34
35 #include "BLT_translation.h"
36
37 #include "RNA_access.h"
38 #include "RNA_define.h"
39 #include "RNA_enum_types.h"
40
41 #include "rna_internal.h"
42
43 #include "WM_types.h"
44
45 /* parent type */
46 static const EnumPropertyItem parent_type_items[] = {
47     {PAROBJECT, "OBJECT", 0, "Object", "The layer is parented to an object"},
48     {PARSKEL, "ARMATURE", 0, "Armature", ""},
49     {PARBONE, "BONE", 0, "Bone", "The layer is parented to a bone"},
50     {0, NULL, 0, NULL, NULL},
51 };
52
53 #ifndef RNA_RUNTIME
54 static EnumPropertyItem rna_enum_gpencil_stroke_depth_order_items[] = {
55     {GP_DRAWMODE_2D,
56      "2D",
57      0,
58      "2D Layers",
59      "Display strokes using grease pencil layers to define order"},
60     {GP_DRAWMODE_3D, "3D", 0, "3D Location", "Display strokes using real 3D position in 3D space"},
61     {0, NULL, 0, NULL, NULL},
62 };
63
64 static EnumPropertyItem rna_enum_gpencil_onion_modes_items[] = {
65     {GP_ONION_MODE_ABSOLUTE,
66      "ABSOLUTE",
67      0,
68      "Frames",
69      "Frames in absolute range of the scene frame"},
70     {GP_ONION_MODE_RELATIVE,
71      "RELATIVE",
72      0,
73      "Keyframes",
74      "Frames in relative range of the Grease Pencil keyframes"},
75     {GP_ONION_MODE_SELECTED, "SELECTED", 0, "Selected", "Only selected keyframes"},
76     {0, NULL, 0, NULL, NULL},
77 };
78
79 static const EnumPropertyItem rna_enum_onion_keyframe_type_items[] = {
80     {-1, "ALL", ICON_ACTION, "All Types", "Include all Keyframe types"},
81     {BEZT_KEYTYPE_KEYFRAME,
82      "KEYFRAME",
83      ICON_KEYTYPE_KEYFRAME_VEC,
84      "Keyframe",
85      "Normal keyframe - e.g. for key poses"},
86     {BEZT_KEYTYPE_BREAKDOWN,
87      "BREAKDOWN",
88      ICON_KEYTYPE_BREAKDOWN_VEC,
89      "Breakdown",
90      "A breakdown pose - e.g. for transitions between key poses"},
91     {BEZT_KEYTYPE_MOVEHOLD,
92      "MOVING_HOLD",
93      ICON_KEYTYPE_MOVING_HOLD_VEC,
94      "Moving Hold",
95      "A keyframe that is part of a moving hold"},
96     {BEZT_KEYTYPE_EXTREME,
97      "EXTREME",
98      ICON_KEYTYPE_EXTREME_VEC,
99      "Extreme",
100      "An 'extreme' pose, or some other purpose as needed"},
101     {BEZT_KEYTYPE_JITTER,
102      "JITTER",
103      ICON_KEYTYPE_JITTER_VEC,
104      "Jitter",
105      "A filler or baked keyframe for keying on ones, or some other purpose as needed"},
106     {0, NULL, 0, NULL, NULL},
107 };
108
109 static const EnumPropertyItem rna_enum_gplayer_move_type_items[] = {
110     {-1, "UP", 0, "Up", ""},
111     {1, "DOWN", 0, "Down", ""},
112     {0, NULL, 0, NULL, NULL},
113 };
114
115 static const EnumPropertyItem rna_enum_layer_blend_modes_items[] = {
116     {eGplBlendMode_Regular, "REGULAR", 0, "Regular", ""},
117     {eGplBlendMode_Overlay, "OVERLAY", 0, "Overlay", ""},
118     {eGplBlendMode_Add, "ADD", 0, "Add", ""},
119     {eGplBlendMode_Subtract, "SUBTRACT", 0, "Subtract", ""},
120     {eGplBlendMode_Multiply, "MULTIPLY", 0, "Multiply", ""},
121     {eGplBlendMode_Divide, "DIVIDE", 0, "Divide", ""},
122     {0, NULL, 0, NULL, NULL}};
123
124 static EnumPropertyItem rna_enum_gpencil_caps_modes_items[] = {
125     {GP_STROKE_CAP_ROUND, "ROUND", 0, "Rounded", ""},
126     {GP_STROKE_CAP_FLAT, "FLAT", 0, "Flat", ""},
127     {0, NULL, 0, NULL, NULL},
128 };
129 #endif
130
131 #ifdef RNA_RUNTIME
132
133 #  include "BLI_ghash.h"
134 #  include "BLI_string_utils.h"
135
136 #  include "WM_api.h"
137
138 #  include "BKE_action.h"
139 #  include "BKE_animsys.h"
140 #  include "BKE_gpencil.h"
141 #  include "BKE_icons.h"
142
143 #  include "DEG_depsgraph.h"
144
145 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
146 {
147   DEG_id_tag_update(ptr->owner_id, ID_RECALC_GEOMETRY);
148   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
149 }
150
151 static void rna_GPencil_autolock(Main *bmain, Scene *scene, PointerRNA *ptr)
152 {
153   bGPdata *gpd = (bGPdata *)ptr->owner_id;
154   BKE_gpencil_layer_autolock_set(gpd, true);
155
156   /* standard update */
157   rna_GPencil_update(bmain, scene, ptr);
158 }
159
160 static void rna_GPencil_editmode_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
161 {
162   bGPdata *gpd = (bGPdata *)ptr->owner_id;
163   DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
164
165   /* Notify all places where GPencil data lives that the editing state is different */
166   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
167   WM_main_add_notifier(NC_SCENE | ND_MODE | NC_MOVIECLIP, NULL);
168 }
169
170 static void UNUSED_FUNCTION(rna_GPencil_onion_skinning_update)(Main *bmain,
171                                                                Scene *scene,
172                                                                PointerRNA *ptr)
173 {
174   bGPdata *gpd = (bGPdata *)ptr->owner_id;
175   bGPDlayer *gpl;
176   bool enabled = false;
177
178   /* Ensure that the data-block's onion-skinning toggle flag
179    * stays in sync with the status of the actual layers
180    */
181   for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
182     if (gpl->onion_flag & GP_LAYER_ONIONSKIN) {
183       enabled = true;
184     }
185   }
186
187   if (enabled) {
188     gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
189   }
190   else {
191     gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
192   }
193
194   /* Now do standard updates... */
195   rna_GPencil_update(bmain, scene, ptr);
196 }
197
198 /* Poll Callback to filter GP Datablocks to only show those for Annotations */
199 bool rna_GPencil_datablocks_annotations_poll(PointerRNA *UNUSED(ptr), const PointerRNA value)
200 {
201   bGPdata *gpd = value.data;
202   return (gpd->flag & GP_DATA_ANNOTATIONS) != 0;
203 }
204
205 /* Poll Callback to filter GP Datablocks to only show those for GP Objects */
206 bool rna_GPencil_datablocks_obdata_poll(PointerRNA *UNUSED(ptr), const PointerRNA value)
207 {
208   bGPdata *gpd = value.data;
209   return (gpd->flag & GP_DATA_ANNOTATIONS) == 0;
210 }
211
212 static char *rna_GPencilLayer_path(PointerRNA *ptr)
213 {
214   bGPDlayer *gpl = (bGPDlayer *)ptr->data;
215   char name_esc[sizeof(gpl->info) * 2];
216
217   BLI_strescape(name_esc, gpl->info, sizeof(name_esc));
218
219   return BLI_sprintfN("layers[\"%s\"]", name_esc);
220 }
221
222 static int rna_GPencilLayer_active_frame_editable(PointerRNA *ptr, const char **UNUSED(r_info))
223 {
224   bGPDlayer *gpl = (bGPDlayer *)ptr->data;
225
226   /* surely there must be other criteria too... */
227   if (gpl->flag & GP_LAYER_LOCKED) {
228     return 0;
229   }
230   else {
231     return PROP_EDITABLE;
232   }
233 }
234
235 /* set parent */
236 static void set_parent(bGPDlayer *gpl, Object *par, const int type, const char *substr)
237 {
238   if (type == PAROBJECT) {
239     invert_m4_m4(gpl->inverse, par->obmat);
240     gpl->parent = par;
241     gpl->partype |= PAROBJECT;
242     gpl->parsubstr[0] = 0;
243   }
244   else if (type == PARSKEL) {
245     invert_m4_m4(gpl->inverse, par->obmat);
246     gpl->parent = par;
247     gpl->partype |= PARSKEL;
248     gpl->parsubstr[0] = 0;
249   }
250   else if (type == PARBONE) {
251     bPoseChannel *pchan = BKE_pose_channel_find_name(par->pose, substr);
252     if (pchan) {
253       float tmp_mat[4][4];
254       mul_m4_m4m4(tmp_mat, par->obmat, pchan->pose_mat);
255
256       invert_m4_m4(gpl->inverse, tmp_mat);
257       gpl->parent = par;
258       gpl->partype |= PARBONE;
259       BLI_strncpy(gpl->parsubstr, substr, sizeof(gpl->parsubstr));
260     }
261   }
262 }
263
264 /* set parent object and inverse matrix */
265 static void rna_GPencilLayer_parent_set(PointerRNA *ptr,
266                                         PointerRNA value,
267                                         struct ReportList *UNUSED(reports))
268 {
269   bGPDlayer *gpl = (bGPDlayer *)ptr->data;
270   Object *par = (Object *)value.data;
271
272   if (par != NULL) {
273     set_parent(gpl, par, gpl->partype, gpl->parsubstr);
274   }
275   else {
276     /* clear parent */
277     gpl->parent = NULL;
278   }
279 }
280
281 /* set parent type */
282 static void rna_GPencilLayer_parent_type_set(PointerRNA *ptr, int value)
283 {
284   bGPDlayer *gpl = (bGPDlayer *)ptr->data;
285   Object *par = gpl->parent;
286   gpl->partype = value;
287
288   if (par != NULL) {
289     set_parent(gpl, par, value, gpl->parsubstr);
290   }
291 }
292
293 /* set parent bone */
294 static void rna_GPencilLayer_parent_bone_set(PointerRNA *ptr, const char *value)
295 {
296   bGPDlayer *gpl = (bGPDlayer *)ptr->data;
297
298   Object *par = gpl->parent;
299   gpl->partype = PARBONE;
300
301   if (par != NULL) {
302     set_parent(gpl, par, gpl->partype, value);
303   }
304 }
305
306 /* parent types enum */
307 static const EnumPropertyItem *rna_Object_parent_type_itemf(bContext *UNUSED(C),
308                                                             PointerRNA *ptr,
309                                                             PropertyRNA *UNUSED(prop),
310                                                             bool *r_free)
311 {
312   bGPDlayer *gpl = (bGPDlayer *)ptr->data;
313   EnumPropertyItem *item = NULL;
314   int totitem = 0;
315
316   RNA_enum_items_add_value(&item, &totitem, parent_type_items, PAROBJECT);
317
318   if (gpl->parent) {
319     Object *par = gpl->parent;
320
321     if (par->type == OB_ARMATURE) {
322       /* special hack: prevents this being overridden */
323       RNA_enum_items_add_value(&item, &totitem, &parent_type_items[1], PARSKEL);
324       RNA_enum_items_add_value(&item, &totitem, parent_type_items, PARBONE);
325     }
326   }
327
328   RNA_enum_item_end(&item, &totitem);
329   *r_free = true;
330
331   return item;
332 }
333
334 static bool rna_GPencilLayer_is_parented_get(PointerRNA *ptr)
335 {
336   bGPDlayer *gpl = (bGPDlayer *)ptr->data;
337   return (gpl->parent != NULL);
338 }
339
340 static PointerRNA rna_GPencil_active_layer_get(PointerRNA *ptr)
341 {
342   bGPdata *gpd = (bGPdata *)ptr->owner_id;
343
344   if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
345     bGPDlayer *gl;
346
347     for (gl = gpd->layers.first; gl; gl = gl->next) {
348       if (gl->flag & GP_LAYER_ACTIVE) {
349         break;
350       }
351     }
352
353     if (gl) {
354       return rna_pointer_inherit_refine(ptr, &RNA_GPencilLayer, gl);
355     }
356   }
357
358   return rna_pointer_inherit_refine(ptr, NULL, NULL);
359 }
360
361 static void rna_GPencil_active_layer_set(PointerRNA *ptr,
362                                          PointerRNA value,
363                                          struct ReportList *UNUSED(reports))
364 {
365   bGPdata *gpd = (bGPdata *)ptr->owner_id;
366
367   /* Don't allow setting active layer to NULL if layers exist
368    * as this breaks various tools. Tools should be used instead
369    * if it's necessary to remove layers
370    */
371   if (value.data == NULL) {
372     printf("%s: Setting active layer to None is not allowed\n", __func__);
373     return;
374   }
375
376   if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
377     bGPDlayer *gl;
378
379     for (gl = gpd->layers.first; gl; gl = gl->next) {
380       if (gl == value.data) {
381         gl->flag |= GP_LAYER_ACTIVE;
382       }
383       else {
384         gl->flag &= ~GP_LAYER_ACTIVE;
385       }
386     }
387
388     WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
389   }
390 }
391
392 static int rna_GPencil_active_layer_index_get(PointerRNA *ptr)
393 {
394   bGPdata *gpd = (bGPdata *)ptr->owner_id;
395   bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
396
397   return BLI_findindex(&gpd->layers, gpl);
398 }
399
400 static void rna_GPencil_active_layer_index_set(PointerRNA *ptr, int value)
401 {
402   bGPdata *gpd = (bGPdata *)ptr->owner_id;
403   bGPDlayer *gpl = BLI_findlink(&gpd->layers, value);
404
405   BKE_gpencil_layer_setactive(gpd, gpl);
406
407   /* Now do standard updates... */
408   DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
409   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED | ND_SPACE_PROPERTIES, NULL);
410 }
411
412 static void rna_GPencil_active_layer_index_range(
413     PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
414 {
415   bGPdata *gpd = (bGPdata *)ptr->owner_id;
416
417   *min = 0;
418   *max = max_ii(0, BLI_listbase_count(&gpd->layers) - 1);
419
420   *softmin = *min;
421   *softmax = *max;
422 }
423
424 static const EnumPropertyItem *rna_GPencil_active_layer_itemf(bContext *C,
425                                                               PointerRNA *ptr,
426                                                               PropertyRNA *UNUSED(prop),
427                                                               bool *r_free)
428 {
429   bGPdata *gpd = (bGPdata *)ptr->owner_id;
430   bGPDlayer *gpl;
431   EnumPropertyItem *item = NULL, item_tmp = {0};
432   int totitem = 0;
433   int i = 0;
434
435   if (ELEM(NULL, C, gpd)) {
436     return DummyRNA_NULL_items;
437   }
438
439   /* Existing layers */
440   for (gpl = gpd->layers.first, i = 0; gpl; gpl = gpl->next, i++) {
441     item_tmp.identifier = gpl->info;
442     item_tmp.name = gpl->info;
443     item_tmp.value = i;
444
445     item_tmp.icon = BKE_icon_gplayer_color_ensure(gpl);
446
447     RNA_enum_item_add(&item, &totitem, &item_tmp);
448   }
449
450   RNA_enum_item_end(&item, &totitem);
451   *r_free = true;
452
453   return item;
454 }
455
456 static void rna_GPencilLayer_info_set(PointerRNA *ptr, const char *value)
457 {
458   bGPdata *gpd = (bGPdata *)ptr->owner_id;
459   bGPDlayer *gpl = ptr->data;
460
461   char oldname[128] = "";
462   BLI_strncpy(oldname, gpl->info, sizeof(oldname));
463
464   /* copy the new name into the name slot */
465   BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));
466
467   BLI_uniquename(
468       &gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
469
470   /* now fix animation paths */
471   BKE_animdata_fix_paths_rename_all(&gpd->id, "layers", oldname, gpl->info);
472 }
473
474 static bGPDstroke *rna_GPencil_stroke_point_find_stroke(const bGPdata *gpd,
475                                                         const bGPDspoint *pt,
476                                                         bGPDlayer **r_gpl,
477                                                         bGPDframe **r_gpf)
478 {
479   bGPDlayer *gpl;
480   bGPDstroke *gps;
481
482   /* sanity checks */
483   if (ELEM(NULL, gpd, pt)) {
484     return NULL;
485   }
486
487   if (r_gpl) {
488     *r_gpl = NULL;
489   }
490   if (r_gpf) {
491     *r_gpf = NULL;
492   }
493
494   /* there's no faster alternative than just looping over everything... */
495   for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
496     if (gpl->actframe) {
497       for (gps = gpl->actframe->strokes.first; gps; gps = gps->next) {
498         if ((pt >= gps->points) && (pt < &gps->points[gps->totpoints])) {
499           /* found it */
500           if (r_gpl) {
501             *r_gpl = gpl;
502           }
503           if (r_gpf) {
504             *r_gpf = gpl->actframe;
505           }
506
507           return gps;
508         }
509       }
510     }
511   }
512
513   /* didn't find it */
514   return NULL;
515 }
516
517 static void rna_GPencil_stroke_point_select_set(PointerRNA *ptr, const bool value)
518 {
519   bGPdata *gpd = (bGPdata *)ptr->owner_id;
520   bGPDspoint *pt = ptr->data;
521   bGPDstroke *gps = NULL;
522
523   /* Ensure that corresponding stroke is set
524    * - Since we don't have direct access, we're going to have to search
525    * - We don't apply selection value unless we can find the corresponding
526    *   stroke, so that they don't get out of sync
527    */
528   gps = rna_GPencil_stroke_point_find_stroke(gpd, pt, NULL, NULL);
529   if (gps) {
530     /* Set the new selection state for the point */
531     if (value) {
532       pt->flag |= GP_SPOINT_SELECT;
533     }
534     else {
535       pt->flag &= ~GP_SPOINT_SELECT;
536     }
537
538     /* Check if the stroke should be selected or not... */
539     BKE_gpencil_stroke_sync_selection(gps);
540   }
541 }
542
543 static void rna_GPencil_stroke_point_add(
544     ID *id, bGPDstroke *stroke, int count, float pressure, float strength)
545 {
546   bGPdata *gpd = (bGPdata *)id;
547
548   if (count > 0) {
549     /* create space at the end of the array for extra points */
550     stroke->points = MEM_recallocN_id(
551         stroke->points, sizeof(bGPDspoint) * (stroke->totpoints + count), "gp_stroke_points");
552     stroke->dvert = MEM_recallocN_id(
553         stroke->dvert, sizeof(MDeformVert) * (stroke->totpoints + count), "gp_stroke_weight");
554
555     /* init the pressure and strength values so that old scripts won't need to
556      * be modified to give these initial values...
557      */
558     for (int i = 0; i < count; i++) {
559       bGPDspoint *pt = stroke->points + (stroke->totpoints + i);
560       MDeformVert *dvert = stroke->dvert + (stroke->totpoints + i);
561       pt->pressure = pressure;
562       pt->strength = strength;
563
564       dvert->totweight = 0;
565       dvert->dw = NULL;
566     }
567
568     stroke->totpoints += count;
569
570     stroke->flag |= GP_STROKE_RECALC_GEOMETRY;
571
572     gpd->flag |= GP_DATA_PYTHON_UPDATED;
573     DEG_id_tag_update(&gpd->id,
574                       ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_COPY_ON_WRITE);
575
576     WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
577   }
578 }
579
580 static void rna_GPencil_stroke_point_pop(ID *id,
581                                          bGPDstroke *stroke,
582                                          ReportList *reports,
583                                          int index)
584 {
585   bGPdata *gpd = (bGPdata *)id;
586   bGPDspoint *pt_tmp = stroke->points;
587   MDeformVert *pt_dvert = stroke->dvert;
588
589   /* python style negative indexing */
590   if (index < 0) {
591     index += stroke->totpoints;
592   }
593
594   if (stroke->totpoints <= index || index < 0) {
595     BKE_report(reports, RPT_ERROR, "GPencilStrokePoints.pop: index out of range");
596     return;
597   }
598
599   stroke->totpoints--;
600
601   stroke->points = MEM_callocN(sizeof(bGPDspoint) * stroke->totpoints, "gp_stroke_points");
602   if (pt_dvert != NULL) {
603     stroke->dvert = MEM_callocN(sizeof(MDeformVert) * stroke->totpoints, "gp_stroke_weights");
604   }
605
606   if (index > 0) {
607     memcpy(stroke->points, pt_tmp, sizeof(bGPDspoint) * index);
608     /* verify weight data is available */
609     if (pt_dvert != NULL) {
610       memcpy(stroke->dvert, pt_dvert, sizeof(MDeformVert) * index);
611     }
612   }
613
614   if (index < stroke->totpoints) {
615     memcpy(&stroke->points[index],
616            &pt_tmp[index + 1],
617            sizeof(bGPDspoint) * (stroke->totpoints - index));
618     if (pt_dvert != NULL) {
619       memcpy(&stroke->dvert[index],
620              &pt_dvert[index + 1],
621              sizeof(MDeformVert) * (stroke->totpoints - index));
622     }
623   }
624
625   /* free temp buffer */
626   MEM_freeN(pt_tmp);
627   if (pt_dvert != NULL) {
628     MEM_freeN(pt_dvert);
629   }
630
631   stroke->flag |= GP_STROKE_RECALC_GEOMETRY;
632
633   gpd->flag |= GP_DATA_PYTHON_UPDATED;
634   DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_COPY_ON_WRITE);
635
636   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
637 }
638
639 static bGPDstroke *rna_GPencil_stroke_new(bGPDframe *frame)
640 {
641   bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
642   stroke->gradient_f = 1.0f;
643   ARRAY_SET_ITEMS(stroke->gradient_s, 1.0f, 1.0f);
644   BLI_addtail(&frame->strokes, stroke);
645
646   return stroke;
647 }
648
649 static void rna_GPencil_stroke_remove(bGPDframe *frame,
650                                       ReportList *reports,
651                                       PointerRNA *stroke_ptr)
652 {
653   bGPDstroke *stroke = stroke_ptr->data;
654   if (BLI_findindex(&frame->strokes, stroke) == -1) {
655     BKE_report(reports, RPT_ERROR, "Stroke not found in grease pencil frame");
656     return;
657   }
658
659   BLI_freelinkN(&frame->strokes, stroke);
660   RNA_POINTER_INVALIDATE(stroke_ptr);
661
662   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
663 }
664
665 static void rna_GPencil_stroke_close(ID *id,
666                                      bGPDframe *frame,
667                                      ReportList *reports,
668                                      PointerRNA *stroke_ptr)
669 {
670   bGPdata *gpd = (bGPdata *)id;
671   bGPDstroke *stroke = stroke_ptr->data;
672   if (BLI_findindex(&frame->strokes, stroke) == -1) {
673     BKE_report(reports, RPT_ERROR, "Stroke not found in grease pencil frame");
674     return;
675   }
676
677   BKE_gpencil_close_stroke(stroke);
678
679   DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_COPY_ON_WRITE);
680   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
681 }
682
683 static void rna_GPencil_stroke_select_set(PointerRNA *ptr, const bool value)
684 {
685   bGPDstroke *gps = ptr->data;
686   bGPDspoint *pt;
687   int i;
688
689   /* set new value */
690   if (value) {
691     gps->flag |= GP_STROKE_SELECT;
692   }
693   else {
694     gps->flag &= ~GP_STROKE_SELECT;
695   }
696
697   /* ensure that the stroke's points are selected in the same way */
698   for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
699     if (value) {
700       pt->flag |= GP_SPOINT_SELECT;
701     }
702     else {
703       pt->flag &= ~GP_SPOINT_SELECT;
704     }
705   }
706 }
707
708 static bGPDframe *rna_GPencil_frame_new(bGPDlayer *layer,
709                                         ReportList *reports,
710                                         int frame_number,
711                                         bool active)
712 {
713   bGPDframe *frame;
714
715   if (BKE_gpencil_layer_find_frame(layer, frame_number)) {
716     BKE_reportf(reports, RPT_ERROR, "Frame already exists on this frame number %d", frame_number);
717     return NULL;
718   }
719
720   frame = BKE_gpencil_frame_addnew(layer, frame_number);
721   if (active) {
722     layer->actframe = BKE_gpencil_layer_getframe(layer, frame_number, GP_GETFRAME_USE_PREV);
723   }
724   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
725
726   return frame;
727 }
728
729 static void rna_GPencil_frame_remove(bGPDlayer *layer, ReportList *reports, PointerRNA *frame_ptr)
730 {
731   bGPDframe *frame = frame_ptr->data;
732   if (BLI_findindex(&layer->frames, frame) == -1) {
733     BKE_report(reports, RPT_ERROR, "Frame not found in grease pencil layer");
734     return;
735   }
736
737   BKE_gpencil_layer_delframe(layer, frame);
738   RNA_POINTER_INVALIDATE(frame_ptr);
739
740   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
741 }
742
743 static bGPDframe *rna_GPencil_frame_copy(bGPDlayer *layer, bGPDframe *src)
744 {
745   bGPDframe *frame = BKE_gpencil_frame_duplicate(src);
746
747   while (BKE_gpencil_layer_find_frame(layer, frame->framenum)) {
748     frame->framenum++;
749   }
750
751   BLI_addtail(&layer->frames, frame);
752
753   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
754
755   return frame;
756 }
757
758 static bGPDlayer *rna_GPencil_layer_new(bGPdata *gpd, const char *name, bool setactive)
759 {
760   bGPDlayer *gpl = BKE_gpencil_layer_addnew(gpd, name, setactive != 0);
761
762   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
763
764   return gpl;
765 }
766
767 static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, PointerRNA *layer_ptr)
768 {
769   bGPDlayer *layer = layer_ptr->data;
770   if (BLI_findindex(&gpd->layers, layer) == -1) {
771     BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
772     return;
773   }
774
775   BKE_gpencil_layer_delete(gpd, layer);
776   RNA_POINTER_INVALIDATE(layer_ptr);
777
778   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
779 }
780
781 static void rna_GPencil_layer_move(bGPdata *gpd,
782                                    ReportList *reports,
783                                    PointerRNA *layer_ptr,
784                                    int type)
785 {
786   bGPDlayer *gpl = layer_ptr->data;
787   if (BLI_findindex(&gpd->layers, gpl) == -1) {
788     BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
789     return;
790   }
791
792   BLI_assert(ELEM(type, -1, 0, 1)); /* we use value below */
793
794   const int direction = type * -1;
795
796   if (BLI_listbase_link_move(&gpd->layers, gpl, direction)) {
797     DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
798   }
799
800   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
801 }
802
803 static void rna_GPencil_frame_clear(bGPDframe *frame)
804 {
805   BKE_gpencil_free_strokes(frame);
806
807   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
808 }
809
810 static void rna_GPencil_layer_clear(bGPDlayer *layer)
811 {
812   BKE_gpencil_free_frames(layer);
813
814   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
815 }
816
817 static void rna_GPencil_clear(bGPdata *gpd)
818 {
819   BKE_gpencil_free_layers(&gpd->layers);
820
821   WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
822 }
823
824 static void rna_GpencilVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
825 {
826   bGPDstroke *gps = ptr->data;
827
828   if (gps->dvert) {
829     MDeformVert *dvert = gps->dvert;
830
831     rna_iterator_array_begin(
832         iter, (void *)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
833   }
834   else {
835     rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
836   }
837 }
838
839 static char *rna_GreasePencilGrid_path(PointerRNA *UNUSED(ptr))
840 {
841   return BLI_strdup("grid");
842 }
843
844 #else
845
846 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
847 {
848   StructRNA *srna;
849   PropertyRNA *prop;
850
851   srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);
852   RNA_def_struct_sdna(srna, "bGPDspoint");
853   RNA_def_struct_ui_text(
854       srna, "Grease Pencil Stroke Point", "Data point for freehand stroke curve");
855
856   prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
857   RNA_def_property_float_sdna(prop, NULL, "x");
858   RNA_def_property_array(prop, 3);
859   RNA_def_property_ui_text(prop, "Coordinates", "");
860   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
861
862   prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_FACTOR);
863   RNA_def_property_float_sdna(prop, NULL, "pressure");
864   RNA_def_property_range(prop, 0.0f, FLT_MAX);
865   RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
866   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
867
868   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
869   RNA_def_property_float_sdna(prop, NULL, "strength");
870   RNA_def_property_range(prop, 0.0f, 1.0f);
871   RNA_def_property_ui_text(prop, "Strength", "Color intensity (alpha factor)");
872   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
873
874   prop = RNA_def_property(srna, "uv_factor", PROP_FLOAT, PROP_FACTOR);
875   RNA_def_property_float_sdna(prop, NULL, "uv_fac");
876   RNA_def_property_range(prop, 0.0f, 1.0f);
877   RNA_def_property_ui_text(prop, "UV Factor", "Internal UV factor");
878   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
879
880   prop = RNA_def_property(srna, "uv_rotation", PROP_FLOAT, PROP_ANGLE);
881   RNA_def_property_float_sdna(prop, NULL, "uv_rot");
882   RNA_def_property_range(prop, 0.0f, M_PI * 2);
883   RNA_def_property_ui_text(prop, "UV Rotation", "Internal UV factor for dot mode");
884   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
885
886   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
887   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SPOINT_SELECT);
888   RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_point_select_set");
889   RNA_def_property_ui_text(prop, "Select", "Point is selected for viewport editing");
890   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
891 }
892
893 static void rna_def_gpencil_stroke_points_api(BlenderRNA *brna, PropertyRNA *cprop)
894 {
895   StructRNA *srna;
896   FunctionRNA *func;
897   PropertyRNA *parm;
898
899   RNA_def_property_srna(cprop, "GPencilStrokePoints");
900   srna = RNA_def_struct(brna, "GPencilStrokePoints", NULL);
901   RNA_def_struct_sdna(srna, "bGPDstroke");
902   RNA_def_struct_ui_text(
903       srna, "Grease Pencil Stroke Points", "Collection of grease pencil stroke points");
904
905   func = RNA_def_function(srna, "add", "rna_GPencil_stroke_point_add");
906   RNA_def_function_ui_description(func, "Add a new grease pencil stroke point");
907   RNA_def_function_flag(func, FUNC_USE_SELF_ID);
908   parm = RNA_def_int(
909       func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the stroke", 0, INT_MAX);
910   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
911   RNA_def_float(func,
912                 "pressure",
913                 1.0f,
914                 0.0f,
915                 FLT_MAX,
916                 "Pressure",
917                 "Pressure for newly created points",
918                 0.0f,
919                 FLT_MAX);
920   RNA_def_float(func,
921                 "strength",
922                 1.0f,
923                 0.0f,
924                 1.0f,
925                 "Strength",
926                 "Color intensity (alpha factor) for newly created points",
927                 0.0f,
928                 1.0f);
929
930   func = RNA_def_function(srna, "pop", "rna_GPencil_stroke_point_pop");
931   RNA_def_function_ui_description(func, "Remove a grease pencil stroke point");
932   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
933   RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "Index", "point index", INT_MIN, INT_MAX);
934 }
935
936 /* This information is read only and it can be used by add-ons */
937 static void rna_def_gpencil_triangle(BlenderRNA *brna)
938 {
939   StructRNA *srna;
940   PropertyRNA *prop;
941
942   srna = RNA_def_struct(brna, "GPencilTriangle", NULL);
943   RNA_def_struct_sdna(srna, "bGPDtriangle");
944   RNA_def_struct_ui_text(srna, "Triangle", "Triangulation data for Grease Pencil fills");
945
946   /* point v1 */
947   prop = RNA_def_property(srna, "v1", PROP_INT, PROP_NONE);
948   RNA_def_property_int_sdna(prop, NULL, "verts[0]");
949   RNA_def_property_ui_text(prop, "v1", "First triangle vertex index");
950   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
951
952   /* point v2 */
953   prop = RNA_def_property(srna, "v2", PROP_INT, PROP_NONE);
954   RNA_def_property_int_sdna(prop, NULL, "verts[1]");
955   RNA_def_property_ui_text(prop, "v2", "Second triangle vertex index");
956   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
957
958   /* point v3 */
959   prop = RNA_def_property(srna, "v3", PROP_INT, PROP_NONE);
960   RNA_def_property_int_sdna(prop, NULL, "verts[2]");
961   RNA_def_property_ui_text(prop, "v3", "Third triangle vertex index");
962   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
963
964   /* texture coord for point v1 */
965   prop = RNA_def_property(srna, "uv1", PROP_FLOAT, PROP_COORDS);
966   RNA_def_property_float_sdna(prop, NULL, "uv[0]");
967   RNA_def_property_array(prop, 2);
968   RNA_def_property_ui_text(prop, "uv1", "First triangle vertex texture coordinates");
969   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
970
971   /* texture coord for point v2 */
972   prop = RNA_def_property(srna, "uv2", PROP_FLOAT, PROP_COORDS);
973   RNA_def_property_float_sdna(prop, NULL, "uv[1]");
974   RNA_def_property_array(prop, 2);
975   RNA_def_property_ui_text(prop, "uv2", "Second triangle vertex texture coordinates");
976   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
977
978   /* texture coord for point v3 */
979   prop = RNA_def_property(srna, "uv3", PROP_FLOAT, PROP_COORDS);
980   RNA_def_property_float_sdna(prop, NULL, "uv[2]");
981   RNA_def_property_array(prop, 2);
982   RNA_def_property_ui_text(prop, "uv3", "Third triangle vertex texture coordinates");
983   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
984 }
985
986 static void rna_def_gpencil_mvert_group(BlenderRNA *brna)
987 {
988   StructRNA *srna;
989   PropertyRNA *prop;
990
991   srna = RNA_def_struct(brna, "GpencilVertexGroupElement", NULL);
992   RNA_def_struct_sdna(srna, "MDeformWeight");
993   RNA_def_struct_ui_text(
994       srna, "Vertex Group Element", "Weight value of a vertex in a vertex group");
995   RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
996
997   /* we can't point to actual group, it is in the object and so
998    * there is no unique group to point to, hence the index */
999   prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
1000   RNA_def_property_int_sdna(prop, NULL, "def_nr");
1001   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1002   RNA_def_property_ui_text(prop, "Group Index", "");
1003   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1004
1005   prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1006   RNA_def_property_range(prop, 0.0f, 1.0f);
1007   RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
1008   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1009 }
1010
1011 static void rna_def_gpencil_stroke(BlenderRNA *brna)
1012 {
1013   StructRNA *srna;
1014   PropertyRNA *prop;
1015
1016   static const EnumPropertyItem stroke_display_mode_items[] = {
1017       {0, "SCREEN", 0, "Screen", "Stroke is in screen-space"},
1018       {GP_STROKE_3DSPACE, "3DSPACE", 0, "3D Space", "Stroke is in 3D-space"},
1019       {GP_STROKE_2DSPACE, "2DSPACE", 0, "2D Space", "Stroke is in 2D-space"},
1020       {GP_STROKE_2DIMAGE,
1021        "2DIMAGE",
1022        0,
1023        "2D Image",
1024        "Stroke is in 2D-space (but with special 'image' scaling)"},
1025       {0, NULL, 0, NULL, NULL},
1026   };
1027
1028   srna = RNA_def_struct(brna, "GPencilStroke", NULL);
1029   RNA_def_struct_sdna(srna, "bGPDstroke");
1030   RNA_def_struct_ui_text(srna, "Grease Pencil Stroke", "Freehand curve defining part of a sketch");
1031
1032   /* Points */
1033   prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
1034   RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
1035   RNA_def_property_struct_type(prop, "GPencilStrokePoint");
1036   RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
1037   rna_def_gpencil_stroke_points_api(brna, prop);
1038
1039   /* vertex groups */
1040   prop = RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
1041   RNA_def_property_collection_funcs(prop,
1042                                     "rna_GpencilVertex_groups_begin",
1043                                     "rna_iterator_array_next",
1044                                     "rna_iterator_array_end",
1045                                     "rna_iterator_array_get",
1046                                     NULL,
1047                                     NULL,
1048                                     NULL,
1049                                     NULL);
1050   RNA_def_property_struct_type(prop, "GpencilVertexGroupElement");
1051   RNA_def_property_ui_text(
1052       prop, "Groups", "Weights for the vertex groups this vertex is member of");
1053
1054   /* Triangles */
1055   prop = RNA_def_property(srna, "triangles", PROP_COLLECTION, PROP_NONE);
1056   RNA_def_property_collection_sdna(prop, NULL, "triangles", "tot_triangles");
1057   RNA_def_property_struct_type(prop, "GPencilTriangle");
1058   RNA_def_property_ui_text(prop, "Triangles", "Triangulation data for HQ fill");
1059
1060   /* Material Index */
1061   prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_NONE);
1062   RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1063   RNA_def_property_ui_text(prop, "Material Index", "Index of material used in this stroke");
1064   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1065
1066   /* Settings */
1067   prop = RNA_def_property(srna, "display_mode", PROP_ENUM, PROP_NONE);
1068   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1069   RNA_def_property_enum_items(prop, stroke_display_mode_items);
1070   RNA_def_property_ui_text(prop, "Draw Mode", "Coordinate space that stroke is in");
1071   RNA_def_property_update(prop, 0, "rna_GPencil_update");
1072
1073   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1074   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_SELECT);
1075   RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_select_set");
1076   RNA_def_property_ui_text(prop, "Select", "Stroke is selected for viewport editing");
1077   RNA_def_property_update(prop, 0, "rna_GPencil_update");
1078
1079   /* Cyclic: Draw a line from end to start point */
1080   prop = RNA_def_property(srna, "draw_cyclic", PROP_BOOLEAN, PROP_NONE);
1081   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_CYCLIC);
1082   RNA_def_property_ui_text(prop, "Cyclic", "Enable cyclic drawing, closing the stroke");
1083   RNA_def_property_update(prop, 0, "rna_GPencil_update");
1084
1085   /* Caps mode */
1086   prop = RNA_def_property(srna, "start_cap_mode", PROP_ENUM, PROP_NONE);
1087   RNA_def_property_enum_sdna(prop, NULL, "caps[0]");
1088   RNA_def_property_enum_items(prop, rna_enum_gpencil_caps_modes_items);
1089   RNA_def_property_ui_text(prop, "Start Cap", "Stroke start extreme cap style");
1090   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1091
1092   prop = RNA_def_property(srna, "end_cap_mode", PROP_ENUM, PROP_NONE);
1093   RNA_def_property_enum_sdna(prop, NULL, "caps[1]");
1094   RNA_def_property_enum_items(prop, rna_enum_gpencil_caps_modes_items);
1095   RNA_def_property_ui_text(prop, "End Cap", "Stroke end extreme cap style");
1096   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1097
1098   /* No fill: The stroke never must fill area and must use fill color as stroke color
1099    * (this is a special flag for fill brush). */
1100   prop = RNA_def_property(srna, "is_nofill_stroke", PROP_BOOLEAN, PROP_NONE);
1101   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_NOFILL);
1102   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1103   RNA_def_property_ui_text(prop, "No Fill", "Special stroke to use as boundary for filling areas");
1104   RNA_def_property_update(prop, 0, "rna_GPencil_update");
1105
1106   /* Line Thickness */
1107   prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
1108   RNA_def_property_int_sdna(prop, NULL, "thickness");
1109   RNA_def_property_range(prop, 1, 1000);
1110   RNA_def_property_ui_range(prop, 1, 10, 1, 0);
1111   RNA_def_property_ui_text(prop, "Thickness", "Thickness of stroke (in pixels)");
1112   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1113
1114   /* gradient control along y */
1115   prop = RNA_def_property(srna, "gradient_factor", PROP_FLOAT, PROP_FACTOR);
1116   RNA_def_property_float_sdna(prop, NULL, "gradient_f");
1117   RNA_def_property_range(prop, 0.001f, 1.0f);
1118   RNA_def_property_float_default(prop, 1.0f);
1119   RNA_def_property_ui_text(
1120       prop, "Border Opacity Factor", "Amount of gradient along section of stroke");
1121   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1122   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1123
1124   /* gradient shape ratio */
1125   prop = RNA_def_property(srna, "gradient_shape", PROP_FLOAT, PROP_XYZ);
1126   RNA_def_property_float_sdna(prop, NULL, "gradient_s");
1127   RNA_def_property_array(prop, 2);
1128   RNA_def_property_range(prop, 0.01f, 1.0f);
1129   RNA_def_property_float_default(prop, 1.0f);
1130   RNA_def_property_ui_text(prop, "Aspect Ratio", "");
1131   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1132 }
1133
1134 static void rna_def_gpencil_strokes_api(BlenderRNA *brna, PropertyRNA *cprop)
1135 {
1136   StructRNA *srna;
1137
1138   FunctionRNA *func;
1139   PropertyRNA *parm;
1140
1141   RNA_def_property_srna(cprop, "GPencilStrokes");
1142   srna = RNA_def_struct(brna, "GPencilStrokes", NULL);
1143   RNA_def_struct_sdna(srna, "bGPDframe");
1144   RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil stroke");
1145
1146   func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");
1147   RNA_def_function_ui_description(func, "Add a new grease pencil stroke");
1148   parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");
1149   RNA_def_function_return(func, parm);
1150
1151   func = RNA_def_function(srna, "remove", "rna_GPencil_stroke_remove");
1152   RNA_def_function_ui_description(func, "Remove a grease pencil stroke");
1153   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1154   parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");
1155   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1156   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1157
1158   func = RNA_def_function(srna, "close", "rna_GPencil_stroke_close");
1159   RNA_def_function_ui_description(func, "Close a grease pencil stroke adding geometry");
1160   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1161   parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to close");
1162   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1163   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1164 }
1165
1166 static void rna_def_gpencil_frame(BlenderRNA *brna)
1167 {
1168   StructRNA *srna;
1169   PropertyRNA *prop;
1170
1171   FunctionRNA *func;
1172
1173   srna = RNA_def_struct(brna, "GPencilFrame", NULL);
1174   RNA_def_struct_sdna(srna, "bGPDframe");
1175   RNA_def_struct_ui_text(
1176       srna, "Grease Pencil Frame", "Collection of related sketches on a particular frame");
1177
1178   /* Strokes */
1179   prop = RNA_def_property(srna, "strokes", PROP_COLLECTION, PROP_NONE);
1180   RNA_def_property_collection_sdna(prop, NULL, "strokes", NULL);
1181   RNA_def_property_struct_type(prop, "GPencilStroke");
1182   RNA_def_property_ui_text(prop, "Strokes", "Freehand curves defining the sketch on this frame");
1183   rna_def_gpencil_strokes_api(brna, prop);
1184
1185   /* Frame Number */
1186   prop = RNA_def_property(srna, "frame_number", PROP_INT, PROP_NONE);
1187   RNA_def_property_int_sdna(prop, NULL, "framenum");
1188   /* XXX note: this cannot occur on the same frame as another sketch */
1189   RNA_def_property_range(prop, -MAXFRAME, MAXFRAME);
1190   RNA_def_property_ui_text(prop, "Frame Number", "The frame on which this sketch appears");
1191
1192   /* Flags */
1193   prop = RNA_def_property(srna, "is_edited", PROP_BOOLEAN, PROP_NONE);
1194   RNA_def_property_boolean_sdna(
1195       prop, NULL, "flag", GP_FRAME_PAINT); /* XXX should it be editable? */
1196   RNA_def_property_ui_text(prop, "Paint Lock", "Frame is being edited (painted on)");
1197
1198   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1199   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_SELECT);
1200   RNA_def_property_ui_text(prop, "Select", "Frame is selected for editing in the Dope Sheet");
1201
1202   /* API */
1203   func = RNA_def_function(srna, "clear", "rna_GPencil_frame_clear");
1204   RNA_def_function_ui_description(func, "Remove all the grease pencil frame data");
1205 }
1206
1207 static void rna_def_gpencil_frames_api(BlenderRNA *brna, PropertyRNA *cprop)
1208 {
1209   StructRNA *srna;
1210
1211   FunctionRNA *func;
1212   PropertyRNA *parm;
1213
1214   RNA_def_property_srna(cprop, "GPencilFrames");
1215   srna = RNA_def_struct(brna, "GPencilFrames", NULL);
1216   RNA_def_struct_sdna(srna, "bGPDlayer");
1217   RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil frames");
1218
1219   func = RNA_def_function(srna, "new", "rna_GPencil_frame_new");
1220   RNA_def_function_ui_description(func, "Add a new grease pencil frame");
1221   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1222   parm = RNA_def_int(func,
1223                      "frame_number",
1224                      1,
1225                      MINAFRAME,
1226                      MAXFRAME,
1227                      "Frame Number",
1228                      "The frame on which this sketch appears",
1229                      MINAFRAME,
1230                      MAXFRAME);
1231   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1232   RNA_def_boolean(func, "active", 0, "Active", "");
1233   parm = RNA_def_pointer(func, "frame", "GPencilFrame", "", "The newly created frame");
1234   RNA_def_function_return(func, parm);
1235
1236   func = RNA_def_function(srna, "remove", "rna_GPencil_frame_remove");
1237   RNA_def_function_ui_description(func, "Remove a grease pencil frame");
1238   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1239   parm = RNA_def_pointer(func, "frame", "GPencilFrame", "Frame", "The frame to remove");
1240   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1241   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1242
1243   func = RNA_def_function(srna, "copy", "rna_GPencil_frame_copy");
1244   RNA_def_function_ui_description(func, "Copy a grease pencil frame");
1245   parm = RNA_def_pointer(func, "source", "GPencilFrame", "Source", "The source frame");
1246   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1247   parm = RNA_def_pointer(func, "copy", "GPencilFrame", "", "The newly copied frame");
1248   RNA_def_function_return(func, parm);
1249 }
1250
1251 static void rna_def_gpencil_layer(BlenderRNA *brna)
1252 {
1253   StructRNA *srna;
1254   PropertyRNA *prop;
1255
1256   FunctionRNA *func;
1257   static const float default_onion_color_b[] = {0.302f, 0.851f, 0.302f};
1258   static const float default_onion_color_a[] = {0.250f, 0.1f, 1.0f};
1259
1260   srna = RNA_def_struct(brna, "GPencilLayer", NULL);
1261   RNA_def_struct_sdna(srna, "bGPDlayer");
1262   RNA_def_struct_ui_text(srna, "Grease Pencil Layer", "Collection of related sketches");
1263   RNA_def_struct_path_func(srna, "rna_GPencilLayer_path");
1264
1265   /* Name */
1266   prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
1267   RNA_def_property_ui_text(prop, "Info", "Layer name");
1268   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_info_set");
1269   RNA_def_struct_name_property(srna, prop);
1270   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_RENAME, NULL);
1271
1272   /* Frames */
1273   prop = RNA_def_property(srna, "frames", PROP_COLLECTION, PROP_NONE);
1274   RNA_def_property_collection_sdna(prop, NULL, "frames", NULL);
1275   RNA_def_property_struct_type(prop, "GPencilFrame");
1276   RNA_def_property_ui_text(prop, "Frames", "Sketches for this layer on different frames");
1277   rna_def_gpencil_frames_api(brna, prop);
1278
1279   /* Active Frame */
1280   prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
1281   RNA_def_property_pointer_sdna(prop, NULL, "actframe");
1282   RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
1283   RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
1284   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1285
1286   /* Layer Opacity */
1287   prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
1288   RNA_def_property_float_sdna(prop, NULL, "opacity");
1289   RNA_def_property_range(prop, 0.0, 1.0f);
1290   RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
1291   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1292
1293   /* layer channel color (grease pencil)  */
1294   prop = RNA_def_property(srna, "channel_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1295   RNA_def_property_float_sdna(prop, NULL, "color");
1296   RNA_def_property_array(prop, 3);
1297   RNA_def_property_range(prop, 0.0f, 1.0f);
1298   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1299   RNA_def_property_ui_text(
1300       prop, "Custom Channel Color", "Custom color for animation channel in Dopesheet");
1301   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1302
1303   /* Stroke Drawing Color (Annotations) */
1304   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1305   RNA_def_property_array(prop, 3);
1306   RNA_def_property_range(prop, 0.0f, 1.0f);
1307   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1308   RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
1309   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1310
1311   /* Line Thickness (Annotations) */
1312   prop = RNA_def_property(srna, "thickness", PROP_INT, PROP_PIXEL);
1313   RNA_def_property_int_sdna(prop, NULL, "thickness");
1314   RNA_def_property_range(prop, 1, 10);
1315   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1316   RNA_def_property_ui_text(prop, "Thickness", "Thickness of annotation strokes");
1317   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1318
1319   /* Tint Color */
1320   prop = RNA_def_property(srna, "tint_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1321   RNA_def_property_float_sdna(prop, NULL, "tintcolor");
1322   RNA_def_property_array(prop, 3);
1323   RNA_def_property_range(prop, 0.0f, 1.0f);
1324   RNA_def_property_ui_text(prop, "Tint Color", "Color for tinting stroke colors");
1325   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1326
1327   /* Tint factor */
1328   prop = RNA_def_property(srna, "tint_factor", PROP_FLOAT, PROP_NONE);
1329   RNA_def_property_float_sdna(prop, NULL, "tintcolor[3]");
1330   RNA_def_property_range(prop, 0.0, 1.0f);
1331   RNA_def_property_ui_text(prop, "Tint Factor", "Factor of tinting color");
1332   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1333
1334   /* Line Thickness Change */
1335   prop = RNA_def_property(srna, "line_change", PROP_INT, PROP_PIXEL);
1336   RNA_def_property_int_sdna(prop, NULL, "line_change");
1337   RNA_def_property_range(prop, -300, 300);
1338   RNA_def_property_ui_range(prop, -100, 100, 1.0, 1);
1339   RNA_def_property_ui_text(
1340       prop, "Thickness Change", "Thickness change to apply to current strokes (in pixels)");
1341   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1342
1343   /* Onion-Skinning */
1344   prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1345   RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_LAYER_ONIONSKIN);
1346   RNA_def_property_ui_text(
1347       prop, "Onion Skinning", "Display onion skins before and after the current frame");
1348   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1349
1350   prop = RNA_def_property(srna, "use_annotation_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1351   RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_LAYER_ONIONSKIN);
1352   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1353   RNA_def_property_ui_text(
1354       prop, "Onion Skinning", "Display annotation onion skins before and after the current frame");
1355   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1356
1357   prop = RNA_def_property(srna, "annotation_onion_before_range", PROP_INT, PROP_NONE);
1358   RNA_def_property_int_sdna(prop, NULL, "gstep");
1359   RNA_def_property_range(prop, -1, 120);
1360   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1361   RNA_def_property_ui_text(
1362       prop, "Frames Before", "Maximum number of frames to show before current frame");
1363   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1364
1365   prop = RNA_def_property(srna, "annotation_onion_after_range", PROP_INT, PROP_NONE);
1366   RNA_def_property_int_sdna(prop, NULL, "gstep_next");
1367   RNA_def_property_range(prop, -1, 120);
1368   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1369   RNA_def_property_ui_text(
1370       prop, "Frames After", "Maximum number of frames to show after current frame");
1371   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1372
1373   prop = RNA_def_property(srna, "annotation_onion_before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1374   RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
1375   RNA_def_property_array(prop, 3);
1376   RNA_def_property_range(prop, 0.0f, 1.0f);
1377   RNA_def_property_float_array_default(prop, default_onion_color_b);
1378   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1379   RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
1380   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1381
1382   prop = RNA_def_property(srna, "annotation_onion_after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1383   RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
1384   RNA_def_property_array(prop, 3);
1385   RNA_def_property_range(prop, 0.0f, 1.0f);
1386   RNA_def_property_float_array_default(prop, default_onion_color_a);
1387   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1388   RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
1389   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1390
1391   /* pass index for compositing and modifiers */
1392   prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
1393   RNA_def_property_int_sdna(prop, NULL, "pass_index");
1394   RNA_def_property_ui_text(prop, "Pass Index", "Index number for the \"Layer Index\" pass");
1395   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1396
1397   prop = RNA_def_property(srna, "viewlayer_render", PROP_STRING, PROP_NONE);
1398   RNA_def_property_string_sdna(prop, NULL, "viewlayername");
1399   RNA_def_property_ui_text(
1400       prop,
1401       "ViewLayer",
1402       "Only include Layer in this View Layer render output (leave blank to include always)");
1403
1404   /* blend mode */
1405   prop = RNA_def_property(srna, "blend_mode", PROP_ENUM, PROP_NONE);
1406   RNA_def_property_enum_sdna(prop, NULL, "blend_mode");
1407   RNA_def_property_enum_items(prop, rna_enum_layer_blend_modes_items);
1408   RNA_def_property_ui_text(prop, "Blend Mode", "Blend mode");
1409   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1410
1411   /* Flags */
1412   prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1413   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
1414   RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, -1);
1415   RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
1416   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1417
1418   prop = RNA_def_property(srna, "annotation_hide", PROP_BOOLEAN, PROP_NONE);
1419   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
1420   RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, -1);
1421   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1422   RNA_def_property_ui_text(prop, "Hide", "Set annotation Visibility");
1423   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1424
1425   prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1426   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_LOCKED);
1427   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1428   RNA_def_property_ui_text(
1429       prop, "Locked", "Protect layer from further editing and/or frame changes");
1430   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1431
1432   prop = RNA_def_property(srna, "lock_frame", PROP_BOOLEAN, PROP_NONE);
1433   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_FRAMELOCK);
1434   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1435   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1436   RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
1437   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1438
1439   prop = RNA_def_property(srna, "lock_material", PROP_BOOLEAN, PROP_NONE);
1440   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_UNLOCK_COLOR);
1441   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1442   RNA_def_property_ui_text(
1443       prop, "Disallow Locked Materials Editing", "Avoids editing locked materials in the layer");
1444   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1445
1446   prop = RNA_def_property(srna, "mask_layer", PROP_BOOLEAN, PROP_NONE);
1447   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_USE_MASK);
1448   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1449   RNA_def_property_ui_text(
1450       prop, "Mask Layer", "Remove any pixel outside underlying layers drawing");
1451   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1452
1453   /* solo mode: Only display frames with keyframe */
1454   prop = RNA_def_property(srna, "use_solo_mode", PROP_BOOLEAN, PROP_NONE);
1455   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SOLO_MODE);
1456   RNA_def_property_ui_text(
1457       prop, "Solo Mode", "In Paint mode display only layers with keyframe in current frame");
1458   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1459
1460   /* exposed as layers.active */
1461 #  if 0
1462   prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1463   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
1464   RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
1465   RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
1466   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1467 #  endif
1468
1469   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1470   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
1471   RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the Dope Sheet");
1472   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, "rna_GPencil_update");
1473
1474   prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
1475   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
1476   RNA_def_property_ui_text(
1477       prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
1478   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1479
1480   /* In Front */
1481   prop = RNA_def_property(srna, "show_in_front", PROP_BOOLEAN, PROP_NONE);
1482   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
1483   RNA_def_property_ui_text(prop, "In Front", "Make the layer draw in front of objects");
1484   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1485
1486   /* Parent object */
1487   prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
1488   RNA_def_property_pointer_funcs(prop, NULL, "rna_GPencilLayer_parent_set", NULL, NULL);
1489   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1490   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1491   RNA_def_property_ui_text(prop, "Parent", "Parent Object");
1492   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1493
1494   /* parent type */
1495   prop = RNA_def_property(srna, "parent_type", PROP_ENUM, PROP_NONE);
1496   RNA_def_property_enum_bitflag_sdna(prop, NULL, "partype");
1497   RNA_def_property_enum_items(prop, parent_type_items);
1498   RNA_def_property_enum_funcs(
1499       prop, NULL, "rna_GPencilLayer_parent_type_set", "rna_Object_parent_type_itemf");
1500   RNA_def_property_ui_text(prop, "Parent Type", "Type of parent relation");
1501   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1502
1503   /* parent bone */
1504   prop = RNA_def_property(srna, "parent_bone", PROP_STRING, PROP_NONE);
1505   RNA_def_property_string_sdna(prop, NULL, "parsubstr");
1506   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_parent_bone_set");
1507   RNA_def_property_ui_text(
1508       prop, "Parent Bone", "Name of parent bone in case of a bone parenting relation");
1509   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1510
1511   /* matrix */
1512   prop = RNA_def_property(srna, "matrix_inverse", PROP_FLOAT, PROP_MATRIX);
1513   RNA_def_property_float_sdna(prop, NULL, "inverse");
1514   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1515   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1516   RNA_def_property_ui_text(prop, "Inverse Matrix", "Parent inverse transformation matrix");
1517   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1518
1519   /* read only parented flag */
1520   prop = RNA_def_property(srna, "is_parented", PROP_BOOLEAN, PROP_NONE);
1521   RNA_def_property_boolean_funcs(prop, "rna_GPencilLayer_is_parented_get", NULL);
1522   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1523   RNA_def_property_ui_text(prop, "Is Parented", "True when the layer parent object is set");
1524
1525   /* Layers API */
1526   func = RNA_def_function(srna, "clear", "rna_GPencil_layer_clear");
1527   RNA_def_function_ui_description(func, "Remove all the grease pencil layer data");
1528 }
1529
1530 static void rna_def_gpencil_layers_api(BlenderRNA *brna, PropertyRNA *cprop)
1531 {
1532   StructRNA *srna;
1533   PropertyRNA *prop;
1534
1535   FunctionRNA *func;
1536   PropertyRNA *parm;
1537
1538   RNA_def_property_srna(cprop, "GreasePencilLayers");
1539   srna = RNA_def_struct(brna, "GreasePencilLayers", NULL);
1540   RNA_def_struct_sdna(srna, "bGPdata");
1541   RNA_def_struct_ui_text(srna, "Grease Pencil Layers", "Collection of grease pencil layers");
1542
1543   func = RNA_def_function(srna, "new", "rna_GPencil_layer_new");
1544   RNA_def_function_ui_description(func, "Add a new grease pencil layer");
1545   parm = RNA_def_string(func, "name", "GPencilLayer", MAX_NAME, "Name", "Name of the layer");
1546   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1547   RNA_def_boolean(
1548       func, "set_active", true, "Set Active", "Set the newly created layer to the active layer");
1549   parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The newly created layer");
1550   RNA_def_function_return(func, parm);
1551
1552   func = RNA_def_function(srna, "remove", "rna_GPencil_layer_remove");
1553   RNA_def_function_ui_description(func, "Remove a grease pencil layer");
1554   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1555   parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to remove");
1556   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1557   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1558
1559   func = RNA_def_function(srna, "move", "rna_GPencil_layer_move");
1560   RNA_def_function_ui_description(func, "Move a grease pencil layer in the layer stack");
1561   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1562   parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to move");
1563   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1564   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1565   parm = RNA_def_enum(
1566       func, "type", rna_enum_gplayer_move_type_items, 1, "", "Direction of movement");
1567   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1568
1569   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1570   RNA_def_property_struct_type(prop, "GPencilLayer");
1571   RNA_def_property_pointer_funcs(
1572       prop, "rna_GPencil_active_layer_get", "rna_GPencil_active_layer_set", NULL, NULL);
1573   RNA_def_property_flag(prop, PROP_EDITABLE);
1574   RNA_def_property_ui_text(prop, "Active Layer", "Active grease pencil layer");
1575   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1576
1577   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1578   RNA_def_property_int_funcs(prop,
1579                              "rna_GPencil_active_layer_index_get",
1580                              "rna_GPencil_active_layer_index_set",
1581                              "rna_GPencil_active_layer_index_range");
1582   RNA_def_property_ui_text(prop, "Active Layer Index", "Index of active grease pencil layer");
1583   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1584
1585   /* Active Layer - As an enum (for selecting active layer for annotations) */
1586   prop = RNA_def_property(srna, "active_note", PROP_ENUM, PROP_NONE);
1587   RNA_def_property_enum_funcs(prop,
1588                               "rna_GPencil_active_layer_index_get",
1589                               "rna_GPencil_active_layer_index_set",
1590                               "rna_GPencil_active_layer_itemf");
1591   RNA_def_property_enum_items(
1592       prop, DummyRNA_DEFAULT_items); /* purely dynamic, as it maps to user-data */
1593   RNA_def_property_ui_text(prop, "Active Note", "Note/Layer to add annotation strokes to");
1594   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1595 }
1596
1597 static void rna_def_gpencil_grid(BlenderRNA *brna)
1598 {
1599   StructRNA *srna;
1600   PropertyRNA *prop;
1601
1602   static const float default_grid_color[] = {0.5f, 0.5f, 0.5f};
1603
1604   srna = RNA_def_struct(brna, "GreasePencilGrid", NULL);
1605   RNA_def_struct_sdna(srna, "bGPgrid");
1606   RNA_def_struct_nested(brna, srna, "GreasePencil");
1607
1608   RNA_def_struct_path_func(srna, "rna_GreasePencilGrid_path");
1609   RNA_def_struct_ui_text(
1610       srna, "Grid and Canvas Settings", "Settings for grid and canvas in 3D viewport");
1611
1612   prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
1613   RNA_def_property_float_sdna(prop, NULL, "scale");
1614   RNA_def_property_range(prop, 0.01f, FLT_MAX);
1615   RNA_def_property_float_default(prop, 1.0f);
1616   RNA_def_property_ui_text(prop, "Grid Scale", "Grid scale");
1617   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1618
1619   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1620   RNA_def_property_float_sdna(prop, NULL, "color");
1621   RNA_def_property_array(prop, 3);
1622   RNA_def_property_range(prop, 0.0f, 1.0f);
1623   RNA_def_property_float_array_default(prop, default_grid_color);
1624   RNA_def_property_ui_text(prop, "Grid Color", "Color for grid lines");
1625   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1626
1627   prop = RNA_def_property(srna, "lines", PROP_INT, PROP_NONE);
1628   RNA_def_property_int_sdna(prop, NULL, "lines");
1629   RNA_def_property_range(prop, 0, SHRT_MAX);
1630   RNA_def_property_int_default(prop, GP_DEFAULT_GRID_LINES);
1631   RNA_def_property_ui_text(
1632       prop, "Grid Subdivisions", "Number of subdivisions in each side of symmetry line");
1633   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1634
1635   prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_TRANSLATION);
1636   RNA_def_property_float_sdna(prop, NULL, "offset");
1637   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1638   RNA_def_property_array(prop, 2);
1639   RNA_def_property_ui_text(prop, "Offset", "Offset of the canvas");
1640   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1641 }
1642
1643 static void rna_def_gpencil_data(BlenderRNA *brna)
1644 {
1645   StructRNA *srna;
1646   PropertyRNA *prop;
1647   FunctionRNA *func;
1648
1649   static float default_1[4] = {0.6f, 0.6f, 0.6f, 0.5f};
1650   static float onion_dft1[3] = {0.145098f, 0.419608f, 0.137255f}; /* green */
1651   static float onion_dft2[3] = {0.125490f, 0.082353f, 0.529412f}; /* blue */
1652
1653   static const EnumPropertyItem stroke_thickness_items[] = {
1654       {0, "WORLDSPACE", 0, "World Space", "Set stroke thickness relative to the world space"},
1655       {GP_DATA_STROKE_KEEPTHICKNESS,
1656        "SCREENSPACE",
1657        0,
1658        "Screen Space",
1659        "Set stroke thickness relative to the screen space"},
1660       {0, NULL, 0, NULL, NULL},
1661   };
1662
1663   srna = RNA_def_struct(brna, "GreasePencil", "ID");
1664   RNA_def_struct_sdna(srna, "bGPdata");
1665   RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
1666   RNA_def_struct_ui_icon(srna, ICON_OUTLINER_DATA_GREASEPENCIL);
1667
1668   /* Layers */
1669   prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
1670   RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
1671   RNA_def_property_struct_type(prop, "GPencilLayer");
1672   RNA_def_property_ui_text(prop, "Layers", "");
1673   rna_def_gpencil_layers_api(brna, prop);
1674
1675   /* Animation Data */
1676   rna_def_animdata_common(srna);
1677
1678   /* materials */
1679   prop = RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
1680   RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
1681   RNA_def_property_struct_type(prop, "Material");
1682   RNA_def_property_ui_text(prop, "Materials", "");
1683   RNA_def_property_srna(prop, "IDMaterials"); /* see rna_ID.c */
1684   RNA_def_property_collection_funcs(
1685       prop, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "rna_IDMaterials_assign_int");
1686
1687   /* Depth */
1688   prop = RNA_def_property(srna, "stroke_depth_order", PROP_ENUM, PROP_NONE);
1689   RNA_def_property_enum_sdna(prop, NULL, "draw_mode");
1690   RNA_def_property_enum_items(prop, rna_enum_gpencil_stroke_depth_order_items);
1691   RNA_def_property_ui_text(
1692       prop, "Stroke Depth Order", "Defines how the strokes are ordered in 3D space");
1693   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1694
1695   /* Flags */
1696   prop = RNA_def_property(srna, "use_stroke_edit_mode", PROP_BOOLEAN, PROP_NONE);
1697   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_EDITMODE);
1698   RNA_def_property_ui_text(
1699       prop, "Stroke Edit Mode", "Edit Grease Pencil strokes instead of viewport data");
1700   RNA_def_property_update(
1701       prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1702
1703   prop = RNA_def_property(srna, "is_stroke_paint_mode", PROP_BOOLEAN, PROP_NONE);
1704   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_PAINTMODE);
1705   RNA_def_property_ui_text(prop, "Stroke Paint Mode", "Draw Grease Pencil strokes on click/drag");
1706   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1707   RNA_def_property_update(
1708       prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1709
1710   prop = RNA_def_property(srna, "is_stroke_sculpt_mode", PROP_BOOLEAN, PROP_NONE);
1711   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_SCULPTMODE);
1712   RNA_def_property_ui_text(
1713       prop, "Stroke Sculpt Mode", "Sculpt Grease Pencil strokes instead of viewport data");
1714   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1715   RNA_def_property_update(
1716       prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1717
1718   prop = RNA_def_property(srna, "is_stroke_weight_mode", PROP_BOOLEAN, PROP_NONE);
1719   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_WEIGHTMODE);
1720   RNA_def_property_ui_text(prop, "Stroke Weight Paint Mode", "Grease Pencil weight paint");
1721   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1722   RNA_def_property_update(
1723       prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1724
1725   prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1726   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_ONIONSKINS);
1727   RNA_def_property_boolean_default(prop, true);
1728   RNA_def_property_ui_text(
1729       prop, "Onion Skins", "Show ghosts of the keyframes before and after the current frame");
1730   RNA_def_property_update(
1731       prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1732
1733   prop = RNA_def_property(srna, "show_stroke_direction", PROP_BOOLEAN, PROP_NONE);
1734   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_DIRECTION);
1735   RNA_def_property_ui_text(prop,
1736                            "Show Direction",
1737                            "Show stroke drawing direction with a bigger green dot (start) "
1738                            "and smaller red dot (end) points");
1739   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1740
1741   prop = RNA_def_property(srna, "stroke_thickness_space", PROP_ENUM, PROP_NONE); /* as an enum */
1742   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1743   RNA_def_property_enum_items(prop, stroke_thickness_items);
1744   RNA_def_property_ui_text(
1745       prop, "Stroke Thickness", "Set stroke thickness in screen space or world space");
1746   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1747
1748   prop = RNA_def_property(srna, "pixel_factor", PROP_FLOAT, PROP_NONE);
1749   RNA_def_property_float_sdna(prop, NULL, "pixfactor");
1750   RNA_def_property_range(prop, 0.1f, 30.0f);
1751   RNA_def_property_ui_range(prop, 0.1f, 30.0f, 1, 2);
1752   RNA_def_property_ui_text(
1753       prop,
1754       "Scale",
1755       "Scale conversion factor for pixel size (use larger values for thicker lines)");
1756   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1757
1758   prop = RNA_def_property(srna, "use_multiedit", PROP_BOOLEAN, PROP_NONE);
1759   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_MULTIEDIT);
1760   RNA_def_property_ui_text(prop,
1761                            "MultiFrame",
1762                            "Edit strokes from multiple grease pencil keyframes at the same time "
1763                            "(keyframes must be selected to be included)");
1764   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1765
1766   prop = RNA_def_property(srna, "use_force_fill_recalc", PROP_BOOLEAN, PROP_NONE);
1767   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_FORCE_RECALC);
1768   RNA_def_property_ui_text(
1769       prop,
1770       "Force Fill Update",
1771       "Force recalc of fill data after use deformation modifiers (reduce FPS)");
1772   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1773
1774   prop = RNA_def_property(srna, "use_adaptive_uv", PROP_BOOLEAN, PROP_NONE);
1775   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_UV_ADAPTIVE);
1776   RNA_def_property_ui_text(
1777       prop, "Adaptive UV", "Automatic UVs are calculated depending of the stroke size");
1778   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1779
1780   prop = RNA_def_property(srna, "use_autolock_layers", PROP_BOOLEAN, PROP_NONE);
1781   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_AUTOLOCK_LAYERS);
1782   RNA_def_property_ui_text(
1783       prop,
1784       "Autolock Layers",
1785       "Lock automatically all layers except active one to avoid accidental changes");
1786   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_autolock");
1787
1788   prop = RNA_def_property(srna, "edit_line_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1789   RNA_def_property_float_sdna(prop, NULL, "line_color");
1790   RNA_def_property_array(prop, 4);
1791   RNA_def_property_range(prop, 0.0f, 1.0f);
1792   RNA_def_property_float_array_default(prop, default_1);
1793   RNA_def_property_ui_text(prop, "Edit Line Color", "Color for editing line");
1794   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1795
1796   /* onion skinning */
1797   prop = RNA_def_property(srna, "ghost_before_range", PROP_INT, PROP_NONE);
1798   RNA_def_property_int_sdna(prop, NULL, "gstep");
1799   RNA_def_property_range(prop, 0, 120);
1800   RNA_def_property_int_default(prop, 1);
1801   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1802   RNA_def_property_ui_text(prop,
1803                            "Frames Before",
1804                            "Maximum number of frames to show before current frame "
1805                            "(0 = don't show any frames before current)");
1806   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1807
1808   prop = RNA_def_property(srna, "ghost_after_range", PROP_INT, PROP_NONE);
1809   RNA_def_property_int_sdna(prop, NULL, "gstep_next");
1810   RNA_def_property_range(prop, 0, 120);
1811   RNA_def_property_int_default(prop, 1);
1812   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1813   RNA_def_property_ui_text(prop,
1814                            "Frames After",
1815                            "Maximum number of frames to show after current frame "
1816                            "(0 = don't show any frames after current)");
1817   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1818
1819   prop = RNA_def_property(srna, "use_ghost_custom_colors", PROP_BOOLEAN, PROP_NONE);
1820   RNA_def_property_boolean_sdna(
1821       prop, NULL, "onion_flag", GP_ONION_GHOST_PREVCOL | GP_ONION_GHOST_NEXTCOL);
1822   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1823   RNA_def_property_ui_text(prop, "Use Custom Ghost Colors", "Use custom colors for ghost frames");
1824   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1825
1826   prop = RNA_def_property(srna, "before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1827   RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
1828   RNA_def_property_array(prop, 3);
1829   RNA_def_property_range(prop, 0.0f, 1.0f);
1830   RNA_def_property_float_array_default(prop, onion_dft1);
1831   RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
1832   RNA_def_property_update(
1833       prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1834
1835   prop = RNA_def_property(srna, "after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1836   RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
1837   RNA_def_property_array(prop, 3);
1838   RNA_def_property_range(prop, 0.0f, 1.0f);
1839   RNA_def_property_float_array_default(prop, onion_dft2);
1840   RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
1841   RNA_def_property_update(
1842       prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1843
1844   prop = RNA_def_property(srna, "use_ghosts_always", PROP_BOOLEAN, PROP_NONE);
1845   RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_GHOST_ALWAYS);
1846   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1847   RNA_def_property_ui_text(prop,
1848                            "Always Show Ghosts",
1849                            "Ghosts are shown in renders and animation playback. Useful for "
1850                            "special effects (e.g. motion blur)");
1851   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1852
1853   prop = RNA_def_property(srna, "onion_mode", PROP_ENUM, PROP_NONE);
1854   RNA_def_property_enum_sdna(prop, NULL, "onion_mode");
1855   RNA_def_property_enum_items(prop, rna_enum_gpencil_onion_modes_items);
1856   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1857   RNA_def_property_ui_text(prop, "Mode", "Mode to display frames");
1858   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1859
1860   prop = RNA_def_property(srna, "onion_keyframe_type", PROP_ENUM, PROP_NONE);
1861   RNA_def_property_enum_sdna(prop, NULL, "onion_keytype");
1862   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1863   RNA_def_property_enum_items(prop, rna_enum_onion_keyframe_type_items);
1864   RNA_def_property_ui_text(prop, "Filter by Type", "Type of keyframe (for filtering)");
1865   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1866
1867   prop = RNA_def_property(srna, "use_onion_fade", PROP_BOOLEAN, PROP_NONE);
1868   RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_FADE);
1869   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1870   RNA_def_property_ui_text(
1871       prop, "Fade", "Display onion keyframes with a fade in color transparency");
1872   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1873
1874   prop = RNA_def_property(srna, "use_onion_loop", PROP_BOOLEAN, PROP_NONE);
1875   RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_LOOP);
1876   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1877   RNA_def_property_ui_text(prop,
1878                            "Loop",
1879                            "Display first onion keyframes using next frame color to show "
1880                            "indication of loop start frame");
1881   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1882
1883   prop = RNA_def_property(srna, "onion_factor", PROP_FLOAT, PROP_NONE);
1884   RNA_def_property_float_sdna(prop, NULL, "onion_factor");
1885   RNA_def_property_float_default(prop, 0.5f);
1886   RNA_def_property_range(prop, 0.0, 1.0f);
1887   RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1888   RNA_def_property_ui_text(prop, "Onion Opacity", "Change fade opacity of displayed onion frames");
1889   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1890
1891   prop = RNA_def_property(srna, "zdepth_offset", PROP_FLOAT, PROP_NONE);
1892   RNA_def_property_float_sdna(prop, NULL, "zdepth_offset");
1893   RNA_def_property_range(prop, 0.0f, 1.0f);
1894   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1f, 3);
1895   RNA_def_property_ui_text(prop, "Surface Offset", "Offset amount when drawing in surface mode");
1896   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1897
1898   prop = RNA_def_property(srna, "is_annotation", PROP_BOOLEAN, PROP_NONE);
1899   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_ANNOTATIONS);
1900   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1901   RNA_def_property_ui_text(prop, "Annotation", "Current datablock is an annotation");
1902
1903   /* Nested Structs */
1904   prop = RNA_def_property(srna, "grid", PROP_POINTER, PROP_NONE);
1905   RNA_def_property_flag(prop, PROP_NEVER_NULL);
1906   RNA_def_property_struct_type(prop, "GreasePencilGrid");
1907   RNA_def_property_ui_text(
1908       prop, "Grid Settings", "Settings for grid and canvas in the 3D viewport");
1909
1910   rna_def_gpencil_grid(brna);
1911
1912   /* API Functions */
1913   func = RNA_def_function(srna, "clear", "rna_GPencil_clear");
1914   RNA_def_function_ui_description(func, "Remove all the Grease Pencil data");
1915 }
1916
1917 /* --- */
1918
1919 void RNA_def_gpencil(BlenderRNA *brna)
1920 {
1921   rna_def_gpencil_data(brna);
1922
1923   rna_def_gpencil_layer(brna);
1924   rna_def_gpencil_frame(brna);
1925
1926   rna_def_gpencil_stroke(brna);
1927   rna_def_gpencil_stroke_point(brna);
1928   rna_def_gpencil_triangle(brna);
1929
1930   rna_def_gpencil_mvert_group(brna);
1931 }
1932
1933 #endif