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