Grease Pencil notifier/listener cleanup
[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 bGPDlayer *rna_GPencil_layer_new(bGPdata *gpd, const char *name, int setactive)
115 {
116         bGPDlayer *gl = gpencil_layer_addnew(gpd, name, setactive);
117
118         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
119
120         return gl;
121 }
122
123 static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, bGPDlayer *layer)
124 {
125         bGPDlayer *gl;
126
127         for (gl = gpd->layers.first; gl; gl = gl->next) {
128                 if (gl == layer)
129                         break;
130         }
131
132         if (gl == NULL) {
133                 BKE_reportf(reports, RPT_ERROR, "Layer not found in grease pencil data");
134                 return;
135         }
136         
137         gpencil_layer_delete(gpd, layer);
138
139         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
140 }
141
142 #else
143
144 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
145 {
146         StructRNA *srna;
147         PropertyRNA *prop;
148         
149         srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);
150         RNA_def_struct_sdna(srna, "bGPDspoint");
151         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Point", "Data point for freehand stroke curve");
152         
153         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
154         RNA_def_property_float_sdna(prop, NULL, "x");
155         RNA_def_property_array(prop, 3);
156         RNA_def_property_ui_text(prop, "Coordinates", "");
157         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
158         
159         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
160         RNA_def_property_float_sdna(prop, NULL, "pressure");
161         RNA_def_property_range(prop, 0.0f, 1.0f);
162         RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
163         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
164 }
165
166 static void rna_def_gpencil_stroke(BlenderRNA *brna)
167 {
168         StructRNA *srna;
169         PropertyRNA *prop;
170         
171         srna = RNA_def_struct(brna, "GPencilStroke", NULL);
172         RNA_def_struct_sdna(srna, "bGPDstroke");
173         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke", "Freehand curve defining part of a sketch");
174         
175         /* Points */
176         prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
177         RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
178         RNA_def_property_struct_type(prop, "GPencilStrokePoint");
179         RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
180         
181         /* Flags - Readonly type-info really... */
182         /* TODO... */
183 }
184
185 static void rna_def_gpencil_frame(BlenderRNA *brna)
186 {
187         StructRNA *srna;
188         PropertyRNA *prop;
189         
190         srna = RNA_def_struct(brna, "GPencilFrame", NULL);
191         RNA_def_struct_sdna(srna, "bGPDframe");
192         RNA_def_struct_ui_text(srna, "Grease Pencil Frame", "Collection of related sketches on a particular frame");
193         
194         /* Strokes */
195         prop = RNA_def_property(srna, "strokes", PROP_COLLECTION, PROP_NONE);
196         RNA_def_property_collection_sdna(prop, NULL, "strokes", NULL);
197         RNA_def_property_struct_type(prop, "GPencilStroke");
198         RNA_def_property_ui_text(prop, "Strokes", "Freehand curves defining the sketch on this frame");
199         
200         /* Frame Number */
201         prop = RNA_def_property(srna, "frame_number", PROP_INT, PROP_NONE);
202         RNA_def_property_int_sdna(prop, NULL, "framenum");
203         RNA_def_property_range(prop, MINFRAME, MAXFRAME); /* XXX note: this cannot occur on the same frame as another sketch */
204         RNA_def_property_ui_text(prop, "Frame Number", "The frame on which this sketch appears");
205         
206         /* Flags */
207         prop = RNA_def_property(srna, "is_edited", PROP_BOOLEAN, PROP_NONE);
208         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_PAINT); /* XXX should it be editable? */
209         RNA_def_property_ui_text(prop, "Paint Lock", "Frame is being edited (painted on)");
210         
211         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
212         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_SELECT);
213         RNA_def_property_ui_text(prop, "Select", "Frame is selected for editing in the DopeSheet");
214 }
215
216 static void rna_def_gpencil_layer(BlenderRNA *brna)
217 {
218         StructRNA *srna;
219         PropertyRNA *prop;
220         
221         srna = RNA_def_struct(brna, "GPencilLayer", NULL);
222         RNA_def_struct_sdna(srna, "bGPDlayer");
223         RNA_def_struct_ui_text(srna, "Grease Pencil Layer", "Collection of related sketches");
224         
225         /* Name */
226         prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
227         RNA_def_property_ui_text(prop, "Info", "Layer name");
228         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_info_set");
229         RNA_def_struct_name_property(srna, prop);
230         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
231
232         /* Frames */
233         prop = RNA_def_property(srna, "frames", PROP_COLLECTION, PROP_NONE);
234         RNA_def_property_collection_sdna(prop, NULL, "frames", NULL);
235         RNA_def_property_struct_type(prop, "GPencilFrame");
236         RNA_def_property_ui_text(prop, "Frames", "Sketches for this layer on different frames");
237         
238         /* Active Frame */
239         prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
240         RNA_def_property_pointer_sdna(prop, NULL, "actframe");
241         RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
242         RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
243         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
244
245         /* Drawing Color */
246         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
247         RNA_def_property_array(prop, 3);
248         RNA_def_property_range(prop, 0.0f, 1.0f);
249         RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
250         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
251         
252         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
253         RNA_def_property_float_sdna(prop, NULL, "color[3]");
254         RNA_def_property_range(prop, 0.3, 1.0f);
255         RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
256         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
257         
258         /* Line Thickness */
259         prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_NONE);
260         RNA_def_property_int_sdna(prop, NULL, "thickness");
261         RNA_def_property_range(prop, 1, 10);
262         RNA_def_property_ui_text(prop, "Thickness", "Thickness of strokes (in pixels)");
263         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
264         
265         /* Onion-Skinning */
266         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
267         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ONIONSKIN);
268         RNA_def_property_ui_text(prop, "Onion Skinning", "Ghost frames on either side of frame");
269         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
270         
271         prop = RNA_def_property(srna, "ghost_range_max", PROP_INT, PROP_NONE);
272         RNA_def_property_int_sdna(prop, NULL, "gstep");
273         RNA_def_property_range(prop, 0, 120);
274         RNA_def_property_ui_text(prop, "Max Ghost Range",
275                                  "Maximum number of frames on either side of the active frame to show "
276                                  "(0 = show the 'first' available sketch on either side)");
277         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
278         
279         /* Flags */
280         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
281         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
282         RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
283         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
284         
285         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
286         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_LOCKED);
287         RNA_def_property_ui_text(prop, "Locked", "Protect layer from further editing and/or frame changes");
288         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
289         
290         prop = RNA_def_property(srna, "lock_frame", PROP_BOOLEAN, PROP_NONE);
291         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_FRAMELOCK);
292         RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
293         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
294
295         /* expose as layers.active */
296 #if 0
297         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
298         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
299         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
300         RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
301         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
302 #endif
303
304         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
305         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
306         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the DopeSheet");
307         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
308         
309         /* XXX keep this option? */
310         prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
311         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
312         RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
313         RNA_def_property_update_runtime(prop, "rna_GPencil_update");
314
315         /* X-Ray */
316         prop = RNA_def_property(srna, "show_x_ray", PROP_BOOLEAN, PROP_NONE);
317         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
318         RNA_def_property_ui_text(prop, "X Ray", "Make the layer draw in front of objects");
319         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
320 }
321
322 static void rna_def_gpencil_layers(BlenderRNA *brna, PropertyRNA *cprop)
323 {
324         StructRNA *srna;
325         PropertyRNA *prop;
326
327         FunctionRNA *func;
328         PropertyRNA *parm;
329
330         RNA_def_property_srna(cprop, "GreasePencilLayers");
331         srna = RNA_def_struct(brna, "GreasePencilLayers", NULL);
332         RNA_def_struct_sdna(srna, "bGPdata");
333         RNA_def_struct_ui_text(srna, "Grease Pencil Layers", "Collection of grease pencil layers");
334
335         func = RNA_def_function(srna, "new", "rna_GPencil_layer_new");
336         RNA_def_function_ui_description(func, "Add a new grease pencil layer");
337         parm =  RNA_def_string(func, "name", "GPencilLayer", MAX_NAME, "Name", "Name of the layer");
338         RNA_def_property_flag(parm, PROP_REQUIRED);
339         RNA_def_boolean(func, "set_active", 0, "Set Active", "Set the newly created layer to the active layer");
340         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The newly created layer");
341         RNA_def_function_return(func, parm);
342
343         func = RNA_def_function(srna, "remove", "rna_GPencil_layer_remove");
344         RNA_def_function_ui_description(func, "Remove a grease pencil layer");
345         RNA_def_function_flag(func, FUNC_USE_REPORTS);
346         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to remove");
347         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
348
349         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
350         RNA_def_property_struct_type(prop, "GreasePencil");
351         RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_layer_get", "rna_GPencil_active_layer_set", NULL, NULL);
352         RNA_def_property_flag(prop, PROP_EDITABLE);
353         RNA_def_property_ui_text(prop, "Active Layer", "Active grease pencil layer");
354 }
355
356 static void rna_def_gpencil_data(BlenderRNA *brna)
357 {
358         StructRNA *srna;
359         PropertyRNA *prop;
360         
361         static EnumPropertyItem draw_mode_items[] = {
362                 {GP_DATA_VIEWALIGN, "CURSOR", 0, "Cursor", "Draw stroke at the 3D cursor"},
363                 {0, "VIEW", 0, "View", "Stick stroke to the view "}, /* weird, GP_DATA_VIEWALIGN is inverted */
364                 {GP_DATA_VIEWALIGN | GP_DATA_DEPTH_VIEW, "SURFACE", 0, "Surface", "Stick stroke to surfaces"},
365                 {GP_DATA_VIEWALIGN | GP_DATA_DEPTH_STROKE, "STROKE", 0, "Stroke", "Stick stroke to other strokes"},
366                 {0, NULL, 0, NULL, NULL}
367         };
368
369         srna = RNA_def_struct(brna, "GreasePencil", "ID");
370         RNA_def_struct_sdna(srna, "bGPdata");
371         RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
372         RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);
373         
374         /* Layers */
375         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
376         RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
377         RNA_def_property_struct_type(prop, "GPencilLayer");
378         RNA_def_property_ui_text(prop, "Layers", "");
379         rna_def_gpencil_layers(brna, prop);
380         
381         /* Flags */
382         prop = RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);
383         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
384         RNA_def_property_enum_items(prop, draw_mode_items);
385         RNA_def_property_ui_text(prop, "Draw Mode", "");
386         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
387
388         prop = RNA_def_property(srna, "use_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
389         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_DEPTH_STROKE_ENDPOINTS);
390         RNA_def_property_ui_text(prop, "Only Endpoints", "Only use the first and last parts of the stroke for snapping");
391         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
392
393 }
394
395 /* --- */
396
397 void RNA_def_gpencil(BlenderRNA *brna)
398 {
399         rna_def_gpencil_data(brna);
400
401         rna_def_gpencil_layer(brna);
402         rna_def_gpencil_frame(brna);
403         rna_def_gpencil_stroke(brna);
404         rna_def_gpencil_stroke_point(brna);
405 }
406
407 #endif