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