rna/py api
[blender-staging.git] / source / blender / makesrna / intern / rna_main_api.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation.
21  * All rights reserved.
22  *
23  * 
24  * Contributor(s): Blender Foundation
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 #include <stdlib.h>
30 #include <stdio.h>
31
32 #include "RNA_define.h"
33 #include "RNA_types.h"
34 #include "RNA_enum_types.h"
35
36 #include "BKE_utildefines.h"
37
38 #ifdef RNA_RUNTIME
39
40 #include "BKE_main.h"
41 #include "BKE_mesh.h"
42 #include "BKE_armature.h"
43 #include "BKE_library.h"
44 #include "BKE_object.h"
45 #include "BKE_material.h"
46 #include "BKE_image.h"
47 #include "BKE_texture.h"
48 #include "BKE_scene.h"
49 #include "BKE_text.h"
50 #include "BKE_action.h"
51 #include "BKE_group.h"
52
53 #include "DNA_armature_types.h"
54 #include "DNA_camera_types.h"
55 #include "DNA_lamp_types.h"
56 #include "DNA_material_types.h"
57 #include "DNA_mesh_types.h"
58 #include "DNA_object_types.h"
59 #include "DNA_text_types.h"
60 #include "DNA_group_types.h"
61
62 #include "ED_screen.h"
63
64 Tex *rna_Main_add_texture(Main *bmain, char *name)
65 {
66         return add_texture(name);
67 }
68
69 /* TODO: remove texture? */
70
71 Image *rna_Main_add_image(Main *bmain, char *filename)
72 {
73         return BKE_add_image_file(filename, 0);
74 }
75
76 Camera *rna_Main_cameras_new(Main *bmain, char* name)
77 {
78         return add_camera(name);
79 }
80 void rna_Main_cameras_remove(Main *bmain, ReportList *reports, struct Camera *camera)
81 {
82         if(camera->id.us == 0)
83                 free_libblock(&bmain->camera, camera);
84         else
85                 BKE_reportf(reports, RPT_ERROR, "Camera \"%s\" must have zero users to be removed, found %d.", camera->id.name+2, camera->id.us);
86
87         /* XXX python now has invalid pointer? */
88 }
89
90 Scene *rna_Main_scenes_new(Main *bmain, char* name)
91 {
92         return add_scene(name);
93 }
94 void rna_Main_scenes_remove(Main *bmain, bContext *C, ReportList *reports, struct Scene *scene)
95 {
96         /* dont call free_libblock(...) directly */
97         Scene *newscene;
98
99         if(scene->id.prev)
100                 newscene= scene->id.prev;
101         else if(scene->id.next)
102                 newscene= scene->id.next;
103         else {
104                 BKE_reportf(reports, RPT_ERROR, "Scene \"%s\" is the last, cant ve removed.", scene->id.name+2);
105                 return;
106         }
107
108         ED_screen_set_scene(C, newscene);
109
110         unlink_scene(bmain, scene, newscene);
111 }
112
113 Object *rna_Main_objects_new(Main *bmain, char* name, int type)
114 {
115         Object *ob= add_only_object(type, name);
116         ob->id.us--;
117         return ob;
118 }
119 void rna_Main_objects_remove(Main *bmain, ReportList *reports, struct Object *object)
120 {
121         /*
122           NOTE: the following example shows when this function should _not_ be called
123
124           ob = bpy.data.add_object()
125           scene.add_object(ob)
126
127           # ob is freed here
128           scene.remove_object(ob)
129
130           # don't do this since ob is already freed!
131           bpy.data.remove_object(ob)
132         */
133         if(object->id.us == 0)
134                 free_libblock(&bmain->object, object);
135         else
136                 BKE_reportf(reports, RPT_ERROR, "Object \"%s\" must have zero users to be removed, found %d.", object->id.name+2, object->id.us);
137 }
138
139 struct Material *rna_Main_materials_new(Main *bmain, char* name)
140 {
141         return add_material(name);
142 }
143 void rna_Main_materials_remove(Main *bmain, ReportList *reports, struct Material *material)
144 {
145         if(material->id.us == 0)
146                 free_libblock(&bmain->mat, material);
147         else
148                 BKE_reportf(reports, RPT_ERROR, "Material \"%s\" must have zero users to be removed, found %d.", material->id.name+2, material->id.us);
149
150         /* XXX python now has invalid pointer? */
151 }
152
153 Mesh *rna_Main_meshes_new(Main *bmain, char* name)
154 {
155         Mesh *me= add_mesh(name);
156         me->id.us--;
157         return me;
158 }
159 void rna_Main_meshes_remove(Main *bmain, ReportList *reports, Mesh *mesh)
160 {
161         if(mesh->id.us == 0)
162                 free_libblock(&bmain->mesh, mesh);
163         else
164                 BKE_reportf(reports, RPT_ERROR, "Mesh \"%s\" must have zero users to be removed, found %d.", mesh->id.name+2, mesh->id.us);
165
166         /* XXX python now has invalid pointer? */
167 }
168
169 Lamp *rna_Main_lamps_new(Main *bmain, char* name)
170 {
171         Lamp *lamp= add_lamp(name);
172         lamp->id.us--;
173         return lamp;
174 }
175 void rna_Main_lamps_remove(Main *bmain, ReportList *reports, Lamp *lamp)
176 {
177         if(lamp->id.us == 0)
178                 free_libblock(&bmain->lamp, lamp);
179         else
180                 BKE_reportf(reports, RPT_ERROR, "Lamp \"%s\" must have zero users to be removed, found %d.", lamp->id.name+2, lamp->id.us);
181
182         /* XXX python now has invalid pointer? */
183 }
184
185 Group *rna_Main_groups_new(Main *bmain, char* name)
186 {
187         return add_group(name);
188 }
189 void rna_Main_groups_remove(Main *bmain, ReportList *reports, Group *group)
190 {
191         free_group(group);
192         unlink_group(group);
193         group->id.us= 0;
194         free_libblock(&bmain->group, group);
195         /* XXX python now has invalid pointer? */
196 }
197
198 Text *rna_Main_texts_new(Main *bmain, char* name)
199 {
200         return add_empty_text(name);
201 }
202 void rna_Main_texts_remove(Main *bmain, ReportList *reports, Text *text)
203 {
204         unlink_text(bmain, text);
205         free_libblock(&bmain->text, text);
206         /* XXX python now has invalid pointer? */
207 }
208 Text *rna_Main_texts_load(Main *bmain, ReportList *reports, char* path)
209 {
210         Text *txt= add_text(path, bmain->name);
211         if(txt==NULL)
212                 BKE_reportf(reports, RPT_ERROR, "Couldn't load text from path \"%s\".", path);
213
214         return txt;
215 }
216
217 bArmature *rna_Main_armatures_new(Main *bmain, char* name)
218 {
219         bArmature *arm= add_armature(name);
220         arm->id.us--;
221         return arm;
222 }
223 void rna_Main_armatures_remove(Main *bmain, ReportList *reports, bArmature *arm)
224 {
225         if(arm->id.us == 0)
226                 free_libblock(&bmain->armature, arm);
227         else
228                 BKE_reportf(reports, RPT_ERROR, "Armature \"%s\" must have zero users to be removed, found %d.", arm->id.name+2, arm->id.us);
229
230         /* XXX python now has invalid pointer? */
231 }
232
233 bAction *rna_Main_actions_new(Main *bmain, char* name)
234 {
235         bAction *act= add_empty_action(name);
236         act->id.us--;
237         act->id.flag &= ~LIB_FAKEUSER;
238         return act;
239 }
240 void rna_Main_actions_remove(Main *bmain, ReportList *reports, bAction *act)
241 {
242         if(act->id.us == 0)
243                 free_libblock(&bmain->action, act);
244         else
245                 BKE_reportf(reports, RPT_ERROR, "Action \"%s\" must have zero users to be removed, found %d.", act->id.name+2, act->id.us);
246
247         /* XXX python now has invalid pointer? */
248 }
249
250 #else
251
252 void RNA_api_main(StructRNA *srna)
253 {
254         FunctionRNA *func;
255         PropertyRNA *parm;
256
257         func= RNA_def_function(srna, "add_texture", "rna_Main_add_texture");
258         RNA_def_function_ui_description(func, "Add a new texture.");
259         parm= RNA_def_string(func, "name", "Tex", 0, "", "New name for the datablock."); /* optional */
260         parm= RNA_def_pointer(func, "texture", "Texture", "", "New texture.");
261         RNA_def_function_return(func, parm);
262
263         func= RNA_def_function(srna, "add_image", "rna_Main_add_image");
264         RNA_def_function_ui_description(func, "Add a new image.");
265         parm= RNA_def_string(func, "filename", "", 0, "", "Filename to load image from.");
266         RNA_def_property_flag(parm, PROP_REQUIRED);
267         parm= RNA_def_pointer(func, "image", "Image", "", "New image.");
268         RNA_def_function_return(func, parm);
269
270 }
271
272 void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop)
273 {
274         StructRNA *srna;
275         FunctionRNA *func;
276         PropertyRNA *parm;
277
278         RNA_def_property_srna(cprop, "MainCameras");
279         srna= RNA_def_struct(brna, "MainCameras", NULL);
280         RNA_def_struct_ui_text(srna, "Main Cameras", "Collection of cameras.");
281
282         func= RNA_def_function(srna, "new", "rna_Main_cameras_new");
283         RNA_def_function_ui_description(func, "Add a new camera to the main database");
284         parm= RNA_def_string(func, "name", "Camera", 0, "", "New name for the datablock.");
285         RNA_def_property_flag(parm, PROP_REQUIRED);
286         /* return type */
287         parm= RNA_def_pointer(func, "camera", "Camera", "", "New camera datablock.");
288         RNA_def_function_return(func, parm);
289
290         func= RNA_def_function(srna, "remove", "rna_Main_cameras_remove");
291         RNA_def_function_flag(func, FUNC_USE_REPORTS);
292         RNA_def_function_ui_description(func, "Remove a camera from the current blendfile.");
293         parm= RNA_def_pointer(func, "camera", "Camera", "", "Camera to remove.");
294         RNA_def_property_flag(parm, PROP_REQUIRED);
295 }
296
297 void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
298 {
299         StructRNA *srna;
300         FunctionRNA *func;
301         PropertyRNA *parm;
302
303         RNA_def_property_srna(cprop, "MainScenes");
304         srna= RNA_def_struct(brna, "MainScenes", NULL);
305         RNA_def_struct_ui_text(srna, "Main Scenes", "Collection of scenes.");
306
307         func= RNA_def_function(srna, "new", "rna_Main_scenes_new");
308         RNA_def_function_ui_description(func, "Add a new scene to the main database");
309         parm= RNA_def_string(func, "name", "Scene", 0, "", "New name for the datablock.");
310         RNA_def_property_flag(parm, PROP_REQUIRED);
311         /* return type */
312         parm= RNA_def_pointer(func, "scene", "Scene", "", "New scene datablock.");
313         RNA_def_function_return(func, parm);
314
315         func= RNA_def_function(srna, "remove", "rna_Main_scenes_remove");
316         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
317         parm= RNA_def_pointer(func, "scene", "Scene", "", "Scene to remove.");
318         RNA_def_property_flag(parm, PROP_REQUIRED);
319         RNA_def_function_ui_description(func, "Remove a scene from the current blendfile.");
320         RNA_def_property_flag(parm, PROP_REQUIRED);
321 }
322
323 void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
324 {
325         StructRNA *srna;
326         FunctionRNA *func;
327         PropertyRNA *parm;
328
329         RNA_def_property_srna(cprop, "MainObjects");
330         srna= RNA_def_struct(brna, "MainObjects", NULL);
331         RNA_def_struct_ui_text(srna, "Main Objects", "Collection of objects.");
332
333         func= RNA_def_function(srna, "new", "rna_Main_objects_new");
334         RNA_def_function_ui_description(func, "Add a new object to the main database");
335         parm= RNA_def_string(func, "name", "Object", 0, "", "New name for the datablock.");
336         RNA_def_property_flag(parm, PROP_REQUIRED);
337         parm= RNA_def_enum(func, "type", object_type_items, 0, "", "Type of Object.");
338         RNA_def_property_flag(parm, PROP_REQUIRED);
339
340         /* return type */
341         parm= RNA_def_pointer(func, "object", "Object", "", "New object datablock.");
342         RNA_def_function_return(func, parm);
343
344         func= RNA_def_function(srna, "remove", "rna_Main_objects_remove");
345         RNA_def_function_flag(func, FUNC_USE_REPORTS);
346         parm= RNA_def_pointer(func, "object", "Object", "", "Object to remove.");
347         RNA_def_property_flag(parm, PROP_REQUIRED);
348         RNA_def_function_ui_description(func, "Remove a object from the current blendfile.");
349 }
350
351 void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
352 {
353         StructRNA *srna;
354         FunctionRNA *func;
355         PropertyRNA *parm;
356
357         RNA_def_property_srna(cprop, "MainMaterials");
358         srna= RNA_def_struct(brna, "MainMaterials", NULL);
359         RNA_def_struct_ui_text(srna, "Main Material", "Collection of materials.");
360
361         func= RNA_def_function(srna, "new", "rna_Main_materials_new");
362         RNA_def_function_ui_description(func, "Add a new material to the main database");
363         parm= RNA_def_string(func, "name", "Material", 0, "", "New name for the datablock.");
364         RNA_def_property_flag(parm, PROP_REQUIRED);
365         /* return type */
366         parm= RNA_def_pointer(func, "material", "Material", "", "New material datablock.");
367         RNA_def_function_return(func, parm);
368
369         func= RNA_def_function(srna, "remove", "rna_Main_materials_remove");
370         RNA_def_function_flag(func, FUNC_USE_REPORTS);
371         RNA_def_function_ui_description(func, "Remove a material from the current blendfile.");
372         parm= RNA_def_pointer(func, "material", "Material", "", "Material to remove.");
373         RNA_def_property_flag(parm, PROP_REQUIRED);
374 }
375 void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop)
376 {
377
378 }
379 void RNA_def_main_meshes(BlenderRNA *brna, PropertyRNA *cprop)
380 {
381         StructRNA *srna;
382         FunctionRNA *func;
383         PropertyRNA *parm;
384
385         RNA_def_property_srna(cprop, "MainMeshes");
386         srna= RNA_def_struct(brna, "MainMeshes", NULL);
387         RNA_def_struct_ui_text(srna, "Main Meshes", "Collection of meshes.");
388
389         func= RNA_def_function(srna, "new", "rna_Main_meshes_new");
390         RNA_def_function_ui_description(func, "Add a new mesh to the main database");
391         parm= RNA_def_string(func, "name", "Mesh", 0, "", "New name for the datablock.");
392         RNA_def_property_flag(parm, PROP_REQUIRED);
393         /* return type */
394         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "New mesh datablock.");
395         RNA_def_function_return(func, parm);
396
397         func= RNA_def_function(srna, "remove", "rna_Main_meshes_remove");
398         RNA_def_function_flag(func, FUNC_USE_REPORTS);
399         RNA_def_function_ui_description(func, "Remove a mesh from the current blendfile.");
400         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh to remove.");
401         RNA_def_property_flag(parm, PROP_REQUIRED);
402 }
403 void RNA_def_main_lamps(BlenderRNA *brna, PropertyRNA *cprop)
404 {
405         StructRNA *srna;
406         FunctionRNA *func;
407         PropertyRNA *parm;
408
409         RNA_def_property_srna(cprop, "MainLamps");
410         srna= RNA_def_struct(brna, "MainLamps", NULL);
411         RNA_def_struct_ui_text(srna, "Main Lamps", "Collection of lamps.");
412
413         func= RNA_def_function(srna, "new", "rna_Main_lamps_new");
414         RNA_def_function_ui_description(func, "Add a new lamp to the main database");
415         parm= RNA_def_string(func, "name", "Lamp", 0, "", "New name for the datablock.");
416         RNA_def_property_flag(parm, PROP_REQUIRED);
417         /* return type */
418         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "New lamp datablock.");
419         RNA_def_function_return(func, parm);
420
421         func= RNA_def_function(srna, "remove", "rna_Main_lamps_remove");
422         RNA_def_function_flag(func, FUNC_USE_REPORTS);
423         RNA_def_function_ui_description(func, "Remove a lamp from the current blendfile.");
424         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "Lamp to remove.");
425         RNA_def_property_flag(parm, PROP_REQUIRED);
426 }
427 void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
428 {
429
430 }
431 void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
432 {
433
434 }
435 void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
436 {
437
438 }
439 void RNA_def_main_images(BlenderRNA *brna, PropertyRNA *cprop)
440 {
441
442 }
443 void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
444 {
445
446 }
447 void RNA_def_main_curves(BlenderRNA *brna, PropertyRNA *cprop)
448 {
449
450 }
451 void RNA_def_main_metaballs(BlenderRNA *brna, PropertyRNA *cprop)
452 {
453
454 }
455 void RNA_def_main_vfonts(BlenderRNA *brna, PropertyRNA *cprop)
456 {
457
458 }
459 void RNA_def_main_textures(BlenderRNA *brna, PropertyRNA *cprop)
460 {
461
462 }
463 void RNA_def_main_brushes(BlenderRNA *brna, PropertyRNA *cprop)
464 {
465
466 }
467 void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
468 {
469
470 }
471 void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
472 {
473         StructRNA *srna;
474         FunctionRNA *func;
475         PropertyRNA *parm;
476
477         RNA_def_property_srna(cprop, "MainGroups");
478         srna= RNA_def_struct(brna, "MainGroups", NULL);
479         RNA_def_struct_ui_text(srna, "Main Groups", "Collection of groups.");
480
481         func= RNA_def_function(srna, "new", "rna_Main_groups_new");
482         RNA_def_function_ui_description(func, "Add a new group to the main database");
483         parm= RNA_def_string(func, "name", "Group", 0, "", "New name for the datablock.");
484         RNA_def_property_flag(parm, PROP_REQUIRED);
485         /* return type */
486         parm= RNA_def_pointer(func, "group", "Group", "", "New group datablock.");
487         RNA_def_function_return(func, parm);
488
489         func= RNA_def_function(srna, "remove", "rna_Main_groups_remove");
490         RNA_def_function_flag(func, FUNC_USE_REPORTS);
491         RNA_def_function_ui_description(func, "Remove a group from the current blendfile.");
492         parm= RNA_def_pointer(func, "group", "Group", "", "Group to remove.");
493         RNA_def_property_flag(parm, PROP_REQUIRED);
494 }
495 void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
496 {
497         StructRNA *srna;
498         FunctionRNA *func;
499         PropertyRNA *parm;
500
501         RNA_def_property_srna(cprop, "MainTexts");
502         srna= RNA_def_struct(brna, "MainTexts", NULL);
503         RNA_def_struct_ui_text(srna, "Main Texts", "Collection of texts.");
504
505         func= RNA_def_function(srna, "new", "rna_Main_texts_new");
506         RNA_def_function_ui_description(func, "Add a new text to the main database");
507         parm= RNA_def_string(func, "name", "Text", 0, "", "New name for the datablock.");
508         RNA_def_property_flag(parm, PROP_REQUIRED);
509         /* return type */
510         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
511         RNA_def_function_return(func, parm);
512
513         func= RNA_def_function(srna, "remove", "rna_Main_texts_remove");
514         RNA_def_function_flag(func, FUNC_USE_REPORTS);
515         RNA_def_function_ui_description(func, "Remove a text from the current blendfile.");
516         parm= RNA_def_pointer(func, "text", "Text", "", "Text to remove.");
517         RNA_def_property_flag(parm, PROP_REQUIRED);
518
519         /* load func */
520         func= RNA_def_function(srna, "load", "rna_Main_texts_load");
521         RNA_def_function_flag(func, FUNC_USE_REPORTS);
522         RNA_def_function_ui_description(func, "Add a new text to the main database from a file");
523         parm= RNA_def_string(func, "path", "Path", FILE_MAXDIR + FILE_MAXFILE, "", "path for the datablock.");
524         RNA_def_property_flag(parm, PROP_REQUIRED);
525         /* return type */
526         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
527         RNA_def_function_return(func, parm);
528 }
529 void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
530 {
531
532 }
533 void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
534 {
535         StructRNA *srna;
536         FunctionRNA *func;
537         PropertyRNA *parm;
538
539         RNA_def_property_srna(cprop, "MainArmatures");
540         srna= RNA_def_struct(brna, "MainArmatures", NULL);
541         RNA_def_struct_ui_text(srna, "Main Armatures", "Collection of armatures.");
542
543         func= RNA_def_function(srna, "new", "rna_Main_armatures_new");
544         RNA_def_function_ui_description(func, "Add a new armature to the main database");
545         parm= RNA_def_string(func, "name", "Armature", 0, "", "New name for the datablock.");
546         RNA_def_property_flag(parm, PROP_REQUIRED);
547         /* return type */
548         parm= RNA_def_pointer(func, "armature", "Armature", "", "New armature datablock.");
549         RNA_def_function_return(func, parm);
550
551         func= RNA_def_function(srna, "remove", "rna_Main_armatures_remove");
552         RNA_def_function_flag(func, FUNC_USE_REPORTS);
553         RNA_def_function_ui_description(func, "Remove a armature from the current blendfile.");
554         parm= RNA_def_pointer(func, "armature", "Armature", "", "Armature to remove.");
555         RNA_def_property_flag(parm, PROP_REQUIRED);
556 }
557 void RNA_def_main_actions(BlenderRNA *brna, PropertyRNA *cprop)
558 {
559         StructRNA *srna;
560         FunctionRNA *func;
561         PropertyRNA *parm;
562
563         RNA_def_property_srna(cprop, "MainActions");
564         srna= RNA_def_struct(brna, "MainActions", NULL);
565         RNA_def_struct_ui_text(srna, "Main Actions", "Collection of actions.");
566
567         func= RNA_def_function(srna, "new", "rna_Main_actions_new");
568         RNA_def_function_ui_description(func, "Add a new action to the main database");
569         parm= RNA_def_string(func, "name", "Action", 0, "", "New name for the datablock.");
570         RNA_def_property_flag(parm, PROP_REQUIRED);
571         /* return type */
572         parm= RNA_def_pointer(func, "action", "Action", "", "New action datablock.");
573         RNA_def_function_return(func, parm);
574
575         func= RNA_def_function(srna, "remove", "rna_Main_actions_remove");
576         RNA_def_function_flag(func, FUNC_USE_REPORTS);
577         RNA_def_function_ui_description(func, "Remove a action from the current blendfile.");
578         parm= RNA_def_pointer(func, "action", "Action", "", "Action to remove.");
579         RNA_def_property_flag(parm, PROP_REQUIRED);
580 }
581 void RNA_def_main_particles(BlenderRNA *brna, PropertyRNA *cprop)
582 {
583
584 }
585 void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
586 {
587
588 }
589
590 #endif
591