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