1fc8e73bb6961064d9a33f37e5070d3162955f2f
[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
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_gpencil.c
24  *  \ingroup RNA
25  */
26
27
28 #include <stdlib.h>
29
30 #include "RNA_define.h"
31
32 #include "rna_internal.h"
33
34 #include "DNA_gpencil_types.h"
35 #include "DNA_scene_types.h"
36
37 #include "MEM_guardedalloc.h"
38
39 #include "WM_types.h"
40
41 #ifdef RNA_RUNTIME
42
43 #include "WM_api.h"
44
45 #include "BKE_gpencil.h"
46
47 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *UNUSED(ptr))
48 {
49         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
50 }
51
52 static int rna_GPencilLayer_active_frame_editable(PointerRNA *ptr)
53 {
54         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
55
56         /* surely there must be other criteria too... */
57         if (gpl->flag & GP_LAYER_LOCKED)
58                 return 0;
59         else
60                 return 1;
61 }
62
63 static PointerRNA rna_GPencil_active_layer_get(PointerRNA *ptr)
64 {
65
66         bGPdata *gpd = ptr->id.data;
67
68         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
69                 bGPDlayer *gl;
70
71                 for (gl = gpd->layers.first; gl; gl = gl->next) {
72                         if (gl->flag & GP_LAYER_ACTIVE) {
73                                 break;
74                         }
75                 }
76
77                 if (gl) {
78                         return rna_pointer_inherit_refine(ptr, &RNA_GPencilLayer, gl);
79                 }
80         }
81
82         return rna_pointer_inherit_refine(ptr, NULL, NULL);
83 }
84
85 static void rna_GPencil_active_layer_set(PointerRNA *ptr, PointerRNA value)
86 {
87         bGPdata *gpd = ptr->id.data;
88
89         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
90                 bGPDlayer *gl;
91
92                 for (gl = gpd->layers.first; gl; gl = gl->next) {
93                         if (gl == value.data) {
94                                 gl->flag |= GP_LAYER_ACTIVE;
95                         }
96                         else {
97                                 gl->flag &= ~GP_LAYER_ACTIVE;
98                         }
99                 }
100         }
101 }
102
103 static void rna_GPencilLayer_info_set(PointerRNA *ptr, const char *value)
104 {
105         bGPdata *gpd = ptr->id.data;
106         bGPDlayer *gpl = ptr->data;
107
108         /* copy the new name into the name slot */
109         BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));
110
111         BLI_uniquename(&gpd->layers, gpl, "GP_Layer", '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
112 }
113
114 static void rna_GPencil_stroke_point_add(bGPDstroke *stroke, int count)
115 {
116         if (count > 0) {
117                 if (stroke->points == NULL)
118                         stroke->points = MEM_callocN(sizeof(bGPDspoint) * count, "gp_stroke_points");
119                 else
120                         stroke->points = MEM_reallocN(stroke->points, sizeof(bGPDspoint) * (stroke->totpoints + count));
121
122                 stroke->totpoints += count;
123         }
124 }
125
126 static void rna_GPencil_stroke_point_pop(bGPDstroke *stroke, ReportList *reports, int index)
127 {
128         bGPDspoint *pt_tmp = stroke->points;
129
130         /* python style negative indexing */
131         if (index < 0) {
132                 index += stroke->totpoints;
133         }
134
135         if (stroke->totpoints <= index || index < 0) {
136                 BKE_report(reports, RPT_ERROR, "GPencilStrokePoints.pop: index out of range");
137                 return;
138         }
139
140         stroke->totpoints--;
141
142         stroke->points = MEM_callocN(sizeof(bGPDspoint) * stroke->totpoints, "gp_stroke_points");
143
144         if (index > 0)
145                 memcpy(stroke->points, pt_tmp, sizeof(bGPDspoint) * index);
146
147         if (index < stroke->totpoints)
148                 memcpy(&stroke->points[index], &pt_tmp[index + 1], sizeof(bGPDspoint) * (stroke->totpoints - index));
149
150         /* free temp buffer */
151         MEM_freeN(pt_tmp);
152
153         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
154 }
155
156 static bGPDstroke *rna_GPencil_stroke_new(bGPDframe *frame)
157 {
158         bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
159
160         BLI_addtail(&frame->strokes, stroke);
161
162         return stroke;
163 }
164
165 static void rna_GPencil_stroke_remove(bGPDframe *frame, ReportList *reports, bGPDstroke *stroke)
166 {
167         if (BLI_findindex(&frame->strokes, stroke) == -1) {
168                 BKE_report(reports, RPT_ERROR, "Stroke not found in grease pencil frame");
169                 return;
170         }
171         
172         BLI_freelinkN(&frame->strokes, stroke);
173
174         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
175 }
176
177 static bGPDframe *rna_GPencil_frame_new(bGPDlayer *layer, ReportList *reports, int frame_number)
178 {
179         bGPDframe *frame;
180
181         if (BKE_gpencil_layer_find_frame(layer, frame_number)) {
182                 BKE_reportf(reports, RPT_ERROR, "Frame already exists on this frame number %d", frame_number);
183                 return NULL;
184         }
185
186         frame = gpencil_frame_addnew(layer, frame_number);
187
188         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
189
190         return frame;
191 }
192
193 static void rna_GPencil_frame_remove(bGPDlayer *layer, ReportList *reports, bGPDframe *frame)
194 {
195         if (BLI_findindex(&layer->frames, frame) == -1) {
196                 BKE_report(reports, RPT_ERROR, "Frame not found in grease pencil layer");
197                 return;
198         }
199         
200         gpencil_layer_delframe(layer, frame);
201
202         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
203 }
204
205 static bGPDframe *rna_GPencil_frame_copy(bGPDlayer *layer, bGPDframe *src)
206 {
207         bGPDframe *frame = gpencil_frame_duplicate(src);
208
209         while (BKE_gpencil_layer_find_frame(layer, frame->framenum)) {
210                 frame->framenum++;
211         }
212
213         BLI_addtail(&layer->frames, frame);
214
215         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
216
217         return frame;
218 }
219
220 static bGPDlayer *rna_GPencil_layer_new(bGPdata *gpd, const char *name, int setactive)
221 {
222         bGPDlayer *gl = gpencil_layer_addnew(gpd, name, setactive);
223
224         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
225
226         return gl;
227 }
228
229 static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, bGPDlayer *layer)
230 {
231         if (BLI_findindex(&gpd->layers, layer) == -1) {
232                 BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
233                 return;
234         }
235         
236         gpencil_layer_delete(gpd, layer);
237
238         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
239 }
240
241 static void rna_GPencil_frame_clear(bGPDframe *frame)
242 {
243         free_gpencil_strokes(frame);
244
245         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
246 }
247
248 static void rna_GPencil_layer_clear(bGPDlayer *layer)
249 {
250         free_gpencil_frames(layer);
251
252         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
253 }
254
255 static void rna_GPencil_clear(bGPdata *gpd)
256 {
257         free_gpencil_layers(&gpd->layers);
258
259         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
260 }
261
262 #else
263
264 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
265 {
266         StructRNA *srna;
267         PropertyRNA *prop;
268         
269         srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);
270         RNA_def_struct_sdna(srna, "bGPDspoint");
271         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Point", "Data point for freehand stroke curve");
272         
273         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
274         RNA_def_property_float_sdna(prop, NULL, "x");
275         RNA_def_property_array(prop, 3);
276         RNA_def_property_ui_text(prop, "Coordinates", "");
277         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
278         
279         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
280         RNA_def_property_float_sdna(prop, NULL, "pressure");
281         RNA_def_property_range(prop, 0.0f, 1.0f);
282         RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
283         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
284 }
285
286 static void rna_def_gpencil_stroke_points_api(BlenderRNA *brna, PropertyRNA *cprop)
287 {
288         StructRNA *srna;
289
290         FunctionRNA *func;
291         /* PropertyRNA *parm; */
292
293         RNA_def_property_srna(cprop, "GPencilStrokePoints");
294         srna = RNA_def_struct(brna, "GPencilStrokePoints", NULL);
295         RNA_def_struct_sdna(srna, "bGPDstroke");
296         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Points", "Collection of grease pencil stroke points");
297
298         func = RNA_def_function(srna, "add", "rna_GPencil_stroke_point_add");
299         RNA_def_function_ui_description(func, "Add a new grease pencil stroke point");
300         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the stroke", 0, INT_MAX);
301
302         func = RNA_def_function(srna, "pop", "rna_GPencil_stroke_point_pop");
303         RNA_def_function_ui_description(func, "Remove a grease pencil stroke point");
304         RNA_def_function_flag(func, FUNC_USE_REPORTS);
305         RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "Index", "point index", INT_MIN, INT_MAX);
306 }
307
308 static void rna_def_gpencil_stroke(BlenderRNA *brna)
309 {
310         StructRNA *srna;
311         PropertyRNA *prop;
312
313         static EnumPropertyItem stroke_draw_mode_items[] = {
314                 {0, "SCREEN", 0, "Screen", "Stroke is in screen-space"},
315                 {GP_STROKE_3DSPACE, "3DSPACE", 0, "3D Space", "Stroke is in 3D-space"},
316                 {GP_STROKE_2DSPACE, "2DSPACE", 0, "2D Space", "Stroke is in 2D-space"},
317                 {GP_STROKE_2DIMAGE, "2DIMAGE", 0, "2D Image", "Stroke is in 2D-space (but with special 'image' scaling)"},
318                 {0, NULL, 0, NULL, NULL}
319         };
320         
321         srna = RNA_def_struct(brna, "GPencilStroke", NULL);
322         RNA_def_struct_sdna(srna, "bGPDstroke");
323         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke", "Freehand curve defining part of a sketch");
324         
325         /* Points */
326         prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
327         RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
328         RNA_def_property_struct_type(prop, "GPencilStrokePoint");
329         RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
330         rna_def_gpencil_stroke_points_api(brna, prop);
331
332         prop = RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);
333         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
334         RNA_def_property_enum_items(prop, stroke_draw_mode_items);
335         RNA_def_property_ui_text(prop, "Draw Mode", "");
336         RNA_def_property_update(prop, 0, "rna_GPencil_update");
337 }
338
339 static void rna_def_gpencil_strokes_api(BlenderRNA *brna, PropertyRNA *cprop)
340 {
341         StructRNA *srna;
342
343         FunctionRNA *func;
344         PropertyRNA *parm;
345
346         RNA_def_property_srna(cprop, "GPencilStrokes");
347         srna = RNA_def_struct(brna, "GPencilStrokes", NULL);
348         RNA_def_struct_sdna(srna, "bGPDframe");
349         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil frames");
350
351         func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");
352         RNA_def_function_ui_description(func, "Add a new grease pencil frame");
353         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");
354         RNA_def_function_return(func, parm);
355
356         func = RNA_def_function(srna, "remove", "rna_GPencil_stroke_remove");
357         RNA_def_function_ui_description(func, "Remove a grease pencil frame");
358         RNA_def_function_flag(func, FUNC_USE_REPORTS);
359         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");
360         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
361 }
362
363 static void rna_def_gpencil_frame(BlenderRNA *brna)
364 {
365         StructRNA *srna;
366         PropertyRNA *prop;
367
368         FunctionRNA *func;
369         
370         srna = RNA_def_struct(brna, "GPencilFrame", NULL);
371         RNA_def_struct_sdna(srna, "bGPDframe");
372         RNA_def_struct_ui_text(srna, "Grease Pencil Frame", "Collection of related sketches on a particular frame");
373         
374         /* Strokes */
375         prop = RNA_def_property(srna, "strokes", PROP_COLLECTION, PROP_NONE);
376         RNA_def_property_collection_sdna(prop, NULL, "strokes", NULL);
377         RNA_def_property_struct_type(prop, "GPencilStroke");
378         RNA_def_property_ui_text(prop, "Strokes", "Freehand curves defining the sketch on this frame");
379         rna_def_gpencil_strokes_api(brna, prop);
380
381         /* Frame Number */
382         prop = RNA_def_property(srna, "frame_number", PROP_INT, PROP_NONE);
383         RNA_def_property_int_sdna(prop, NULL, "framenum");
384         RNA_def_property_range(prop, MINFRAME, MAXFRAME); /* XXX note: this cannot occur on the same frame as another sketch */
385         RNA_def_property_ui_text(prop, "Frame Number", "The frame on which this sketch appears");
386         
387         /* Flags */
388         prop = RNA_def_property(srna, "is_edited", PROP_BOOLEAN, PROP_NONE);
389         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_PAINT); /* XXX should it be editable? */
390         RNA_def_property_ui_text(prop, "Paint Lock", "Frame is being edited (painted on)");
391         
392         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
393         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_SELECT);
394         RNA_def_property_ui_text(prop, "Select", "Frame is selected for editing in the DopeSheet");
395
396         func = RNA_def_function(srna, "clear", "rna_GPencil_frame_clear");
397         RNA_def_function_ui_description(func, "Remove all the grease pencil frame data");
398 }
399
400 static void rna_def_gpencil_frames_api(BlenderRNA *brna, PropertyRNA *cprop)
401 {
402         StructRNA *srna;
403
404         FunctionRNA *func;
405         PropertyRNA *parm;
406
407         RNA_def_property_srna(cprop, "GPencilFrames");
408         srna = RNA_def_struct(brna, "GPencilFrames", NULL);
409         RNA_def_struct_sdna(srna, "bGPDlayer");
410         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil frames");
411
412         func = RNA_def_function(srna, "new", "rna_GPencil_frame_new");
413         RNA_def_function_ui_description(func, "Add a new grease pencil frame");
414         RNA_def_function_flag(func, FUNC_USE_REPORTS);
415         parm = RNA_def_int(func, "frame_number", 1, MINFRAME, MAXFRAME, "Frame Number", "The frame on which this sketch appears", MINFRAME, MAXFRAME);
416         RNA_def_property_flag(parm, PROP_REQUIRED);
417         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "", "The newly created frame");
418         RNA_def_function_return(func, parm);
419
420         func = RNA_def_function(srna, "remove", "rna_GPencil_frame_remove");
421         RNA_def_function_ui_description(func, "Remove a grease pencil frame");
422         RNA_def_function_flag(func, FUNC_USE_REPORTS);
423         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "Frame", "The frame to remove");
424         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
425
426         func = RNA_def_function(srna, "copy", "rna_GPencil_frame_copy");
427         RNA_def_function_ui_description(func, "Copy a grease pencil frame");
428         parm = RNA_def_pointer(func, "source", "GPencilFrame", "Source", "The source frame");
429         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
430         parm = RNA_def_pointer(func, "copy", "GPencilFrame", "", "The newly copied frame");
431         RNA_def_function_return(func, parm);
432 }
433
434 static void rna_def_gpencil_layer(BlenderRNA *brna)
435 {
436         StructRNA *srna;
437         PropertyRNA *prop;
438
439         FunctionRNA *func;
440         
441         srna = RNA_def_struct(brna, "GPencilLayer", NULL);
442         RNA_def_struct_sdna(srna, "bGPDlayer");
443         RNA_def_struct_ui_text(srna, "Grease Pencil Layer", "Collection of related sketches");
444         
445         /* Name */
446         prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
447         RNA_def_property_ui_text(prop, "Info", "Layer name");
448         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_info_set");
449         RNA_def_struct_name_property(srna, prop);
450         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
451
452         /* Frames */
453         prop = RNA_def_property(srna, "frames", PROP_COLLECTION, PROP_NONE);
454         RNA_def_property_collection_sdna(prop, NULL, "frames", NULL);
455         RNA_def_property_struct_type(prop, "GPencilFrame");
456         RNA_def_property_ui_text(prop, "Frames", "Sketches for this layer on different frames");
457         rna_def_gpencil_frames_api(brna, prop);
458
459         /* Active Frame */
460         prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
461         RNA_def_property_pointer_sdna(prop, NULL, "actframe");
462         RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
463         RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
464         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
465
466         /* Drawing Color */
467         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
468         RNA_def_property_array(prop, 3);
469         RNA_def_property_range(prop, 0.0f, 1.0f);
470         RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
471         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
472         
473         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
474         RNA_def_property_float_sdna(prop, NULL, "color[3]");
475         RNA_def_property_range(prop, 0.3, 1.0f);
476         RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
477         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
478         
479         /* Line Thickness */
480         prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_NONE);
481         RNA_def_property_int_sdna(prop, NULL, "thickness");
482         RNA_def_property_range(prop, 1, 10);
483         RNA_def_property_ui_text(prop, "Thickness", "Thickness of strokes (in pixels)");
484         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
485         
486         /* Onion-Skinning */
487         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
488         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ONIONSKIN);
489         RNA_def_property_ui_text(prop, "Onion Skinning", "Ghost frames on either side of frame");
490         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
491         
492         prop = RNA_def_property(srna, "ghost_range_max", PROP_INT, PROP_NONE);
493         RNA_def_property_int_sdna(prop, NULL, "gstep");
494         RNA_def_property_range(prop, 0, 120);
495         RNA_def_property_ui_text(prop, "Max Ghost Range",
496                                  "Maximum number of frames on either side of the active frame to show "
497                                  "(0 = show the 'first' available sketch on either side)");
498         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
499         
500         /* Flags */
501         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
502         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
503         RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
504         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
505         
506         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
507         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_LOCKED);
508         RNA_def_property_ui_text(prop, "Locked", "Protect layer from further editing and/or frame changes");
509         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
510         
511         prop = RNA_def_property(srna, "lock_frame", PROP_BOOLEAN, PROP_NONE);
512         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_FRAMELOCK);
513         RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
514         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
515
516         /* expose as layers.active */
517 #if 0
518         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
519         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
520         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
521         RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
522         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
523 #endif
524
525         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
526         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
527         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the DopeSheet");
528         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
529         
530         /* XXX keep this option? */
531         prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
532         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
533         RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
534         RNA_def_property_update_runtime(prop, "rna_GPencil_update");
535
536         /* X-Ray */
537         prop = RNA_def_property(srna, "show_x_ray", PROP_BOOLEAN, PROP_NONE);
538         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
539         RNA_def_property_ui_text(prop, "X Ray", "Make the layer draw in front of objects");
540         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
541
542         func = RNA_def_function(srna, "clear", "rna_GPencil_layer_clear");
543         RNA_def_function_ui_description(func, "Remove all the grease pencil layer data");
544 }
545
546 static void rna_def_gpencil_layers_api(BlenderRNA *brna, PropertyRNA *cprop)
547 {
548         StructRNA *srna;
549         PropertyRNA *prop;
550
551         FunctionRNA *func;
552         PropertyRNA *parm;
553
554         RNA_def_property_srna(cprop, "GreasePencilLayers");
555         srna = RNA_def_struct(brna, "GreasePencilLayers", NULL);
556         RNA_def_struct_sdna(srna, "bGPdata");
557         RNA_def_struct_ui_text(srna, "Grease Pencil Layers", "Collection of grease pencil layers");
558
559         func = RNA_def_function(srna, "new", "rna_GPencil_layer_new");
560         RNA_def_function_ui_description(func, "Add a new grease pencil layer");
561         parm = RNA_def_string(func, "name", "GPencilLayer", MAX_NAME, "Name", "Name of the layer");
562         RNA_def_property_flag(parm, PROP_REQUIRED);
563         RNA_def_boolean(func, "set_active", 0, "Set Active", "Set the newly created layer to the active layer");
564         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The newly created layer");
565         RNA_def_function_return(func, parm);
566
567         func = RNA_def_function(srna, "remove", "rna_GPencil_layer_remove");
568         RNA_def_function_ui_description(func, "Remove a grease pencil layer");
569         RNA_def_function_flag(func, FUNC_USE_REPORTS);
570         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to remove");
571         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
572
573         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
574         RNA_def_property_struct_type(prop, "GreasePencil");
575         RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_layer_get", "rna_GPencil_active_layer_set", NULL, NULL);
576         RNA_def_property_flag(prop, PROP_EDITABLE);
577         RNA_def_property_ui_text(prop, "Active Layer", "Active grease pencil layer");
578 }
579
580 static void rna_def_gpencil_data(BlenderRNA *brna)
581 {
582         StructRNA *srna;
583         PropertyRNA *prop;
584         FunctionRNA *func;
585
586         static EnumPropertyItem draw_mode_items[] = {
587                 {GP_DATA_VIEWALIGN, "CURSOR", 0, "Cursor", "Draw stroke at the 3D cursor"},
588                 {0, "VIEW", 0, "View", "Stick stroke to the view "}, /* weird, GP_DATA_VIEWALIGN is inverted */
589                 {GP_DATA_VIEWALIGN | GP_DATA_DEPTH_VIEW, "SURFACE", 0, "Surface", "Stick stroke to surfaces"},
590                 {GP_DATA_VIEWALIGN | GP_DATA_DEPTH_STROKE, "STROKE", 0, "Stroke", "Stick stroke to other strokes"},
591                 {0, NULL, 0, NULL, NULL}
592         };
593
594         srna = RNA_def_struct(brna, "GreasePencil", "ID");
595         RNA_def_struct_sdna(srna, "bGPdata");
596         RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
597         RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);
598         
599         /* Layers */
600         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
601         RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
602         RNA_def_property_struct_type(prop, "GPencilLayer");
603         RNA_def_property_ui_text(prop, "Layers", "");
604         rna_def_gpencil_layers_api(brna, prop);
605         
606         /* Flags */
607         prop = RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);
608         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
609         RNA_def_property_enum_items(prop, draw_mode_items);
610         RNA_def_property_ui_text(prop, "Draw Mode", "");
611         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
612
613         prop = RNA_def_property(srna, "use_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
614         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_DEPTH_STROKE_ENDPOINTS);
615         RNA_def_property_ui_text(prop, "Only Endpoints", "Only use the first and last parts of the stroke for snapping");
616         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
617
618         func = RNA_def_function(srna, "clear", "rna_GPencil_clear");
619         RNA_def_function_ui_description(func, "Remove all the grease pencil data");
620 }
621
622 /* --- */
623
624 void RNA_def_gpencil(BlenderRNA *brna)
625 {
626         rna_def_gpencil_data(brna);
627
628         rna_def_gpencil_layer(brna);
629         rna_def_gpencil_frame(brna);
630         rna_def_gpencil_stroke(brna);
631         rna_def_gpencil_stroke_point(brna);
632 }
633
634 #endif