naming changes
[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 #include "BKE_brush.h"
54 #include "BKE_lattice.h"
55 #include "BKE_mball.h"
56 #include "BKE_world.h"
57 #include "BKE_particle.h"
58 #include "BKE_font.h"
59 #include "BKE_node.h"
60
61 #include "DNA_armature_types.h"
62 #include "DNA_camera_types.h"
63 #include "DNA_curve_types.h"
64 #include "DNA_lamp_types.h"
65 #include "DNA_material_types.h"
66 #include "DNA_mesh_types.h"
67 #include "DNA_object_types.h"
68 #include "DNA_text_types.h"
69 #include "DNA_texture_types.h"
70 #include "DNA_group_types.h"
71 #include "DNA_brush_types.h"
72 #include "DNA_lattice_types.h"
73 #include "DNA_meta_types.h"
74 #include "DNA_world_types.h"
75 #include "DNA_particle_types.h"
76 #include "DNA_vfont_types.h"
77 #include "DNA_node_types.h"
78
79 #include "ED_screen.h"
80
81 Tex *rna_Main_add_texture(Main *bmain, char *name)
82 {
83         return add_texture(name);
84 }
85
86 Camera *rna_Main_cameras_new(Main *bmain, char* name)
87 {
88         return add_camera(name);
89 }
90 void rna_Main_cameras_remove(Main *bmain, ReportList *reports, struct Camera *camera)
91 {
92         if(ID_REAL_USERS(camera) <= 0)
93                 free_libblock(&bmain->camera, camera);
94         else
95                 BKE_reportf(reports, RPT_ERROR, "Camera \"%s\" must have zero users to be removed, found %d.", camera->id.name+2, ID_REAL_USERS(camera));
96
97         /* XXX python now has invalid pointer? */
98 }
99
100 Scene *rna_Main_scenes_new(Main *bmain, char* name)
101 {
102         return add_scene(name);
103 }
104 void rna_Main_scenes_remove(Main *bmain, bContext *C, ReportList *reports, struct Scene *scene)
105 {
106         /* dont call free_libblock(...) directly */
107         Scene *newscene;
108
109         if(scene->id.prev)
110                 newscene= scene->id.prev;
111         else if(scene->id.next)
112                 newscene= scene->id.next;
113         else {
114                 BKE_reportf(reports, RPT_ERROR, "Scene \"%s\" is the last, cant ve removed.", scene->id.name+2);
115                 return;
116         }
117
118         ED_screen_set_scene(C, newscene);
119
120         unlink_scene(bmain, scene, newscene);
121 }
122
123 Object *rna_Main_objects_new(Main *bmain, ReportList *reports, char* name, ID *data)
124 {
125         Object *ob;
126         int type= OB_EMPTY;
127         if(data) {
128                 switch(GS(data->name)) {
129                         case ID_ME:
130                                 type= OB_MESH;
131                                 break;
132                         case ID_CU:
133                                 type= curve_type((struct Curve *)data);
134                                 break;
135                         case ID_MB:
136                                 type= OB_MBALL;
137                                 break;
138                         case ID_LA:
139                                 type= OB_LAMP;
140                                 break;
141                         case ID_CA:
142                                 type= OB_CAMERA;
143                                 break;
144                         case ID_LT:
145                                 type= OB_LATTICE;
146                                 break;
147                         case ID_AR:
148                                 type= OB_ARMATURE;
149                                 break;
150                         default:
151                         {
152                                 const char *idname;
153                                 if(RNA_enum_id_from_value(id_type_items, GS(data->name), &idname) == 0)
154                                         idname= "UNKNOWN";
155
156                                 BKE_reportf(reports, RPT_ERROR, "ID type '%s' is not valid for a object.", idname);
157                                 return NULL;
158                         }
159                 }
160
161                 data->us++;
162         }
163
164         ob= add_only_object(type, name);
165         ob->id.us--;
166
167         ob->data= data;
168         test_object_materials(ob->data);
169         
170         return ob;
171 }
172
173 void rna_Main_objects_remove(Main *bmain, ReportList *reports, struct Object *object)
174 {
175         /*
176           NOTE: the following example shows when this function should _not_ be called
177
178           ob = bpy.data.add_object()
179           scene.add_object(ob)
180
181           # ob is freed here
182           scene.remove_object(ob)
183
184           # don't do this since ob is already freed!
185           bpy.data.remove_object(ob)
186         */
187         if(ID_REAL_USERS(object) <= 0)
188                 free_libblock(&bmain->object, object);
189         else
190                 BKE_reportf(reports, RPT_ERROR, "Object \"%s\" must have zero users to be removed, found %d.", object->id.name+2, ID_REAL_USERS(object));
191 }
192
193 struct Material *rna_Main_materials_new(Main *bmain, char* name)
194 {
195         return add_material(name);
196 }
197 void rna_Main_materials_remove(Main *bmain, ReportList *reports, struct Material *material)
198 {
199         if(ID_REAL_USERS(material) <= 0)
200                 free_libblock(&bmain->mat, material);
201         else
202                 BKE_reportf(reports, RPT_ERROR, "Material \"%s\" must have zero users to be removed, found %d.", material->id.name+2, ID_REAL_USERS(material));
203
204         /* XXX python now has invalid pointer? */
205 }
206
207 // XXX, commended for now, need to see how this can be used with node groups.
208 struct bNodeTree *rna_Main_nodetree_new(Main *bmain, int type)
209 {
210         bNodeTree *tree = ntreeAddTree(type);
211         tree->id.us--;
212         return tree;
213 }
214 void rna_Main_nodetree_remove(Main *bmain, ReportList *reports, struct bNodeTree *tree)
215 {
216         if(ID_REAL_USERS(tree) <= 0)
217                 free_libblock(&bmain->nodetree, tree);
218         else
219                 BKE_reportf(reports, RPT_ERROR, "Node Tree \"%s\" must have zero users to be removed, found %d.", tree->id.name+2, ID_REAL_USERS(tree));
220
221         /* XXX python now has invalid pointer? */
222 }
223
224 Mesh *rna_Main_meshes_new(Main *bmain, char* name)
225 {
226         Mesh *me= add_mesh(name);
227         me->id.us--;
228         return me;
229 }
230 void rna_Main_meshes_remove(Main *bmain, ReportList *reports, Mesh *mesh)
231 {
232         if(ID_REAL_USERS(mesh) <= 0)
233                 free_libblock(&bmain->mesh, mesh);
234         else
235                 BKE_reportf(reports, RPT_ERROR, "Mesh \"%s\" must have zero users to be removed, found %d.", mesh->id.name+2, ID_REAL_USERS(mesh));
236
237         /* XXX python now has invalid pointer? */
238 }
239
240 Lamp *rna_Main_lamps_new(Main *bmain, char* name)
241 {
242         Lamp *lamp= add_lamp(name);
243         lamp->id.us--;
244         return lamp;
245 }
246 void rna_Main_lamps_remove(Main *bmain, ReportList *reports, Lamp *lamp)
247 {
248         if(ID_REAL_USERS(lamp) <= 0)
249                 free_libblock(&bmain->lamp, lamp);
250         else
251                 BKE_reportf(reports, RPT_ERROR, "Lamp \"%s\" must have zero users to be removed, found %d.", lamp->id.name+2, ID_REAL_USERS(lamp));
252
253         /* XXX python now has invalid pointer? */
254 }
255
256 Image *rna_Main_images_new(Main *bmain, char* name, int width, int height, int float_buffer)
257 {
258         float color[4]= {0.0, 0.0, 0.0, 1.0};
259         Image *image= BKE_add_image_size(width, height, name, float_buffer, 0, color);
260         image->id.us--;
261         return image;
262 }
263 Image *rna_Main_images_load(Main *bmain, char *filepath)
264 {
265         return BKE_add_image_file(filepath, 0);
266 }
267 void rna_Main_images_remove(Main *bmain, ReportList *reports, Image *image)
268 {
269         if(ID_REAL_USERS(image) <= 0)
270                 free_libblock(&bmain->image, image);
271         else
272                 BKE_reportf(reports, RPT_ERROR, "Image \"%s\" must have zero users to be removed, found %d.", image->id.name+2, ID_REAL_USERS(image));
273
274         /* XXX python now has invalid pointer? */
275 }
276
277 Lattice *rna_Main_lattices_new(Main *bmain, char* name)
278 {
279         Lattice *lt= add_lattice(name);
280         lt->id.us--;
281         return lt;
282 }
283 void rna_Main_lattices_remove(Main *bmain, ReportList *reports, struct Lattice *lt)
284 {
285         if(ID_REAL_USERS(lt) <= 0)
286                 free_libblock(&bmain->latt, lt);
287         else
288                 BKE_reportf(reports, RPT_ERROR, "Lattice \"%s\" must have zero users to be removed, found %d.", lt->id.name+2, ID_REAL_USERS(lt));
289 }
290
291 Curve *rna_Main_curves_new(Main *bmain, char* name, int type)
292 {
293         Curve *cu= add_curve(name, type);
294         cu->id.us--;
295         return cu;
296 }
297 void rna_Main_curves_remove(Main *bmain, ReportList *reports, struct Curve *cu)
298 {
299         if(ID_REAL_USERS(cu) <= 0)
300                 free_libblock(&bmain->curve, cu);
301         else
302                 BKE_reportf(reports, RPT_ERROR, "Curve \"%s\" must have zero users to be removed, found %d.", cu->id.name+2, ID_REAL_USERS(cu));
303 }
304
305 MetaBall *rna_Main_metaballs_new(Main *bmain, char* name)
306 {
307         MetaBall *mb= add_mball(name);
308         mb->id.us--;
309         return mb;
310 }
311 void rna_Main_metaballs_remove(Main *bmain, ReportList *reports, struct MetaBall *mb)
312 {
313         if(ID_REAL_USERS(mb) <= 0)
314                 free_libblock(&bmain->mball, mb);
315         else
316                 BKE_reportf(reports, RPT_ERROR, "MetaBall \"%s\" must have zero users to be removed, found %d.", mb->id.name+2, ID_REAL_USERS(mb));
317 }
318
319 VFont *rna_Main_fonts_load(Main *bmain, char *filepath)
320 {
321         return load_vfont(filepath);
322 }
323 void rna_Main_fonts_remove(Main *bmain, ReportList *reports, VFont *vfont)
324 {
325         if(ID_REAL_USERS(vfont) <= 0)
326                 free_libblock(&bmain->vfont, vfont);
327         else
328                 BKE_reportf(reports, RPT_ERROR, "Font \"%s\" must have zero users to be removed, found %d.", vfont->id.name+2, ID_REAL_USERS(vfont));
329
330         /* XXX python now has invalid pointer? */
331 }
332
333 Tex *rna_Main_textures_new(Main *bmain, char* name)
334 {
335         Tex *tex= add_texture(name);
336         tex->id.us--;
337         return tex;
338 }
339 void rna_Main_textures_remove(Main *bmain, ReportList *reports, struct Tex *tex)
340 {
341         if(ID_REAL_USERS(tex) <= 0)
342                 free_libblock(&bmain->tex, tex);
343         else
344                 BKE_reportf(reports, RPT_ERROR, "Texture \"%s\" must have zero users to be removed, found %d.", tex->id.name+2, ID_REAL_USERS(tex));
345 }
346
347 Brush *rna_Main_brushes_new(Main *bmain, char* name)
348 {
349         Brush *brush = add_brush(name);
350         brush->id.us--;
351         return brush;
352 }
353 void rna_Main_brushes_remove(Main *bmain, ReportList *reports, struct Brush *brush)
354 {
355         if(ID_REAL_USERS(brush) <= 0)
356                 free_libblock(&bmain->brush, brush);
357         else
358                 BKE_reportf(reports, RPT_ERROR, "Brush \"%s\" must have zero users to be removed, found %d.", brush->id.name+2, ID_REAL_USERS(brush));
359 }
360
361 World *rna_Main_worlds_new(Main *bmain, char* name)
362 {
363         World *world = add_world(name);
364         world->id.us--;
365         return world;
366 }
367 void rna_Main_worlds_remove(Main *bmain, ReportList *reports, struct World *world)
368 {
369         if(ID_REAL_USERS(world) <= 0)
370                 free_libblock(&bmain->world, world);
371         else
372                 BKE_reportf(reports, RPT_ERROR, "World \"%s\" must have zero users to be removed, found %d.", world->id.name+2, ID_REAL_USERS(world));
373 }
374
375 Group *rna_Main_groups_new(Main *bmain, char* name)
376 {
377         return add_group(name);
378 }
379 void rna_Main_groups_remove(Main *bmain, ReportList *reports, Group *group)
380 {
381         unlink_group(group);
382         group->id.us= 0;
383         free_libblock(&bmain->group, group);
384         /* XXX python now has invalid pointer? */
385 }
386
387 Text *rna_Main_texts_new(Main *bmain, char* name)
388 {
389         return add_empty_text(name);
390 }
391 void rna_Main_texts_remove(Main *bmain, ReportList *reports, Text *text)
392 {
393         unlink_text(bmain, text);
394         free_libblock(&bmain->text, text);
395         /* XXX python now has invalid pointer? */
396 }
397 Text *rna_Main_texts_load(Main *bmain, ReportList *reports, char* path)
398 {
399         Text *txt= add_text(path, bmain->name);
400         if(txt==NULL)
401                 BKE_reportf(reports, RPT_ERROR, "Couldn't load text from path \"%s\".", path);
402
403         return txt;
404 }
405
406 bArmature *rna_Main_armatures_new(Main *bmain, char* name)
407 {
408         bArmature *arm= add_armature(name);
409         arm->id.us--;
410         return arm;
411 }
412 void rna_Main_armatures_remove(Main *bmain, ReportList *reports, bArmature *arm)
413 {
414         if(ID_REAL_USERS(arm) <= 0)
415                 free_libblock(&bmain->armature, arm);
416         else
417                 BKE_reportf(reports, RPT_ERROR, "Armature \"%s\" must have zero users to be removed, found %d.", arm->id.name+2, ID_REAL_USERS(arm));
418
419         /* XXX python now has invalid pointer? */
420 }
421
422 bAction *rna_Main_actions_new(Main *bmain, char* name)
423 {
424         bAction *act= add_empty_action(name);
425         act->id.us--;
426         act->id.flag &= ~LIB_FAKEUSER;
427         return act;
428 }
429 void rna_Main_actions_remove(Main *bmain, ReportList *reports, bAction *act)
430 {
431         if(ID_REAL_USERS(act) <= 0)
432                 free_libblock(&bmain->action, act);
433         else
434                 BKE_reportf(reports, RPT_ERROR, "Action \"%s\" must have zero users to be removed, found %d.", act->id.name+2, ID_REAL_USERS(act));
435
436         /* XXX python now has invalid pointer? */
437 }
438
439 ParticleSettings *rna_Main_particles_new(Main *bmain, char* name)
440 {
441         ParticleSettings *part = psys_new_settings(name, bmain);
442         part->id.us--;
443         return part;
444 }
445 void rna_Main_particles_remove(Main *bmain, ReportList *reports, ParticleSettings *part)
446 {
447         if(ID_REAL_USERS(part) <= 0)
448                 free_libblock(&bmain->particle, part);
449         else
450                 BKE_reportf(reports, RPT_ERROR, "Particle Settings \"%s\" must have zero users to be removed, found %d.", part->id.name+2, ID_REAL_USERS(part));
451
452         /* XXX python now has invalid pointer? */
453 }
454
455 #else
456
457 void RNA_api_main(StructRNA *srna)
458 {
459         /*
460         FunctionRNA *func;
461         PropertyRNA *parm;
462         */
463         /* maybe we want to add functions in 'bpy.data' still?
464          * for now they are all in collections bpy.data.images.new(...) */
465         /*
466         func= RNA_def_function(srna, "add_image", "rna_Main_add_image");
467         RNA_def_function_ui_description(func, "Add a new image.");
468         parm= RNA_def_string(func, "filepath", "", 0, "", "File path to load image from.");
469         RNA_def_property_flag(parm, PROP_REQUIRED);
470         parm= RNA_def_pointer(func, "image", "Image", "", "New image.");
471         RNA_def_function_return(func, parm);
472         */
473
474 }
475
476 void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop)
477 {
478         StructRNA *srna;
479         FunctionRNA *func;
480         PropertyRNA *parm;
481
482         RNA_def_property_srna(cprop, "MainCameras");
483         srna= RNA_def_struct(brna, "MainCameras", NULL);
484         RNA_def_struct_ui_text(srna, "Main Cameras", "Collection of cameras");
485
486         func= RNA_def_function(srna, "new", "rna_Main_cameras_new");
487         RNA_def_function_ui_description(func, "Add a new camera to the main database");
488         parm= RNA_def_string(func, "name", "Camera", 0, "", "New name for the datablock.");
489         RNA_def_property_flag(parm, PROP_REQUIRED);
490         /* return type */
491         parm= RNA_def_pointer(func, "camera", "Camera", "", "New camera datablock.");
492         RNA_def_function_return(func, parm);
493
494         func= RNA_def_function(srna, "remove", "rna_Main_cameras_remove");
495         RNA_def_function_flag(func, FUNC_USE_REPORTS);
496         RNA_def_function_ui_description(func, "Remove a camera from the current blendfile.");
497         parm= RNA_def_pointer(func, "camera", "Camera", "", "Camera to remove.");
498         RNA_def_property_flag(parm, PROP_REQUIRED);
499 }
500
501 void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
502 {
503         StructRNA *srna;
504         FunctionRNA *func;
505         PropertyRNA *parm;
506
507         RNA_def_property_srna(cprop, "MainScenes");
508         srna= RNA_def_struct(brna, "MainScenes", NULL);
509         RNA_def_struct_ui_text(srna, "Main Scenes", "Collection of scenes");
510
511         func= RNA_def_function(srna, "new", "rna_Main_scenes_new");
512         RNA_def_function_ui_description(func, "Add a new scene to the main database");
513         parm= RNA_def_string(func, "name", "Scene", 0, "", "New name for the datablock.");
514         RNA_def_property_flag(parm, PROP_REQUIRED);
515         /* return type */
516         parm= RNA_def_pointer(func, "scene", "Scene", "", "New scene datablock.");
517         RNA_def_function_return(func, parm);
518
519         func= RNA_def_function(srna, "remove", "rna_Main_scenes_remove");
520         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
521         parm= RNA_def_pointer(func, "scene", "Scene", "", "Scene to remove.");
522         RNA_def_property_flag(parm, PROP_REQUIRED);
523         RNA_def_function_ui_description(func, "Remove a scene from the current blendfile.");
524         RNA_def_property_flag(parm, PROP_REQUIRED);
525 }
526
527 void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
528 {
529         StructRNA *srna;
530         FunctionRNA *func;
531         PropertyRNA *parm;
532
533         RNA_def_property_srna(cprop, "MainObjects");
534         srna= RNA_def_struct(brna, "MainObjects", NULL);
535         RNA_def_struct_ui_text(srna, "Main Objects", "Collection of objects");
536
537         func= RNA_def_function(srna, "new", "rna_Main_objects_new");
538         RNA_def_function_flag(func, FUNC_USE_REPORTS);
539         RNA_def_function_ui_description(func, "Add a new object to the main database");
540         parm= RNA_def_string(func, "name", "Object", 0, "", "New name for the datablock.");
541         RNA_def_property_flag(parm, PROP_REQUIRED);
542         parm= RNA_def_pointer(func, "object_data", "ID", "", "Object data or None for an empty object.");
543         RNA_def_property_flag(parm, PROP_REQUIRED);
544
545         /* return type */
546         parm= RNA_def_pointer(func, "object", "Object", "", "New object datablock.");
547         RNA_def_function_return(func, parm);
548
549         func= RNA_def_function(srna, "remove", "rna_Main_objects_remove");
550         RNA_def_function_flag(func, FUNC_USE_REPORTS);
551         parm= RNA_def_pointer(func, "object", "Object", "", "Object to remove.");
552         RNA_def_property_flag(parm, PROP_REQUIRED);
553         RNA_def_function_ui_description(func, "Remove a object from the current blendfile.");
554 }
555
556 void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
557 {
558         StructRNA *srna;
559         FunctionRNA *func;
560         PropertyRNA *parm;
561
562         RNA_def_property_srna(cprop, "MainMaterials");
563         srna= RNA_def_struct(brna, "MainMaterials", NULL);
564         RNA_def_struct_ui_text(srna, "Main Material", "Collection of materials");
565
566         func= RNA_def_function(srna, "new", "rna_Main_materials_new");
567         RNA_def_function_ui_description(func, "Add a new material to the main database");
568         parm= RNA_def_string(func, "name", "Material", 0, "", "New name for the datablock.");
569         RNA_def_property_flag(parm, PROP_REQUIRED);
570         /* return type */
571         parm= RNA_def_pointer(func, "material", "Material", "", "New material datablock.");
572         RNA_def_function_return(func, parm);
573
574         func= RNA_def_function(srna, "remove", "rna_Main_materials_remove");
575         RNA_def_function_flag(func, FUNC_USE_REPORTS);
576         RNA_def_function_ui_description(func, "Remove a material from the current blendfile.");
577         parm= RNA_def_pointer(func, "material", "Material", "", "Material to remove.");
578         RNA_def_property_flag(parm, PROP_REQUIRED);
579 }
580 void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop)
581 {
582         StructRNA *srna;
583 //      FunctionRNA *func;
584 //      PropertyRNA *parm;
585
586 /*      static EnumPropertyItem node_nodetree_items[] = {
587         {0, "SHADER",       0,    "Shader",       ""},
588         {1, "COMPOSITE",    0,    "Composite",    ""},
589         {2, "TEXTURE",      0,    "Texture",      ""},
590         {0, NULL, 0, NULL, NULL}}; */
591
592         RNA_def_property_srna(cprop, "MainNodeTrees");
593         srna= RNA_def_struct(brna, "MainNodeTrees", NULL);
594         RNA_def_struct_ui_text(srna, "Main Node Trees", "Collection of node trees");
595
596 #if 0 // need to see some examples of using these functions before enabling.
597         func= RNA_def_function(srna, "new", "rna_Main_nodetree_new");
598         RNA_def_function_ui_description(func, "Add a new node tree to the main database");
599         parm= RNA_def_enum(func, "type", node_nodetree_items, 0, "Type", "The type of curve object to add");
600         RNA_def_property_flag(parm, PROP_REQUIRED);
601         /* return type */
602         parm= RNA_def_pointer(func, "tree", "NodeTree", "", "New node tree datablock.");
603         RNA_def_function_return(func, parm);
604
605         func= RNA_def_function(srna, "remove", "rna_Main_nodetree_remove");
606         RNA_def_function_flag(func, FUNC_USE_REPORTS);
607         RNA_def_function_ui_description(func, "Remove a node tree from the current blendfile.");
608         parm= RNA_def_pointer(func, "tree", "NodeTree", "", "Node tree to remove.");
609         RNA_def_property_flag(parm, PROP_REQUIRED);
610 #endif
611 }
612 void RNA_def_main_meshes(BlenderRNA *brna, PropertyRNA *cprop)
613 {
614         StructRNA *srna;
615         FunctionRNA *func;
616         PropertyRNA *parm;
617
618         RNA_def_property_srna(cprop, "MainMeshes");
619         srna= RNA_def_struct(brna, "MainMeshes", NULL);
620         RNA_def_struct_ui_text(srna, "Main Meshes", "Collection of meshes");
621
622         func= RNA_def_function(srna, "new", "rna_Main_meshes_new");
623         RNA_def_function_ui_description(func, "Add a new mesh to the main database");
624         parm= RNA_def_string(func, "name", "Mesh", 0, "", "New name for the datablock.");
625         RNA_def_property_flag(parm, PROP_REQUIRED);
626         /* return type */
627         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "New mesh datablock.");
628         RNA_def_function_return(func, parm);
629
630         func= RNA_def_function(srna, "remove", "rna_Main_meshes_remove");
631         RNA_def_function_flag(func, FUNC_USE_REPORTS);
632         RNA_def_function_ui_description(func, "Remove a mesh from the current blendfile.");
633         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh to remove.");
634         RNA_def_property_flag(parm, PROP_REQUIRED);
635 }
636 void RNA_def_main_lamps(BlenderRNA *brna, PropertyRNA *cprop)
637 {
638         StructRNA *srna;
639         FunctionRNA *func;
640         PropertyRNA *parm;
641
642         RNA_def_property_srna(cprop, "MainLamps");
643         srna= RNA_def_struct(brna, "MainLamps", NULL);
644         RNA_def_struct_ui_text(srna, "Main Lamps", "Collection of lamps");
645
646         func= RNA_def_function(srna, "new", "rna_Main_lamps_new");
647         RNA_def_function_ui_description(func, "Add a new lamp to the main database");
648         parm= RNA_def_string(func, "name", "Lamp", 0, "", "New name for the datablock.");
649         RNA_def_property_flag(parm, PROP_REQUIRED);
650         /* return type */
651         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "New lamp datablock.");
652         RNA_def_function_return(func, parm);
653
654         func= RNA_def_function(srna, "remove", "rna_Main_lamps_remove");
655         RNA_def_function_flag(func, FUNC_USE_REPORTS);
656         RNA_def_function_ui_description(func, "Remove a lamp from the current blendfile.");
657         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "Lamp to remove.");
658         RNA_def_property_flag(parm, PROP_REQUIRED);
659 }
660 void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
661 {
662
663 }
664 void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
665 {
666
667 }
668 void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
669 {
670     
671 }
672 void RNA_def_main_images(BlenderRNA *brna, PropertyRNA *cprop)
673 {
674         StructRNA *srna;
675         FunctionRNA *func;
676         PropertyRNA *parm;
677
678         RNA_def_property_srna(cprop, "MainImages");
679         srna= RNA_def_struct(brna, "MainImages", NULL);
680         RNA_def_struct_ui_text(srna, "Main Images", "Collection of images");
681
682         func= RNA_def_function(srna, "new", "rna_Main_images_new");
683         RNA_def_function_ui_description(func, "Add a new image to the main database");
684         parm= RNA_def_string(func, "name", "Image", 0, "", "New name for the datablock.");
685         RNA_def_property_flag(parm, PROP_REQUIRED);
686         parm= RNA_def_int(func, "width", 1024, 1, INT_MAX, "", "Width of the image.", 0, INT_MAX);
687         parm= RNA_def_int(func, "height", 1024, 1, INT_MAX, "", "Height of the image.", 0, INT_MAX);
688         parm= RNA_def_boolean(func, "float_buffer", 0, "Float Buffer", "Create an image with floating point color");
689         /* return type */
690         parm= RNA_def_pointer(func, "image", "Image", "", "New image datablock.");
691         RNA_def_function_return(func, parm);
692
693         func= RNA_def_function(srna, "load", "rna_Main_images_load");
694         RNA_def_function_ui_description(func, "Load a new image into the main database");
695         parm= RNA_def_string(func, "filepath", "File Path", 0, "", "path of the file to load.");
696         RNA_def_property_flag(parm, PROP_REQUIRED);
697         /* return type */
698         parm= RNA_def_pointer(func, "image", "Image", "", "New image datablock.");
699         RNA_def_function_return(func, parm);
700
701         func= RNA_def_function(srna, "remove", "rna_Main_images_remove");
702         RNA_def_function_flag(func, FUNC_USE_REPORTS);
703         RNA_def_function_ui_description(func, "Remove an image from the current blendfile.");
704         parm= RNA_def_pointer(func, "image", "Image", "", "Image to remove.");
705         RNA_def_property_flag(parm, PROP_REQUIRED);
706 }
707
708 void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
709 {
710         StructRNA *srna;
711         FunctionRNA *func;
712         PropertyRNA *parm;
713
714         RNA_def_property_srna(cprop, "MainLattices");
715         srna= RNA_def_struct(brna, "MainLattices", NULL);
716         RNA_def_struct_ui_text(srna, "Main Lattices", "Collection of lattices");
717
718         func= RNA_def_function(srna, "new", "rna_Main_lattices_new");
719         RNA_def_function_ui_description(func, "Add a new lattice to the main database");
720         parm= RNA_def_string(func, "name", "Lattice", 0, "", "New name for the datablock.");
721         RNA_def_property_flag(parm, PROP_REQUIRED);
722         /* return type */
723         parm= RNA_def_pointer(func, "lattice", "Lattice", "", "New lattices datablock.");
724         RNA_def_function_return(func, parm);
725
726         func= RNA_def_function(srna, "remove", "rna_Main_lattices_remove");
727         RNA_def_function_flag(func, FUNC_USE_REPORTS);
728         RNA_def_function_ui_description(func, "Remove a lattice from the current blendfile.");
729         parm= RNA_def_pointer(func, "lattice", "Lattice", "", "Lattice to remove.");
730         RNA_def_property_flag(parm, PROP_REQUIRED);
731 }
732 void RNA_def_main_curves(BlenderRNA *brna, PropertyRNA *cprop)
733 {
734         StructRNA *srna;
735         FunctionRNA *func;
736         PropertyRNA *parm;
737
738         RNA_def_property_srna(cprop, "MainCurves");
739         srna= RNA_def_struct(brna, "MainCurves", NULL);
740         RNA_def_struct_ui_text(srna, "Main Curves", "Collection of curves");
741
742         func= RNA_def_function(srna, "new", "rna_Main_curves_new");
743         RNA_def_function_ui_description(func, "Add a new curve to the main database");
744         parm= RNA_def_string(func, "name", "Curve", 0, "", "New name for the datablock.");
745         RNA_def_property_flag(parm, PROP_REQUIRED);
746         parm= RNA_def_enum(func, "type", object_type_curve_items, 0, "Type", "The type of curve object to add");
747         RNA_def_property_flag(parm, PROP_REQUIRED);
748         /* return type */
749         parm= RNA_def_pointer(func, "curve", "Curve", "", "New curve datablock.");
750         RNA_def_function_return(func, parm);
751
752         func= RNA_def_function(srna, "remove", "rna_Main_curves_remove");
753         RNA_def_function_flag(func, FUNC_USE_REPORTS);
754         RNA_def_function_ui_description(func, "Remove a curve from the current blendfile.");
755         parm= RNA_def_pointer(func, "curve", "Curve", "", "Curve to remove.");
756         RNA_def_property_flag(parm, PROP_REQUIRED);
757 }
758 void RNA_def_main_metaballs(BlenderRNA *brna, PropertyRNA *cprop)
759 {
760         StructRNA *srna;
761         FunctionRNA *func;
762         PropertyRNA *parm;
763
764         RNA_def_property_srna(cprop, "MainMetaBalls");
765         srna= RNA_def_struct(brna, "MainMetaBalls", NULL);
766         RNA_def_struct_ui_text(srna, "Main MetaBall", "Collection of metaballs");
767
768         func= RNA_def_function(srna, "new", "rna_Main_metaballs_new");
769         RNA_def_function_ui_description(func, "Add a new metaball to the main database");
770         parm= RNA_def_string(func, "name", "MetaBall", 0, "", "New name for the datablock.");
771         RNA_def_property_flag(parm, PROP_REQUIRED);
772         /* return type */
773         parm= RNA_def_pointer(func, "metaball", "MetaBall", "", "New metaball datablock.");
774         RNA_def_function_return(func, parm);
775
776         func= RNA_def_function(srna, "remove", "rna_Main_metaballs_remove");
777         RNA_def_function_flag(func, FUNC_USE_REPORTS);
778         RNA_def_function_ui_description(func, "Remove a metaball from the current blendfile.");
779         parm= RNA_def_pointer(func, "metaball", "MetaBall", "", "MetaBall to remove.");
780         RNA_def_property_flag(parm, PROP_REQUIRED);
781 }
782 void RNA_def_main_fonts(BlenderRNA *brna, PropertyRNA *cprop)
783 {
784         StructRNA *srna;
785         FunctionRNA *func;
786         PropertyRNA *parm;
787
788         RNA_def_property_srna(cprop, "MainFonts");
789         srna= RNA_def_struct(brna, "MainFonts", NULL);
790         RNA_def_struct_ui_text(srna, "Main Fonts", "Collection of fonts");
791
792         func= RNA_def_function(srna, "load", "rna_Main_fonts_load");
793         RNA_def_function_ui_description(func, "Load a new font into the main database");
794         parm= RNA_def_string(func, "filepath", "File Path", 0, "", "path of the font to load.");
795         RNA_def_property_flag(parm, PROP_REQUIRED);
796         /* return type */
797         parm= RNA_def_pointer(func, "vfont", "VectorFont", "", "New font datablock.");
798         RNA_def_function_return(func, parm);
799
800         func= RNA_def_function(srna, "remove", "rna_Main_fonts_remove");
801         RNA_def_function_flag(func, FUNC_USE_REPORTS);
802         RNA_def_function_ui_description(func, "Remove a font from the current blendfile.");
803         parm= RNA_def_pointer(func, "vfont", "VectorFont", "", "Font to remove.");
804         RNA_def_property_flag(parm, PROP_REQUIRED);
805 }
806 void RNA_def_main_textures(BlenderRNA *brna, PropertyRNA *cprop)
807 {
808         StructRNA *srna;
809         FunctionRNA *func;
810         PropertyRNA *parm;
811
812         RNA_def_property_srna(cprop, "MainTextures");
813         srna= RNA_def_struct(brna, "MainTextures", NULL);
814         RNA_def_struct_ui_text(srna, "Main Textures", "Collection of groups");
815
816         func= RNA_def_function(srna, "new", "rna_Main_textures_new");
817         RNA_def_function_ui_description(func, "Add a new texture to the main database");
818         parm= RNA_def_string(func, "name", "Texture", 0, "", "New name for the datablock.");
819         RNA_def_property_flag(parm, PROP_REQUIRED);
820         /* return type */
821         parm= RNA_def_pointer(func, "texture", "Texture", "", "New texture datablock.");
822         RNA_def_function_return(func, parm);
823
824         func= RNA_def_function(srna, "remove", "rna_Main_textures_remove");
825         RNA_def_function_flag(func, FUNC_USE_REPORTS);
826         RNA_def_function_ui_description(func, "Remove a texture from the current blendfile.");
827         parm= RNA_def_pointer(func, "texture", "Texture", "", "Texture to remove.");
828         RNA_def_property_flag(parm, PROP_REQUIRED);
829 }
830 void RNA_def_main_brushes(BlenderRNA *brna, PropertyRNA *cprop)
831 {
832         StructRNA *srna;
833         FunctionRNA *func;
834         PropertyRNA *parm;
835
836         RNA_def_property_srna(cprop, "MainBrushes");
837         srna= RNA_def_struct(brna, "MainBrushes", NULL);
838         RNA_def_struct_ui_text(srna, "Main Brushes", "Collection of brushes");
839
840         func= RNA_def_function(srna, "new", "rna_Main_brushes_new");
841         RNA_def_function_ui_description(func, "Add a new brush to the main database");
842         parm= RNA_def_string(func, "name", "Brush", 0, "", "New name for the datablock.");
843         RNA_def_property_flag(parm, PROP_REQUIRED);
844         /* return type */
845         parm= RNA_def_pointer(func, "brush", "Brush", "", "New brush datablock.");
846         RNA_def_function_return(func, parm);
847
848         func= RNA_def_function(srna, "remove", "rna_Main_brushes_remove");
849         RNA_def_function_flag(func, FUNC_USE_REPORTS);
850         RNA_def_function_ui_description(func, "Remove a brush from the current blendfile.");
851         parm= RNA_def_pointer(func, "brush", "Brush", "", "Brush to remove.");
852         RNA_def_property_flag(parm, PROP_REQUIRED);
853 }
854
855 void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
856 {
857         StructRNA *srna;
858         FunctionRNA *func;
859         PropertyRNA *parm;
860
861         RNA_def_property_srna(cprop, "MainWorlds");
862         srna= RNA_def_struct(brna, "MainWorlds", NULL);
863         RNA_def_struct_ui_text(srna, "Main Worlds", "Collection of worlds");
864
865         func= RNA_def_function(srna, "new", "rna_Main_worlds_new");
866         RNA_def_function_ui_description(func, "Add a new world to the main database");
867         parm= RNA_def_string(func, "name", "World", 0, "", "New name for the datablock.");
868         RNA_def_property_flag(parm, PROP_REQUIRED);
869         /* return type */
870         parm= RNA_def_pointer(func, "world", "World", "", "New world datablock.");
871         RNA_def_function_return(func, parm);
872
873         func= RNA_def_function(srna, "remove", "rna_Main_worlds_remove");
874         RNA_def_function_flag(func, FUNC_USE_REPORTS);
875         RNA_def_function_ui_description(func, "Remove a world from the current blendfile.");
876         parm= RNA_def_pointer(func, "world", "World", "", "World to remove.");
877         RNA_def_property_flag(parm, PROP_REQUIRED);
878 }
879
880 void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
881 {
882         StructRNA *srna;
883         FunctionRNA *func;
884         PropertyRNA *parm;
885
886         RNA_def_property_srna(cprop, "MainGroups");
887         srna= RNA_def_struct(brna, "MainGroups", NULL);
888         RNA_def_struct_ui_text(srna, "Main Groups", "Collection of groups");
889
890         func= RNA_def_function(srna, "new", "rna_Main_groups_new");
891         RNA_def_function_ui_description(func, "Add a new group to the main database");
892         parm= RNA_def_string(func, "name", "Group", 0, "", "New name for the datablock.");
893         RNA_def_property_flag(parm, PROP_REQUIRED);
894         /* return type */
895         parm= RNA_def_pointer(func, "group", "Group", "", "New group datablock.");
896         RNA_def_function_return(func, parm);
897
898         func= RNA_def_function(srna, "remove", "rna_Main_groups_remove");
899         RNA_def_function_flag(func, FUNC_USE_REPORTS);
900         RNA_def_function_ui_description(func, "Remove a group from the current blendfile.");
901         parm= RNA_def_pointer(func, "group", "Group", "", "Group to remove.");
902         RNA_def_property_flag(parm, PROP_REQUIRED);
903 }
904 void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
905 {
906         StructRNA *srna;
907         FunctionRNA *func;
908         PropertyRNA *parm;
909
910         RNA_def_property_srna(cprop, "MainTexts");
911         srna= RNA_def_struct(brna, "MainTexts", NULL);
912         RNA_def_struct_ui_text(srna, "Main Texts", "Collection of texts");
913
914         func= RNA_def_function(srna, "new", "rna_Main_texts_new");
915         RNA_def_function_ui_description(func, "Add a new text to the main database");
916         parm= RNA_def_string(func, "name", "Text", 0, "", "New name for the datablock.");
917         RNA_def_property_flag(parm, PROP_REQUIRED);
918         /* return type */
919         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
920         RNA_def_function_return(func, parm);
921
922         func= RNA_def_function(srna, "remove", "rna_Main_texts_remove");
923         RNA_def_function_flag(func, FUNC_USE_REPORTS);
924         RNA_def_function_ui_description(func, "Remove a text from the current blendfile.");
925         parm= RNA_def_pointer(func, "text", "Text", "", "Text to remove.");
926         RNA_def_property_flag(parm, PROP_REQUIRED);
927
928         /* load func */
929         func= RNA_def_function(srna, "load", "rna_Main_texts_load");
930         RNA_def_function_flag(func, FUNC_USE_REPORTS);
931         RNA_def_function_ui_description(func, "Add a new text to the main database from a file");
932         parm= RNA_def_string(func, "filepath", "Path", FILE_MAXDIR + FILE_MAXFILE, "", "path for the datablock.");
933         RNA_def_property_flag(parm, PROP_REQUIRED);
934         /* return type */
935         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
936         RNA_def_function_return(func, parm);
937 }
938 void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
939 {
940
941 }
942 void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
943 {
944         StructRNA *srna;
945         FunctionRNA *func;
946         PropertyRNA *parm;
947
948         RNA_def_property_srna(cprop, "MainArmatures");
949         srna= RNA_def_struct(brna, "MainArmatures", NULL);
950         RNA_def_struct_ui_text(srna, "Main Armatures", "Collection of armatures");
951
952         func= RNA_def_function(srna, "new", "rna_Main_armatures_new");
953         RNA_def_function_ui_description(func, "Add a new armature to the main database");
954         parm= RNA_def_string(func, "name", "Armature", 0, "", "New name for the datablock.");
955         RNA_def_property_flag(parm, PROP_REQUIRED);
956         /* return type */
957         parm= RNA_def_pointer(func, "armature", "Armature", "", "New armature datablock.");
958         RNA_def_function_return(func, parm);
959
960         func= RNA_def_function(srna, "remove", "rna_Main_armatures_remove");
961         RNA_def_function_flag(func, FUNC_USE_REPORTS);
962         RNA_def_function_ui_description(func, "Remove a armature from the current blendfile.");
963         parm= RNA_def_pointer(func, "armature", "Armature", "", "Armature to remove.");
964         RNA_def_property_flag(parm, PROP_REQUIRED);
965 }
966 void RNA_def_main_actions(BlenderRNA *brna, PropertyRNA *cprop)
967 {
968         StructRNA *srna;
969         FunctionRNA *func;
970         PropertyRNA *parm;
971
972         RNA_def_property_srna(cprop, "MainActions");
973         srna= RNA_def_struct(brna, "MainActions", NULL);
974         RNA_def_struct_ui_text(srna, "Main Actions", "Collection of actions");
975
976         func= RNA_def_function(srna, "new", "rna_Main_actions_new");
977         RNA_def_function_ui_description(func, "Add a new action to the main database");
978         parm= RNA_def_string(func, "name", "Action", 0, "", "New name for the datablock.");
979         RNA_def_property_flag(parm, PROP_REQUIRED);
980         /* return type */
981         parm= RNA_def_pointer(func, "action", "Action", "", "New action datablock.");
982         RNA_def_function_return(func, parm);
983
984         func= RNA_def_function(srna, "remove", "rna_Main_actions_remove");
985         RNA_def_function_flag(func, FUNC_USE_REPORTS);
986         RNA_def_function_ui_description(func, "Remove a action from the current blendfile.");
987         parm= RNA_def_pointer(func, "action", "Action", "", "Action to remove.");
988         RNA_def_property_flag(parm, PROP_REQUIRED);
989 }
990 void RNA_def_main_particles(BlenderRNA *brna, PropertyRNA *cprop)
991 {
992         StructRNA *srna;
993         FunctionRNA *func;
994         PropertyRNA *parm;
995
996         RNA_def_property_srna(cprop, "MainParticles");
997         srna= RNA_def_struct(brna, "MainParticles", NULL);
998         RNA_def_struct_ui_text(srna, "Main Particle Settings", "Collection of particle settings");
999
1000         func= RNA_def_function(srna, "new", "rna_Main_particles_new");
1001         RNA_def_function_ui_description(func, "Add a new particle settings instance to the main database");
1002         parm= RNA_def_string(func, "name", "ParticleSettings", 0, "", "New name for the datablock.");
1003         RNA_def_property_flag(parm, PROP_REQUIRED);
1004         /* return type */
1005         parm= RNA_def_pointer(func, "particle", "ParticleSettings", "", "New particle settings datablock.");
1006         RNA_def_function_return(func, parm);
1007
1008         func= RNA_def_function(srna, "remove", "rna_Main_particles_remove");
1009         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1010         RNA_def_function_ui_description(func, "Remove a particle settings instance from the current blendfile.");
1011         parm= RNA_def_pointer(func, "particle", "ParticleSettings", "", "Particle Settings to remove.");
1012         RNA_def_property_flag(parm, PROP_REQUIRED);
1013 }
1014 void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
1015 {
1016
1017 }
1018
1019 #endif
1020