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