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