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