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