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