/* add a new gp-layer and make it the active layer */ bGPDlayer *gpencil_layer_addnew(bGPdata *gpd, const char *name, int setactive) { bGPDlayer *gpl; /* check that list is ok */ if (gpd == NULL) return NULL; /* allocate memory for frame and add to end of list */ gpl = MEM_callocN(sizeof(bGPDlayer), "bGPDlayer"); /* add to datablock */ BLI_addtail(&gpd->layers, gpl); /* set basic settings */ copy_v4_v4(gpl->color, U.gpencil_new_layer_col); gpl->thickness = 3; /* auto-name */ BLI_strncpy(gpl->info, name, sizeof(gpl->info)); BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info)); /* make this one the active one */ if (setactive) gpencil_layer_setactive(gpd, gpl); /* return layer */ return gpl; }
void BKE_sequence_modifier_unique_name(Sequence *seq, SequenceModifierData *smd) { const SequenceModifierTypeInfo *smti = BKE_sequence_modifier_type_info_get(smd->type); BLI_uniquename(&seq->modifiers, smd, CTX_DATA_(BLT_I18NCONTEXT_ID_SEQUENCE, smti->name), '.', offsetof(SequenceModifierData, name), sizeof(smd->name)); }
static void rna_Sensor_name_set(PointerRNA *ptr, const char *value) { Object *ob = ptr->id.data; bSensor *sens = ptr->data; BLI_strncpy_utf8(sens->name, value, sizeof(sens->name)); BLI_uniquename(&ob->sensors, sens, DATA_("Sensor"), '.', offsetof(bSensor, name), sizeof(sens->name)); }
static int poselib_rename_exec (bContext *C, wmOperator *op) { Object *ob= object_pose_armature_get(CTX_data_active_object(C)); bAction *act= (ob) ? ob->poselib : NULL; TimeMarker *marker; char newname[64]; /* check if valid poselib */ if (act == NULL) { BKE_report(op->reports, RPT_ERROR, "Object doesn't have PoseLib data"); return OPERATOR_CANCELLED; } /* get index (and pointer) of pose to remove */ marker= BLI_findlink(&act->markers, RNA_int_get(op->ptr, "pose")); if (marker == NULL) { BKE_report(op->reports, RPT_ERROR, "Invalid index for Pose"); return OPERATOR_CANCELLED; } /* get new name */ RNA_string_get(op->ptr, "name", newname); /* copy name and validate it */ BLI_strncpy(marker->name, newname, sizeof(marker->name)); BLI_uniquename(&act->markers, marker, "Pose", '.', offsetof(TimeMarker, name), sizeof(marker->name)); /* send notifiers for this - using keyframe editing notifiers, since action * may be being shown in anim editors as active action */ WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL); /* done */ return OPERATOR_FINISHED; }
void modifier_unique_name(ListBase *modifiers, ModifierData *md) { if (modifiers && md) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); BLI_uniquename(modifiers, md, mti->name, '.', offsetof(ModifierData, name), sizeof(md->name)); } }
static void rna_GameProperty_name_set(PointerRNA *ptr, const char *value) { Object *ob = ptr->id.data; bProperty *prop = ptr->data; BLI_strncpy_utf8(prop->name, value, sizeof(prop->name)); BLI_uniquename(&ob->prop, prop, DATA_("Property"), '.', offsetof(bProperty, name), sizeof(prop->name)); }
bool modifier_unique_name(ListBase *modifiers, ModifierData *md) { if (modifiers && md) { const ModifierTypeInfo *mti = modifierType_getInfo(md->type); return BLI_uniquename(modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name)); } return false; }
static void rna_GPencilLayer_info_set(PointerRNA *ptr, const char *value) { bGPdata *gpd = ptr->id.data; bGPDlayer *gpl = ptr->data; /* copy the new name into the name slot */ BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info)); BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info)); }
void rna_Sensor_name_set(PointerRNA *ptr, const char *value) { bSensor *sens = (bSensor *)ptr->data; BLI_strncpy_utf8(sens->name, value, sizeof(sens->name)); if (ptr->id.data) { Object *ob = (Object *)ptr->id.data; BLI_uniquename(&ob->sensors, sens, "Sensor", '.', offsetof(bSensor, name), sizeof(sens->name)); } }
void rna_Constroller_name_set(PointerRNA *ptr, const char *value) { bController *cont = (bController *)ptr->data; BLI_strncpy_utf8(cont->name, value, sizeof(cont->name)); if (ptr->id.data) { Object *ob = (Object *)ptr->id.data; BLI_uniquename(&ob->controllers, cont, "Controller", '.', offsetof(bController, name), sizeof(cont->name)); } }
static int controller_add_exec(bContext *C, wmOperator *op) { Object *ob; bController *cont; PointerRNA cont_ptr; PropertyRNA *prop; const char *cont_name; int bit; char name[MAX_NAME]; int type = RNA_enum_get(op->ptr, "type"); ob = edit_object_property_get(C, op); if (!ob) return OPERATOR_CANCELLED; cont = new_controller(type); BLI_addtail(&(ob->controllers), cont); /* set the controller name based on rna type enum */ RNA_pointer_create((ID *)ob, &RNA_Controller, cont, &cont_ptr); prop = RNA_struct_find_property(&cont_ptr, "type"); RNA_string_get(op->ptr, "name", name); if (*name) { BLI_strncpy(cont->name, name, sizeof(cont->name)); } else { RNA_property_enum_name(C, &cont_ptr, prop, RNA_property_enum_get(&cont_ptr, prop), &cont_name); BLI_strncpy(cont->name, cont_name, sizeof(cont->name)); } BLI_uniquename(&ob->controllers, cont, DATA_("Controller"), '.', offsetof(bController, name), sizeof(cont->name)); /* set the controller state mask from the current object state. * A controller is always in a single state, so select the lowest bit set * from the object state */ for (bit = 0; bit < OB_MAX_STATES; bit++) { if (ob->state & (1 << bit)) break; } cont->state_mask = (1 << bit); if (cont->state_mask == 0) { /* shouldn't happen, object state is never 0 */ cont->state_mask = 1; } ob->scaflag |= OB_SHOWCONT; WM_event_add_notifier(C, NC_LOGIC, NULL); return OPERATOR_FINISHED; }
static int poselib_add_exec (bContext *C, wmOperator *op) { Object *ob= get_poselib_object(C); bAction *act = poselib_validate(ob); bPose *pose= (ob) ? ob->pose : NULL; TimeMarker *marker; KeyingSet *ks= ANIM_builtin_keyingset_get_named(NULL, ANIM_KS_WHOLE_CHARACTER_ID); /* this includes custom props :)*/ int frame= RNA_int_get(op->ptr, "frame"); char name[64]; /* sanity check (invoke should have checked this anyway) */ if (ELEM(NULL, ob, pose)) return OPERATOR_CANCELLED; /* get name to give to pose */ RNA_string_get(op->ptr, "name", name); /* add pose to poselib - replaces any existing pose there * - for the 'replace' option, this should end up finding the appropriate marker, * so no new one will be added */ for (marker= act->markers.first; marker; marker= marker->next) { if (marker->frame == frame) { BLI_strncpy(marker->name, name, sizeof(marker->name)); break; } } if (marker == NULL) { marker= MEM_callocN(sizeof(TimeMarker), "ActionMarker"); BLI_strncpy(marker->name, name, sizeof(marker->name)); marker->frame= frame; BLI_addtail(&act->markers, marker); } /* validate name */ BLI_uniquename(&act->markers, marker, "Pose", '.', offsetof(TimeMarker, name), sizeof(marker->name)); /* use Keying Set to determine what to store for the pose */ // FIXME: in the past, the Keying Set respected selections (LocRotScale), but the current one doesn't (Whole Character) // so perhaps we need either a new Keying Set, or just to add overrides here... ANIM_apply_keyingset(C, NULL, act, ks, MODIFYKEY_MODE_INSERT, (float)frame); /* store new 'active' pose number */ act->active_marker= BLI_countlist(&act->markers); /* done */ return OPERATOR_FINISHED; }
/* Adds a new bone-group */ void pose_add_group (Object *ob) { bPose *pose= (ob) ? ob->pose : NULL; bActionGroup *grp; if (ELEM(NULL, ob, ob->pose)) return; grp= MEM_callocN(sizeof(bActionGroup), "PoseGroup"); BLI_strncpy(grp->name, "Group", sizeof(grp->name)); BLI_addtail(&pose->agroups, grp); BLI_uniquename(&pose->agroups, grp, "Group", '.', offsetof(bActionGroup, name), sizeof(grp->name)); pose->active_group= BLI_countlist(&pose->agroups); }
/* Adds a new bone-group (name may be NULL) */ bActionGroup *BKE_pose_add_group(bPose *pose, const char *name) { bActionGroup *grp; if (!name) { name = DATA_("Group"); } grp = MEM_callocN(sizeof(bActionGroup), "PoseGroup"); BLI_strncpy(grp->name, name, sizeof(grp->name)); BLI_addtail(&pose->agroups, grp); BLI_uniquename(&pose->agroups, grp, name, '.', offsetof(bActionGroup, name), sizeof(grp->name)); pose->active_group = BLI_listbase_count(&pose->agroups); return grp; }
/** * Add a new view layer * by default, a view layer has the master collection */ ViewLayer *BKE_view_layer_add(Scene *scene, const char *name) { ViewLayer *view_layer = view_layer_add(name); BLI_addtail(&scene->view_layers, view_layer); /* unique name */ BLI_uniquename(&scene->view_layers, view_layer, DATA_("ViewLayer"), '.', offsetof(ViewLayer, name), sizeof(view_layer->name)); BKE_layer_collection_sync(scene, view_layer); return view_layer; }
void BKE_view_layer_rename(Main *bmain, Scene *scene, ViewLayer *view_layer, const char *newname) { char oldname[sizeof(view_layer->name)]; BLI_strncpy(oldname, view_layer->name, sizeof(view_layer->name)); BLI_strncpy_utf8(view_layer->name, newname, sizeof(view_layer->name)); BLI_uniquename(&scene->view_layers, view_layer, DATA_("ViewLayer"), '.', offsetof(ViewLayer, name), sizeof(view_layer->name)); if (scene->nodetree) { bNode *node; int index = BLI_findindex(&scene->view_layers, view_layer); for (node = scene->nodetree->nodes.first; node; node = node->next) { if (node->type == CMP_NODE_R_LAYERS && node->id == NULL) { if (node->custom1 == index) { BLI_strncpy(node->name, view_layer->name, NODE_MAXSTR); } } } } /* Fix all the animation data and windows which may link to this. */ BKE_animdata_fix_paths_rename_all(NULL, "view_layers", oldname, view_layer->name); /* WM can be missing on startup. */ wmWindowManager *wm = bmain->wm.first; if (wm) { for (wmWindow *win = wm->windows.first; win; win = win->next) { if (win->scene == scene && STREQ(win->view_layer_name, oldname)) { STRNCPY(win->view_layer_name, view_layer->name); } } } /* Dependency graph uses view layer name based lookups. */ DEG_id_tag_update(&scene->id, 0); }
/* return default layer, also used to patch old files */ SceneRenderLayer *BKE_scene_add_render_layer(Scene *sce, const char *name) { SceneRenderLayer *srl; if (!name) name = "RenderLayer"; srl = MEM_callocN(sizeof(SceneRenderLayer), "new render layer"); BLI_strncpy(srl->name, name, sizeof(srl->name)); BLI_uniquename(&sce->r.layers, srl, "RenderLayer", '.', offsetof(SceneRenderLayer, name), sizeof(srl->name)); BLI_addtail(&sce->r.layers, srl); /* note, this is also in render, pipeline.c, to make layer when scenedata doesnt have it */ srl->lay = (1 << 20) - 1; srl->layflag = 0x7FFF; /* solid ztra halo edge strand */ srl->passflag = SCE_PASS_COMBINED | SCE_PASS_Z; return srl; }
void rna_ShapeKey_name_set(PointerRNA *ptr, const char *value) { KeyBlock *kb= ptr->data; char oldname[sizeof(kb->name)]; /* make a copy of the old name first */ BLI_strncpy(oldname, kb->name, sizeof(kb->name)); /* copy the new name into the name slot */ BLI_strncpy_utf8(kb->name, value, sizeof(kb->name)); /* make sure the name is truly unique */ if (ptr->id.data) { Key *key= rna_ShapeKey_find_key(ptr->id.data); BLI_uniquename(&key->block, kb, "Key", '.', offsetof(KeyBlock, name), sizeof(kb->name)); } /* fix all the animation data which may link to this */ BKE_all_animdata_fix_paths_rename("key_blocks", oldname, kb->name); }
/* Add a new action group with the given name to the action */ bActionGroup *action_groups_add_new(bAction *act, const char name[]) { bActionGroup *agrp; /* sanity check: must have action and name */ if (ELEM(NULL, act, name)) return NULL; /* allocate a new one */ agrp = MEM_callocN(sizeof(bActionGroup), "bActionGroup"); /* make it selected, with default name */ agrp->flag = AGRP_SELECTED; BLI_strncpy(agrp->name, name[0] ? name : DATA_("Group"), sizeof(agrp->name)); /* add to action, and validate */ BLI_addtail(&act->groups, agrp); BLI_uniquename(&act->groups, agrp, DATA_("Group"), '.', offsetof(bActionGroup, name), sizeof(agrp->name)); /* return the new group */ return agrp; }
static int actuator_add_exec(bContext *C, wmOperator *op) { Object *ob; bActuator *act; PointerRNA act_ptr; PropertyRNA *prop; const char *act_name; char name[MAX_NAME]; int type = RNA_enum_get(op->ptr, "type"); ob = edit_object_property_get(C, op); if (!ob) return OPERATOR_CANCELLED; act = new_actuator(type); BLI_addtail(&(ob->actuators), act); /* set the actuator name based on rna type enum */ RNA_pointer_create((ID *)ob, &RNA_Actuator, act, &act_ptr); prop = RNA_struct_find_property(&act_ptr, "type"); RNA_string_get(op->ptr, "name", name); if (*name) { BLI_strncpy(act->name, name, sizeof(act->name)); } else { RNA_property_enum_name(C, &act_ptr, prop, RNA_property_enum_get(&act_ptr, prop), &act_name); BLI_strncpy(act->name, act_name, sizeof(act->name)); } BLI_uniquename(&ob->actuators, act, DATA_("Actuator"), '.', offsetof(bActuator, name), sizeof(act->name)); ob->scaflag |= OB_SHOWACT; WM_event_add_notifier(C, NC_LOGIC, NULL); return OPERATOR_FINISHED; }
void BKE_sequence_modifier_unique_name(Sequence *seq, SequenceModifierData *smd) { SequenceModifierTypeInfo *smti = BKE_sequence_modifier_type_info_get(smd->type); BLI_uniquename(&seq->modifiers, smd, smti->name, '.', offsetof(SequenceModifierData, name), sizeof(smd->name)); }
static void add_to_modifier_list(ListBase *lb, LineStyleModifier *m) { BLI_addtail(lb, (void *)m); BLI_uniquename(lb, m, modifier_name[m->type], '.', offsetof(LineStyleModifier, name), sizeof(m->name)); }
void tracks_map_merge(TracksMap *map, MovieTracking *tracking) { MovieTrackingTrack *track; ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL}; ListBase *old_tracks; int a; if (map->is_camera) { old_tracks = &tracking->tracks; } else { MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name); if (!object) { /* object was deleted by user, create new one */ object = BKE_tracking_object_add(tracking, map->object_name); } old_tracks = &object->tracks; } /* duplicate currently operating tracks to temporary list. * this is needed to keep names in unique state and it's faster to change names * of currently operating tracks (if needed) */ for (a = 0; a < map->num_tracks; a++) { MovieTrackingTrack *old_track; bool mapped_to_old = false; track = &map->tracks[a]; /* find original of operating track in list of previously displayed tracks */ old_track = BLI_ghash_lookup(map->hash, track); if (old_track) { if (BLI_findindex(old_tracks, old_track) != -1) { BLI_remlink(old_tracks, old_track); BLI_spin_lock(&map->spin_lock); /* Copy flags like selection back to the track map. */ track->flag = old_track->flag; track->pat_flag = old_track->pat_flag; track->search_flag = old_track->search_flag; /* Copy all the rest settings back from the map to the actual tracks. */ MEM_freeN(old_track->markers); *old_track = *track; old_track->markers = MEM_dupallocN(old_track->markers); BLI_spin_unlock(&map->spin_lock); BLI_addtail(&tracks, old_track); mapped_to_old = true; } } if (mapped_to_old == false) { MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track); /* Update old-new track mapping */ BLI_ghash_reinsert(map->hash, track, new_track, NULL, NULL); BLI_addtail(&tracks, new_track); } } /* move all tracks, which aren't operating */ track = old_tracks->first; while (track) { MovieTrackingTrack *next = track->next; BLI_addtail(&new_tracks, track); track = next; } /* now move all tracks which are currently operating and keep their names unique */ track = tracks.first; while (track) { MovieTrackingTrack *next = track->next; BLI_remlink(&tracks, track); track->next = track->prev = NULL; BLI_addtail(&new_tracks, track); BLI_uniquename(&new_tracks, track, CTX_DATA_(BLF_I18NCONTEXT_ID_MOVIECLIP, "Track"), '.', offsetof(MovieTrackingTrack, name), sizeof(track->name)); track = next; } *old_tracks = new_tracks; }