svn merge ^/trunk/blender -r55357:55372
[blender.git] / source / blender / makesrna / intern / rna_main_api.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2009 Blender Foundation.
19  * All rights reserved.
20  *
21  *
22  * Contributor(s): Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/makesrna/intern/rna_main_api.c
28  *  \ingroup RNA
29  */
30
31
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <errno.h>
35
36 #include "DNA_ID.h"
37 #include "DNA_modifier_types.h"
38
39 #include "BLI_utildefines.h"
40 #include "BLI_path_util.h"
41
42 #include "RNA_define.h"
43 #include "RNA_access.h"
44 #include "RNA_enum_types.h"
45
46 #include "rna_internal.h"
47
48 #ifdef RNA_RUNTIME
49
50 #include "BKE_main.h"
51 #include "BKE_camera.h"
52 #include "BKE_curve.h"
53 #include "BKE_DerivedMesh.h"
54 #include "BKE_displist.h"
55 #include "BKE_mesh.h"
56 #include "BKE_armature.h"
57 #include "BKE_lamp.h"
58 #include "BKE_library.h"
59 #include "BKE_object.h"
60 #include "BKE_material.h"
61 #include "BKE_image.h"
62 #include "BKE_texture.h"
63 #include "BKE_scene.h"
64 #include "BKE_text.h"
65 #include "BKE_action.h"
66 #include "BKE_group.h"
67 #include "BKE_brush.h"
68 #include "BKE_lattice.h"
69 #include "BKE_mball.h"
70 #include "BKE_world.h"
71 #include "BKE_particle.h"
72 #include "BKE_font.h"
73 #include "BKE_node.h"
74 #include "BKE_depsgraph.h"
75 #include "BKE_speaker.h"
76 #include "BKE_movieclip.h"
77 #include "BKE_mask.h"
78 #include "BKE_gpencil.h"
79 #ifdef WITH_FREESTYLE
80 #  include "BKE_linestyle.h"
81 #endif
82
83 #include "DNA_armature_types.h"
84 #include "DNA_camera_types.h"
85 #include "DNA_curve_types.h"
86 #include "DNA_lamp_types.h"
87 #include "DNA_material_types.h"
88 #include "DNA_mesh_types.h"
89 #include "DNA_object_types.h"
90 #include "DNA_speaker_types.h"
91 #include "DNA_text_types.h"
92 #include "DNA_texture_types.h"
93 #include "DNA_group_types.h"
94 #include "DNA_brush_types.h"
95 #include "DNA_lattice_types.h"
96 #include "DNA_meta_types.h"
97 #include "DNA_world_types.h"
98 #include "DNA_particle_types.h"
99 #include "DNA_vfont_types.h"
100 #include "DNA_node_types.h"
101 #include "DNA_movieclip_types.h"
102 #include "DNA_mask_types.h"
103 #include "DNA_gpencil_types.h"
104
105 #include "ED_screen.h"
106
107 #include "BLF_translation.h"
108
109 static Camera *rna_Main_cameras_new(Main *bmain, const char *name)
110 {
111         ID *id = BKE_camera_add(bmain, name);
112         id_us_min(id);
113         return (Camera *)id;
114 }
115 static void rna_Main_cameras_remove(Main *bmain, ReportList *reports, PointerRNA *camera_ptr)
116 {
117         Camera *camera = camera_ptr->data;
118         if (ID_REAL_USERS(camera) <= 0) {
119                 BKE_libblock_free(&bmain->camera, camera);
120                 RNA_POINTER_INVALIDATE(camera_ptr);
121         }
122         else {
123                 BKE_reportf(reports, RPT_ERROR, "Camera '%s' must have zero users to be removed, found %d",
124                             camera->id.name + 2, ID_REAL_USERS(camera));
125         }
126 }
127
128 static Scene *rna_Main_scenes_new(Main *bmain, const char *name)
129 {
130         return BKE_scene_add(bmain, name);
131 }
132 static void rna_Main_scenes_remove(Main *bmain, bContext *C, ReportList *reports, PointerRNA *scene_ptr)
133 {
134         /* don't call BKE_libblock_free(...) directly */
135         Scene *scene = scene_ptr->data;
136         Scene *scene_new;
137
138         if ((scene_new = scene->id.prev) ||
139             (scene_new = scene->id.next))
140         {
141                 bScreen *sc = CTX_wm_screen(C);
142                 if (sc->scene == scene) {
143                         ED_screen_set_scene(C, sc, scene_new);
144                 }
145
146                 BKE_scene_unlink(bmain, scene, scene_new);
147                 RNA_POINTER_INVALIDATE(scene_ptr);
148         }
149         else {
150                 BKE_reportf(reports, RPT_ERROR, "Scene '%s' is the last, cannot be removed", scene->id.name + 2);
151         }
152 }
153
154 static Object *rna_Main_objects_new(Main *bmain, ReportList *reports, const char *name, ID *data)
155 {
156         Object *ob;
157         int type = OB_EMPTY;
158         if (data) {
159                 /* keep in sync with OB_DATA_SUPPORT_ID() macro */
160                 switch (GS(data->name)) {
161                         case ID_ME:
162                                 type = OB_MESH;
163                                 break;
164                         case ID_CU:
165                                 type = BKE_curve_type_get((Curve *)data);
166                                 break;
167                         case ID_MB:
168                                 type = OB_MBALL;
169                                 break;
170                         case ID_LA:
171                                 type = OB_LAMP;
172                                 break;
173                         case ID_SPK:
174                                 type = OB_SPEAKER;
175                                 break;
176                         case ID_CA:
177                                 type = OB_CAMERA;
178                                 break;
179                         case ID_LT:
180                                 type = OB_LATTICE;
181                                 break;
182                         case ID_AR:
183                                 type = OB_ARMATURE;
184                                 break;
185                         default:
186                         {
187                                 const char *idname;
188                                 if (RNA_enum_id_from_value(id_type_items, GS(data->name), &idname) == 0)
189                                         idname = "UNKNOWN";
190
191                                 BKE_reportf(reports, RPT_ERROR, "ID type '%s' is not valid for an object", idname);
192                                 return NULL;
193                         }
194                 }
195
196                 id_us_plus(data);
197         }
198
199         ob = BKE_object_add_only_object(bmain, type, name);
200         id_us_min(&ob->id);
201
202         ob->data = data;
203         test_object_materials(ob->data);
204         
205         return ob;
206 }
207
208 static void rna_Main_objects_remove(Main *bmain, ReportList *reports, PointerRNA *object_ptr)
209 {
210         Object *object = object_ptr->data;
211         if (ID_REAL_USERS(object) <= 0) {
212                 BKE_object_unlink(object); /* needed or ID pointers to this are not cleared */
213                 BKE_libblock_free(&bmain->object, object);
214                 RNA_POINTER_INVALIDATE(object_ptr);
215         }
216         else {
217                 BKE_reportf(reports, RPT_ERROR, "Object '%s' must have zero users to be removed, found %d",
218                             object->id.name + 2, ID_REAL_USERS(object));
219         }
220 }
221
222 static Material *rna_Main_materials_new(Main *bmain, const char *name)
223 {
224         ID *id = (ID *)BKE_material_add(bmain, name);
225         id_us_min(id);
226         return (Material *)id;
227 }
228 static void rna_Main_materials_remove(Main *bmain, ReportList *reports, PointerRNA *material_ptr)
229 {
230         Material *material = material_ptr->data;
231         if (ID_REAL_USERS(material) <= 0) {
232                 BKE_libblock_free(&bmain->mat, material);
233                 RNA_POINTER_INVALIDATE(material_ptr);
234         }
235         else {
236                 BKE_reportf(reports, RPT_ERROR, "Material '%s' must have zero users to be removed, found %d",
237                             material->id.name + 2, ID_REAL_USERS(material));
238         }
239 }
240
241 static bNodeTree *rna_Main_nodetree_new(Main *bmain, const char *name, int type)
242 {
243         bNodeTree *tree = ntreeAddTree(bmain, name, type, NODE_GROUP);
244
245         id_us_min(&tree->id);
246         return tree;
247 }
248 static void rna_Main_nodetree_remove(Main *bmain, ReportList *reports, PointerRNA *tree_ptr)
249 {
250         bNodeTree *tree = tree_ptr->data;
251         if (ID_REAL_USERS(tree) <= 0) {
252                 BKE_libblock_free(&bmain->nodetree, tree);
253                 RNA_POINTER_INVALIDATE(tree_ptr);
254         }
255         else {
256                 BKE_reportf(reports, RPT_ERROR, "Node tree '%s' must have zero users to be removed, found %d",
257                             tree->id.name + 2, ID_REAL_USERS(tree));
258         }
259 }
260
261 static Mesh *rna_Main_meshes_new(Main *bmain, const char *name)
262 {
263         Mesh *me = BKE_mesh_add(bmain, name);
264         id_us_min(&me->id);
265         return me;
266 }
267
268 /* copied from Mesh_getFromObject and adapted to RNA interface */
269 /* settings: 1 - preview, 2 - render */
270 Mesh *rna_Main_meshes_new_from_object(
271         Main *bmain, ReportList *reports, Scene *sce,
272         Object *ob, int apply_modifiers, int settings, int calc_tessface)
273 {
274         Mesh *tmpmesh;
275         Curve *tmpcu = NULL, *copycu;
276         Object *tmpobj = NULL;
277         int render = settings == eModifierMode_Render, i;
278         int cage = !apply_modifiers;
279
280         /* perform the mesh extraction based on type */
281         switch (ob->type) {
282                 case OB_FONT:
283                 case OB_CURVE:
284                 case OB_SURF:
285                 {
286                         ListBase dispbase = {NULL, NULL};
287                         DerivedMesh *derivedFinal = NULL;
288                         int uv_from_orco;
289
290                         /* copies object and modifiers (but not the data) */
291                         tmpobj = BKE_object_copy_ex(bmain, ob, TRUE);
292                         tmpcu = (Curve *)tmpobj->data;
293                         tmpcu->id.us--;
294
295                         /* if getting the original caged mesh, delete object modifiers */
296                         if (cage)
297                                 BKE_object_free_modifiers(tmpobj);
298
299                         /* copies the data */
300                         copycu = tmpobj->data = BKE_curve_copy((Curve *) ob->data);
301
302                         /* temporarily set edit so we get updates from edit mode, but
303                          * also because for text datablocks copying it while in edit
304                          * mode gives invalid data structures */
305                         copycu->editfont = tmpcu->editfont;
306                         copycu->editnurb = tmpcu->editnurb;
307
308                         /* get updated display list, and convert to a mesh */
309                         BKE_displist_make_curveTypes_forRender(sce, tmpobj, &dispbase, &derivedFinal, FALSE);
310
311                         copycu->editfont = NULL;
312                         copycu->editnurb = NULL;
313
314                         tmpobj->derivedFinal = derivedFinal;
315
316                         /* convert object type to mesh */
317                         uv_from_orco = (tmpcu->flag & CU_UV_ORCO) != 0;
318                         BKE_mesh_from_nurbs_displist(tmpobj, &dispbase, uv_from_orco);
319
320                         tmpmesh = tmpobj->data;
321
322                         BKE_displist_free(&dispbase);
323
324                         /* BKE_mesh_from_nurbs changes the type to a mesh, check it worked */
325                         if (tmpobj->type != OB_MESH) {
326                                 BKE_libblock_free_us(&(G.main->object), tmpobj);
327                                 BKE_report(reports, RPT_ERROR, "Cannot convert curve to mesh (does the curve have any segments?)");
328                                 return NULL;
329                         }
330
331                         BKE_libblock_free_us(&bmain->object, tmpobj);
332                         break;
333                 }
334
335                 case OB_MBALL:
336                 {
337                         /* metaballs don't have modifiers, so just convert to mesh */
338                         Object *basis_ob = BKE_mball_basis_find(sce, ob);
339                         /* todo, re-generatre for render-res */
340                         /* metaball_polygonize(scene, ob) */
341
342                         if (ob != basis_ob)
343                                 return NULL;  /* only do basis metaball */
344
345                         tmpmesh = BKE_mesh_add(bmain, "Mesh");
346                         /* BKE_mesh_add gives us a user count we don't need */
347                         tmpmesh->id.us--;
348
349                         if (render) {
350                                 ListBase disp = {NULL, NULL};
351                                 BKE_displist_make_mball_forRender(sce, ob, &disp);
352                                 BKE_mesh_from_metaball(&disp, tmpmesh);
353                                 BKE_displist_free(&disp);
354                         }
355                         else
356                                 BKE_mesh_from_metaball(&ob->disp, tmpmesh);
357
358                         break;
359
360                 }
361                 case OB_MESH:
362                         /* copies object and modifiers (but not the data) */
363                         if (cage) {
364                                 /* copies the data */
365                                 tmpmesh = BKE_mesh_copy_ex(bmain, ob->data);
366                                 /* if not getting the original caged mesh, get final derived mesh */
367                         }
368                         else {
369                                 /* Make a dummy mesh, saves copying */
370                                 DerivedMesh *dm;
371                                 /* CustomDataMask mask = CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL; */
372                                 CustomDataMask mask = CD_MASK_MESH; /* this seems more suitable, exporter,
373                                                                  * for example, needs CD_MASK_MDEFORMVERT */
374
375                                 /* Write the display mesh into the dummy mesh */
376                                 if (render)
377                                         dm = mesh_create_derived_render(sce, ob, mask);
378                                 else
379                                         dm = mesh_create_derived_view(sce, ob, mask);
380
381                                 tmpmesh = BKE_mesh_add(bmain, "Mesh");
382                                 DM_to_mesh(dm, tmpmesh, ob);
383                                 dm->release(dm);
384                         }
385
386                         /* BKE_mesh_add/copy gives us a user count we don't need */
387                         tmpmesh->id.us--;
388
389                         break;
390                 default:
391                         BKE_report(reports, RPT_ERROR, "Object does not have geometry data");
392                         return NULL;
393         }
394
395         /* Copy materials to new mesh */
396         switch (ob->type) {
397                 case OB_SURF:
398                 case OB_FONT:
399                 case OB_CURVE:
400                         tmpmesh->totcol = tmpcu->totcol;
401
402                         /* free old material list (if it exists) and adjust user counts */
403                         if (tmpcu->mat) {
404                                 for (i = tmpcu->totcol; i-- > 0; ) {
405                                         /* are we an object material or data based? */
406
407                                         tmpmesh->mat[i] = ob->matbits[i] ? ob->mat[i] : tmpcu->mat[i];
408
409                                         if (tmpmesh->mat[i]) {
410                                                 tmpmesh->mat[i]->id.us++;
411                                         }
412                                 }
413                         }
414                         break;
415
416 #if 0
417                 /* Crashes when assigning the new material, not sure why */
418                 case OB_MBALL:
419                         tmpmb = (MetaBall *)ob->data;
420                         tmpmesh->totcol = tmpmb->totcol;
421
422                         /* free old material list (if it exists) and adjust user counts */
423                         if (tmpmb->mat) {
424                                 for (i = tmpmb->totcol; i-- > 0; ) {
425                                         tmpmesh->mat[i] = tmpmb->mat[i]; /* CRASH HERE ??? */
426                                         if (tmpmesh->mat[i]) {
427                                                 tmpmb->mat[i]->id.us++;
428                                         }
429                                 }
430                         }
431                         break;
432 #endif
433
434                 case OB_MESH:
435                         if (!cage) {
436                                 Mesh *origmesh = ob->data;
437                                 tmpmesh->flag = origmesh->flag;
438                                 tmpmesh->mat = MEM_dupallocN(origmesh->mat);
439                                 tmpmesh->totcol = origmesh->totcol;
440                                 tmpmesh->smoothresh = origmesh->smoothresh;
441                                 if (origmesh->mat) {
442                                         for (i = origmesh->totcol; i-- > 0; ) {
443                                                 /* are we an object material or data based? */
444                                                 tmpmesh->mat[i] = ob->matbits[i] ? ob->mat[i] : origmesh->mat[i];
445
446                                                 if (tmpmesh->mat[i]) {
447                                                         tmpmesh->mat[i]->id.us++;
448                                                 }
449                                         }
450                                 }
451                         }
452                         break;
453         } /* end copy materials */
454
455         if (calc_tessface) {
456                 /* cycles and exporters rely on this still */
457                 BKE_mesh_tessface_ensure(tmpmesh);
458         }
459
460         /* make sure materials get updated in objects */
461         test_object_materials(&tmpmesh->id);
462
463         return tmpmesh;
464 }
465
466 static void rna_Main_meshes_remove(Main *bmain, ReportList *reports, PointerRNA *mesh_ptr)
467 {
468         Mesh *mesh = mesh_ptr->data;
469         if (ID_REAL_USERS(mesh) <= 0) {
470                 BKE_libblock_free(&bmain->mesh, mesh);
471                 RNA_POINTER_INVALIDATE(mesh_ptr);
472         }
473         else {
474                 BKE_reportf(reports, RPT_ERROR, "Mesh '%s' must have zero users to be removed, found %d",
475                             mesh->id.name + 2, ID_REAL_USERS(mesh));
476         }
477 }
478
479 static Lamp *rna_Main_lamps_new(Main *bmain, const char *name, int type)
480 {
481         Lamp *lamp = BKE_lamp_add(bmain, name);
482         lamp->type = type;
483         id_us_min(&lamp->id);
484         return lamp;
485 }
486 static void rna_Main_lamps_remove(Main *bmain, ReportList *reports, PointerRNA *lamp_ptr)
487 {
488         Lamp *lamp = lamp_ptr->data;
489         if (ID_REAL_USERS(lamp) <= 0) {
490                 BKE_libblock_free(&bmain->lamp, lamp);
491                 RNA_POINTER_INVALIDATE(lamp_ptr);
492         }
493         else {
494                 BKE_reportf(reports, RPT_ERROR, "Lamp '%s' must have zero users to be removed, found %d",
495                             lamp->id.name + 2, ID_REAL_USERS(lamp));
496         }
497 }
498
499 static Image *rna_Main_images_new(Main *bmain, const char *name, int width, int height, int alpha, int float_buffer)
500 {
501         float color[4] = {0.0, 0.0, 0.0, 1.0};
502         Image *image = BKE_image_add_generated(bmain, width, height, name, alpha ? 32 : 24, float_buffer, 0, color);
503         id_us_min(&image->id);
504         return image;
505 }
506 static Image *rna_Main_images_load(Main *bmain, ReportList *reports, const char *filepath)
507 {
508         Image *ima;
509
510         errno = 0;
511         ima = BKE_image_load(bmain, filepath);
512
513         if (!ima) {
514                 BKE_reportf(reports, RPT_ERROR, "Cannot read '%s': %s", filepath,
515                             errno ? strerror(errno) : TIP_("unsupported image format"));
516         }
517
518         return ima;
519 }
520 static void rna_Main_images_remove(Main *bmain, ReportList *reports, PointerRNA *image_ptr)
521 {
522         Image *image = image_ptr->data;
523         if (ID_REAL_USERS(image) <= 0) {
524                 BKE_libblock_free(&bmain->image, image);
525                 RNA_POINTER_INVALIDATE(image_ptr);
526         }
527         else {
528                 BKE_reportf(reports, RPT_ERROR, "Image '%s' must have zero users to be removed, found %d",
529                             image->id.name + 2, ID_REAL_USERS(image));
530         }
531 }
532
533 static Lattice *rna_Main_lattices_new(Main *bmain, const char *name)
534 {
535         Lattice *lt = BKE_lattice_add(bmain, name);
536         id_us_min(&lt->id);
537         return lt;
538 }
539 static void rna_Main_lattices_remove(Main *bmain, ReportList *reports, PointerRNA *lt_ptr)
540 {
541         Lattice *lt = lt_ptr->data;
542         if (ID_REAL_USERS(lt) <= 0) {
543                 BKE_libblock_free(&bmain->latt, lt);
544                 RNA_POINTER_INVALIDATE(lt_ptr);
545         }
546         else {
547                 BKE_reportf(reports, RPT_ERROR, "Lattice '%s' must have zero users to be removed, found %d",
548                             lt->id.name + 2, ID_REAL_USERS(lt));
549         }
550 }
551
552 static Curve *rna_Main_curves_new(Main *bmain, const char *name, int type)
553 {
554         Curve *cu = BKE_curve_add(bmain, name, type);
555         id_us_min(&cu->id);
556         return cu;
557 }
558 static void rna_Main_curves_remove(Main *bmain, ReportList *reports, PointerRNA *cu_ptr)
559 {
560         Curve *cu = cu_ptr->data;
561         if (ID_REAL_USERS(cu) <= 0) {
562                 BKE_libblock_free(&bmain->curve, cu);
563                 RNA_POINTER_INVALIDATE(cu_ptr);
564         }
565         else {
566                 BKE_reportf(reports, RPT_ERROR, "Curve '%s' must have zero users to be removed, found %d",
567                             cu->id.name + 2, ID_REAL_USERS(cu));
568         }
569 }
570
571 static MetaBall *rna_Main_metaballs_new(Main *bmain, const char *name)
572 {
573         MetaBall *mb = BKE_mball_add(bmain, name);
574         id_us_min(&mb->id);
575         return mb;
576 }
577 static void rna_Main_metaballs_remove(Main *bmain, ReportList *reports, PointerRNA *mb_ptr)
578 {
579         MetaBall *mb = mb_ptr->data;
580         if (ID_REAL_USERS(mb) <= 0) {
581                 BKE_libblock_free(&bmain->mball, mb);
582                 RNA_POINTER_INVALIDATE(mb_ptr);
583         }
584         else {
585                 BKE_reportf(reports, RPT_ERROR, "Metaball '%s' must have zero users to be removed, found %d",
586                             mb->id.name + 2, ID_REAL_USERS(mb));
587         }
588 }
589
590 static VFont *rna_Main_fonts_load(Main *bmain, ReportList *reports, const char *filepath)
591 {
592         VFont *font;
593
594         errno = 0;
595         font = BKE_vfont_load(bmain, filepath);
596
597         if (!font)
598                 BKE_reportf(reports, RPT_ERROR, "Cannot read '%s': %s", filepath,
599                             errno ? strerror(errno) : TIP_("unsupported font format"));
600
601         return font;
602
603 }
604 static void rna_Main_fonts_remove(Main *bmain, ReportList *reports, PointerRNA *vfont_ptr)
605 {
606         VFont *vfont = vfont_ptr->data;
607         if (ID_REAL_USERS(vfont) <= 0) {
608                 BKE_libblock_free(&bmain->vfont, vfont);
609                 RNA_POINTER_INVALIDATE(vfont_ptr);
610         }
611         else {
612                 BKE_reportf(reports, RPT_ERROR, "Font '%s' must have zero users to be removed, found %d",
613                             vfont->id.name + 2, ID_REAL_USERS(vfont));
614         }
615 }
616
617 static Tex *rna_Main_textures_new(Main *bmain, const char *name, int type)
618 {
619         Tex *tex = add_texture(bmain, name);
620         tex_set_type(tex, type);
621         id_us_min(&tex->id);
622         return tex;
623 }
624 static void rna_Main_textures_remove(Main *bmain, ReportList *reports, PointerRNA *tex_ptr)
625 {
626         Tex *tex = tex_ptr->data;
627         if (ID_REAL_USERS(tex) <= 0) {
628                 BKE_libblock_free(&bmain->tex, tex);
629                 RNA_POINTER_INVALIDATE(tex_ptr);
630         }
631         else {
632                 BKE_reportf(reports, RPT_ERROR, "Texture '%s' must have zero users to be removed, found %d",
633                             tex->id.name + 2, ID_REAL_USERS(tex));
634         }
635 }
636
637 static Brush *rna_Main_brushes_new(Main *bmain, const char *name)
638 {
639         Brush *brush = BKE_brush_add(bmain, name);
640         id_us_min(&brush->id);
641         return brush;
642 }
643 static void rna_Main_brushes_remove(Main *bmain, ReportList *reports, PointerRNA *brush_ptr)
644 {
645         Brush *brush = brush_ptr->data;
646         if (ID_REAL_USERS(brush) <= 0) {
647                 BKE_libblock_free(&bmain->brush, brush);
648                 RNA_POINTER_INVALIDATE(brush_ptr);
649         }
650         else {
651                 BKE_reportf(reports, RPT_ERROR, "Brush '%s' must have zero users to be removed, found %d",
652                             brush->id.name + 2, ID_REAL_USERS(brush));
653         }
654 }
655
656 static World *rna_Main_worlds_new(Main *bmain, const char *name)
657 {
658         World *world = add_world(bmain, name);
659         id_us_min(&world->id);
660         return world;
661 }
662 static void rna_Main_worlds_remove(Main *bmain, ReportList *reports, PointerRNA *world_ptr)
663 {
664         Group *world = world_ptr->data;
665         if (ID_REAL_USERS(world) <= 0) {
666                 BKE_libblock_free(&bmain->world, world);
667                 RNA_POINTER_INVALIDATE(world_ptr);
668         }
669         else {
670                 BKE_reportf(reports, RPT_ERROR, "World '%s' must have zero users to be removed, found %d",
671                             world->id.name + 2, ID_REAL_USERS(world));
672         }
673 }
674
675 static Group *rna_Main_groups_new(Main *bmain, const char *name)
676 {
677         return add_group(bmain, name);
678 }
679 static void rna_Main_groups_remove(Main *bmain, PointerRNA *group_ptr)
680 {
681         Group *group = group_ptr->data;
682         BKE_group_unlink(group);
683         BKE_libblock_free(&bmain->group, group);
684         RNA_POINTER_INVALIDATE(group_ptr);
685 }
686
687 static Speaker *rna_Main_speakers_new(Main *bmain, const char *name)
688 {
689         Speaker *speaker = BKE_speaker_add(bmain, name);
690         id_us_min(&speaker->id);
691         return speaker;
692 }
693 static void rna_Main_speakers_remove(Main *bmain, ReportList *reports, PointerRNA *speaker_ptr)
694 {
695         Speaker *speaker = speaker_ptr->data;
696         if (ID_REAL_USERS(speaker) <= 0) {
697                 BKE_libblock_free(&bmain->speaker, speaker);
698                 RNA_POINTER_INVALIDATE(speaker_ptr);
699         }
700         else {
701                 BKE_reportf(reports, RPT_ERROR, "Speaker '%s' must have zero users to be removed, found %d",
702                             speaker->id.name + 2, ID_REAL_USERS(speaker));
703         }
704 }
705
706 static Text *rna_Main_texts_new(Main *bmain, const char *name)
707 {
708         return BKE_text_add(bmain, name);
709 }
710 static void rna_Main_texts_remove(Main *bmain, PointerRNA *text_ptr)
711 {
712         Text *text = text_ptr->data;
713         BKE_text_unlink(bmain, text);
714         BKE_libblock_free(&bmain->text, text);
715         RNA_POINTER_INVALIDATE(text_ptr);
716 }
717
718 static Text *rna_Main_texts_load(Main *bmain, ReportList *reports, const char *filepath)
719 {
720         Text *txt;
721
722         errno = 0;
723         txt = BKE_text_load(bmain, filepath, bmain->name);
724
725         if (!txt)
726                 BKE_reportf(reports, RPT_ERROR, "Cannot read '%s': %s", filepath,
727                             errno ? strerror(errno) : TIP_("unable to load text"));
728
729         return txt;
730 }
731
732 static bArmature *rna_Main_armatures_new(Main *bmain, const char *name)
733 {
734         bArmature *arm = BKE_armature_add(bmain, name);
735         id_us_min(&arm->id);
736         return arm;
737 }
738 static void rna_Main_armatures_remove(Main *bmain, ReportList *reports, PointerRNA *arm_ptr)
739 {
740         bArmature *arm = arm_ptr->data;
741         if (ID_REAL_USERS(arm) <= 0) {
742                 BKE_libblock_free(&bmain->armature, arm);
743                 RNA_POINTER_INVALIDATE(arm_ptr);
744         }
745         else {
746                 BKE_reportf(reports, RPT_ERROR, "Armature '%s' must have zero users to be removed, found %d",
747                             arm->id.name + 2, ID_REAL_USERS(arm));
748         }
749 }
750
751 static bAction *rna_Main_actions_new(Main *bmain, const char *name)
752 {
753         bAction *act = add_empty_action(bmain, name);
754         id_us_min(&act->id);
755         act->id.flag &= ~LIB_FAKEUSER;
756         return act;
757 }
758 static void rna_Main_actions_remove(Main *bmain, ReportList *reports, PointerRNA *act_ptr)
759 {
760         bAction *act = act_ptr->data;
761         if (ID_REAL_USERS(act) <= 0) {
762                 BKE_libblock_free(&bmain->action, act);
763                 RNA_POINTER_INVALIDATE(act_ptr);
764         }
765         else {
766                 BKE_reportf(reports, RPT_ERROR, "Action '%s' must have zero users to be removed, found %d",
767                             act->id.name + 2, ID_REAL_USERS(act));
768         }
769 }
770
771 static ParticleSettings *rna_Main_particles_new(Main *bmain, const char *name)
772 {
773         ParticleSettings *part = psys_new_settings(name, bmain);
774         id_us_min(&part->id);
775         return part;
776 }
777 static void rna_Main_particles_remove(Main *bmain, ReportList *reports, PointerRNA *part_ptr)
778 {
779         ParticleSettings *part = part_ptr->data;
780         if (ID_REAL_USERS(part) <= 0) {
781                 BKE_libblock_free(&bmain->particle, part);
782                 RNA_POINTER_INVALIDATE(part_ptr);
783         }
784         else {
785                 BKE_reportf(reports, RPT_ERROR, "Particle settings '%s' must have zero users to be removed, found %d",
786                             part->id.name + 2, ID_REAL_USERS(part));
787         }
788 }
789
790 static MovieClip *rna_Main_movieclip_load(Main *bmain, ReportList *reports, const char *filepath)
791 {
792         MovieClip *clip;
793
794         errno = 0;
795         clip = BKE_movieclip_file_add(bmain, filepath);
796
797         if (!clip)
798                 BKE_reportf(reports, RPT_ERROR, "Cannot read '%s': %s", filepath,
799                             errno ? strerror(errno) : TIP_("unable to load movie clip"));
800
801         return clip;
802 }
803
804 static void rna_Main_movieclips_remove(Main *bmain, PointerRNA *clip_ptr)
805 {
806         MovieClip *clip = clip_ptr->data;
807         BKE_movieclip_unlink(bmain, clip);
808         BKE_libblock_free(&bmain->movieclip, clip);
809         RNA_POINTER_INVALIDATE(clip_ptr);
810 }
811
812 static Mask *rna_Main_mask_new(Main *bmain, const char *name)
813 {
814         Mask *mask;
815
816         mask = BKE_mask_new(bmain, "Mask");
817
818         return mask;
819 }
820
821 static void rna_Main_masks_remove(Main *bmain, PointerRNA *mask_ptr)
822 {
823         Mask *mask = mask_ptr->data;
824         BKE_mask_free(bmain, mask);
825         BKE_libblock_free(&bmain->mask, mask);
826         RNA_POINTER_INVALIDATE(mask_ptr);
827 }
828
829 static void rna_Main_grease_pencil_remove(Main *bmain, ReportList *reports, PointerRNA *gpd_ptr)
830 {
831         bGPdata *gpd = gpd_ptr->data;
832         if (ID_REAL_USERS(gpd) <= 0) {
833                 BKE_gpencil_free(gpd);
834                 BKE_libblock_free(&bmain->gpencil, gpd);
835                 RNA_POINTER_INVALIDATE(gpd_ptr);
836         }
837         else
838                 BKE_reportf(reports, RPT_ERROR, "Grease pencil '%s' must have zero users to be removed, found %d",
839                             gpd->id.name + 2, ID_REAL_USERS(gpd));
840 }
841
842 #ifdef WITH_FREESTYLE
843 FreestyleLineStyle *rna_Main_linestyles_new(Main *bmain, const char* name)
844 {
845         FreestyleLineStyle *linestyle = FRS_new_linestyle(name, bmain);
846         id_us_min(&linestyle->id);
847         return linestyle;
848 }
849
850 void rna_Main_linestyles_remove(Main *bmain, ReportList *reports, FreestyleLineStyle *linestyle)
851 {
852         if(ID_REAL_USERS(linestyle) <= 0)
853                 BKE_libblock_free(&bmain->linestyle, linestyle);
854         else
855                 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));
856
857         /* XXX python now has invalid pointer? */
858 }
859 #endif
860
861 /* tag functions, all the same */
862 static void rna_Main_cameras_tag(Main *bmain, int value) { tag_main_lb(&bmain->camera, value); }
863 static void rna_Main_scenes_tag(Main *bmain, int value) { tag_main_lb(&bmain->scene, value); }
864 static void rna_Main_objects_tag(Main *bmain, int value) { tag_main_lb(&bmain->object, value); }
865 static void rna_Main_materials_tag(Main *bmain, int value) { tag_main_lb(&bmain->mat, value); }
866 static void rna_Main_node_groups_tag(Main *bmain, int value) { tag_main_lb(&bmain->nodetree, value); }
867 static void rna_Main_meshes_tag(Main *bmain, int value) { tag_main_lb(&bmain->mesh, value); }
868 static void rna_Main_lamps_tag(Main *bmain, int value) { tag_main_lb(&bmain->lamp, value); }
869 static void rna_Main_libraries_tag(Main *bmain, int value) { tag_main_lb(&bmain->library, value); }
870 static void rna_Main_screens_tag(Main *bmain, int value) { tag_main_lb(&bmain->screen, value); }
871 static void rna_Main_window_managers_tag(Main *bmain, int value) { tag_main_lb(&bmain->wm, value); }
872 static void rna_Main_images_tag(Main *bmain, int value) { tag_main_lb(&bmain->image, value); }
873 static void rna_Main_lattices_tag(Main *bmain, int value) { tag_main_lb(&bmain->latt, value); }
874 static void rna_Main_curves_tag(Main *bmain, int value) { tag_main_lb(&bmain->curve, value); }
875 static void rna_Main_metaballs_tag(Main *bmain, int value) { tag_main_lb(&bmain->mball, value); }
876 static void rna_Main_fonts_tag(Main *bmain, int value) { tag_main_lb(&bmain->vfont, value); }
877 static void rna_Main_textures_tag(Main *bmain, int value) { tag_main_lb(&bmain->tex, value); }
878 static void rna_Main_brushes_tag(Main *bmain, int value) { tag_main_lb(&bmain->brush, value); }
879 static void rna_Main_worlds_tag(Main *bmain, int value) { tag_main_lb(&bmain->world, value); }
880 static void rna_Main_groups_tag(Main *bmain, int value) { tag_main_lb(&bmain->group, value); }
881 // static void rna_Main_shape_keys_tag(Main *bmain, int value) { tag_main_lb(&bmain->key, value); }
882 // static void rna_Main_scripts_tag(Main *bmain, int value) { tag_main_lb(&bmain->script, value); }
883 static void rna_Main_texts_tag(Main *bmain, int value) { tag_main_lb(&bmain->text, value); }
884 static void rna_Main_speakers_tag(Main *bmain, int value) { tag_main_lb(&bmain->speaker, value); }
885 static void rna_Main_sounds_tag(Main *bmain, int value) { tag_main_lb(&bmain->sound, value); }
886 static void rna_Main_armatures_tag(Main *bmain, int value) { tag_main_lb(&bmain->armature, value); }
887 static void rna_Main_actions_tag(Main *bmain, int value) { tag_main_lb(&bmain->action, value); }
888 static void rna_Main_particles_tag(Main *bmain, int value) { tag_main_lb(&bmain->particle, value); }
889 static void rna_Main_gpencil_tag(Main *bmain, int value) { tag_main_lb(&bmain->gpencil, value); }
890 static void rna_Main_movieclips_tag(Main *bmain, int value) { tag_main_lb(&bmain->movieclip, value); }
891 static void rna_Main_masks_tag(Main *bmain, int value) { tag_main_lb(&bmain->mask, value); }
892 #ifdef WITH_FREESTYLE
893 void rna_Main_linestyle_tag(Main *bmain, int value) { tag_main_lb(&bmain->linestyle, value); }
894 #endif
895
896 static int rna_Main_cameras_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_CA); }
897 static int rna_Main_scenes_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SCE); }
898 static int rna_Main_objects_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_OB); }
899 static int rna_Main_materials_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_MA); }
900 static int rna_Main_node_groups_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_NT); }
901 static int rna_Main_meshes_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_ME); }
902 static int rna_Main_lamps_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_LA); }
903 static int rna_Main_libraries_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_LI); }
904 static int rna_Main_screens_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SCR); }
905 static int rna_Main_window_managers_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_WM); }
906 static int rna_Main_images_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_IM); }
907 static int rna_Main_lattices_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_LT); }
908 static int rna_Main_curves_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_CU); }
909 static int rna_Main_metaballs_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_MB); }
910 static int rna_Main_fonts_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_VF); }
911 static int rna_Main_textures_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_TE); }
912 static int rna_Main_brushes_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_BR); }
913 static int rna_Main_worlds_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_WO); }
914 static int rna_Main_groups_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_GR); }
915 static int rna_Main_texts_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_TXT); }
916 static int rna_Main_speakers_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SPK); }
917 static int rna_Main_sounds_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SO); }
918 static int rna_Main_armatures_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_AR); }
919 static int rna_Main_actions_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_AC); }
920 static int rna_Main_particles_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_PA); }
921 static int rna_Main_gpencil_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_GD); }
922
923 #else
924
925 void RNA_api_main(StructRNA *srna)
926 {
927 #if 0
928         FunctionRNA *func;
929         PropertyRNA *parm;
930         /* maybe we want to add functions in 'bpy.data' still?
931          * for now they are all in collections bpy.data.images.new(...) */
932         func = RNA_def_function(srna, "add_image", "rna_Main_add_image");
933         RNA_def_function_ui_description(func, "Add a new image");
934         parm = RNA_def_string_file_path(func, "filepath", "", 0, "", "File path to load image from");
935         RNA_def_property_flag(parm, PROP_REQUIRED);
936         parm = RNA_def_pointer(func, "image", "Image", "", "New image");
937         RNA_def_function_return(func, parm);
938 #else
939         (void)srna;
940 #endif
941 }
942
943 void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop)
944 {
945         StructRNA *srna;
946         FunctionRNA *func;
947         PropertyRNA *parm;
948         PropertyRNA *prop;
949
950         RNA_def_property_srna(cprop, "BlendDataCameras");
951         srna = RNA_def_struct(brna, "BlendDataCameras", NULL);
952         RNA_def_struct_sdna(srna, "Main");
953         RNA_def_struct_ui_text(srna, "Main Cameras", "Collection of cameras");
954
955         func = RNA_def_function(srna, "new", "rna_Main_cameras_new");
956         RNA_def_function_ui_description(func, "Add a new camera to the main database");
957         parm = RNA_def_string(func, "name", "Camera", 0, "", "New name for the datablock");
958         RNA_def_property_flag(parm, PROP_REQUIRED);
959         /* return type */
960         parm = RNA_def_pointer(func, "camera", "Camera", "", "New camera datablock");
961         RNA_def_function_return(func, parm);
962
963         func = RNA_def_function(srna, "remove", "rna_Main_cameras_remove");
964         RNA_def_function_flag(func, FUNC_USE_REPORTS);
965         RNA_def_function_ui_description(func, "Remove a camera from the current blendfile");
966         parm = RNA_def_pointer(func, "camera", "Camera", "", "Camera to remove");
967         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
968         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
969
970         func = RNA_def_function(srna, "tag", "rna_Main_cameras_tag");
971         parm = RNA_def_boolean(func, "value", 0, "Value", "");
972         RNA_def_property_flag(parm, PROP_REQUIRED);
973
974         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
975         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
976         RNA_def_property_boolean_funcs(prop, "rna_Main_cameras_is_updated_get", NULL);
977 }
978
979 void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
980 {
981         StructRNA *srna;
982         FunctionRNA *func;
983         PropertyRNA *parm;
984         PropertyRNA *prop;
985
986         RNA_def_property_srna(cprop, "BlendDataScenes");
987         srna = RNA_def_struct(brna, "BlendDataScenes", NULL);
988         RNA_def_struct_sdna(srna, "Main");
989         RNA_def_struct_ui_text(srna, "Main Scenes", "Collection of scenes");
990
991         func = RNA_def_function(srna, "new", "rna_Main_scenes_new");
992         RNA_def_function_ui_description(func, "Add a new scene to the main database");
993         parm = RNA_def_string(func, "name", "Scene", 0, "", "New name for the datablock");
994         RNA_def_property_flag(parm, PROP_REQUIRED);
995         /* return type */
996         parm = RNA_def_pointer(func, "scene", "Scene", "", "New scene datablock");
997         RNA_def_function_return(func, parm);
998
999         func = RNA_def_function(srna, "remove", "rna_Main_scenes_remove");
1000         RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
1001         RNA_def_function_ui_description(func, "Remove a scene from the current blendfile");
1002         parm = RNA_def_pointer(func, "scene", "Scene", "", "Scene to remove");
1003         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1004         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1005
1006         func = RNA_def_function(srna, "tag", "rna_Main_scenes_tag");
1007         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1008         RNA_def_property_flag(parm, PROP_REQUIRED);
1009
1010         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1011         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1012         RNA_def_property_boolean_funcs(prop, "rna_Main_scenes_is_updated_get", NULL);
1013 }
1014
1015 void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
1016 {
1017         StructRNA *srna;
1018         FunctionRNA *func;
1019         PropertyRNA *parm;
1020         PropertyRNA *prop;
1021
1022         RNA_def_property_srna(cprop, "BlendDataObjects");
1023         srna = RNA_def_struct(brna, "BlendDataObjects", NULL);
1024         RNA_def_struct_sdna(srna, "Main");
1025         RNA_def_struct_ui_text(srna, "Main Objects", "Collection of objects");
1026
1027         func = RNA_def_function(srna, "new", "rna_Main_objects_new");
1028         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1029         RNA_def_function_ui_description(func, "Add a new object to the main database");
1030         parm = RNA_def_string(func, "name", "Object", 0, "", "New name for the datablock");
1031         RNA_def_property_flag(parm, PROP_REQUIRED);
1032         parm = RNA_def_pointer(func, "object_data", "ID", "", "Object data or None for an empty object");
1033         RNA_def_property_flag(parm, PROP_REQUIRED);
1034
1035         /* return type */
1036         parm = RNA_def_pointer(func, "object", "Object", "", "New object datablock");
1037         RNA_def_function_return(func, parm);
1038
1039         func = RNA_def_function(srna, "remove", "rna_Main_objects_remove");
1040         RNA_def_function_ui_description(func, "Remove a object from the current blendfile");
1041         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1042         parm = RNA_def_pointer(func, "object", "Object", "", "Object to remove");
1043         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1044         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1045
1046         func = RNA_def_function(srna, "tag", "rna_Main_objects_tag");
1047         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1048         RNA_def_property_flag(parm, PROP_REQUIRED);
1049
1050         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1051         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1052         RNA_def_property_boolean_funcs(prop, "rna_Main_objects_is_updated_get", NULL);
1053 }
1054
1055 void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
1056 {
1057         StructRNA *srna;
1058         FunctionRNA *func;
1059         PropertyRNA *parm;
1060         PropertyRNA *prop;
1061
1062         RNA_def_property_srna(cprop, "BlendDataMaterials");
1063         srna = RNA_def_struct(brna, "BlendDataMaterials", NULL);
1064         RNA_def_struct_sdna(srna, "Main");
1065         RNA_def_struct_ui_text(srna, "Main Materials", "Collection of materials");
1066
1067         func = RNA_def_function(srna, "new", "rna_Main_materials_new");
1068         RNA_def_function_ui_description(func, "Add a new material to the main database");
1069         parm = RNA_def_string(func, "name", "Material", 0, "", "New name for the datablock");
1070         RNA_def_property_flag(parm, PROP_REQUIRED);
1071         /* return type */
1072         parm = RNA_def_pointer(func, "material", "Material", "", "New material datablock");
1073         RNA_def_function_return(func, parm);
1074
1075         func = RNA_def_function(srna, "remove", "rna_Main_materials_remove");
1076         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1077         RNA_def_function_ui_description(func, "Remove a material from the current blendfile");
1078         parm = RNA_def_pointer(func, "material", "Material", "", "Material to remove");
1079         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1080         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1081
1082         func = RNA_def_function(srna, "tag", "rna_Main_materials_tag");
1083         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1084         RNA_def_property_flag(parm, PROP_REQUIRED);
1085
1086         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1087         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1088         RNA_def_property_boolean_funcs(prop, "rna_Main_materials_is_updated_get", NULL);
1089 }
1090 void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop)
1091 {
1092         StructRNA *srna;
1093         FunctionRNA *func;
1094         PropertyRNA *parm;
1095         PropertyRNA *prop;
1096
1097         static EnumPropertyItem node_nodetree_items[] = {
1098                 {0, "SHADER",       0,    "Shader",       ""},
1099                 {1, "COMPOSITE",    0,    "Composite",    ""},
1100                 {2, "TEXTURE",      0,    "Texture",      ""},
1101                 {0, NULL, 0, NULL, NULL}
1102         };
1103
1104         RNA_def_property_srna(cprop, "BlendDataNodeTrees");
1105         srna = RNA_def_struct(brna, "BlendDataNodeTrees", NULL);
1106         RNA_def_struct_sdna(srna, "Main");
1107         RNA_def_struct_ui_text(srna, "Main Node Trees", "Collection of node trees");
1108
1109         func = RNA_def_function(srna, "new", "rna_Main_nodetree_new");
1110         RNA_def_function_ui_description(func, "Add a new node tree to the main database");
1111         parm = RNA_def_string(func, "name", "NodeGroup", 0, "", "New name for the datablock");
1112         RNA_def_property_flag(parm, PROP_REQUIRED);
1113         parm = RNA_def_enum(func, "type", node_nodetree_items, 0, "Type", "The type of node_group to add");
1114         RNA_def_property_flag(parm, PROP_REQUIRED);
1115         /* return type */
1116         parm = RNA_def_pointer(func, "tree", "NodeTree", "", "New node tree datablock");
1117         RNA_def_function_return(func, parm);
1118
1119         func = RNA_def_function(srna, "remove", "rna_Main_nodetree_remove");
1120         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1121         RNA_def_function_ui_description(func, "Remove a node tree from the current blendfile");
1122         parm = RNA_def_pointer(func, "tree", "NodeTree", "", "Node tree to remove");
1123         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1124         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1125
1126         func = RNA_def_function(srna, "tag", "rna_Main_node_groups_tag");
1127         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1128         RNA_def_property_flag(parm, PROP_REQUIRED);
1129
1130         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1131         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1132         RNA_def_property_boolean_funcs(prop, "rna_Main_node_groups_is_updated_get", NULL);
1133 }
1134 void RNA_def_main_meshes(BlenderRNA *brna, PropertyRNA *cprop)
1135 {
1136         StructRNA *srna;
1137         FunctionRNA *func;
1138         PropertyRNA *parm;
1139         PropertyRNA *prop;
1140
1141         static EnumPropertyItem mesh_type_items[] = {
1142                 {eModifierMode_Realtime, "PREVIEW", 0, "Preview", "Apply modifier preview settings"},
1143                 {eModifierMode_Render, "RENDER", 0, "Render", "Apply modifier render settings"},
1144                 {0, NULL, 0, NULL, NULL}
1145         };
1146
1147         RNA_def_property_srna(cprop, "BlendDataMeshes");
1148         srna = RNA_def_struct(brna, "BlendDataMeshes", NULL);
1149         RNA_def_struct_sdna(srna, "Main");
1150         RNA_def_struct_ui_text(srna, "Main Meshes", "Collection of meshes");
1151
1152         func = RNA_def_function(srna, "new", "rna_Main_meshes_new");
1153         RNA_def_function_ui_description(func, "Add a new mesh to the main database");
1154         parm = RNA_def_string(func, "name", "Mesh", 0, "", "New name for the datablock");
1155         RNA_def_property_flag(parm, PROP_REQUIRED);
1156         /* return type */
1157         parm = RNA_def_pointer(func, "mesh", "Mesh", "", "New mesh datablock");
1158         RNA_def_function_return(func, parm);
1159
1160         func = RNA_def_function(srna, "new_from_object", "rna_Main_meshes_new_from_object");
1161         RNA_def_function_ui_description(func, "Add a new mesh created from object with modifiers applied");
1162         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1163         parm = RNA_def_pointer(func, "scene", "Scene", "", "Scene within which to evaluate modifiers");
1164         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
1165         parm = RNA_def_pointer(func, "object", "Object", "", "Object to create mesh from");
1166         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
1167         parm = RNA_def_boolean(func, "apply_modifiers", 0, "", "Apply modifiers");
1168         RNA_def_property_flag(parm, PROP_REQUIRED);
1169         parm = RNA_def_enum(func, "settings", mesh_type_items, 0, "", "Modifier settings to apply");
1170         RNA_def_property_flag(parm, PROP_REQUIRED);
1171         RNA_def_boolean(func, "calc_tessface", true, "Calculate Tessellation", "Calculate tessellation faces");
1172         parm = RNA_def_pointer(func, "mesh", "Mesh", "",
1173                                "Mesh created from object, remove it if it is only used for export");
1174         RNA_def_function_return(func, parm);
1175
1176         func = RNA_def_function(srna, "remove", "rna_Main_meshes_remove");
1177         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1178         RNA_def_function_ui_description(func, "Remove a mesh from the current blendfile");
1179         parm = RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh to remove");
1180         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1181         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1182
1183         func = RNA_def_function(srna, "tag", "rna_Main_meshes_tag");
1184         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1185         RNA_def_property_flag(parm, PROP_REQUIRED);
1186
1187         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1188         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1189         RNA_def_property_boolean_funcs(prop, "rna_Main_meshes_is_updated_get", NULL);
1190 }
1191 void RNA_def_main_lamps(BlenderRNA *brna, PropertyRNA *cprop)
1192 {
1193         StructRNA *srna;
1194         FunctionRNA *func;
1195         PropertyRNA *parm;
1196         PropertyRNA *prop;
1197
1198         RNA_def_property_srna(cprop, "BlendDataLamps");
1199         srna = RNA_def_struct(brna, "BlendDataLamps", NULL);
1200         RNA_def_struct_sdna(srna, "Main");
1201         RNA_def_struct_ui_text(srna, "Main Lamps", "Collection of lamps");
1202
1203         func = RNA_def_function(srna, "new", "rna_Main_lamps_new");
1204         RNA_def_function_ui_description(func, "Add a new lamp to the main database");
1205         parm = RNA_def_string(func, "name", "Lamp", 0, "", "New name for the datablock");
1206         RNA_def_property_flag(parm, PROP_REQUIRED);
1207         parm = RNA_def_enum(func, "type", lamp_type_items, 0, "Type", "The type of texture to add");
1208         RNA_def_property_flag(parm, PROP_REQUIRED);
1209         /* return type */
1210         parm = RNA_def_pointer(func, "lamp", "Lamp", "", "New lamp datablock");
1211         RNA_def_function_return(func, parm);
1212
1213         func = RNA_def_function(srna, "remove", "rna_Main_lamps_remove");
1214         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1215         RNA_def_function_ui_description(func, "Remove a lamp from the current blendfile");
1216         parm = RNA_def_pointer(func, "lamp", "Lamp", "", "Lamp to remove");
1217         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1218         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1219
1220         func = RNA_def_function(srna, "tag", "rna_Main_lamps_tag");
1221         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1222         RNA_def_property_flag(parm, PROP_REQUIRED);
1223
1224         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1225         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1226         RNA_def_property_boolean_funcs(prop, "rna_Main_lamps_is_updated_get", NULL);
1227 }
1228
1229 void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
1230 {
1231         StructRNA *srna;
1232         FunctionRNA *func;
1233         PropertyRNA *parm;
1234         PropertyRNA *prop;
1235
1236         RNA_def_property_srna(cprop, "BlendDataLibraries");
1237         srna = RNA_def_struct(brna, "BlendDataLibraries", NULL);
1238         RNA_def_struct_sdna(srna, "Main");
1239         RNA_def_struct_ui_text(srna, "Main Libraries", "Collection of libraries");
1240
1241         func = RNA_def_function(srna, "tag", "rna_Main_libraries_tag");
1242         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1243         RNA_def_property_flag(parm, PROP_REQUIRED);
1244
1245         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1246         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1247         RNA_def_property_boolean_funcs(prop, "rna_Main_libraries_is_updated_get", NULL);
1248 }
1249
1250 void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
1251 {
1252         StructRNA *srna;
1253         FunctionRNA *func;
1254         PropertyRNA *parm;
1255         PropertyRNA *prop;
1256
1257         RNA_def_property_srna(cprop, "BlendDataScreens");
1258         srna = RNA_def_struct(brna, "BlendDataScreens", NULL);
1259         RNA_def_struct_sdna(srna, "Main");
1260         RNA_def_struct_ui_text(srna, "Main Screens", "Collection of screens");
1261
1262         func = RNA_def_function(srna, "tag", "rna_Main_screens_tag");
1263         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1264         RNA_def_property_flag(parm, PROP_REQUIRED);
1265
1266         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1267         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1268         RNA_def_property_boolean_funcs(prop, "rna_Main_screens_is_updated_get", NULL);
1269 }
1270
1271 void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
1272 {
1273         StructRNA *srna;
1274         FunctionRNA *func;
1275         PropertyRNA *parm;
1276         PropertyRNA *prop;
1277
1278         RNA_def_property_srna(cprop, "BlendDataWindowManagers");
1279         srna = RNA_def_struct(brna, "BlendDataWindowManagers", NULL);
1280         RNA_def_struct_sdna(srna, "Main");
1281         RNA_def_struct_ui_text(srna, "Main Window Managers", "Collection of window managers");
1282
1283         func = RNA_def_function(srna, "tag", "rna_Main_window_managers_tag");
1284         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1285         RNA_def_property_flag(parm, PROP_REQUIRED);
1286
1287         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1288         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1289         RNA_def_property_boolean_funcs(prop, "rna_Main_window_managers_is_updated_get", NULL);
1290 }
1291 void RNA_def_main_images(BlenderRNA *brna, PropertyRNA *cprop)
1292 {
1293         StructRNA *srna;
1294         FunctionRNA *func;
1295         PropertyRNA *parm;
1296         PropertyRNA *prop;
1297
1298         RNA_def_property_srna(cprop, "BlendDataImages");
1299         srna = RNA_def_struct(brna, "BlendDataImages", NULL);
1300         RNA_def_struct_sdna(srna, "Main");
1301         RNA_def_struct_ui_text(srna, "Main Images", "Collection of images");
1302
1303         func = RNA_def_function(srna, "new", "rna_Main_images_new");
1304         RNA_def_function_ui_description(func, "Add a new image to the main database");
1305         parm = RNA_def_string(func, "name", "Image", 0, "", "New name for the datablock");
1306         RNA_def_property_flag(parm, PROP_REQUIRED);
1307         parm = RNA_def_int(func, "width", 1024, 1, INT_MAX, "", "Width of the image", 1, INT_MAX);
1308         RNA_def_property_flag(parm, PROP_REQUIRED);
1309         parm = RNA_def_int(func, "height", 1024, 1, INT_MAX, "", "Height of the image", 1, INT_MAX);
1310         RNA_def_property_flag(parm, PROP_REQUIRED);
1311         RNA_def_boolean(func, "alpha", 0, "Alpha", "Use alpha channel");
1312         RNA_def_boolean(func, "float_buffer", 0, "Float Buffer", "Create an image with floating point color");
1313         /* return type */
1314         parm = RNA_def_pointer(func, "image", "Image", "", "New image datablock");
1315         RNA_def_function_return(func, parm);
1316
1317         func = RNA_def_function(srna, "load", "rna_Main_images_load");
1318         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1319         RNA_def_function_ui_description(func, "Load a new image into the main database");
1320         parm = RNA_def_string_file_path(func, "filepath", "File Path", 0, "", "path of the file to load");
1321         RNA_def_property_flag(parm, PROP_REQUIRED);
1322         /* return type */
1323         parm = RNA_def_pointer(func, "image", "Image", "", "New image datablock");
1324         RNA_def_function_return(func, parm);
1325
1326         func = RNA_def_function(srna, "remove", "rna_Main_images_remove");
1327         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1328         RNA_def_function_ui_description(func, "Remove an image from the current blendfile");
1329         parm = RNA_def_pointer(func, "image", "Image", "", "Image to remove");
1330         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1331         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1332
1333         func = RNA_def_function(srna, "tag", "rna_Main_images_tag");
1334         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1335         RNA_def_property_flag(parm, PROP_REQUIRED);
1336
1337         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1338         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1339         RNA_def_property_boolean_funcs(prop, "rna_Main_images_is_updated_get", NULL);
1340 }
1341
1342 void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
1343 {
1344         StructRNA *srna;
1345         FunctionRNA *func;
1346         PropertyRNA *parm;
1347         PropertyRNA *prop;
1348
1349         RNA_def_property_srna(cprop, "BlendDataLattices");
1350         srna = RNA_def_struct(brna, "BlendDataLattices", NULL);
1351         RNA_def_struct_sdna(srna, "Main");
1352         RNA_def_struct_ui_text(srna, "Main Lattices", "Collection of lattices");
1353
1354         func = RNA_def_function(srna, "new", "rna_Main_lattices_new");
1355         RNA_def_function_ui_description(func, "Add a new lattice to the main database");
1356         parm = RNA_def_string(func, "name", "Lattice", 0, "", "New name for the datablock");
1357         RNA_def_property_flag(parm, PROP_REQUIRED);
1358         /* return type */
1359         parm = RNA_def_pointer(func, "lattice", "Lattice", "", "New lattices datablock");
1360         RNA_def_function_return(func, parm);
1361
1362         func = RNA_def_function(srna, "remove", "rna_Main_lattices_remove");
1363         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1364         RNA_def_function_ui_description(func, "Remove a lattice from the current blendfile");
1365         parm = RNA_def_pointer(func, "lattice", "Lattice", "", "Lattice to remove");
1366         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1367         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1368
1369         func = RNA_def_function(srna, "tag", "rna_Main_lattices_tag");
1370         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1371         RNA_def_property_flag(parm, PROP_REQUIRED);
1372
1373         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1374         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1375         RNA_def_property_boolean_funcs(prop, "rna_Main_lattices_is_updated_get", NULL);
1376 }
1377 void RNA_def_main_curves(BlenderRNA *brna, PropertyRNA *cprop)
1378 {
1379         StructRNA *srna;
1380         FunctionRNA *func;
1381         PropertyRNA *parm;
1382         PropertyRNA *prop;
1383
1384         RNA_def_property_srna(cprop, "BlendDataCurves");
1385         srna = RNA_def_struct(brna, "BlendDataCurves", NULL);
1386         RNA_def_struct_sdna(srna, "Main");
1387         RNA_def_struct_ui_text(srna, "Main Curves", "Collection of curves");
1388
1389         func = RNA_def_function(srna, "new", "rna_Main_curves_new");
1390         RNA_def_function_ui_description(func, "Add a new curve to the main database");
1391         parm = RNA_def_string(func, "name", "Curve", 0, "", "New name for the datablock");
1392         RNA_def_property_flag(parm, PROP_REQUIRED);
1393         parm = RNA_def_enum(func, "type", object_type_curve_items, 0, "Type", "The type of curve to add");
1394         RNA_def_property_flag(parm, PROP_REQUIRED);
1395         /* return type */
1396         parm = RNA_def_pointer(func, "curve", "Curve", "", "New curve datablock");
1397         RNA_def_function_return(func, parm);
1398
1399         func = RNA_def_function(srna, "remove", "rna_Main_curves_remove");
1400         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1401         RNA_def_function_ui_description(func, "Remove a curve from the current blendfile");
1402         parm = RNA_def_pointer(func, "curve", "Curve", "", "Curve to remove");
1403         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1404         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1405
1406         func = RNA_def_function(srna, "tag", "rna_Main_curves_tag");
1407         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1408         RNA_def_property_flag(parm, PROP_REQUIRED);
1409
1410         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1411         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1412         RNA_def_property_boolean_funcs(prop, "rna_Main_curves_is_updated_get", NULL);
1413 }
1414 void RNA_def_main_metaballs(BlenderRNA *brna, PropertyRNA *cprop)
1415 {
1416         StructRNA *srna;
1417         FunctionRNA *func;
1418         PropertyRNA *parm;
1419         PropertyRNA *prop;
1420
1421         RNA_def_property_srna(cprop, "BlendDataMetaBalls");
1422         srna = RNA_def_struct(brna, "BlendDataMetaBalls", NULL);
1423         RNA_def_struct_sdna(srna, "Main");
1424         RNA_def_struct_ui_text(srna, "Main Metaballs", "Collection of metaballs");
1425
1426         func = RNA_def_function(srna, "new", "rna_Main_metaballs_new");
1427         RNA_def_function_ui_description(func, "Add a new metaball to the main database");
1428         parm = RNA_def_string(func, "name", "MetaBall", 0, "", "New name for the datablock");
1429         RNA_def_property_flag(parm, PROP_REQUIRED);
1430         /* return type */
1431         parm = RNA_def_pointer(func, "metaball", "MetaBall", "", "New metaball datablock");
1432         RNA_def_function_return(func, parm);
1433
1434         func = RNA_def_function(srna, "remove", "rna_Main_metaballs_remove");
1435         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1436         RNA_def_function_ui_description(func, "Remove a metaball from the current blendfile");
1437         parm = RNA_def_pointer(func, "metaball", "MetaBall", "", "Metaball to remove");
1438         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1439         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1440
1441         func = RNA_def_function(srna, "tag", "rna_Main_metaballs_tag");
1442         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1443         RNA_def_property_flag(parm, PROP_REQUIRED);
1444
1445         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1446         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1447         RNA_def_property_boolean_funcs(prop, "rna_Main_metaballs_is_updated_get", NULL);
1448 }
1449 void RNA_def_main_fonts(BlenderRNA *brna, PropertyRNA *cprop)
1450 {
1451         StructRNA *srna;
1452         FunctionRNA *func;
1453         PropertyRNA *parm;
1454         PropertyRNA *prop;
1455
1456         RNA_def_property_srna(cprop, "BlendDataFonts");
1457         srna = RNA_def_struct(brna, "BlendDataFonts", NULL);
1458         RNA_def_struct_sdna(srna, "Main");
1459         RNA_def_struct_ui_text(srna, "Main Fonts", "Collection of fonts");
1460
1461         func = RNA_def_function(srna, "load", "rna_Main_fonts_load");
1462         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1463         RNA_def_function_ui_description(func, "Load a new font into the main database");
1464         parm = RNA_def_string_file_path(func, "filepath", "File Path", 0, "", "path of the font to load");
1465         RNA_def_property_flag(parm, PROP_REQUIRED);
1466         /* return type */
1467         parm = RNA_def_pointer(func, "vfont", "VectorFont", "", "New font datablock");
1468         RNA_def_function_return(func, parm);
1469
1470         func = RNA_def_function(srna, "remove", "rna_Main_fonts_remove");
1471         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1472         RNA_def_function_ui_description(func, "Remove a font from the current blendfile");
1473         parm = RNA_def_pointer(func, "vfont", "VectorFont", "", "Font to remove");
1474         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1475         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1476
1477         func = RNA_def_function(srna, "tag", "rna_Main_fonts_tag");
1478         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1479         RNA_def_property_flag(parm, PROP_REQUIRED);
1480
1481         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1482         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1483         RNA_def_property_boolean_funcs(prop, "rna_Main_fonts_is_updated_get", NULL);
1484 }
1485 void RNA_def_main_textures(BlenderRNA *brna, PropertyRNA *cprop)
1486 {
1487         StructRNA *srna;
1488         FunctionRNA *func;
1489         PropertyRNA *parm;
1490         PropertyRNA *prop;
1491
1492         RNA_def_property_srna(cprop, "BlendDataTextures");
1493         srna = RNA_def_struct(brna, "BlendDataTextures", NULL);
1494         RNA_def_struct_sdna(srna, "Main");
1495         RNA_def_struct_ui_text(srna, "Main Textures", "Collection of groups");
1496
1497         func = RNA_def_function(srna, "new", "rna_Main_textures_new");
1498         RNA_def_function_ui_description(func, "Add a new texture to the main database");
1499         parm = RNA_def_string(func, "name", "Texture", 0, "", "New name for the datablock");
1500         RNA_def_property_flag(parm, PROP_REQUIRED);
1501         parm = RNA_def_enum(func, "type", texture_type_items, 0, "Type", "The type of texture to add");
1502         RNA_def_property_flag(parm, PROP_REQUIRED);
1503         /* return type */
1504         parm = RNA_def_pointer(func, "texture", "Texture", "", "New texture datablock");
1505         RNA_def_function_return(func, parm);
1506
1507         func = RNA_def_function(srna, "remove", "rna_Main_textures_remove");
1508         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1509         RNA_def_function_ui_description(func, "Remove a texture from the current blendfile");
1510         parm = RNA_def_pointer(func, "texture", "Texture", "", "Texture to remove");
1511         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1512         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1513
1514         func = RNA_def_function(srna, "tag", "rna_Main_textures_tag");
1515         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1516         RNA_def_property_flag(parm, PROP_REQUIRED);
1517
1518         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1519         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1520         RNA_def_property_boolean_funcs(prop, "rna_Main_textures_is_updated_get", NULL);
1521 }
1522 void RNA_def_main_brushes(BlenderRNA *brna, PropertyRNA *cprop)
1523 {
1524         StructRNA *srna;
1525         FunctionRNA *func;
1526         PropertyRNA *parm;
1527         PropertyRNA *prop;
1528
1529         RNA_def_property_srna(cprop, "BlendDataBrushes");
1530         srna = RNA_def_struct(brna, "BlendDataBrushes", NULL);
1531         RNA_def_struct_sdna(srna, "Main");
1532         RNA_def_struct_ui_text(srna, "Main Brushes", "Collection of brushes");
1533
1534         func = RNA_def_function(srna, "new", "rna_Main_brushes_new");
1535         RNA_def_function_ui_description(func, "Add a new brush to the main database");
1536         parm = RNA_def_string(func, "name", "Brush", 0, "", "New name for the datablock");
1537         RNA_def_property_flag(parm, PROP_REQUIRED);
1538         /* return type */
1539         parm = RNA_def_pointer(func, "brush", "Brush", "", "New brush datablock");
1540         RNA_def_function_return(func, parm);
1541
1542         func = RNA_def_function(srna, "remove", "rna_Main_brushes_remove");
1543         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1544         RNA_def_function_ui_description(func, "Remove a brush from the current blendfile");
1545         parm = RNA_def_pointer(func, "brush", "Brush", "", "Brush to remove");
1546         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1547         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1548
1549         func = RNA_def_function(srna, "tag", "rna_Main_brushes_tag");
1550         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1551         RNA_def_property_flag(parm, PROP_REQUIRED);
1552
1553         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1554         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1555         RNA_def_property_boolean_funcs(prop, "rna_Main_brushes_is_updated_get", NULL);
1556 }
1557
1558 void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
1559 {
1560         StructRNA *srna;
1561         FunctionRNA *func;
1562         PropertyRNA *parm;
1563         PropertyRNA *prop;
1564
1565         RNA_def_property_srna(cprop, "BlendDataWorlds");
1566         srna = RNA_def_struct(brna, "BlendDataWorlds", NULL);
1567         RNA_def_struct_sdna(srna, "Main");
1568         RNA_def_struct_ui_text(srna, "Main Worlds", "Collection of worlds");
1569
1570         func = RNA_def_function(srna, "new", "rna_Main_worlds_new");
1571         RNA_def_function_ui_description(func, "Add a new world to the main database");
1572         parm = RNA_def_string(func, "name", "World", 0, "", "New name for the datablock");
1573         RNA_def_property_flag(parm, PROP_REQUIRED);
1574         /* return type */
1575         parm = RNA_def_pointer(func, "world", "World", "", "New world datablock");
1576         RNA_def_function_return(func, parm);
1577
1578         func = RNA_def_function(srna, "remove", "rna_Main_worlds_remove");
1579         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1580         RNA_def_function_ui_description(func, "Remove a world from the current blendfile");
1581         parm = RNA_def_pointer(func, "world", "World", "", "World to remove");
1582         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1583         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1584
1585         func = RNA_def_function(srna, "tag", "rna_Main_worlds_tag");
1586         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1587         RNA_def_property_flag(parm, PROP_REQUIRED);
1588
1589         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1590         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1591         RNA_def_property_boolean_funcs(prop, "rna_Main_worlds_is_updated_get", NULL);
1592 }
1593
1594 void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
1595 {
1596         StructRNA *srna;
1597         FunctionRNA *func;
1598         PropertyRNA *parm;
1599         PropertyRNA *prop;
1600
1601         RNA_def_property_srna(cprop, "BlendDataGroups");
1602         srna = RNA_def_struct(brna, "BlendDataGroups", NULL);
1603         RNA_def_struct_sdna(srna, "Main");
1604         RNA_def_struct_ui_text(srna, "Main Groups", "Collection of groups");
1605
1606         func = RNA_def_function(srna, "new", "rna_Main_groups_new");
1607         RNA_def_function_ui_description(func, "Add a new group to the main database");
1608         parm = RNA_def_string(func, "name", "Group", 0, "", "New name for the datablock");
1609         RNA_def_property_flag(parm, PROP_REQUIRED);
1610         /* return type */
1611         parm = RNA_def_pointer(func, "group", "Group", "", "New group datablock");
1612         RNA_def_function_return(func, parm);
1613
1614         func = RNA_def_function(srna, "remove", "rna_Main_groups_remove");
1615         RNA_def_function_ui_description(func, "Remove a group from the current blendfile");
1616         parm = RNA_def_pointer(func, "group", "Group", "", "Group to remove");
1617         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1618         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1619
1620         func = RNA_def_function(srna, "tag", "rna_Main_groups_tag");
1621         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1622         RNA_def_property_flag(parm, PROP_REQUIRED);
1623
1624         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1625         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1626         RNA_def_property_boolean_funcs(prop, "rna_Main_groups_is_updated_get", NULL);
1627 }
1628
1629 void RNA_def_main_speakers(BlenderRNA *brna, PropertyRNA *cprop)
1630 {
1631         StructRNA *srna;
1632         FunctionRNA *func;
1633         PropertyRNA *parm;
1634         PropertyRNA *prop;
1635
1636         RNA_def_property_srna(cprop, "BlendDataSpeakers");
1637         srna = RNA_def_struct(brna, "BlendDataSpeakers", NULL);
1638         RNA_def_struct_sdna(srna, "Main");
1639         RNA_def_struct_ui_text(srna, "Main Speakers", "Collection of speakers");
1640
1641         func = RNA_def_function(srna, "new", "rna_Main_speakers_new");
1642         RNA_def_function_ui_description(func, "Add a new speaker to the main database");
1643         parm = RNA_def_string(func, "name", "Speaker", 0, "", "New name for the datablock");
1644         RNA_def_property_flag(parm, PROP_REQUIRED);
1645         /* return type */
1646         parm = RNA_def_pointer(func, "speaker", "Speaker", "", "New speaker datablock");
1647         RNA_def_function_return(func, parm);
1648
1649         func = RNA_def_function(srna, "remove", "rna_Main_speakers_remove");
1650         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1651         RNA_def_function_ui_description(func, "Remove a speaker from the current blendfile");
1652         parm = RNA_def_pointer(func, "speaker", "Speaker", "", "Speaker to remove");
1653         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1654         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1655
1656         func = RNA_def_function(srna, "tag", "rna_Main_speakers_tag");
1657         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1658         RNA_def_property_flag(parm, PROP_REQUIRED);
1659
1660         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1661         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1662         RNA_def_property_boolean_funcs(prop, "rna_Main_speakers_is_updated_get", NULL);
1663 }
1664
1665 void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
1666 {
1667         StructRNA *srna;
1668         FunctionRNA *func;
1669         PropertyRNA *parm;
1670         PropertyRNA *prop;
1671
1672         RNA_def_property_srna(cprop, "BlendDataTexts");
1673         srna = RNA_def_struct(brna, "BlendDataTexts", NULL);
1674         RNA_def_struct_sdna(srna, "Main");
1675         RNA_def_struct_ui_text(srna, "Main Texts", "Collection of texts");
1676
1677         func = RNA_def_function(srna, "new", "rna_Main_texts_new");
1678         RNA_def_function_ui_description(func, "Add a new text to the main database");
1679         parm = RNA_def_string(func, "name", "Text", 0, "", "New name for the datablock");
1680         RNA_def_property_flag(parm, PROP_REQUIRED);
1681         /* return type */
1682         parm = RNA_def_pointer(func, "text", "Text", "", "New text datablock");
1683         RNA_def_function_return(func, parm);
1684
1685         func = RNA_def_function(srna, "remove", "rna_Main_texts_remove");
1686         RNA_def_function_ui_description(func, "Remove a text from the current blendfile");
1687         parm = RNA_def_pointer(func, "text", "Text", "", "Text to remove");
1688         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1689         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1690
1691         /* load func */
1692         func = RNA_def_function(srna, "load", "rna_Main_texts_load");
1693         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1694         RNA_def_function_ui_description(func, "Add a new text to the main database from a file");
1695         parm = RNA_def_string_file_path(func, "filepath", "Path", FILE_MAX, "", "path for the datablock");
1696         RNA_def_property_flag(parm, PROP_REQUIRED);
1697         /* return type */
1698         parm = RNA_def_pointer(func, "text", "Text", "", "New text datablock");
1699         RNA_def_function_return(func, parm);
1700
1701         func = RNA_def_function(srna, "tag", "rna_Main_texts_tag");
1702         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1703         RNA_def_property_flag(parm, PROP_REQUIRED);
1704
1705         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1706         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1707         RNA_def_property_boolean_funcs(prop, "rna_Main_texts_is_updated_get", NULL);
1708 }
1709
1710 void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
1711 {
1712         StructRNA *srna;
1713         FunctionRNA *func;
1714         PropertyRNA *parm;
1715         PropertyRNA *prop;
1716
1717         RNA_def_property_srna(cprop, "BlendDataSounds");
1718         srna = RNA_def_struct(brna, "BlendDataSounds", NULL);
1719         RNA_def_struct_sdna(srna, "Main");
1720         RNA_def_struct_ui_text(srna, "Main Sounds", "Collection of sounds");
1721
1722         /* TODO, 'load' */
1723
1724         func = RNA_def_function(srna, "tag", "rna_Main_sounds_tag");
1725         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1726         RNA_def_property_flag(parm, PROP_REQUIRED);
1727
1728         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1729         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1730         RNA_def_property_boolean_funcs(prop, "rna_Main_sounds_is_updated_get", NULL);
1731 }
1732
1733 void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
1734 {
1735         StructRNA *srna;
1736         FunctionRNA *func;
1737         PropertyRNA *parm;
1738         PropertyRNA *prop;
1739
1740         RNA_def_property_srna(cprop, "BlendDataArmatures");
1741         srna = RNA_def_struct(brna, "BlendDataArmatures", NULL);
1742         RNA_def_struct_sdna(srna, "Main");
1743         RNA_def_struct_ui_text(srna, "Main Armatures", "Collection of armatures");
1744
1745         func = RNA_def_function(srna, "new", "rna_Main_armatures_new");
1746         RNA_def_function_ui_description(func, "Add a new armature to the main database");
1747         parm = RNA_def_string(func, "name", "Armature", 0, "", "New name for the datablock");
1748         RNA_def_property_flag(parm, PROP_REQUIRED);
1749         /* return type */
1750         parm = RNA_def_pointer(func, "armature", "Armature", "", "New armature datablock");
1751         RNA_def_function_return(func, parm);
1752
1753         func = RNA_def_function(srna, "remove", "rna_Main_armatures_remove");
1754         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1755         RNA_def_function_ui_description(func, "Remove a armature from the current blendfile");
1756         parm = RNA_def_pointer(func, "armature", "Armature", "", "Armature to remove");
1757         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1758         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1759
1760         func = RNA_def_function(srna, "tag", "rna_Main_armatures_tag");
1761         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1762         RNA_def_property_flag(parm, PROP_REQUIRED);
1763
1764         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1765         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1766         RNA_def_property_boolean_funcs(prop, "rna_Main_armatures_is_updated_get", NULL);
1767 }
1768 void RNA_def_main_actions(BlenderRNA *brna, PropertyRNA *cprop)
1769 {
1770         StructRNA *srna;
1771         FunctionRNA *func;
1772         PropertyRNA *parm;
1773         PropertyRNA *prop;
1774
1775         RNA_def_property_srna(cprop, "BlendDataActions");
1776         srna = RNA_def_struct(brna, "BlendDataActions", NULL);
1777         RNA_def_struct_sdna(srna, "Main");
1778         RNA_def_struct_ui_text(srna, "Main Actions", "Collection of actions");
1779
1780         func = RNA_def_function(srna, "new", "rna_Main_actions_new");
1781         RNA_def_function_ui_description(func, "Add a new action to the main database");
1782         parm = RNA_def_string(func, "name", "Action", 0, "", "New name for the datablock");
1783         RNA_def_property_flag(parm, PROP_REQUIRED);
1784         /* return type */
1785         parm = RNA_def_pointer(func, "action", "Action", "", "New action datablock");
1786         RNA_def_function_return(func, parm);
1787
1788         func = RNA_def_function(srna, "remove", "rna_Main_actions_remove");
1789         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1790         RNA_def_function_ui_description(func, "Remove a action from the current blendfile");
1791         parm = RNA_def_pointer(func, "action", "Action", "", "Action to remove");
1792         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1793         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1794
1795         func = RNA_def_function(srna, "tag", "rna_Main_actions_tag");
1796         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1797         RNA_def_property_flag(parm, PROP_REQUIRED);
1798
1799         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1800         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1801         RNA_def_property_boolean_funcs(prop, "rna_Main_actions_is_updated_get", NULL);
1802 }
1803 void RNA_def_main_particles(BlenderRNA *brna, PropertyRNA *cprop)
1804 {
1805         StructRNA *srna;
1806         FunctionRNA *func;
1807         PropertyRNA *parm;
1808         PropertyRNA *prop;
1809
1810         RNA_def_property_srna(cprop, "BlendDataParticles");
1811         srna = RNA_def_struct(brna, "BlendDataParticles", NULL);
1812         RNA_def_struct_sdna(srna, "Main");
1813         RNA_def_struct_ui_text(srna, "Main Particle Settings", "Collection of particle settings");
1814
1815         func = RNA_def_function(srna, "new", "rna_Main_particles_new");
1816         RNA_def_function_ui_description(func, "Add a new particle settings instance to the main database");
1817         parm = RNA_def_string(func, "name", "ParticleSettings", 0, "", "New name for the datablock");
1818         RNA_def_property_flag(parm, PROP_REQUIRED);
1819         /* return type */
1820         parm = RNA_def_pointer(func, "particle", "ParticleSettings", "", "New particle settings datablock");
1821         RNA_def_function_return(func, parm);
1822
1823         func = RNA_def_function(srna, "remove", "rna_Main_particles_remove");
1824         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1825         RNA_def_function_ui_description(func, "Remove a particle settings instance from the current blendfile");
1826         parm = RNA_def_pointer(func, "particle", "ParticleSettings", "", "Particle Settings to remove");
1827         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1828         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1829
1830         func = RNA_def_function(srna, "tag", "rna_Main_particles_tag");
1831         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1832         RNA_def_property_flag(parm, PROP_REQUIRED);
1833
1834         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1835         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1836         RNA_def_property_boolean_funcs(prop, "rna_Main_particles_is_updated_get", NULL);
1837 }
1838
1839 void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
1840 {
1841         StructRNA *srna;
1842         FunctionRNA *func;
1843         PropertyRNA *parm;
1844         PropertyRNA *prop;
1845
1846         RNA_def_property_srna(cprop, "BlendDataGreasePencils");
1847         srna = RNA_def_struct(brna, "BlendDataGreasePencils", NULL);
1848         RNA_def_struct_sdna(srna, "Main");
1849         RNA_def_struct_ui_text(srna, "Main Grease Pencils", "Collection of grease pencils");
1850
1851         func = RNA_def_function(srna, "tag", "rna_Main_gpencil_tag");
1852         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1853         RNA_def_property_flag(parm, PROP_REQUIRED);
1854
1855         func = RNA_def_function(srna, "new", "gpencil_data_addnew");
1856         RNA_def_function_flag(func, FUNC_NO_SELF);
1857         parm = RNA_def_string(func, "name", "GreasePencil", 0, "", "New name for the datablock");
1858         RNA_def_property_flag(parm, PROP_REQUIRED);
1859         /* return type */
1860         parm = RNA_def_pointer(func, "grease_pencil", "GreasePencil", "", "New grease pencil datablock");
1861         RNA_def_function_return(func, parm);
1862
1863         func = RNA_def_function(srna, "remove", "rna_Main_grease_pencil_remove");
1864         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1865         RNA_def_function_ui_description(func, "Remove a grease pencil instance from the current blendfile");
1866         parm = RNA_def_pointer(func, "grease_pencil", "GreasePencil", "", "Grease Pencil to remove");
1867         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1868         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1869
1870         prop = RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
1871         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1872         RNA_def_property_boolean_funcs(prop, "rna_Main_gpencil_is_updated_get", NULL);
1873 }
1874
1875 void RNA_def_main_movieclips(BlenderRNA *brna, PropertyRNA *cprop)
1876 {
1877         StructRNA *srna;
1878         FunctionRNA *func;
1879         PropertyRNA *parm;
1880
1881         RNA_def_property_srna(cprop, "BlendDataMovieClips");
1882         srna = RNA_def_struct(brna, "BlendDataMovieClips", NULL);
1883         RNA_def_struct_sdna(srna, "Main");
1884         RNA_def_struct_ui_text(srna, "Main Movie Clips", "Collection of movie clips");
1885
1886         func = RNA_def_function(srna, "tag", "rna_Main_movieclips_tag");
1887         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1888         RNA_def_property_flag(parm, PROP_REQUIRED);
1889
1890         func = RNA_def_function(srna, "remove", "rna_Main_movieclips_remove");
1891         RNA_def_function_ui_description(func, "Remove a movie clip from the current blendfile.");
1892         parm = RNA_def_pointer(func, "clip", "MovieClip", "", "Movie clip to remove");
1893         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1894         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1895
1896         /* load func */
1897         func = RNA_def_function(srna, "load", "rna_Main_movieclip_load");
1898         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1899         RNA_def_function_ui_description(func, "Add a new movie clip to the main database from a file");
1900         parm = RNA_def_string_file_path(func, "filepath", "Path", FILE_MAX, "", "path for the datablock");
1901         RNA_def_property_flag(parm, PROP_REQUIRED);
1902         /* return type */
1903         parm = RNA_def_pointer(func, "clip", "MovieClip", "", "New movie clip datablock");
1904         RNA_def_function_return(func, parm);
1905 }
1906
1907 void RNA_def_main_masks(BlenderRNA *brna, PropertyRNA *cprop)
1908 {
1909         StructRNA *srna;
1910         FunctionRNA *func;
1911         PropertyRNA *parm;
1912
1913         RNA_def_property_srna(cprop, "BlendDataMasks");
1914         srna = RNA_def_struct(brna, "BlendDataMasks", NULL);
1915         RNA_def_struct_sdna(srna, "Main");
1916         RNA_def_struct_ui_text(srna, "Main Masks", "Collection of masks");
1917
1918         func = RNA_def_function(srna, "tag", "rna_Main_masks_tag");
1919         parm = RNA_def_boolean(func, "value", 0, "Value", "");
1920         RNA_def_property_flag(parm, PROP_REQUIRED);
1921
1922         /* new func */
1923         func = RNA_def_function(srna, "new", "rna_Main_mask_new");
1924         RNA_def_function_ui_description(func, "Add a new mask with a given name to the main database");
1925         RNA_def_string_file_path(func, "name", "", MAX_ID_NAME - 2, "Mask", "Name of new mask datablock");
1926         /* return type */
1927         parm = RNA_def_pointer(func, "mask", "Mask", "", "New mask datablock");
1928         RNA_def_function_return(func, parm);
1929
1930         /* remove func */
1931         func = RNA_def_function(srna, "remove", "rna_Main_masks_remove");
1932         RNA_def_function_ui_description(func, "Remove a masks from the current blendfile.");
1933         parm = RNA_def_pointer(func, "mask", "Mask", "", "Mask to remove");
1934         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1935         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1936 }
1937
1938 #ifdef WITH_FREESTYLE
1939 void RNA_def_main_linestyles(BlenderRNA *brna, PropertyRNA *cprop)
1940 {
1941         StructRNA *srna;
1942         FunctionRNA *func;
1943         PropertyRNA *parm;
1944
1945         RNA_def_property_srna(cprop, "BlendDataLineStyles");
1946         srna = RNA_def_struct(brna, "BlendDataLineStyles", NULL);
1947         RNA_def_struct_sdna(srna, "Main");
1948         RNA_def_struct_ui_text(srna, "Main Line Styles", "Collection of line styles");
1949
1950         func = RNA_def_function(srna, "new", "rna_Main_linestyles_new");
1951         RNA_def_function_ui_description(func, "Add a new line style instance to the main database");
1952         parm = RNA_def_string(func, "name", "FreestyleLineStyle", 0, "", "New name for the datablock");
1953         RNA_def_property_flag(parm, PROP_REQUIRED);
1954         /* return type */
1955         parm = RNA_def_pointer(func, "linestyle", "FreestyleLineStyle", "", "New line style datablock");
1956         RNA_def_function_return(func, parm);
1957
1958         func = RNA_def_function(srna, "remove", "rna_Main_linestyles_remove");
1959         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1960         RNA_def_function_ui_description(func, "Remove a line style instance from the current blendfile");
1961         parm = RNA_def_pointer(func, "linestyle", "FreestyleLineStyle", "", "Line style to remove");
1962         RNA_def_property_flag(parm, PROP_REQUIRED);
1963 }
1964 #endif
1965
1966 #endif