Merged changes in the trunk up to revision 34193.
[blender.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 #include <errno.h>
32
33 #include "RNA_define.h"
34 #include "RNA_access.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 #include "BKE_brush.h"
55 #include "BKE_lattice.h"
56 #include "BKE_mball.h"
57 #include "BKE_world.h"
58 #include "BKE_particle.h"
59 #include "BKE_font.h"
60 #include "BKE_node.h"
61 #include "BKE_linestyle.h"
62
63 #include "DNA_armature_types.h"
64 #include "DNA_camera_types.h"
65 #include "DNA_curve_types.h"
66 #include "DNA_lamp_types.h"
67 #include "DNA_material_types.h"
68 #include "DNA_mesh_types.h"
69 #include "DNA_object_types.h"
70 #include "DNA_text_types.h"
71 #include "DNA_texture_types.h"
72 #include "DNA_group_types.h"
73 #include "DNA_brush_types.h"
74 #include "DNA_lattice_types.h"
75 #include "DNA_meta_types.h"
76 #include "DNA_world_types.h"
77 #include "DNA_particle_types.h"
78 #include "DNA_vfont_types.h"
79 #include "DNA_node_types.h"
80
81 #include "ED_screen.h"
82
83 Tex *rna_Main_add_texture(Main *bmain, const char *name)
84 {
85         return add_texture(name);
86 }
87
88 Camera *rna_Main_cameras_new(Main *bmain, const char *name)
89 {
90         ID *id= add_camera(name);
91         id_us_min(id);
92         return (Camera *)id;
93 }
94 void rna_Main_cameras_remove(Main *bmain, ReportList *reports, struct Camera *camera)
95 {
96         if(ID_REAL_USERS(camera) <= 0)
97                 free_libblock(&bmain->camera, camera);
98         else
99                 BKE_reportf(reports, RPT_ERROR, "Camera \"%s\" must have zero users to be removed, found %d.", camera->id.name+2, ID_REAL_USERS(camera));
100
101         /* XXX python now has invalid pointer? */
102 }
103
104 Scene *rna_Main_scenes_new(Main *bmain, const char *name)
105 {
106         return add_scene(name);
107 }
108 void rna_Main_scenes_remove(Main *bmain, bContext *C, ReportList *reports, struct Scene *scene)
109 {
110         /* dont call free_libblock(...) directly */
111         Scene *newscene;
112
113         if(scene->id.prev)
114                 newscene= scene->id.prev;
115         else if(scene->id.next)
116                 newscene= scene->id.next;
117         else {
118                 BKE_reportf(reports, RPT_ERROR, "Scene \"%s\" is the last, cant ve removed.", scene->id.name+2);
119                 return;
120         }
121
122         if(CTX_wm_screen(C)->scene == scene)
123                 ED_screen_set_scene(C, newscene);
124
125         unlink_scene(bmain, scene, newscene);
126 }
127
128 Object *rna_Main_objects_new(Main *bmain, ReportList *reports, const char *name, ID *data)
129 {
130         Object *ob;
131         int type= OB_EMPTY;
132         if(data) {
133                 switch(GS(data->name)) {
134                         case ID_ME:
135                                 type= OB_MESH;
136                                 break;
137                         case ID_CU:
138                                 type= curve_type((struct Curve *)data);
139                                 break;
140                         case ID_MB:
141                                 type= OB_MBALL;
142                                 break;
143                         case ID_LA:
144                                 type= OB_LAMP;
145                                 break;
146                         case ID_CA:
147                                 type= OB_CAMERA;
148                                 break;
149                         case ID_LT:
150                                 type= OB_LATTICE;
151                                 break;
152                         case ID_AR:
153                                 type= OB_ARMATURE;
154                                 break;
155                         default:
156                         {
157                                 const char *idname;
158                                 if(RNA_enum_id_from_value(id_type_items, GS(data->name), &idname) == 0)
159                                         idname= "UNKNOWN";
160
161                                 BKE_reportf(reports, RPT_ERROR, "ID type '%s' is not valid for a object.", idname);
162                                 return NULL;
163                         }
164                 }
165
166                 id_us_plus(data);
167         }
168
169         ob= add_only_object(type, name);
170         id_us_min(&ob->id);
171
172         ob->data= data;
173         test_object_materials(ob->data);
174         
175         return ob;
176 }
177
178 void rna_Main_objects_remove(Main *bmain, ReportList *reports, struct Object *object)
179 {
180         if(ID_REAL_USERS(object) <= 0) {
181                 unlink_object(object); /* needed or ID pointers to this are not cleared */
182                 free_libblock(&bmain->object, object);
183         }
184         else {
185                 BKE_reportf(reports, RPT_ERROR, "Object \"%s\" must have zero users to be removed, found %d.", object->id.name+2, ID_REAL_USERS(object));
186         }
187 }
188
189 struct Material *rna_Main_materials_new(Main *bmain, const char *name)
190 {
191         ID *id= (ID *)add_material(name);
192         id_us_min(id);
193         return (Material *)id;
194 }
195 void rna_Main_materials_remove(Main *bmain, ReportList *reports, struct Material *material)
196 {
197         if(ID_REAL_USERS(material) <= 0)
198                 free_libblock(&bmain->mat, material);
199         else
200                 BKE_reportf(reports, RPT_ERROR, "Material \"%s\" must have zero users to be removed, found %d.", material->id.name+2, ID_REAL_USERS(material));
201
202         /* XXX python now has invalid pointer? */
203 }
204
205 struct bNodeTree *rna_Main_nodetree_new(Main *bmain, const char *name, int type)
206 {
207         bNodeTree *tree = ntreeAddTree(name, type, TRUE);
208
209         ntreeMakeOwnType(tree);
210
211         id_us_min(&tree->id);
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, const char *name)
225 {
226         Mesh *me= add_mesh(name);
227         id_us_min(&me->id);
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, const char *name)
241 {
242         Lamp *lamp= add_lamp(name);
243         id_us_min(&lamp->id);
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, const char *name, int width, int height, int alpha, 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, alpha ? 32:24, float_buffer, 0, color);
260         id_us_min(&image->id);
261         return image;
262 }
263 Image *rna_Main_images_load(Main *bmain, ReportList *reports, const char *filepath)
264 {
265         Image *ima;
266
267         errno= 0;
268         ima= BKE_add_image_file(filepath);
269
270         if(!ima)
271                 BKE_reportf(reports, RPT_ERROR, "Can't read: \"%s\", %s.", filepath, errno ? strerror(errno) : "Unsupported image format");
272
273         return ima;
274 }
275 void rna_Main_images_remove(Main *bmain, ReportList *reports, Image *image)
276 {
277         if(ID_REAL_USERS(image) <= 0)
278                 free_libblock(&bmain->image, image);
279         else
280                 BKE_reportf(reports, RPT_ERROR, "Image \"%s\" must have zero users to be removed, found %d.", image->id.name+2, ID_REAL_USERS(image));
281
282         /* XXX python now has invalid pointer? */
283 }
284
285 Lattice *rna_Main_lattices_new(Main *bmain, const char *name)
286 {
287         Lattice *lt= add_lattice(name);
288         id_us_min(&lt->id);
289         return lt;
290 }
291 void rna_Main_lattices_remove(Main *bmain, ReportList *reports, struct Lattice *lt)
292 {
293         if(ID_REAL_USERS(lt) <= 0)
294                 free_libblock(&bmain->latt, lt);
295         else
296                 BKE_reportf(reports, RPT_ERROR, "Lattice \"%s\" must have zero users to be removed, found %d.", lt->id.name+2, ID_REAL_USERS(lt));
297 }
298
299 Curve *rna_Main_curves_new(Main *bmain, const char *name, int type)
300 {
301         Curve *cu= add_curve(name, type);
302         id_us_min(&cu->id);
303         return cu;
304 }
305 void rna_Main_curves_remove(Main *bmain, ReportList *reports, struct Curve *cu)
306 {
307         if(ID_REAL_USERS(cu) <= 0)
308                 free_libblock(&bmain->curve, cu);
309         else
310                 BKE_reportf(reports, RPT_ERROR, "Curve \"%s\" must have zero users to be removed, found %d.", cu->id.name+2, ID_REAL_USERS(cu));
311 }
312
313 MetaBall *rna_Main_metaballs_new(Main *bmain, const char *name)
314 {
315         MetaBall *mb= add_mball(name);
316         id_us_min(&mb->id);
317         return mb;
318 }
319 void rna_Main_metaballs_remove(Main *bmain, ReportList *reports, struct MetaBall *mb)
320 {
321         if(ID_REAL_USERS(mb) <= 0)
322                 free_libblock(&bmain->mball, mb);
323         else
324                 BKE_reportf(reports, RPT_ERROR, "MetaBall \"%s\" must have zero users to be removed, found %d.", mb->id.name+2, ID_REAL_USERS(mb));
325 }
326
327 VFont *rna_Main_fonts_load(Main *bmain, ReportList *reports, const char *filepath)
328 {
329         VFont *font;
330
331         errno= 0;
332         font= load_vfont(filepath);
333
334         if(!font)
335                 BKE_reportf(reports, RPT_ERROR, "Can't read: \"%s\", %s.", filepath, errno ? strerror(errno) : "Unsupported font format");
336
337         return font;
338
339 }
340 void rna_Main_fonts_remove(Main *bmain, ReportList *reports, VFont *vfont)
341 {
342         if(ID_REAL_USERS(vfont) <= 0)
343                 free_libblock(&bmain->vfont, vfont);
344         else
345                 BKE_reportf(reports, RPT_ERROR, "Font \"%s\" must have zero users to be removed, found %d.", vfont->id.name+2, ID_REAL_USERS(vfont));
346
347         /* XXX python now has invalid pointer? */
348 }
349
350 Tex *rna_Main_textures_new(Main *bmain, const char *name, int type)
351 {
352         Tex *tex= add_texture(name);
353         tex_set_type(tex, type);
354         id_us_min(&tex->id);
355         return tex;
356 }
357 void rna_Main_textures_remove(Main *bmain, ReportList *reports, struct Tex *tex)
358 {
359         if(ID_REAL_USERS(tex) <= 0)
360                 free_libblock(&bmain->tex, tex);
361         else
362                 BKE_reportf(reports, RPT_ERROR, "Texture \"%s\" must have zero users to be removed, found %d.", tex->id.name+2, ID_REAL_USERS(tex));
363 }
364
365 Brush *rna_Main_brushes_new(Main *bmain, const char *name)
366 {
367         Brush *brush = add_brush(name);
368         id_us_min(&brush->id);
369         return brush;
370 }
371 void rna_Main_brushes_remove(Main *bmain, ReportList *reports, struct Brush *brush)
372 {
373         if(ID_REAL_USERS(brush) <= 0)
374                 free_libblock(&bmain->brush, brush);
375         else
376                 BKE_reportf(reports, RPT_ERROR, "Brush \"%s\" must have zero users to be removed, found %d.", brush->id.name+2, ID_REAL_USERS(brush));
377 }
378
379 World *rna_Main_worlds_new(Main *bmain, const char *name)
380 {
381         World *world = add_world(name);
382         id_us_min(&world->id);
383         return world;
384 }
385 void rna_Main_worlds_remove(Main *bmain, ReportList *reports, struct World *world)
386 {
387         if(ID_REAL_USERS(world) <= 0)
388                 free_libblock(&bmain->world, world);
389         else
390                 BKE_reportf(reports, RPT_ERROR, "World \"%s\" must have zero users to be removed, found %d.", world->id.name+2, ID_REAL_USERS(world));
391 }
392
393 Group *rna_Main_groups_new(Main *bmain, const char *name)
394 {
395         return add_group(name);
396 }
397 void rna_Main_groups_remove(Main *bmain, ReportList *reports, Group *group)
398 {
399         unlink_group(group);
400         free_libblock(&bmain->group, group);
401         /* XXX python now has invalid pointer? */
402 }
403
404 Text *rna_Main_texts_new(Main *bmain, const char *name)
405 {
406         return add_empty_text(name);
407 }
408 void rna_Main_texts_remove(Main *bmain, ReportList *reports, Text *text)
409 {
410         unlink_text(bmain, text);
411         free_libblock(&bmain->text, text);
412         /* XXX python now has invalid pointer? */
413 }
414
415 Text *rna_Main_texts_load(Main *bmain, ReportList *reports, const char *filepath)
416 {
417         Text *txt;
418
419         errno= 0;
420         txt= add_text(filepath, bmain->name);
421
422         if(!txt)
423                 BKE_reportf(reports, RPT_ERROR, "Can't read: \"%s\", %s.", filepath, errno ? strerror(errno) : "Unable to load text");
424
425         return txt;
426 }
427
428 bArmature *rna_Main_armatures_new(Main *bmain, const char *name)
429 {
430         bArmature *arm= add_armature(name);
431         id_us_min(&arm->id);
432         return arm;
433 }
434 void rna_Main_armatures_remove(Main *bmain, ReportList *reports, bArmature *arm)
435 {
436         if(ID_REAL_USERS(arm) <= 0)
437                 free_libblock(&bmain->armature, arm);
438         else
439                 BKE_reportf(reports, RPT_ERROR, "Armature \"%s\" must have zero users to be removed, found %d.", arm->id.name+2, ID_REAL_USERS(arm));
440
441         /* XXX python now has invalid pointer? */
442 }
443
444 bAction *rna_Main_actions_new(Main *bmain, const char *name)
445 {
446         bAction *act= add_empty_action(name);
447         id_us_min(&act->id);
448         act->id.flag &= ~LIB_FAKEUSER;
449         return act;
450 }
451 void rna_Main_actions_remove(Main *bmain, ReportList *reports, bAction *act)
452 {
453         if(ID_REAL_USERS(act) <= 0)
454                 free_libblock(&bmain->action, act);
455         else
456                 BKE_reportf(reports, RPT_ERROR, "Action \"%s\" must have zero users to be removed, found %d.", act->id.name+2, ID_REAL_USERS(act));
457
458         /* XXX python now has invalid pointer? */
459 }
460
461 ParticleSettings *rna_Main_particles_new(Main *bmain, const char *name)
462 {
463         ParticleSettings *part = psys_new_settings(name, bmain);
464         id_us_min(&part->id);
465         return part;
466 }
467 void rna_Main_particles_remove(Main *bmain, ReportList *reports, ParticleSettings *part)
468 {
469         if(ID_REAL_USERS(part) <= 0)
470                 free_libblock(&bmain->particle, part);
471         else
472                 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));
473
474         /* XXX python now has invalid pointer? */
475 }
476
477 FreestyleLineStyle *rna_Main_linestyles_new(Main *bmain, const char* name)
478 {
479         FreestyleLineStyle *linestyle = FRS_new_linestyle(name, bmain);
480         linestyle->id.us--;
481         return linestyle;
482 }
483 void rna_Main_linestyles_remove(Main *bmain, ReportList *reports, FreestyleLineStyle *linestyle)
484 {
485         if(ID_REAL_USERS(linestyle) <= 0)
486                 free_libblock(&bmain->linestyle, linestyle);
487         else
488                 BKE_reportf(reports, RPT_ERROR, "Line style \"%s\" must have zero users to be removed, found %d.", linestyle->id.name+2, ID_REAL_USERS(linestyle));
489
490         /* XXX python now has invalid pointer? */
491 }
492
493 /* tag functions, all the same */
494 void rna_Main_cameras_tag(Main *bmain, int value) { tag_main_lb(&bmain->camera, value); }
495 void rna_Main_scenes_tag(Main *bmain, int value) { tag_main_lb(&bmain->scene, value); }
496 void rna_Main_objects_tag(Main *bmain, int value) { tag_main_lb(&bmain->object, value); }
497 void rna_Main_materials_tag(Main *bmain, int value) { tag_main_lb(&bmain->mat, value); }
498 void rna_Main_node_groups_tag(Main *bmain, int value) { tag_main_lb(&bmain->nodetree, value); }
499 void rna_Main_meshes_tag(Main *bmain, int value) { tag_main_lb(&bmain->mesh, value); }
500 void rna_Main_lamps_tag(Main *bmain, int value) { tag_main_lb(&bmain->lamp, value); }
501 void rna_Main_libraries_tag(Main *bmain, int value) { tag_main_lb(&bmain->library, value); }
502 void rna_Main_screens_tag(Main *bmain, int value) { tag_main_lb(&bmain->screen, value); }
503 void rna_Main_window_managers_tag(Main *bmain, int value) { tag_main_lb(&bmain->wm, value); }
504 void rna_Main_images_tag(Main *bmain, int value) { tag_main_lb(&bmain->image, value); }
505 void rna_Main_lattices_tag(Main *bmain, int value) { tag_main_lb(&bmain->latt, value); }
506 void rna_Main_curves_tag(Main *bmain, int value) { tag_main_lb(&bmain->curve, value); }
507 void rna_Main_metaballs_tag(Main *bmain, int value) { tag_main_lb(&bmain->mball, value); }
508 void rna_Main_fonts_tag(Main *bmain, int value) { tag_main_lb(&bmain->vfont, value); }
509 void rna_Main_textures_tag(Main *bmain, int value) { tag_main_lb(&bmain->tex, value); }
510 void rna_Main_brushes_tag(Main *bmain, int value) { tag_main_lb(&bmain->brush, value); }
511 void rna_Main_worlds_tag(Main *bmain, int value) { tag_main_lb(&bmain->world, value); }
512 void rna_Main_groups_tag(Main *bmain, int value) { tag_main_lb(&bmain->group, value); }
513 void rna_Main_shape_keys_tag(Main *bmain, int value) { tag_main_lb(&bmain->key, value); }
514 void rna_Main_scripts_tag(Main *bmain, int value) { tag_main_lb(&bmain->script, value); }
515 void rna_Main_texts_tag(Main *bmain, int value) { tag_main_lb(&bmain->text, value); }
516 void rna_Main_sounds_tag(Main *bmain, int value) { tag_main_lb(&bmain->sound, value); }
517 void rna_Main_armatures_tag(Main *bmain, int value) { tag_main_lb(&bmain->armature, value); }
518 void rna_Main_actions_tag(Main *bmain, int value) { tag_main_lb(&bmain->action, value); }
519 void rna_Main_particles_tag(Main *bmain, int value) { tag_main_lb(&bmain->particle, value); }
520 void rna_Main_gpencil_tag(Main *bmain, int value) { tag_main_lb(&bmain->gpencil, value); }
521 void rna_Main_linestyle_tag(Main *bmain, int value) { tag_main_lb(&bmain->linestyle, value); }
522
523 #else
524
525 void RNA_api_main(StructRNA *srna)
526 {
527         /*
528         FunctionRNA *func;
529         PropertyRNA *parm;
530         */
531         /* maybe we want to add functions in 'bpy.data' still?
532          * for now they are all in collections bpy.data.images.new(...) */
533         /*
534         func= RNA_def_function(srna, "add_image", "rna_Main_add_image");
535         RNA_def_function_ui_description(func, "Add a new image.");
536         parm= RNA_def_string(func, "filepath", "", 0, "", "File path to load image from.");
537         RNA_def_property_flag(parm, PROP_REQUIRED);
538         parm= RNA_def_pointer(func, "image", "Image", "", "New image.");
539         RNA_def_function_return(func, parm);
540         */
541
542 }
543
544 void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop)
545 {
546         StructRNA *srna;
547         FunctionRNA *func;
548         PropertyRNA *parm;
549
550         RNA_def_property_srna(cprop, "MainCameras");
551         srna= RNA_def_struct(brna, "MainCameras", NULL);
552         RNA_def_struct_ui_text(srna, "Main Cameras", "Collection of cameras");
553
554         func= RNA_def_function(srna, "new", "rna_Main_cameras_new");
555         RNA_def_function_ui_description(func, "Add a new camera to the main database");
556         parm= RNA_def_string(func, "name", "Camera", 0, "", "New name for the datablock.");
557         RNA_def_property_flag(parm, PROP_REQUIRED);
558         /* return type */
559         parm= RNA_def_pointer(func, "camera", "Camera", "", "New camera datablock.");
560         RNA_def_function_return(func, parm);
561
562         func= RNA_def_function(srna, "remove", "rna_Main_cameras_remove");
563         RNA_def_function_flag(func, FUNC_USE_REPORTS);
564         RNA_def_function_ui_description(func, "Remove a camera from the current blendfile.");
565         parm= RNA_def_pointer(func, "camera", "Camera", "", "Camera to remove.");
566         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
567
568         func= RNA_def_function(srna, "tag", "rna_Main_cameras_tag");
569         parm= RNA_def_boolean(func, "value", 0, "Value", "");
570         RNA_def_property_flag(parm, PROP_REQUIRED);
571 }
572
573 void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
574 {
575         StructRNA *srna;
576         FunctionRNA *func;
577         PropertyRNA *parm;
578
579         RNA_def_property_srna(cprop, "MainScenes");
580         srna= RNA_def_struct(brna, "MainScenes", NULL);
581         RNA_def_struct_ui_text(srna, "Main Scenes", "Collection of scenes");
582
583         func= RNA_def_function(srna, "new", "rna_Main_scenes_new");
584         RNA_def_function_ui_description(func, "Add a new scene to the main database");
585         parm= RNA_def_string(func, "name", "Scene", 0, "", "New name for the datablock.");
586         RNA_def_property_flag(parm, PROP_REQUIRED);
587         /* return type */
588         parm= RNA_def_pointer(func, "scene", "Scene", "", "New scene datablock.");
589         RNA_def_function_return(func, parm);
590
591         func= RNA_def_function(srna, "remove", "rna_Main_scenes_remove");
592         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
593         RNA_def_function_ui_description(func, "Remove a scene from the current blendfile.");
594         parm= RNA_def_pointer(func, "scene", "Scene", "", "Scene to remove.");
595         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
596 }
597
598 void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
599 {
600         StructRNA *srna;
601         FunctionRNA *func;
602         PropertyRNA *parm;
603
604         RNA_def_property_srna(cprop, "MainObjects");
605         srna= RNA_def_struct(brna, "MainObjects", NULL);
606         RNA_def_struct_ui_text(srna, "Main Objects", "Collection of objects");
607
608         func= RNA_def_function(srna, "new", "rna_Main_objects_new");
609         RNA_def_function_flag(func, FUNC_USE_REPORTS);
610         RNA_def_function_ui_description(func, "Add a new object to the main database");
611         parm= RNA_def_string(func, "name", "Object", 0, "", "New name for the datablock.");
612         RNA_def_property_flag(parm, PROP_REQUIRED);
613         parm= RNA_def_pointer(func, "object_data", "ID", "", "Object data or None for an empty object.");
614         RNA_def_property_flag(parm, PROP_REQUIRED);
615
616         /* return type */
617         parm= RNA_def_pointer(func, "object", "Object", "", "New object datablock.");
618         RNA_def_function_return(func, parm);
619
620         func= RNA_def_function(srna, "remove", "rna_Main_objects_remove");
621         RNA_def_function_ui_description(func, "Remove a object from the current blendfile.");
622         RNA_def_function_flag(func, FUNC_USE_REPORTS);
623         parm= RNA_def_pointer(func, "object", "Object", "", "Object to remove.");
624         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
625
626         func= RNA_def_function(srna, "tag", "rna_Main_objects_tag");
627         parm= RNA_def_boolean(func, "value", 0, "Value", "");
628         RNA_def_property_flag(parm, PROP_REQUIRED);
629 }
630
631 void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
632 {
633         StructRNA *srna;
634         FunctionRNA *func;
635         PropertyRNA *parm;
636
637         RNA_def_property_srna(cprop, "MainMaterials");
638         srna= RNA_def_struct(brna, "MainMaterials", NULL);
639         RNA_def_struct_ui_text(srna, "Main Material", "Collection of materials");
640
641         func= RNA_def_function(srna, "new", "rna_Main_materials_new");
642         RNA_def_function_ui_description(func, "Add a new material to the main database");
643         parm= RNA_def_string(func, "name", "Material", 0, "", "New name for the datablock.");
644         RNA_def_property_flag(parm, PROP_REQUIRED);
645         /* return type */
646         parm= RNA_def_pointer(func, "material", "Material", "", "New material datablock.");
647         RNA_def_function_return(func, parm);
648
649         func= RNA_def_function(srna, "remove", "rna_Main_materials_remove");
650         RNA_def_function_flag(func, FUNC_USE_REPORTS);
651         RNA_def_function_ui_description(func, "Remove a material from the current blendfile.");
652         parm= RNA_def_pointer(func, "material", "Material", "", "Material to remove.");
653         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
654
655         func= RNA_def_function(srna, "tag", "rna_Main_materials_tag");
656         parm= RNA_def_boolean(func, "value", 0, "Value", "");
657         RNA_def_property_flag(parm, PROP_REQUIRED);
658 }
659 void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop)
660 {
661         StructRNA *srna;
662         FunctionRNA *func;
663         PropertyRNA *parm;
664
665         static EnumPropertyItem node_nodetree_items[] = {
666         {0, "SHADER",       0,    "Shader",       ""},
667         {1, "COMPOSITE",    0,    "Composite",    ""},
668         {2, "TEXTURE",      0,    "Texture",      ""},
669         {0, NULL, 0, NULL, NULL}};
670
671         RNA_def_property_srna(cprop, "MainNodeTrees");
672         srna= RNA_def_struct(brna, "MainNodeTrees", NULL);
673         RNA_def_struct_ui_text(srna, "Main Node Trees", "Collection of node trees");
674
675         func= RNA_def_function(srna, "new", "rna_Main_nodetree_new");
676         RNA_def_function_ui_description(func, "Add a new node tree to the main database");
677         parm= RNA_def_string(func, "name", "NodeGroup", 0, "", "New name for the datablock.");
678         RNA_def_property_flag(parm, PROP_REQUIRED);
679         parm= RNA_def_enum(func, "type", node_nodetree_items, 0, "Type", "The type of node_group to add");
680         RNA_def_property_flag(parm, PROP_REQUIRED);
681         /* return type */
682         parm= RNA_def_pointer(func, "tree", "NodeTree", "", "New node tree datablock.");
683         RNA_def_function_return(func, parm);
684
685         func= RNA_def_function(srna, "remove", "rna_Main_nodetree_remove");
686         RNA_def_function_flag(func, FUNC_USE_REPORTS);
687         RNA_def_function_ui_description(func, "Remove a node tree from the current blendfile.");
688         parm= RNA_def_pointer(func, "tree", "NodeTree", "", "Node tree to remove.");
689         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
690
691         func= RNA_def_function(srna, "tag", "rna_Main_node_groups_tag");
692         parm= RNA_def_boolean(func, "value", 0, "Value", "");
693         RNA_def_property_flag(parm, PROP_REQUIRED);
694 }
695 void RNA_def_main_meshes(BlenderRNA *brna, PropertyRNA *cprop)
696 {
697         StructRNA *srna;
698         FunctionRNA *func;
699         PropertyRNA *parm;
700
701         RNA_def_property_srna(cprop, "MainMeshes");
702         srna= RNA_def_struct(brna, "MainMeshes", NULL);
703         RNA_def_struct_ui_text(srna, "Main Meshes", "Collection of meshes");
704
705         func= RNA_def_function(srna, "new", "rna_Main_meshes_new");
706         RNA_def_function_ui_description(func, "Add a new mesh to the main database");
707         parm= RNA_def_string(func, "name", "Mesh", 0, "", "New name for the datablock.");
708         RNA_def_property_flag(parm, PROP_REQUIRED);
709         /* return type */
710         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "New mesh datablock.");
711         RNA_def_function_return(func, parm);
712
713         func= RNA_def_function(srna, "remove", "rna_Main_meshes_remove");
714         RNA_def_function_flag(func, FUNC_USE_REPORTS);
715         RNA_def_function_ui_description(func, "Remove a mesh from the current blendfile.");
716         parm= RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh to remove.");
717         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
718
719         func= RNA_def_function(srna, "tag", "rna_Main_meshes_tag");
720         parm= RNA_def_boolean(func, "value", 0, "Value", "");
721         RNA_def_property_flag(parm, PROP_REQUIRED);
722 }
723 void RNA_def_main_lamps(BlenderRNA *brna, PropertyRNA *cprop)
724 {
725         StructRNA *srna;
726         FunctionRNA *func;
727         PropertyRNA *parm;
728
729         RNA_def_property_srna(cprop, "MainLamps");
730         srna= RNA_def_struct(brna, "MainLamps", NULL);
731         RNA_def_struct_ui_text(srna, "Main Lamps", "Collection of lamps");
732
733         func= RNA_def_function(srna, "new", "rna_Main_lamps_new");
734         RNA_def_function_ui_description(func, "Add a new lamp to the main database");
735         parm= RNA_def_string(func, "name", "Lamp", 0, "", "New name for the datablock.");
736         RNA_def_property_flag(parm, PROP_REQUIRED);
737         /* return type */
738         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "New lamp datablock.");
739         RNA_def_function_return(func, parm);
740
741         func= RNA_def_function(srna, "remove", "rna_Main_lamps_remove");
742         RNA_def_function_flag(func, FUNC_USE_REPORTS);
743         RNA_def_function_ui_description(func, "Remove a lamp from the current blendfile.");
744         parm= RNA_def_pointer(func, "lamp", "Lamp", "", "Lamp to remove.");
745         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
746
747         func= RNA_def_function(srna, "tag", "rna_Main_lamps_tag");
748         parm= RNA_def_boolean(func, "value", 0, "Value", "");
749         RNA_def_property_flag(parm, PROP_REQUIRED);
750 }
751
752 void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
753 {
754         StructRNA *srna;
755         FunctionRNA *func;
756         PropertyRNA *parm;
757
758         RNA_def_property_srna(cprop, "MainLibraries");
759         srna= RNA_def_struct(brna, "MainLibraries", NULL);
760         RNA_def_struct_ui_text(srna, "Main Libraries", "Collection of libraries");
761
762         func= RNA_def_function(srna, "tag", "rna_Main_libraries_tag");
763         parm= RNA_def_boolean(func, "value", 0, "Value", "");
764         RNA_def_property_flag(parm, PROP_REQUIRED);
765 }
766
767 void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
768 {
769         StructRNA *srna;
770         FunctionRNA *func;
771         PropertyRNA *parm;
772
773         RNA_def_property_srna(cprop, "MainScreens");
774         srna= RNA_def_struct(brna, "MainScreens", NULL);
775         RNA_def_struct_ui_text(srna, "Main Screens", "Collection of screens");
776
777         func= RNA_def_function(srna, "tag", "rna_Main_screens_tag");
778         parm= RNA_def_boolean(func, "value", 0, "Value", "");
779         RNA_def_property_flag(parm, PROP_REQUIRED);
780 }
781
782 void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
783 {
784         StructRNA *srna;
785         FunctionRNA *func;
786         PropertyRNA *parm;
787     
788         RNA_def_property_srna(cprop, "MainWindowManagers");
789         srna= RNA_def_struct(brna, "MainWindowManagers", NULL);
790         RNA_def_struct_ui_text(srna, "Main Window Managers", "Collection of window managers");
791
792         func= RNA_def_function(srna, "tag", "rna_Main_window_managers_tag");
793         parm= RNA_def_boolean(func, "value", 0, "Value", "");
794         RNA_def_property_flag(parm, PROP_REQUIRED);
795 }
796 void RNA_def_main_images(BlenderRNA *brna, PropertyRNA *cprop)
797 {
798         StructRNA *srna;
799         FunctionRNA *func;
800         PropertyRNA *parm;
801
802         RNA_def_property_srna(cprop, "MainImages");
803         srna= RNA_def_struct(brna, "MainImages", NULL);
804         RNA_def_struct_ui_text(srna, "Main Images", "Collection of images");
805
806         func= RNA_def_function(srna, "new", "rna_Main_images_new");
807         RNA_def_function_ui_description(func, "Add a new image to the main database");
808         parm= RNA_def_string(func, "name", "Image", 0, "", "New name for the datablock.");
809         RNA_def_property_flag(parm, PROP_REQUIRED);
810         parm= RNA_def_int(func, "width", 1024, 1, INT_MAX, "", "Width of the image.", 0, INT_MAX);
811         parm= RNA_def_int(func, "height", 1024, 1, INT_MAX, "", "Height of the image.", 0, INT_MAX);
812         parm= RNA_def_boolean(func, "alpha", 0, "Alpha", "Use alpha channel");
813         parm= RNA_def_boolean(func, "float_buffer", 0, "Float Buffer", "Create an image with floating point color");
814         /* return type */
815         parm= RNA_def_pointer(func, "image", "Image", "", "New image datablock.");
816         RNA_def_function_return(func, parm);
817
818         func= RNA_def_function(srna, "load", "rna_Main_images_load");
819         RNA_def_function_flag(func, FUNC_USE_REPORTS);
820         RNA_def_function_ui_description(func, "Load a new image into the main database");
821         parm= RNA_def_string(func, "filepath", "File Path", 0, "", "path of the file to load.");
822         RNA_def_property_flag(parm, PROP_REQUIRED);
823         /* return type */
824         parm= RNA_def_pointer(func, "image", "Image", "", "New image datablock.");
825         RNA_def_function_return(func, parm);
826
827         func= RNA_def_function(srna, "remove", "rna_Main_images_remove");
828         RNA_def_function_flag(func, FUNC_USE_REPORTS);
829         RNA_def_function_ui_description(func, "Remove an image from the current blendfile.");
830         parm= RNA_def_pointer(func, "image", "Image", "", "Image to remove.");
831         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
832
833         func= RNA_def_function(srna, "tag", "rna_Main_images_tag");
834         parm= RNA_def_boolean(func, "value", 0, "Value", "");
835         RNA_def_property_flag(parm, PROP_REQUIRED);
836 }
837
838 void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
839 {
840         StructRNA *srna;
841         FunctionRNA *func;
842         PropertyRNA *parm;
843
844         RNA_def_property_srna(cprop, "MainLattices");
845         srna= RNA_def_struct(brna, "MainLattices", NULL);
846         RNA_def_struct_ui_text(srna, "Main Lattices", "Collection of lattices");
847
848         func= RNA_def_function(srna, "new", "rna_Main_lattices_new");
849         RNA_def_function_ui_description(func, "Add a new lattice to the main database");
850         parm= RNA_def_string(func, "name", "Lattice", 0, "", "New name for the datablock.");
851         RNA_def_property_flag(parm, PROP_REQUIRED);
852         /* return type */
853         parm= RNA_def_pointer(func, "lattice", "Lattice", "", "New lattices datablock.");
854         RNA_def_function_return(func, parm);
855
856         func= RNA_def_function(srna, "remove", "rna_Main_lattices_remove");
857         RNA_def_function_flag(func, FUNC_USE_REPORTS);
858         RNA_def_function_ui_description(func, "Remove a lattice from the current blendfile.");
859         parm= RNA_def_pointer(func, "lattice", "Lattice", "", "Lattice to remove.");
860         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
861
862         func= RNA_def_function(srna, "tag", "rna_Main_lattices_tag");
863         parm= RNA_def_boolean(func, "value", 0, "Value", "");
864         RNA_def_property_flag(parm, PROP_REQUIRED);
865 }
866 void RNA_def_main_curves(BlenderRNA *brna, PropertyRNA *cprop)
867 {
868         StructRNA *srna;
869         FunctionRNA *func;
870         PropertyRNA *parm;
871
872         RNA_def_property_srna(cprop, "MainCurves");
873         srna= RNA_def_struct(brna, "MainCurves", NULL);
874         RNA_def_struct_ui_text(srna, "Main Curves", "Collection of curves");
875
876         func= RNA_def_function(srna, "new", "rna_Main_curves_new");
877         RNA_def_function_ui_description(func, "Add a new curve to the main database");
878         parm= RNA_def_string(func, "name", "Curve", 0, "", "New name for the datablock.");
879         RNA_def_property_flag(parm, PROP_REQUIRED);
880         parm= RNA_def_enum(func, "type", object_type_curve_items, 0, "Type", "The type of curve to add");
881         RNA_def_property_flag(parm, PROP_REQUIRED);
882         /* return type */
883         parm= RNA_def_pointer(func, "curve", "Curve", "", "New curve datablock.");
884         RNA_def_function_return(func, parm);
885
886         func= RNA_def_function(srna, "remove", "rna_Main_curves_remove");
887         RNA_def_function_flag(func, FUNC_USE_REPORTS);
888         RNA_def_function_ui_description(func, "Remove a curve from the current blendfile.");
889         parm= RNA_def_pointer(func, "curve", "Curve", "", "Curve to remove.");
890         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
891
892         func= RNA_def_function(srna, "tag", "rna_Main_curves_tag");
893         parm= RNA_def_boolean(func, "value", 0, "Value", "");
894         RNA_def_property_flag(parm, PROP_REQUIRED);
895 }
896 void RNA_def_main_metaballs(BlenderRNA *brna, PropertyRNA *cprop)
897 {
898         StructRNA *srna;
899         FunctionRNA *func;
900         PropertyRNA *parm;
901
902         RNA_def_property_srna(cprop, "MainMetaBalls");
903         srna= RNA_def_struct(brna, "MainMetaBalls", NULL);
904         RNA_def_struct_ui_text(srna, "Main MetaBall", "Collection of metaballs");
905
906         func= RNA_def_function(srna, "new", "rna_Main_metaballs_new");
907         RNA_def_function_ui_description(func, "Add a new metaball to the main database");
908         parm= RNA_def_string(func, "name", "MetaBall", 0, "", "New name for the datablock.");
909         RNA_def_property_flag(parm, PROP_REQUIRED);
910         /* return type */
911         parm= RNA_def_pointer(func, "metaball", "MetaBall", "", "New metaball datablock.");
912         RNA_def_function_return(func, parm);
913
914         func= RNA_def_function(srna, "remove", "rna_Main_metaballs_remove");
915         RNA_def_function_flag(func, FUNC_USE_REPORTS);
916         RNA_def_function_ui_description(func, "Remove a metaball from the current blendfile.");
917         parm= RNA_def_pointer(func, "metaball", "MetaBall", "", "MetaBall to remove.");
918         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
919
920         func= RNA_def_function(srna, "tag", "rna_Main_metaballs_tag");
921         parm= RNA_def_boolean(func, "value", 0, "Value", "");
922         RNA_def_property_flag(parm, PROP_REQUIRED);
923 }
924 void RNA_def_main_fonts(BlenderRNA *brna, PropertyRNA *cprop)
925 {
926         StructRNA *srna;
927         FunctionRNA *func;
928         PropertyRNA *parm;
929
930         RNA_def_property_srna(cprop, "MainFonts");
931         srna= RNA_def_struct(brna, "MainFonts", NULL);
932         RNA_def_struct_ui_text(srna, "Main Fonts", "Collection of fonts");
933
934         func= RNA_def_function(srna, "load", "rna_Main_fonts_load");
935         RNA_def_function_flag(func, FUNC_USE_REPORTS);
936         RNA_def_function_ui_description(func, "Load a new font into the main database");
937         parm= RNA_def_string(func, "filepath", "File Path", 0, "", "path of the font to load.");
938         RNA_def_property_flag(parm, PROP_REQUIRED);
939         /* return type */
940         parm= RNA_def_pointer(func, "vfont", "VectorFont", "", "New font datablock.");
941         RNA_def_function_return(func, parm);
942
943         func= RNA_def_function(srna, "remove", "rna_Main_fonts_remove");
944         RNA_def_function_flag(func, FUNC_USE_REPORTS);
945         RNA_def_function_ui_description(func, "Remove a font from the current blendfile.");
946         parm= RNA_def_pointer(func, "vfont", "VectorFont", "", "Font to remove.");
947         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
948
949         func= RNA_def_function(srna, "tag", "rna_Main_fonts_tag");
950         parm= RNA_def_boolean(func, "value", 0, "Value", "");
951         RNA_def_property_flag(parm, PROP_REQUIRED);
952 }
953 void RNA_def_main_textures(BlenderRNA *brna, PropertyRNA *cprop)
954 {
955         StructRNA *srna;
956         FunctionRNA *func;
957         PropertyRNA *parm;
958
959         RNA_def_property_srna(cprop, "MainTextures");
960         srna= RNA_def_struct(brna, "MainTextures", NULL);
961         RNA_def_struct_ui_text(srna, "Main Textures", "Collection of groups");
962
963         func= RNA_def_function(srna, "new", "rna_Main_textures_new");
964         RNA_def_function_ui_description(func, "Add a new texture to the main database");
965         parm= RNA_def_string(func, "name", "Texture", 0, "", "New name for the datablock.");
966         RNA_def_property_flag(parm, PROP_REQUIRED);
967         parm= RNA_def_enum(func, "type", texture_type_items, 0, "Type", "The type of texture to add");
968         RNA_def_property_flag(parm, PROP_REQUIRED);
969         /* return type */
970         parm= RNA_def_pointer(func, "texture", "Texture", "", "New texture datablock.");
971         RNA_def_function_return(func, parm);
972
973         func= RNA_def_function(srna, "remove", "rna_Main_textures_remove");
974         RNA_def_function_flag(func, FUNC_USE_REPORTS);
975         RNA_def_function_ui_description(func, "Remove a texture from the current blendfile.");
976         parm= RNA_def_pointer(func, "texture", "Texture", "", "Texture to remove.");
977         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
978
979         func= RNA_def_function(srna, "tag", "rna_Main_textures_tag");
980         parm= RNA_def_boolean(func, "value", 0, "Value", "");
981         RNA_def_property_flag(parm, PROP_REQUIRED);
982 }
983 void RNA_def_main_brushes(BlenderRNA *brna, PropertyRNA *cprop)
984 {
985         StructRNA *srna;
986         FunctionRNA *func;
987         PropertyRNA *parm;
988
989         RNA_def_property_srna(cprop, "MainBrushes");
990         srna= RNA_def_struct(brna, "MainBrushes", NULL);
991         RNA_def_struct_ui_text(srna, "Main Brushes", "Collection of brushes");
992
993         func= RNA_def_function(srna, "new", "rna_Main_brushes_new");
994         RNA_def_function_ui_description(func, "Add a new brush to the main database");
995         parm= RNA_def_string(func, "name", "Brush", 0, "", "New name for the datablock.");
996         RNA_def_property_flag(parm, PROP_REQUIRED);
997         /* return type */
998         parm= RNA_def_pointer(func, "brush", "Brush", "", "New brush datablock.");
999         RNA_def_function_return(func, parm);
1000
1001         func= RNA_def_function(srna, "remove", "rna_Main_brushes_remove");
1002         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1003         RNA_def_function_ui_description(func, "Remove a brush from the current blendfile.");
1004         parm= RNA_def_pointer(func, "brush", "Brush", "", "Brush to remove.");
1005         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1006
1007         func= RNA_def_function(srna, "tag", "rna_Main_brushes_tag");
1008         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1009         RNA_def_property_flag(parm, PROP_REQUIRED);
1010 }
1011
1012 void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
1013 {
1014         StructRNA *srna;
1015         FunctionRNA *func;
1016         PropertyRNA *parm;
1017
1018         RNA_def_property_srna(cprop, "MainWorlds");
1019         srna= RNA_def_struct(brna, "MainWorlds", NULL);
1020         RNA_def_struct_ui_text(srna, "Main Worlds", "Collection of worlds");
1021
1022         func= RNA_def_function(srna, "new", "rna_Main_worlds_new");
1023         RNA_def_function_ui_description(func, "Add a new world to the main database");
1024         parm= RNA_def_string(func, "name", "World", 0, "", "New name for the datablock.");
1025         RNA_def_property_flag(parm, PROP_REQUIRED);
1026         /* return type */
1027         parm= RNA_def_pointer(func, "world", "World", "", "New world datablock.");
1028         RNA_def_function_return(func, parm);
1029
1030         func= RNA_def_function(srna, "remove", "rna_Main_worlds_remove");
1031         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1032         RNA_def_function_ui_description(func, "Remove a world from the current blendfile.");
1033         parm= RNA_def_pointer(func, "world", "World", "", "World to remove.");
1034         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1035
1036         func= RNA_def_function(srna, "tag", "rna_Main_worlds_tag");
1037         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1038         RNA_def_property_flag(parm, PROP_REQUIRED);
1039 }
1040
1041 void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
1042 {
1043         StructRNA *srna;
1044         FunctionRNA *func;
1045         PropertyRNA *parm;
1046
1047         RNA_def_property_srna(cprop, "MainGroups");
1048         srna= RNA_def_struct(brna, "MainGroups", NULL);
1049         RNA_def_struct_ui_text(srna, "Main Groups", "Collection of groups");
1050
1051         func= RNA_def_function(srna, "new", "rna_Main_groups_new");
1052         RNA_def_function_ui_description(func, "Add a new group to the main database");
1053         parm= RNA_def_string(func, "name", "Group", 0, "", "New name for the datablock.");
1054         RNA_def_property_flag(parm, PROP_REQUIRED);
1055         /* return type */
1056         parm= RNA_def_pointer(func, "group", "Group", "", "New group datablock.");
1057         RNA_def_function_return(func, parm);
1058
1059         func= RNA_def_function(srna, "remove", "rna_Main_groups_remove");
1060         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1061         RNA_def_function_ui_description(func, "Remove a group from the current blendfile.");
1062         parm= RNA_def_pointer(func, "group", "Group", "", "Group to remove.");
1063         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1064
1065         func= RNA_def_function(srna, "tag", "rna_Main_groups_tag");
1066         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1067         RNA_def_property_flag(parm, PROP_REQUIRED);
1068 }
1069 void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
1070 {
1071         StructRNA *srna;
1072         FunctionRNA *func;
1073         PropertyRNA *parm;
1074
1075         RNA_def_property_srna(cprop, "MainTexts");
1076         srna= RNA_def_struct(brna, "MainTexts", NULL);
1077         RNA_def_struct_ui_text(srna, "Main Texts", "Collection of texts");
1078
1079         func= RNA_def_function(srna, "new", "rna_Main_texts_new");
1080         RNA_def_function_ui_description(func, "Add a new text to the main database");
1081         parm= RNA_def_string(func, "name", "Text", 0, "", "New name for the datablock.");
1082         RNA_def_property_flag(parm, PROP_REQUIRED);
1083         /* return type */
1084         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
1085         RNA_def_function_return(func, parm);
1086
1087         func= RNA_def_function(srna, "remove", "rna_Main_texts_remove");
1088         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1089         RNA_def_function_ui_description(func, "Remove a text from the current blendfile.");
1090         parm= RNA_def_pointer(func, "text", "Text", "", "Text to remove.");
1091         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1092
1093         /* load func */
1094         func= RNA_def_function(srna, "load", "rna_Main_texts_load");
1095         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1096         RNA_def_function_ui_description(func, "Add a new text to the main database from a file");
1097         parm= RNA_def_string(func, "filepath", "Path", FILE_MAXDIR + FILE_MAXFILE, "", "path for the datablock.");
1098         RNA_def_property_flag(parm, PROP_REQUIRED);
1099         /* return type */
1100         parm= RNA_def_pointer(func, "text", "Text", "", "New text datablock.");
1101         RNA_def_function_return(func, parm);
1102
1103         func= RNA_def_function(srna, "tag", "rna_Main_texts_tag");
1104         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1105         RNA_def_property_flag(parm, PROP_REQUIRED);
1106 }
1107
1108 void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
1109 {
1110         StructRNA *srna;
1111         FunctionRNA *func;
1112         PropertyRNA *parm;
1113
1114         RNA_def_property_srna(cprop, "MainSounds");
1115         srna= RNA_def_struct(brna, "MainSounds", NULL);
1116         RNA_def_struct_ui_text(srna, "Main Sounds", "Collection of sounds");
1117
1118         /* TODO, 'load' */
1119
1120         func= RNA_def_function(srna, "tag", "rna_Main_sounds_tag");
1121         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1122         RNA_def_property_flag(parm, PROP_REQUIRED);
1123 }
1124
1125 void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
1126 {
1127         StructRNA *srna;
1128         FunctionRNA *func;
1129         PropertyRNA *parm;
1130
1131         RNA_def_property_srna(cprop, "MainArmatures");
1132         srna= RNA_def_struct(brna, "MainArmatures", NULL);
1133         RNA_def_struct_ui_text(srna, "Main Armatures", "Collection of armatures");
1134
1135         func= RNA_def_function(srna, "new", "rna_Main_armatures_new");
1136         RNA_def_function_ui_description(func, "Add a new armature to the main database");
1137         parm= RNA_def_string(func, "name", "Armature", 0, "", "New name for the datablock.");
1138         RNA_def_property_flag(parm, PROP_REQUIRED);
1139         /* return type */
1140         parm= RNA_def_pointer(func, "armature", "Armature", "", "New armature datablock.");
1141         RNA_def_function_return(func, parm);
1142
1143         func= RNA_def_function(srna, "remove", "rna_Main_armatures_remove");
1144         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1145         RNA_def_function_ui_description(func, "Remove a armature from the current blendfile.");
1146         parm= RNA_def_pointer(func, "armature", "Armature", "", "Armature to remove.");
1147         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1148
1149         func= RNA_def_function(srna, "tag", "rna_Main_armatures_tag");
1150         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1151         RNA_def_property_flag(parm, PROP_REQUIRED);
1152 }
1153 void RNA_def_main_actions(BlenderRNA *brna, PropertyRNA *cprop)
1154 {
1155         StructRNA *srna;
1156         FunctionRNA *func;
1157         PropertyRNA *parm;
1158
1159         RNA_def_property_srna(cprop, "MainActions");
1160         srna= RNA_def_struct(brna, "MainActions", NULL);
1161         RNA_def_struct_ui_text(srna, "Main Actions", "Collection of actions");
1162
1163         func= RNA_def_function(srna, "new", "rna_Main_actions_new");
1164         RNA_def_function_ui_description(func, "Add a new action to the main database");
1165         parm= RNA_def_string(func, "name", "Action", 0, "", "New name for the datablock.");
1166         RNA_def_property_flag(parm, PROP_REQUIRED);
1167         /* return type */
1168         parm= RNA_def_pointer(func, "action", "Action", "", "New action datablock.");
1169         RNA_def_function_return(func, parm);
1170
1171         func= RNA_def_function(srna, "remove", "rna_Main_actions_remove");
1172         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1173         RNA_def_function_ui_description(func, "Remove a action from the current blendfile.");
1174         parm= RNA_def_pointer(func, "action", "Action", "", "Action to remove.");
1175         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1176
1177         func= RNA_def_function(srna, "tag", "rna_Main_actions_tag");
1178         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1179         RNA_def_property_flag(parm, PROP_REQUIRED);
1180 }
1181 void RNA_def_main_particles(BlenderRNA *brna, PropertyRNA *cprop)
1182 {
1183         StructRNA *srna;
1184         FunctionRNA *func;
1185         PropertyRNA *parm;
1186
1187         RNA_def_property_srna(cprop, "MainParticles");
1188         srna= RNA_def_struct(brna, "MainParticles", NULL);
1189         RNA_def_struct_ui_text(srna, "Main Particle Settings", "Collection of particle settings");
1190
1191         func= RNA_def_function(srna, "new", "rna_Main_particles_new");
1192         RNA_def_function_ui_description(func, "Add a new particle settings instance to the main database");
1193         parm= RNA_def_string(func, "name", "ParticleSettings", 0, "", "New name for the datablock.");
1194         RNA_def_property_flag(parm, PROP_REQUIRED);
1195         /* return type */
1196         parm= RNA_def_pointer(func, "particle", "ParticleSettings", "", "New particle settings datablock.");
1197         RNA_def_function_return(func, parm);
1198
1199         func= RNA_def_function(srna, "remove", "rna_Main_particles_remove");
1200         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1201         RNA_def_function_ui_description(func, "Remove a particle settings instance from the current blendfile.");
1202         parm= RNA_def_pointer(func, "particle", "ParticleSettings", "", "Particle Settings to remove.");
1203         RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
1204
1205         func= RNA_def_function(srna, "tag", "rna_Main_particles_tag");
1206         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1207         RNA_def_property_flag(parm, PROP_REQUIRED);
1208 }
1209
1210 void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
1211 {
1212         StructRNA *srna;
1213         FunctionRNA *func;
1214         PropertyRNA *parm;
1215
1216         RNA_def_property_srna(cprop, "MainGreasePencils");
1217         srna= RNA_def_struct(brna, "MainGreasePencils", NULL);
1218         RNA_def_struct_ui_text(srna, "Main Grease Pencils", "Collection of grease pencils");
1219
1220         func= RNA_def_function(srna, "tag", "rna_Main_gpencil_tag");
1221         parm= RNA_def_boolean(func, "value", 0, "Value", "");
1222         RNA_def_property_flag(parm, PROP_REQUIRED);
1223 }
1224 void RNA_def_main_linestyles(BlenderRNA *brna, PropertyRNA *cprop)
1225 {
1226         StructRNA *srna;
1227         FunctionRNA *func;
1228         PropertyRNA *parm;
1229
1230         RNA_def_property_srna(cprop, "MainLineStyles");
1231         srna= RNA_def_struct(brna, "MainLineStyles", NULL);
1232         RNA_def_struct_ui_text(srna, "Main Line Styles", "Collection of line styles");
1233
1234         func= RNA_def_function(srna, "new", "rna_Main_linestyles_new");
1235         RNA_def_function_ui_description(func, "Add a new line style instance to the main database");
1236         parm= RNA_def_string(func, "name", "FreestyleLineStyle", 0, "", "New name for the datablock.");
1237         RNA_def_property_flag(parm, PROP_REQUIRED);
1238         /* return type */
1239         parm= RNA_def_pointer(func, "linestyle", "FreestyleLineStyle", "", "New line style datablock.");
1240         RNA_def_function_return(func, parm);
1241
1242         func= RNA_def_function(srna, "remove", "rna_Main_linestyles_remove");
1243         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1244         RNA_def_function_ui_description(func, "Remove a line style instance from the current blendfile.");
1245         parm= RNA_def_pointer(func, "linestyle", "FreestyleLineStyle", "", "Line style to remove.");
1246         RNA_def_property_flag(parm, PROP_REQUIRED);
1247 }
1248
1249 #endif
1250