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