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