Page MenuHome
Differential D10030 Diff 32522 source/blender/makesrna/intern/rna_main_api.c

Changeset View

Standalone View

View Options

source/blender/makesrna/intern/rna_main_api.c

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
static Camera *rna_Main_cameras_new(Main *bmain, const char *name) static Camera *rna_Main_cameras_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
ID *id = BKE_camera_add(bmain, safe_name); ID *id = BKE_camera_add(bmain, safe_name);
id_us_min(id); id_us_min(id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return (Camera *)id; return (Camera *)id;
} }
static Scene *rna_Main_scenes_new(Main *bmain, const char *name) static Scene *rna_Main_scenes_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return BKE_scene_add(bmain, safe_name); return BKE_scene_add(bmain, safe_name);
} }
static void rna_Main_scenes_remove( static void rna_Main_scenes_remove(
Main *bmain, bContext *C, ReportList *reports, PointerRNA *scene_ptr, bool do_unlink) Main *bmain, bContext *C, ReportList *reports, PointerRNA *scene_ptr, bool do_unlink)
{ {
/* don't call BKE_id_free(...) directly */ /* don't call BKE_id_free(...) directly */
Scene *scene = scene_ptr->data; Scene *scene = scene_ptr->data;
Scene *scene_new; Scene *scene_new;
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines if (data) {
id_us_plus(data); id_us_plus(data);
} }
ob = BKE_object_add_only_object(bmain, type, safe_name); ob = BKE_object_add_only_object(bmain, type, safe_name);
ob->data = data; ob->data = data;
BKE_object_materials_test(bmain, ob, ob->data); BKE_object_materials_test(bmain, ob, ob->data);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return ob; return ob;
} }
static Material *rna_Main_materials_new(Main *bmain, const char *name) static Material *rna_Main_materials_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
ID *id = (ID *)BKE_material_add(bmain, safe_name); ID *id = (ID *)BKE_material_add(bmain, safe_name);
id_us_min(id); id_us_min(id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return (Material *)id; return (Material *)id;
} }
static void rna_Main_materials_gpencil_data(Main *UNUSED(bmain), PointerRNA *id_ptr) static void rna_Main_materials_gpencil_data(Main *UNUSED(bmain), PointerRNA *id_ptr)
{ {
ID *id = id_ptr->data; ID *id = id_ptr->data;
Material *ma = (Material *)id; Material *ma = (Material *)id;
BKE_gpencil_material_attr_init(ma); BKE_gpencil_material_attr_init(ma);
Show All 34 Lines
static Mesh *rna_Main_meshes_new(Main *bmain, const char *name) static Mesh *rna_Main_meshes_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Mesh *me = BKE_mesh_add(bmain, safe_name); Mesh *me = BKE_mesh_add(bmain, safe_name);
id_us_min(&me->id); id_us_min(&me->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return me; return me;
} }
/* copied from Mesh_getFromObject and adapted to RNA interface */ /* copied from Mesh_getFromObject and adapted to RNA interface */
static Mesh *rna_Main_meshes_new_from_object(Main *bmain, static Mesh *rna_Main_meshes_new_from_object(Main *bmain,
ReportList *reports, ReportList *reports,
Object *object, Object *object,
bool preserve_all_data_layers, bool preserve_all_data_layers,
Depsgraph *depsgraph) Depsgraph *depsgraph)
{ {
switch (object->type) { switch (object->type) {
case OB_FONT: case OB_FONT:
case OB_CURVE: case OB_CURVE:
case OB_SURF: case OB_SURF:
case OB_MBALL: case OB_MBALL:
case OB_MESH: case OB_MESH:
break; break;
default: default:
BKE_report(reports, RPT_ERROR, "Object does not have geometry data"); BKE_report(reports, RPT_ERROR, "Object does not have geometry data");
return NULL; return NULL;
} }
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return BKE_mesh_new_from_object_to_bmain(bmain, depsgraph, object, preserve_all_data_layers); return BKE_mesh_new_from_object_to_bmain(bmain, depsgraph, object, preserve_all_data_layers);
} }
static Light *rna_Main_lights_new(Main *bmain, const char *name, int type) static Light *rna_Main_lights_new(Main *bmain, const char *name, int type)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Light *lamp = BKE_light_add(bmain, safe_name); Light *lamp = BKE_light_add(bmain, safe_name);
lamp->type = type; lamp->type = type;
id_us_min(&lamp->id); id_us_min(&lamp->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return lamp; return lamp;
} }
static Image *rna_Main_images_new(Main *bmain, static Image *rna_Main_images_new(Main *bmain,
const char *name, const char *name,
int width, int width,
int height, int height,
bool alpha, bool alpha,
Show All 13 Lines Image *image = BKE_image_add_generated(bmain,
alpha ? 32 : 24, alpha ? 32 : 24,
float_buffer, float_buffer,
0, 0,
color, color,
stereo3d, stereo3d,
is_data, is_data,
tiled); tiled);
id_us_min(&image->id); id_us_min(&image->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return image; return image;
} }
static Image *rna_Main_images_load(Main *bmain, static Image *rna_Main_images_load(Main *bmain,
ReportList *reports, ReportList *reports,
const char *filepath, const char *filepath,
bool check_existing) bool check_existing)
{ {
Image *ima; Image *ima;
Show All 10 Lines if (!ima) {
BKE_reportf(reports, BKE_reportf(reports,
RPT_ERROR, RPT_ERROR,
"Cannot read '%s': %s", "Cannot read '%s': %s",
filepath, filepath,
errno ? strerror(errno) : TIP_("unsupported image format")); errno ? strerror(errno) : TIP_("unsupported image format"));
} }
id_us_min((ID *)ima); id_us_min((ID *)ima);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return ima; return ima;
} }
static Lattice *rna_Main_lattices_new(Main *bmain, const char *name) static Lattice *rna_Main_lattices_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Lattice *lt = BKE_lattice_add(bmain, safe_name); Lattice *lt = BKE_lattice_add(bmain, safe_name);
id_us_min(&lt->id); id_us_min(&lt->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return lt; return lt;
} }
static Curve *rna_Main_curves_new(Main *bmain, const char *name, int type) static Curve *rna_Main_curves_new(Main *bmain, const char *name, int type)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Curve *cu = BKE_curve_add(bmain, safe_name, type); Curve *cu = BKE_curve_add(bmain, safe_name, type);
id_us_min(&cu->id); id_us_min(&cu->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return cu; return cu;
} }
static MetaBall *rna_Main_metaballs_new(Main *bmain, const char *name) static MetaBall *rna_Main_metaballs_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
MetaBall *mb = BKE_mball_add(bmain, safe_name); MetaBall *mb = BKE_mball_add(bmain, safe_name);
id_us_min(&mb->id); id_us_min(&mb->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return mb; return mb;
} }
static VFont *rna_Main_fonts_load(Main *bmain, static VFont *rna_Main_fonts_load(Main *bmain,
ReportList *reports, ReportList *reports,
const char *filepath, const char *filepath,
bool check_existing) bool check_existing)
{ {
Show All 9 Linesstatic VFont *rna_Main_fonts_load(Main *bmain,
if (!font) { if (!font) {
BKE_reportf(reports, BKE_reportf(reports,
RPT_ERROR, RPT_ERROR,
"Cannot read '%s': %s", "Cannot read '%s': %s",
filepath, filepath,
errno ? strerror(errno) : TIP_("unsupported font format")); errno ? strerror(errno) : TIP_("unsupported font format"));
} }
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return font; return font;
} }
static Tex *rna_Main_textures_new(Main *bmain, const char *name, int type) static Tex *rna_Main_textures_new(Main *bmain, const char *name, int type)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Tex *tex = BKE_texture_add(bmain, safe_name); Tex *tex = BKE_texture_add(bmain, safe_name);
BKE_texture_type_set(tex, type); BKE_texture_type_set(tex, type);
id_us_min(&tex->id); id_us_min(&tex->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return tex; return tex;
} }
static Brush *rna_Main_brushes_new(Main *bmain, const char *name, int mode) static Brush *rna_Main_brushes_new(Main *bmain, const char *name, int mode)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Brush *brush = BKE_brush_add(bmain, safe_name, mode); Brush *brush = BKE_brush_add(bmain, safe_name, mode);
id_us_min(&brush->id); id_us_min(&brush->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return brush; return brush;
} }
static void rna_Main_brush_gpencil_data(Main *UNUSED(bmain), PointerRNA *id_ptr) static void rna_Main_brush_gpencil_data(Main *UNUSED(bmain), PointerRNA *id_ptr)
{ {
ID *id = id_ptr->data; ID *id = id_ptr->data;
Brush *brush = (Brush *)id; Brush *brush = (Brush *)id;
BKE_brush_init_gpencil_settings(brush); BKE_brush_init_gpencil_settings(brush);
} }
static World *rna_Main_worlds_new(Main *bmain, const char *name) static World *rna_Main_worlds_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
World *world = BKE_world_add(bmain, safe_name); World *world = BKE_world_add(bmain, safe_name);
id_us_min(&world->id); id_us_min(&world->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return world; return world;
} }
static Collection *rna_Main_collections_new(Main *bmain, const char *name) static Collection *rna_Main_collections_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
mont29Unsubmitted
Not Done
Inline Actions

