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