bugfix [#21233] Crash in pyapi, with new object.
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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_access.h"
34 #include "RNA_types.h"
35 #include "RNA_enum_types.h"
36
37 #include "BKE_utildefines.h"
38
39 #ifdef RNA_RUNTIME
40
41 #include "BKE_main.h"
42 #include "BKE_curve.h"
43 #include "BKE_mesh.h"
44 #include "BKE_armature.h"
45 #include "BKE_library.h"
46 #include "BKE_object.h"
47 #include "BKE_material.h"
48 #include "BKE_image.h"
49 #include "BKE_texture.h"
50 #include "BKE_scene.h"
51 #include "BKE_text.h"
52 #include "BKE_action.h"
53 #include "BKE_group.h"
54
55 #include "DNA_armature_types.h"
56 #include "DNA_camera_types.h"
57 #include "DNA_lamp_types.h"
58 #include "DNA_material_types.h"
59 #include "DNA_mesh_types.h"
60 #include "DNA_object_types.h"
61 #include "DNA_text_types.h"
62 #include "DNA_texture_types.h"
63 #include "DNA_group_types.h"
64
65 #include "ED_screen.h"
66
67 Tex *rna_Main_add_texture(Main *bmain, char *name)
68 {
69         return add_texture(name);
70 }
71
72 Image *rna_Main_add_image(Main *bmain, char *filename)
73 {
74         return BKE_add_image_file(filename, 0);
75 }
76
77 Camera *rna_Main_cameras_new(Main *bmain, char* name)
78 {
79         return add_camera(name);
80 }
81 void rna_Main_cameras_remove(Main *bmain, ReportList *reports, struct Camera *camera)
82 {
83         if(ID_REAL_USERS(camera) <= 0)
84                 free_libblock(&bmain->camera, camera);
85         else
86                 BKE_reportf(reports, RPT_ERROR, "Camera \"%s\" must have zero users to be removed, found %d.", camera->id.name+2, ID_REAL_USERS(camera));
87
88         /* XXX python now has invalid pointer? */
89 }
90
91 Scene *rna_Main_scenes_new(Main *bmain, char* name)
92 {
93         return add_scene(name);
94 }
95 void rna_Main_scenes_remove(Main *bmain, bContext *C, ReportList *reports, struct Scene *scene)
96 {
97         /* dont call free_libblock(...) directly */
98         Scene *newscene;
99
100         if(scene->id.prev)
101                 newscene= scene->id.prev;
102         else if(scene->id.next)
103                 newscene= scene->id.next;
104         else {
105                 BKE_reportf(reports, RPT_ERROR, "Scene \"%s\" is the last, cant ve removed.", scene->id.name+2);
106                 return;
107         }
108
109         ED_screen_set_scene(C, newscene);
110
111         unlink_scene(bmain, scene, newscene);
112 }
113
114 Object *rna_Main_objects_new(Main *bmain, ReportList *reports, char* name, ID *data)
115 {
116         Object *ob;
117         int type= OB_EMPTY;
118         if(data) {
119                 switch(GS(data->name)) {
120                         case ID_ME:
121                                 type= OB_MESH;
122                                 break;
123                         case ID_CU:
124                                 type= curve_type((struct Curve *)data);
125                                 break;
126                         case ID_MB:
127                                 type= OB_MBALL;
128                                 break;
129                         case ID_LA:
130                                 type= OB_LAMP;
131                                 break;
132                         case ID_CA:
133                                 type= OB_CAMERA;
134                                 break;
135                         case ID_LT:
136                                 type= OB_LATTICE;
137                                 break;
138                         case ID_AR:
139                                 type= OB_ARMATURE;
140                                 break;
141                         default:
142                         {
143                                 const char *idname;
144                                 if(RNA_enum_id_from_value(id_type_items, GS(data->name), &idname) == 0)
145                                         idname= "UNKNOWN";
146
147                                 BKE_reportf(reports, RPT_ERROR, "ID type '%s' is not valid for a object.", idname);
148                                 return NULL;
149                         }
150                 }
151
152                 data->us++;
153         }
154
155         ob= add_only_object(type, name);
156         ob->id.us--;
157
158         ob->data= data;
159         return ob;
160 }
161
162 void rna_Main_objects_remove(Main *bmain, ReportList *reports, struct Object *object)
163 {
164         /*
165           NOTE: the following example shows when this function should _not_ be called
166
167           ob = bpy.data.add_object()
168           scene.add_object(ob)
169
170           # ob is freed here
171           scene.remove_object(ob)
172
173           # don't do this since ob is already freed!
174           bpy.data.remove_object(ob)
175         */
176         if(ID_REAL_USERS(object) <= 0)
177                 free_libblock(&bmain->object, object);
178         else
179                 BKE_reportf(reports, RPT_ERROR, "Object \"%s\" must have zero users to be removed, found %d.", object->id.name+2, ID_REAL_USERS(object));
180 }
181
182 struct Material *rna_Main_materials_new(Main *bmain, char* name)
183 {
184         return add_material(name);
185 }
186 void rna_Main_materials_remove(Main *bmain, ReportList *reports, struct Material *material)
187 {
188         if(ID_REAL_USERS(material) <= 0)
189                 free_libblock(&bmain->mat, material);
190         else
191                 BKE_reportf(reports, RPT_ERROR, "Material \"%s\" must have zero users to be removed, found %d.", material->id.name+2, ID_REAL_USERS(material));
192
193         /* XXX python now has invalid pointer? */
194 }
195
196 Mesh *rna_Main_meshes_new(Main *bmain, char* name)
197 {
198         Mesh *me= add_mesh(name);
199         me->id.us--;
200         return me;
201 }
202 void rna_Main_meshes_remove(Main *bmain, ReportList *reports, Mesh *mesh)
203 {
204         if(ID_REAL_USERS(mesh) <= 0)
205                 free_libblock(&bmain->mesh, mesh);
206         else
207                 BKE_reportf(reports, RPT_ERROR, "Mesh \"%s\" must have zero users to be removed, found %d.", mesh->id.name+2, ID_REAL_USERS(mesh));
208
209         /* XXX python now has invalid pointer? */
210 }
211
212 Lamp *rna_Main_lamps_new(Main *bmain, char* name)
213 {
214         Lamp *lamp= add_lamp(name);
215         lamp->id.us--;
216         return lamp;
217 }
218 void rna_Main_lamps_remove(Main *bmain, ReportList *reports, Lamp *lamp)
219 {
220         if(ID_REAL_USERS(lamp) <= 0)
221                 free_libblock(&bmain->lamp, lamp);
222         else
223                 BKE_reportf(reports, RPT_ERROR, "Lamp \"%s\" must have zero users to be removed, found %d.", lamp->id.name+2, ID_REAL_USERS(lamp));
224
225         /* XXX python now has invalid pointer? */
226 }
227
228 Tex *rna_Main_textures_new(Main *bmain, char* name)
229 {
230         Tex *tex= add_texture(name);
231         tex->id.us--;
232         return tex;
233 }
234 void rna_Main_textures_remove(Main *bmain, ReportList *reports, struct Tex *tex)
235 {
236         if(ID_REAL_USERS(tex) <= 0)
237                 free_libblock(&bmain->tex, tex);
238         else
239                 BKE_reportf(reports, RPT_ERROR, "Texture \"%s\" must have zero users to be removed, found %d.", tex->id.name+2, ID_REAL_USERS(tex));
240 }
241
242 Group *rna_Main_groups_new(Main *bmain, char* name)
243 {
244         return add_group(name);
245 }
246 void rna_Main_groups_remove(Main *bmain, ReportList *reports, Group *group)
247 {
248         unlink_group(group);
249         group->id.us= 0;
250         free_libblock(&bmain->group, group);
251         /* XXX python now has invalid pointer? */
252 }
253
254 Text *rna_Main_texts_new(Main *bmain, char* name)
255 {
256         return add_empty_text(name);
257 }
258 void rna_Main_texts_remove(Main *bmain, ReportList *reports, Text *text)
259 {
260         unlink_text(bmain, text);
261         free_libblock(&bmain->text, text);
262         /* XXX python now has invalid pointer? */
263 }
264 Text *rna_Main_texts_load(Main *bmain, ReportList *reports, char* path)
265 {
266         Text *txt= add_text(path, bmain->name);
267         if(txt==NULL)
268                 BKE_reportf(reports, RPT_ERROR, "Couldn't load text from path \"%s\".", path);
269
270         return txt;
271 }
272
273 bArmature *rna_Main_armatures_new(Main *bmain, char* name)
274 {
275         bArmature *arm= add_armature(name);
276         arm->id.us--;
277         return arm;
278 }
279 void rna_Main_armatures_remove(Main *bmain, ReportList *reports, bArmature *arm)
280 {
281         if(ID_REAL_USERS(arm) <= 0)
282                 free_libblock(&bmain->armature, arm);
283         else
284                 BKE_reportf(reports, RPT_ERROR, "Armature \"%s\" must have zero users to be removed, found %d.", arm->id.name+2, ID_REAL_USERS(arm));
285
286         /* XXX python now has invalid pointer? */
287 }
288
289 bAction *rna_Main_actions_new(Main *bmain, char* name)
290 {
291         bAction *act= add_empty_action(name);
292         act->id.us--;
293         act->id.flag &= ~LIB_FAKEUSER;
294         return act;
295 }
296 void rna_Main_actions_remove(Main *bmain, ReportList *reports, bAction *act)
297 {
298         if(ID_REAL_USERS(act) <= 0)
299                 free_libblock(&bmain->action, act);
300         else
301                 BKE_reportf(reports, RPT_ERROR, "Action \"%s\" must have zero users to be removed, found %d.", act->id.name+2, ID_REAL_USERS(act));
302
303         /* XXX python now has invalid pointer? */
304 }
305
306 #else
307
308 void RNA_api_main(StructRNA *srna)
309 {
310         FunctionRNA *func;
311         PropertyRNA *parm;
312
313         func= RNA_def_function(srna, "add_image", "rna_Main_add_image");
314         RNA_def_function_ui_description(func, "Add a new image.");
315         parm= RNA_def_string(func, "filename", "", 0, "", "Filename to load image from.");
316         RNA_def_property_flag(parm, PROP_REQUIRED);
317         parm= RNA_def_pointer(func, "image", "Image", "", "New image.");
318         RNA_def_function_return(func, parm);
319
320 }
321
322 void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop)
323 {
324         StructRNA *srna;
325         FunctionRNA *func;
326         PropertyRNA *parm;
327
328         RNA_def_property_srna(cprop, "MainCameras");
329         srna= RNA_def_struct(brna, "MainCameras", NULL);
330         RNA_def_struct_ui_text(srna, "Main Cameras", "Collection of cameras");
331
332         func= RNA_def_function(srna, "new", "rna_Main_cameras_new");
333         RNA_def_function_ui_description(func, "Add a new camera to the main database");
334         parm= RNA_def_string(func, "name", "Camera", 0, "", "New name for the datablock.");
335         RNA_def_property_flag(parm, PROP_REQUIRED);
336         /* return type */
337         parm= RNA_def_pointer(func, "camera", "Camera", "", "New camera datablock.");
338         RNA_def_function_return(func, parm);
339
340         func= RNA_def_function(srna, "remove", "rna_Main_cameras_remove");
341         RNA_def_function_flag(func, FUNC_USE_REPORTS);
342         RNA_def_function_ui_description(func, "Remove a camera from the current blendfile.");
343         parm= RNA_def_pointer(func, "camera", "Camera", "", "Camera to remove.");
344         RNA_def_property_flag(parm, PROP_REQUIRED);
345 }
346
347 void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
348 {
349         StructRNA *srna;
350         FunctionRNA *func;
351         PropertyRNA *parm;
352
353         RNA_def_property_srna(cprop, "MainScenes");
354         srna= RNA_def_struct(brna, "MainScenes", NULL);
355         RNA_def_struct_ui_text(srna, "Main Scenes", "Collection of scenes");
356
357         func= RNA_def_function(srna, "new", "rna_Main_scenes_new");
358         RNA_def_function_ui_description(func, "Add a new scene to the main database");
359         parm= RNA_def_string(func, "name", "Scene", 0, "", "New name for the datablock.");
360         RNA_def_property_flag(parm, PROP_REQUIRED);
361         /* return type */
362         parm= RNA_def_pointer(func, "scene", "Scene", "", "New scene datablock.");
363         RNA_def_function_return(func, parm);
364
365         func= RNA_def_function(srna, "remove", "rna_Main_scenes_remove");
366         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
367         parm= RNA_def_pointer(func, "scene", "Scene", "", "Scene to remove.");
368         RNA_def_property_flag(parm, PROP_REQUIRED);
369         RNA_def_function_ui_description(func, "Remove a scene from the current blendfile.");
370         RNA_def_property_flag(parm, PROP_REQUIRED);
371 }
372
373 void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
374 {
375         StructRNA *srna;
376         FunctionRNA *func;
377         PropertyRNA *parm;
378
379         RNA_def_property_srna(cprop, "MainObjects");
380         srna= RNA_def_struct(brna, "MainObjects", NULL);
381         RNA_def_struct_ui_text(srna, "Main Objects", "Collection of objects");
382
383         func= RNA_def_function(srna, "new", "rna_Main_objects_new");
384         RNA_def_function_flag(func, FUNC_USE_REPORTS);
385         RNA_def_function_ui_description(func, "Add a new object to the main database");
386         parm= RNA_def_string(func, "name", "Object", 0, "", "New name for the datablock.");
387         RNA_def_property_flag(parm, PROP_REQUIRED);
388         parm= RNA_def_pointer(func, "object_data", "ID", "", "Object data or None for an empty object.");
389         RNA_def_property_flag(parm, PROP_REQUIRED);
390
391         /* return type */
392         parm= RNA_def_pointer(func, "object", "Object", "", "New object datablock.");
393         RNA_def_function_return(func, parm);
394
395         func= RNA_def_function(srna, "remove", "rna_Main_objects_remove");
396         RNA_def_function_flag(func, FUNC_USE_REPORTS);
397         parm= RNA_def_pointer(func, "object", "Object", "", "Object to remove.");
398         RNA_def_property_flag(parm, PROP_REQUIRED);
399         RNA_def_function_ui_description(func, "Remove a object from the current blendfile.");
400 }
401
402 void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
403 {
404         StructRNA *srna;
405         FunctionRNA *func;
406         PropertyRNA *parm;
407
408         RNA_def_property_srna(cprop, "MainMaterials");
409         srna= RNA_def_struct(brna, "MainMaterials", NULL);
410         RNA_def_struct_ui_text(srna, "Main Material", "Collection of materials");
411
412         func= RNA_def_function(srna, "new", "rna_Main_materials_new");
413         RNA_def_function_ui_description(func, "Add a new material to the main database");
414         parm= RNA_def_string(func, "name", "Material", 0, "", "New name for the datablock.");
415         RNA_def_property_flag(parm, PROP_REQUIRED);
416         /* return type */
417         parm= RNA_def_pointer(func, "material", "Material", "", "New material datablock.");
418         RNA_def_function_return(func, parm);
419
420         func= RNA_def_function(srna, "remove", "rna_Main_materials_remove");
421         RNA_def_function_flag(func, FUNC_USE_REPORTS);
422         RNA_def_function_ui_description(func, "Remove a material from the current blendfile.");
423         parm= RNA_def_pointer(func, "material", "Material", "", "Material to remove.");
424         RNA_def_property_flag(parm, PROP_REQUIRED);
425 }
426 void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop)
427 {
428
429 }
430 void RNA_def_main_meshes(BlenderRNA *brna, PropertyRNA *cprop)
431 {
432         StructRNA *srna;
433         FunctionRNA *func;
434         PropertyRNA *parm;
435
436         RNA_def_property_srna(cprop, "MainMeshes");
437         srna= RNA_def_struct(brna, "MainMeshes", NULL);
438         RNA_def_struct_ui_text(srna, "Main Meshes", "Collection of meshes");
439
440         func= RNA_def_function(srna, "new", "rna_Main_meshes_new");
441         RNA_def_function_ui_description(func, "Add a new mesh to the main database");
442         parm= RNA_def_string(func, "name", "Mesh", 0, "", "New name for the datablock.");
443         RNA_def_property_flag(parm, PROP_REQUIRED);
444         /* return type */
445         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "New mesh datablock.");
446         RNA_def_function_return(func, parm);
447
448         func= RNA_def_function(srna, "remove", "rna_Main_meshes_remove");
449         RNA_def_function_flag(func, FUNC_USE_REPORTS);
450         RNA_def_function_ui_description(func, "Remove a mesh from the current blendfile.");
451         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh to remove.");
452         RNA_def_property_flag(parm, PROP_REQUIRED);
453 }
454 void RNA_def_main_lamps(BlenderRNA *brna, PropertyRNA *cprop)
455 {
456         StructRNA *srna;
457         FunctionRNA *func;
458         PropertyRNA *parm;
459
460         RNA_def_property_srna(cprop, "MainLamps");
461         srna= RNA_def_struct(brna, "MainLamps", NULL);
462         RNA_def_struct_ui_text(srna, "Main Lamps", "Collection of lamps");
463
464         func= RNA_def_function(srna, "new", "rna_Main_lamps_new");
465         RNA_def_function_ui_description(func, "Add a new lamp to the main database");
466         parm= RNA_def_string(func, "name", "Lamp", 0, "", "New name for the datablock.");
467         RNA_def_property_flag(parm, PROP_REQUIRED);
468         /* return type */
469         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "New lamp datablock.");
470         RNA_def_function_return(func, parm);
471
472         func= RNA_def_function(srna, "remove", "rna_Main_lamps_remove");
473         RNA_def_function_flag(func, FUNC_USE_REPORTS);
474         RNA_def_function_ui_description(func, "Remove a lamp from the current blendfile.");
475         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "Lamp to remove.");
476         RNA_def_property_flag(parm, PROP_REQUIRED);
477 }
478 void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
479 {
480
481 }
482 void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
483 {
484
485 }
486 void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
487 {
488
489 }
490 void RNA_def_main_images(BlenderRNA *brna, PropertyRNA *cprop)
491 {
492
493 }
494 void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
495 {
496
497 }
498 void RNA_def_main_curves(BlenderRNA *brna, PropertyRNA *cprop)
499 {
500
501 }
502 void RNA_def_main_metaballs(BlenderRNA *brna, PropertyRNA *cprop)
503 {
504
505 }
506 void RNA_def_main_vfonts(BlenderRNA *brna, PropertyRNA *cprop)
507 {
508
509 }
510 void RNA_def_main_textures(BlenderRNA *brna, PropertyRNA *cprop)
511 {
512         StructRNA *srna;
513         FunctionRNA *func;
514         PropertyRNA *parm;
515
516         RNA_def_property_srna(cprop, "MainTextures");
517         srna= RNA_def_struct(brna, "MainTextures", NULL);
518         RNA_def_struct_ui_text(srna, "Main Textures", "Collection of groups");
519
520         func= RNA_def_function(srna, "new", "rna_Main_textures_new");
521         RNA_def_function_ui_description(func, "Add a new texture to the main database");
522         parm= RNA_def_string(func, "name", "Texture", 0, "", "New name for the datablock.");
523         RNA_def_property_flag(parm, PROP_REQUIRED);
524         /* return type */
525         parm= RNA_def_pointer(func, "texture", "Texture", "", "New texture datablock.");
526         RNA_def_function_return(func, parm);
527
528         func= RNA_def_function(srna, "remove", "rna_Main_textures_remove");
529         RNA_def_function_flag(func, FUNC_USE_REPORTS);
530         RNA_def_function_ui_description(func, "Remove a texture from the current blendfile.");
531         parm= RNA_def_pointer(func, "texture", "Texture", "", "Texture to remove.");
532         RNA_def_property_flag(parm, PROP_REQUIRED);
533 }
534 void RNA_def_main_brushes(BlenderRNA *brna, PropertyRNA *cprop)
535 {
536
537 }
538 void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
539 {
540
541 }
542 void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
543 {
544         StructRNA *srna;
545         FunctionRNA *func;
546         PropertyRNA *parm;
547
548         RNA_def_property_srna(cprop, "MainGroups");
549         srna= RNA_def_struct(brna, "MainGroups", NULL);
550         RNA_def_struct_ui_text(srna, "Main Groups", "Collection of groups");
551
552         func= RNA_def_function(srna, "new", "rna_Main_groups_new");
553         RNA_def_function_ui_description(func, "Add a new group to the main database");
554         parm= RNA_def_string(func, "name", "Group", 0, "", "New name for the datablock.");
555         RNA_def_property_flag(parm, PROP_REQUIRED);
556         /* return type */
557         parm= RNA_def_pointer(func, "group", "Group", "", "New group datablock.");
558         RNA_def_function_return(func, parm);
559
560         func= RNA_def_function(srna, "remove", "rna_Main_groups_remove");
561         RNA_def_function_flag(func, FUNC_USE_REPORTS);
562         RNA_def_function_ui_description(func, "Remove a group from the current blendfile.");
563         parm= RNA_def_pointer(func, "group", "Group", "", "Group to remove.");
564         RNA_def_property_flag(parm, PROP_REQUIRED);
565 }
566 void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
567 {
568         StructRNA *srna;
569         FunctionRNA *func;
570         PropertyRNA *parm;
571
572         RNA_def_property_srna(cprop, "MainTexts");
573         srna= RNA_def_struct(brna, "MainTexts", NULL);
574         RNA_def_struct_ui_text(srna, "Main Texts", "Collection of texts");
575
576         func= RNA_def_function(srna, "new", "rna_Main_texts_new");
577         RNA_def_function_ui_description(func, "Add a new text to the main database");
578         parm= RNA_def_string(func, "name", "Text", 0, "", "New name for the datablock.");
579         RNA_def_property_flag(parm, PROP_REQUIRED);
580         /* return type */
581         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
582         RNA_def_function_return(func, parm);
583
584         func= RNA_def_function(srna, "remove", "rna_Main_texts_remove");
585         RNA_def_function_flag(func, FUNC_USE_REPORTS);
586         RNA_def_function_ui_description(func, "Remove a text from the current blendfile.");
587         parm= RNA_def_pointer(func, "text", "Text", "", "Text to remove.");
588         RNA_def_property_flag(parm, PROP_REQUIRED);
589
590         /* load func */
591         func= RNA_def_function(srna, "load", "rna_Main_texts_load");
592         RNA_def_function_flag(func, FUNC_USE_REPORTS);
593         RNA_def_function_ui_description(func, "Add a new text to the main database from a file");
594         parm= RNA_def_string(func, "path", "Path", FILE_MAXDIR + FILE_MAXFILE, "", "path for the datablock.");
595         RNA_def_property_flag(parm, PROP_REQUIRED);
596         /* return type */
597         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
598         RNA_def_function_return(func, parm);
599 }
600 void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
601 {
602
603 }
604 void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
605 {
606         StructRNA *srna;
607         FunctionRNA *func;
608         PropertyRNA *parm;
609
610         RNA_def_property_srna(cprop, "MainArmatures");
611         srna= RNA_def_struct(brna, "MainArmatures", NULL);
612         RNA_def_struct_ui_text(srna, "Main Armatures", "Collection of armatures");
613
614         func= RNA_def_function(srna, "new", "rna_Main_armatures_new");
615         RNA_def_function_ui_description(func, "Add a new armature to the main database");
616         parm= RNA_def_string(func, "name", "Armature", 0, "", "New name for the datablock.");
617         RNA_def_property_flag(parm, PROP_REQUIRED);
618         /* return type */
619         parm= RNA_def_pointer(func, "armature", "Armature", "", "New armature datablock.");
620         RNA_def_function_return(func, parm);
621
622         func= RNA_def_function(srna, "remove", "rna_Main_armatures_remove");
623         RNA_def_function_flag(func, FUNC_USE_REPORTS);
624         RNA_def_function_ui_description(func, "Remove a armature from the current blendfile.");
625         parm= RNA_def_pointer(func, "armature", "Armature", "", "Armature to remove.");
626         RNA_def_property_flag(parm, PROP_REQUIRED);
627 }
628 void RNA_def_main_actions(BlenderRNA *brna, PropertyRNA *cprop)
629 {
630         StructRNA *srna;
631         FunctionRNA *func;
632         PropertyRNA *parm;
633
634         RNA_def_property_srna(cprop, "MainActions");
635         srna= RNA_def_struct(brna, "MainActions", NULL);
636         RNA_def_struct_ui_text(srna, "Main Actions", "Collection of actions");
637
638         func= RNA_def_function(srna, "new", "rna_Main_actions_new");
639         RNA_def_function_ui_description(func, "Add a new action to the main database");
640         parm= RNA_def_string(func, "name", "Action", 0, "", "New name for the datablock.");
641         RNA_def_property_flag(parm, PROP_REQUIRED);
642         /* return type */
643         parm= RNA_def_pointer(func, "action", "Action", "", "New action datablock.");
644         RNA_def_function_return(func, parm);
645
646         func= RNA_def_function(srna, "remove", "rna_Main_actions_remove");
647         RNA_def_function_flag(func, FUNC_USE_REPORTS);
648         RNA_def_function_ui_description(func, "Remove a action from the current blendfile.");
649         parm= RNA_def_pointer(func, "action", "Action", "", "Action to remove.");
650         RNA_def_property_flag(parm, PROP_REQUIRED);
651 }
652 void RNA_def_main_particles(BlenderRNA *brna, PropertyRNA *cprop)
653 {
654
655 }
656 void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
657 {
658
659 }
660
661 #endif
662