header cleanup and typo's
[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 static int rna_GPencilLayer_active_frame_editable(PointerRNA *ptr)
44 {
45         bGPDlayer *gpl= (bGPDlayer *)ptr->data;
46
47         /* surely there must be other criteria too... */
48         if (gpl->flag & GP_LAYER_LOCKED)
49                 return 0;
50         else
51                 return 1;
52 }
53
54 static PointerRNA rna_GPencil_active_layer_get(PointerRNA *ptr)
55 {
56         bGPdata *gpd= ptr->id.data;
57
58         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
59                 bGPDlayer *gl;
60
61                 for (gl= gpd->layers.first; gl; gl= gl->next) {
62                         if(gl->flag & GP_LAYER_ACTIVE) {
63                                 break;
64                         }
65                 }
66
67                 if(gl) {
68                         return rna_pointer_inherit_refine(ptr, &RNA_GPencilLayer, gl);
69                 }
70         }
71
72         return rna_pointer_inherit_refine(ptr, NULL, NULL);
73 }
74
75 static void rna_GPencil_active_layer_set(PointerRNA *ptr, PointerRNA value)
76 {
77         bGPdata *gpd= ptr->id.data;
78
79         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
80                 bGPDlayer *gl;
81
82                 for (gl= gpd->layers.first; gl; gl= gl->next) {
83                         if(gl == value.data) {
84                                 gl->flag |= GP_LAYER_ACTIVE;
85                         }
86                         else {
87                                 gl->flag &= ~GP_LAYER_ACTIVE;
88                         }
89                 }
90         }
91 }
92
93 void rna_GPencilLayer_info_set(PointerRNA *ptr, const char *value)
94 {
95         bGPdata *gpd= ptr->id.data;
96         bGPDlayer *gpl= ptr->data;
97
98         /* copy the new name into the name slot */
99         BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));
100
101         BLI_uniquename(&gpd->layers, gpl, "GP_Layer", '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
102 }
103
104 #else
105
106 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
107 {
108         StructRNA *srna;
109         PropertyRNA *prop;
110         
111         srna= RNA_def_struct(brna, "GPencilStrokePoint", NULL);
112         RNA_def_struct_sdna(srna, "bGPDspoint");
113         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Point", "Data point for freehand stroke curve");
114         
115         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
116         RNA_def_property_float_sdna(prop, NULL, "x");
117         RNA_def_property_array(prop, 3);
118         RNA_def_property_ui_text(prop, "Coordinates", "");
119         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
120         
121         prop= RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
122         RNA_def_property_float_sdna(prop, NULL, "pressure");
123         RNA_def_property_range(prop, 0.0f, 1.0f);
124         RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
125         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
126 }
127
128 static void rna_def_gpencil_stroke(BlenderRNA *brna)
129 {
130         StructRNA *srna;
131         PropertyRNA *prop;
132         
133         srna= RNA_def_struct(brna, "GPencilStroke", NULL);
134         RNA_def_struct_sdna(srna, "bGPDstroke");
135         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke", "Freehand curve defining part of a sketch");
136         
137         /* Points */
138         prop= RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
139         RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
140         RNA_def_property_struct_type(prop, "GPencilStrokePoint");
141         RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
142         
143         /* Flags - Readonly type-info really... */
144         // TODO...
145 }
146
147 static void rna_def_gpencil_frame(BlenderRNA *brna)
148 {
149         StructRNA *srna;
150         PropertyRNA *prop;
151         
152         srna= RNA_def_struct(brna, "GPencilFrame", NULL);
153         RNA_def_struct_sdna(srna, "bGPDframe");
154         RNA_def_struct_ui_text(srna, "Grease Pencil Frame", "Collection of related sketches on a particular frame");
155         
156         /* Strokes */
157         prop= RNA_def_property(srna, "strokes", PROP_COLLECTION, PROP_NONE);
158         RNA_def_property_collection_sdna(prop, NULL, "strokes", NULL);
159         RNA_def_property_struct_type(prop, "GPencilStroke");
160         RNA_def_property_ui_text(prop, "Strokes", "Freehand curves defining the sketch on this frame");
161         
162         /* Frame Number */
163         prop= RNA_def_property(srna, "frame_number", PROP_INT, PROP_NONE);
164         RNA_def_property_int_sdna(prop, NULL, "framenum");
165         RNA_def_property_range(prop, MINFRAME, MAXFRAME); // XXX note: this cannot occur on the same frame as another sketch
166         RNA_def_property_ui_text(prop, "Frame Number", "The frame on which this sketch appears");
167         
168         /* Flags */
169         prop= RNA_def_property(srna, "is_edited", PROP_BOOLEAN, PROP_NONE);
170         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_PAINT); // XXX should it be editable?
171         RNA_def_property_ui_text(prop, "Paint Lock", "Frame is being edited (painted on)");
172         
173         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
174         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_SELECT);
175         RNA_def_property_ui_text(prop, "Select", "Frame is selected for editing in the DopeSheet");
176 }
177
178 static void rna_def_gpencil_layer(BlenderRNA *brna)
179 {
180         StructRNA *srna;
181         PropertyRNA *prop;
182         
183         srna= RNA_def_struct(brna, "GPencilLayer", NULL);
184         RNA_def_struct_sdna(srna, "bGPDlayer");
185         RNA_def_struct_ui_text(srna, "Grease Pencil Layer", "Collection of related sketches");
186         
187         /* Name */
188         prop= RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
189         RNA_def_property_ui_text(prop, "Info", "Layer name");
190         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_info_set");
191         RNA_def_struct_name_property(srna, prop);
192         
193         /* Frames */
194         prop= RNA_def_property(srna, "frames", PROP_COLLECTION, PROP_NONE);
195         RNA_def_property_collection_sdna(prop, NULL, "frames", NULL);
196         RNA_def_property_struct_type(prop, "GPencilFrame");
197         RNA_def_property_ui_text(prop, "Frames", "Sketches for this layer on different frames");
198         
199         /* Active Frame */
200         prop= RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
201         RNA_def_property_pointer_sdna(prop, NULL, "actframe");
202         RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
203         RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
204         
205         /* Drawing Color */
206         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
207         RNA_def_property_array(prop, 3);
208         RNA_def_property_range(prop, 0.0f, 1.0f);
209         RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
210         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
211         
212         prop= RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
213         RNA_def_property_float_sdna(prop, NULL, "color[3]");
214         RNA_def_property_range(prop, 0.3, 1.0f);
215         RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
216         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
217         
218         /* Line Thickness */
219         prop= RNA_def_property(srna, "line_width", PROP_INT, PROP_NONE);
220         RNA_def_property_int_sdna(prop, NULL, "thickness");
221         RNA_def_property_range(prop, 1, 10);
222         RNA_def_property_ui_text(prop, "Thickness", "Thickness of strokes (in pixels)");
223         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
224         
225         /* Onion-Skinning */
226         prop= RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
227         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ONIONSKIN);
228         RNA_def_property_ui_text(prop, "Use Onion Skinning", "Ghost frames on either side of frame");
229         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
230         
231         prop= RNA_def_property(srna, "ghost_range_max", PROP_INT, PROP_NONE);
232         RNA_def_property_int_sdna(prop, NULL, "gstep");
233         RNA_def_property_range(prop, 0, 120);
234         RNA_def_property_ui_text(prop, "Max Ghost Range", "Maximum number of frames on either side of the active frame to show (0 = show the 'first' available sketch on either side)");
235         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
236         
237         /* Flags */
238         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
239         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
240         RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
241         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
242         
243         prop= RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
244         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_LOCKED);
245         RNA_def_property_ui_text(prop, "Locked", "Protect layer from further editing and/or frame changes");
246         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
247         
248         prop= RNA_def_property(srna, "lock_frame", PROP_BOOLEAN, PROP_NONE);
249         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_FRAMELOCK);
250         RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
251         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
252
253         /* expose as layers.active */
254         /*
255         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
256         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
257         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
258         RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
259         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
260         */
261
262         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
263         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
264         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the DopeSheet");
265         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
266         
267                 // XXX keep this option?
268         prop= RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
269         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
270         RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
271         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
272
273         /* X-Ray */
274         prop= RNA_def_property(srna, "show_x_ray", PROP_BOOLEAN, PROP_NONE);
275         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
276         RNA_def_property_ui_text(prop, "X Ray", "");
277         RNA_def_property_update(prop, NC_SCREEN|ND_GPENCIL, NULL);
278 }
279
280 static void rna_def_gpencil_layers(BlenderRNA *brna, PropertyRNA *cprop)
281 {
282         StructRNA *srna;
283         PropertyRNA *prop;
284
285 //      FunctionRNA *func;
286 //      PropertyRNA *parm;
287
288         RNA_def_property_srna(cprop, "GreasePencilLayers");
289         srna= RNA_def_struct(brna, "GreasePencilLayers", NULL);
290         RNA_def_struct_sdna(srna, "bGPdata");
291         RNA_def_struct_ui_text(srna, "Grease Pencil Layers", "Collection of grease pencil layers");
292
293 #if 0
294         func= RNA_def_function(srna, "new", "rna_GPencil_layer_new");
295         RNA_def_function_ui_description(func, "Add a new spline to the curve");
296         parm= RNA_def_enum(func, "type", curve_type_items, CU_POLY, "", "type for the new spline");
297         RNA_def_property_flag(parm, PROP_REQUIRED);
298         parm= RNA_def_pointer(func, "spline", "Spline", "", "The newly created spline");
299         RNA_def_function_return(func, parm);
300
301         func= RNA_def_function(srna, "remove", "rna_GPencil_layer_remove");
302         RNA_def_function_ui_description(func, "Remove a spline from a curve");
303         RNA_def_function_flag(func, FUNC_USE_REPORTS);
304         parm= RNA_def_pointer(func, "spline", "Spline", "", "The spline to remove");
305         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
306 #endif
307
308         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
309         RNA_def_property_struct_type(prop, "GreasePencil");
310         RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_layer_get", "rna_GPencil_active_layer_set", NULL, NULL);
311         RNA_def_property_flag(prop, PROP_EDITABLE);
312         RNA_def_property_ui_text(prop, "Active Layer", "Active grease pencil layer");
313 }
314
315 static void rna_def_gpencil_data(BlenderRNA *brna)
316 {
317         StructRNA *srna;
318         PropertyRNA *prop;
319         
320         static EnumPropertyItem draw_mode_items[] = {
321                 {GP_DATA_VIEWALIGN, "CURSOR", 0, "Cursor", "Draw stroke at the 3D cursor"},
322                 {0, "VIEW", 0, "View", "Stick stroke to the view "}, /* weird, GP_DATA_VIEWALIGN is inverted */
323                 {GP_DATA_VIEWALIGN|GP_DATA_DEPTH_VIEW, "SURFACE", 0, "Surface", "Stick stroke to surfaces"},
324                 {GP_DATA_VIEWALIGN|GP_DATA_DEPTH_STROKE, "STROKE", 0, "Stroke", "Stick stroke to other strokes"},
325                 {0, NULL, 0, NULL, NULL}};
326
327         srna= RNA_def_struct(brna, "GreasePencil", "ID");
328         RNA_def_struct_sdna(srna, "bGPdata");
329         RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
330         RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);
331         
332         /* Layers */
333         prop= RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
334         RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
335         RNA_def_property_struct_type(prop, "GPencilLayer");
336         RNA_def_property_ui_text(prop, "Layers", "");
337         rna_def_gpencil_layers(brna, prop);
338         
339         /* Flags */
340         prop= RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);
341         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
342         RNA_def_property_enum_items(prop, draw_mode_items);
343         RNA_def_property_ui_text(prop, "Draw Mode", "");
344
345         prop= RNA_def_property(srna, "use_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
346         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_DEPTH_STROKE_ENDPOINTS);
347         RNA_def_property_ui_text(prop, "Only Endpoints", "Only use the first and last parts of the stroke for snapping");
348
349
350 }
351
352 /* --- */
353
354 void RNA_def_gpencil(BlenderRNA *brna)
355 {
356         rna_def_gpencil_data(brna);
357
358         rna_def_gpencil_layer(brna);
359         rna_def_gpencil_frame(brna);
360         rna_def_gpencil_stroke(brna);
361         rna_def_gpencil_stroke_point(brna);
362 }
363
364 #endif