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