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