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