Notifier should not be added before ID is actually created imho... It's not technically an issue here, but as a general logical principal it's not a good idea to notify of something that did not yet happen ;)

mont29: Notifier should not be added before ID is actually created imho... It's not technically an…
return BKE_collection_add(bmain, NULL, safe_name); return BKE_collection_add(bmain, NULL, safe_name);
} }
static Speaker *rna_Main_speakers_new(Main *bmain, const char *name) static Speaker *rna_Main_speakers_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Speaker *speaker = BKE_speaker_add(bmain, safe_name); Speaker *speaker = BKE_speaker_add(bmain, safe_name);
id_us_min(&speaker->id); id_us_min(&speaker->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return speaker; return speaker;
} }
static bSound *rna_Main_sounds_load(Main *bmain, const char *name, bool check_existing) static bSound *rna_Main_sounds_load(Main *bmain, const char *name, bool check_existing)
{ {
bSound *sound; bSound *sound;
if (check_existing) { if (check_existing) {
sound = BKE_sound_new_file_exists(bmain, name); sound = BKE_sound_new_file_exists(bmain, name);
} }
else { else {
sound = BKE_sound_new_file(bmain, name); sound = BKE_sound_new_file(bmain, name);
} }
id_us_min(&sound->id); id_us_min(&sound->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return sound; return sound;
} }
static Text *rna_Main_texts_new(Main *bmain, const char *name) static Text *rna_Main_texts_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return BKE_text_add(bmain, safe_name); return BKE_text_add(bmain, safe_name);
} }
static Text *rna_Main_texts_load(Main *bmain, static Text *rna_Main_texts_load(Main *bmain,
ReportList *reports, ReportList *reports,
const char *filepath, const char *filepath,
bool is_internal) bool is_internal)
{ {
Text *txt; Text *txt;
errno = 0; errno = 0;
txt = BKE_text_load_ex(bmain, filepath, BKE_main_blendfile_path(bmain), is_internal); txt = BKE_text_load_ex(bmain, filepath, BKE_main_blendfile_path(bmain), is_internal);
if (!txt) { if (!txt) {
BKE_reportf(reports, BKE_reportf(reports,
RPT_ERROR, RPT_ERROR,
"Cannot read '%s': %s", "Cannot read '%s': %s",
filepath, filepath,
errno ? strerror(errno) : TIP_("unable to load text")); errno ? strerror(errno) : TIP_("unable to load text"));
} }
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return txt; return txt;
} }
static bArmature *rna_Main_armatures_new(Main *bmain, const char *name) static bArmature *rna_Main_armatures_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
bArmature *arm = BKE_armature_add(bmain, safe_name); bArmature *arm = BKE_armature_add(bmain, safe_name);
id_us_min(&arm->id); id_us_min(&arm->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return arm; return arm;
} }
static bAction *rna_Main_actions_new(Main *bmain, const char *name) static bAction *rna_Main_actions_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
bAction *act = BKE_action_add(bmain, safe_name); bAction *act = BKE_action_add(bmain, safe_name);
id_fake_user_clear(&act->id); id_fake_user_clear(&act->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return act; return act;
} }
static ParticleSettings *rna_Main_particles_new(Main *bmain, const char *name) static ParticleSettings *rna_Main_particles_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
ParticleSettings *part = BKE_particlesettings_add(bmain, safe_name); ParticleSettings *part = BKE_particlesettings_add(bmain, safe_name);
id_us_min(&part->id); id_us_min(&part->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return part; return part;
} }
static Palette *rna_Main_palettes_new(Main *bmain, const char *name) static Palette *rna_Main_palettes_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Palette *palette = BKE_palette_add(bmain, safe_name); Palette *palette = BKE_palette_add(bmain, safe_name);
id_us_min(&palette->id); id_us_min(&palette->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return (Palette *)palette; return (Palette *)palette;
} }
static MovieClip *rna_Main_movieclip_load(Main *bmain, static MovieClip *rna_Main_movieclip_load(Main *bmain,
ReportList *reports, ReportList *reports,
const char *filepath, const char *filepath,
bool check_existing) bool check_existing)
{ {
Show All 15 Lines else {
BKE_reportf(reports, BKE_reportf(reports,
RPT_ERROR, RPT_ERROR,
"Cannot read '%s': %s", "Cannot read '%s': %s",
filepath, filepath,
errno ? strerror(errno) : TIP_("unable to load movie clip")); errno ? strerror(errno) : TIP_("unable to load movie clip"));
} }
id_us_min((ID *)clip); id_us_min((ID *)clip);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return clip; return clip;
} }
static Mask *rna_Main_mask_new(Main *bmain, const char *name) static Mask *rna_Main_mask_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return BKE_mask_new(bmain, safe_name); return BKE_mask_new(bmain, safe_name);
} }
static FreestyleLineStyle *rna_Main_linestyles_new(Main *bmain, const char *name) static FreestyleLineStyle *rna_Main_linestyles_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
FreestyleLineStyle *linestyle = BKE_linestyle_new(bmain, safe_name); FreestyleLineStyle *linestyle = BKE_linestyle_new(bmain, safe_name);
id_us_min(&linestyle->id); id_us_min(&linestyle->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return linestyle; return linestyle;
} }
static LightProbe *rna_Main_lightprobe_new(Main *bmain, const char *name, int type) static LightProbe *rna_Main_lightprobe_new(Main *bmain, const char *name, int type)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
LightProbe *probe = BKE_lightprobe_add(bmain, safe_name); LightProbe *probe = BKE_lightprobe_add(bmain, safe_name);
BKE_lightprobe_type_set(probe, type); BKE_lightprobe_type_set(probe, type);
id_us_min(&probe->id); id_us_min(&probe->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return probe; return probe;
} }
static bGPdata *rna_Main_gpencils_new(Main *bmain, const char *name) static bGPdata *rna_Main_gpencils_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
bGPdata *gpd = BKE_gpencil_data_addnew(bmain, safe_name); bGPdata *gpd = BKE_gpencil_data_addnew(bmain, safe_name);
id_us_min(&gpd->id); id_us_min(&gpd->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return gpd; return gpd;
} }
# ifdef WITH_HAIR_NODES # ifdef WITH_HAIR_NODES
static Hair *rna_Main_hairs_new(Main *bmain, const char *name) static Hair *rna_Main_hairs_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Hair *hair = BKE_hair_add(bmain, safe_name); Hair *hair = BKE_hair_add(bmain, safe_name);
id_us_min(&hair->id); id_us_min(&hair->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return hair; return hair;
} }
# endif # endif
# ifdef WITH_POINT_CLOUD # ifdef WITH_POINT_CLOUD
static PointCloud *rna_Main_pointclouds_new(Main *bmain, const char *name) static PointCloud *rna_Main_pointclouds_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
PointCloud *pointcloud = BKE_pointcloud_add(bmain, safe_name); PointCloud *pointcloud = BKE_pointcloud_add(bmain, safe_name);
id_us_min(&pointcloud->id); id_us_min(&pointcloud->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return pointcloud; return pointcloud;
} }
# endif # endif
static Volume *rna_Main_volumes_new(Main *bmain, const char *name) static Volume *rna_Main_volumes_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Volume *volume = BKE_volume_add(bmain, safe_name); Volume *volume = BKE_volume_add(bmain, safe_name);
id_us_min(&volume->id); id_us_min(&volume->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
return volume; return volume;
} }
# ifdef WITH_GEOMETRY_NODES # ifdef WITH_GEOMETRY_NODES
static Simulation *rna_Main_simulations_new(Main *bmain, const char *name) static Simulation *rna_Main_simulations_new(Main *bmain, const char *name)
{ {
char safe_name[MAX_ID_NAME - 2]; char safe_name[MAX_ID_NAME - 2];
rna_idname_validate(name, safe_name); rna_idname_validate(name, safe_name);
Simulation *simulation = BKE_simulation_add(bmain, safe_name); Simulation *simulation = BKE_simulation_add(bmain, safe_name);
id_us_min(&simulation->id); id_us_min(&simulation->id);
WM_main_add_notifier(NC_ID | NA_ADDED, NULL);
Petri_JUnsubmitted
Done
Inline Actions

Since there is a lot of copy paste of this line of code, I think it would make sense to put this line in a function.
That would make this line more maintainable for the future.. For example if someone wants to modify the notification, and forgets to modify all similar lines, then that would become a bug in the codebase.

Personally i think a static function at the top of the file would do the trick nicely.

Petri_J: Since there is a lot of copy paste of this line of code, I think it would make sense to put…
return simulation; return simulation;
} }
# endif # endif
/* tag functions, all the same */ /* tag functions, all the same */
# define RNA_MAIN_ID_TAG_FUNCS_DEF(_func_name, _listbase_name, _id_type) \ # define RNA_MAIN_ID_TAG_FUNCS_DEF(_func_name, _listbase_name, _id_type) \
static void rna_Main_##_func_name##_tag(Main *bmain, bool value) \ static void rna_Main_##_func_name##_tag(Main *bmain, bool value) \
{ \ { \
▲ Show 20 Lines • Show All 1,630 Lines • Show Last 20 Lines