Revert "Fix T67040: Undo crashes after renaming"
[blender.git] / source / blender / editors / armature / armature_naming.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  * Operators and API's for renaming bones both in and out of Edit Mode
19  */
20
21 /** \file
22  * \ingroup edarmature
23  */
24
25 #include <string.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_armature_types.h"
30 #include "DNA_constraint_types.h"
31 #include "DNA_object_types.h"
32 #include "DNA_gpencil_types.h"
33 #include "DNA_gpencil_modifier_types.h"
34
35 #include "BLI_blenlib.h"
36 #include "BLI_ghash.h"
37 #include "BLI_string_utils.h"
38 #include "BLI_utildefines.h"
39
40 #include "BLT_translation.h"
41
42 #include "BKE_animsys.h"
43 #include "BKE_action.h"
44 #include "BKE_armature.h"
45 #include "BKE_constraint.h"
46 #include "BKE_context.h"
47 #include "BKE_deform.h"
48 #include "BKE_layer.h"
49 #include "BKE_main.h"
50 #include "BKE_modifier.h"
51 #include "BKE_gpencil_modifier.h"
52
53 #include "DEG_depsgraph.h"
54
55 #include "RNA_access.h"
56 #include "RNA_define.h"
57
58 #include "WM_api.h"
59 #include "WM_types.h"
60
61 #include "ED_armature.h"
62 #include "ED_screen.h"
63
64 #include "armature_intern.h"
65
66 /* This file contains functions/API's for renaming bones and/or working with them */
67
68 /* ************************************************** */
69 /* EditBone Names */
70
71 /* note: there's a unique_bone_name() too! */
72 static bool editbone_unique_check(void *arg, const char *name)
73 {
74   struct {
75     ListBase *lb;
76     void *bone;
77   } *data = arg;
78   EditBone *dupli = ED_armature_ebone_find_name(data->lb, name);
79   return dupli && dupli != data->bone;
80 }
81
82 void ED_armature_ebone_unique_name(ListBase *edbo, char *name, EditBone *bone)
83 {
84   struct {
85     ListBase *lb;
86     void *bone;
87   } data;
88   data.lb = edbo;
89   data.bone = bone;
90
91   BLI_uniquename_cb(editbone_unique_check, &data, DATA_("Bone"), '.', name, sizeof(bone->name));
92 }
93
94 /* ************************************************** */
95 /* Bone Renaming - API */
96
97 static bool bone_unique_check(void *arg, const char *name)
98 {
99   return BKE_armature_find_bone_name((bArmature *)arg, name) != NULL;
100 }
101
102 static void unique_bone_name(bArmature *arm, char *name)
103 {
104   BLI_uniquename_cb(
105       bone_unique_check, (void *)arm, DATA_("Bone"), '.', name, sizeof(((Bone *)NULL)->name));
106 }
107
108 /* helper call for armature_bone_rename */
109 static void constraint_bone_name_fix(Object *ob,
110                                      ListBase *conlist,
111                                      const char *oldname,
112                                      const char *newname)
113 {
114   bConstraint *curcon;
115   bConstraintTarget *ct;
116
117   for (curcon = conlist->first; curcon; curcon = curcon->next) {
118     const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(curcon);
119     ListBase targets = {NULL, NULL};
120
121     /* constraint targets */
122     if (cti && cti->get_constraint_targets) {
123       cti->get_constraint_targets(curcon, &targets);
124
125       for (ct = targets.first; ct; ct = ct->next) {
126         if (ct->tar == ob) {
127           if (STREQ(ct->subtarget, oldname)) {
128             BLI_strncpy(ct->subtarget, newname, MAXBONENAME);
129           }
130         }
131       }
132
133       if (cti->flush_constraint_targets) {
134         cti->flush_constraint_targets(curcon, &targets, 0);
135       }
136     }
137
138     /* action constraints */
139     if (curcon->type == CONSTRAINT_TYPE_ACTION) {
140       bActionConstraint *actcon = (bActionConstraint *)curcon->data;
141       BKE_action_fix_paths_rename(&ob->id, actcon->act, "pose.bones", oldname, newname, 0, 0, 1);
142     }
143   }
144 }
145
146 /* called by UI for renaming a bone */
147 /* warning: make sure the original bone was not renamed yet! */
148 /* seems messy, but that's what you get with not using pointers but channel names :) */
149 void ED_armature_bone_rename(Main *bmain,
150                              bArmature *arm,
151                              const char *oldnamep,
152                              const char *newnamep)
153 {
154   Object *ob;
155   char newname[MAXBONENAME];
156   char oldname[MAXBONENAME];
157
158   /* names better differ! */
159   if (!STREQLEN(oldnamep, newnamep, MAXBONENAME)) {
160
161     /* we alter newname string... so make copy */
162     BLI_strncpy(newname, newnamep, MAXBONENAME);
163     /* we use oldname for search... so make copy */
164     BLI_strncpy(oldname, oldnamep, MAXBONENAME);
165
166     /* now check if we're in editmode, we need to find the unique name */
167     if (arm->edbo) {
168       EditBone *eBone = ED_armature_ebone_find_name(arm->edbo, oldname);
169
170       if (eBone) {
171         ED_armature_ebone_unique_name(arm->edbo, newname, NULL);
172         BLI_strncpy(eBone->name, newname, MAXBONENAME);
173       }
174       else {
175         return;
176       }
177     }
178     else {
179       Bone *bone = BKE_armature_find_bone_name(arm, oldname);
180
181       if (bone) {
182         unique_bone_name(arm, newname);
183
184         if (arm->bonehash) {
185           BLI_assert(BLI_ghash_haskey(arm->bonehash, bone->name));
186           BLI_ghash_remove(arm->bonehash, bone->name, NULL, NULL);
187         }
188
189         BLI_strncpy(bone->name, newname, MAXBONENAME);
190
191         if (arm->bonehash) {
192           BLI_ghash_insert(arm->bonehash, bone->name, bone);
193         }
194       }
195       else {
196         return;
197       }
198     }
199
200     /* force copy on write to update database */
201     DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
202
203     /* do entire dbase - objects */
204     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
205       ModifierData *md;
206
207       /* we have the object using the armature */
208       if (arm == ob->data) {
209         Object *cob;
210
211         /* Rename the pose channel, if it exists */
212         if (ob->pose) {
213           bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, oldname);
214           if (pchan) {
215             GHash *gh = ob->pose->chanhash;
216
217             /* remove the old hash entry, and replace with the new name */
218             if (gh) {
219               BLI_assert(BLI_ghash_haskey(gh, pchan->name));
220               BLI_ghash_remove(gh, pchan->name, NULL, NULL);
221             }
222
223             BLI_strncpy(pchan->name, newname, MAXBONENAME);
224
225             if (gh) {
226               BLI_ghash_insert(gh, pchan->name, pchan);
227             }
228           }
229
230           BLI_assert(BKE_pose_channels_is_valid(ob->pose) == true);
231         }
232
233         /* Update any object constraints to use the new bone name */
234         for (cob = bmain->objects.first; cob; cob = cob->id.next) {
235           if (cob->constraints.first) {
236             constraint_bone_name_fix(ob, &cob->constraints, oldname, newname);
237           }
238           if (cob->pose) {
239             bPoseChannel *pchan;
240             for (pchan = cob->pose->chanbase.first; pchan; pchan = pchan->next) {
241               constraint_bone_name_fix(ob, &pchan->constraints, oldname, newname);
242             }
243           }
244         }
245       }
246
247       /* See if an object is parented to this armature */
248       if (ob->parent && (ob->parent->data == arm)) {
249         if (ob->partype == PARBONE) {
250           /* bone name in object */
251           if (STREQ(ob->parsubstr, oldname)) {
252             BLI_strncpy(ob->parsubstr, newname, MAXBONENAME);
253           }
254         }
255       }
256
257       if (modifiers_usesArmature(ob, arm)) {
258         bDeformGroup *dg = defgroup_find_name(ob, oldname);
259         if (dg) {
260           BLI_strncpy(dg->name, newname, MAXBONENAME);
261         }
262       }
263
264       /* fix modifiers that might be using this name */
265       for (md = ob->modifiers.first; md; md = md->next) {
266         switch (md->type) {
267           case eModifierType_Hook: {
268             HookModifierData *hmd = (HookModifierData *)md;
269
270             if (hmd->object && (hmd->object->data == arm)) {
271               if (STREQ(hmd->subtarget, oldname)) {
272                 BLI_strncpy(hmd->subtarget, newname, MAXBONENAME);
273               }
274             }
275             break;
276           }
277           case eModifierType_UVWarp: {
278             UVWarpModifierData *umd = (UVWarpModifierData *)md;
279
280             if (umd->object_src && (umd->object_src->data == arm)) {
281               if (STREQ(umd->bone_src, oldname)) {
282                 BLI_strncpy(umd->bone_src, newname, MAXBONENAME);
283               }
284             }
285             if (umd->object_dst && (umd->object_dst->data == arm)) {
286               if (STREQ(umd->bone_dst, oldname)) {
287                 BLI_strncpy(umd->bone_dst, newname, MAXBONENAME);
288               }
289             }
290             break;
291           }
292           default:
293             break;
294         }
295       }
296
297       /* fix grease pencil modifiers and vertex groups */
298       if (ob->type == OB_GPENCIL) {
299
300         bGPdata *gpd = (bGPdata *)ob->data;
301         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
302           if ((gpl->parent != NULL) && (gpl->parent->data == arm)) {
303             if (STREQ(gpl->parsubstr, oldname)) {
304               BLI_strncpy(gpl->parsubstr, newname, MAXBONENAME);
305             }
306           }
307         }
308
309         for (GpencilModifierData *gp_md = ob->greasepencil_modifiers.first; gp_md;
310              gp_md = gp_md->next) {
311           switch (gp_md->type) {
312             case eGpencilModifierType_Armature: {
313               ArmatureGpencilModifierData *mmd = (ArmatureGpencilModifierData *)gp_md;
314               if (mmd->object && mmd->object->data == arm) {
315                 bDeformGroup *dg = defgroup_find_name(ob, oldname);
316                 if (dg) {
317                   BLI_strncpy(dg->name, newname, MAXBONENAME);
318                 }
319               }
320               break;
321             }
322             case eGpencilModifierType_Hook: {
323               HookGpencilModifierData *hgp_md = (HookGpencilModifierData *)gp_md;
324               if (hgp_md->object && (hgp_md->object->data == arm)) {
325                 if (STREQ(hgp_md->subtarget, oldname)) {
326                   BLI_strncpy(hgp_md->subtarget, newname, MAXBONENAME);
327                 }
328               }
329               break;
330             }
331             default:
332               break;
333           }
334         }
335       }
336       DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
337     }
338
339     /* Fix all animdata that may refer to this bone -
340      * we can't just do the ones attached to objects,
341      * since other ID-blocks may have drivers referring to this bone T29822. */
342
343     /* XXX: the ID here is for armatures,
344      * but most bone drivers are actually on the object instead. */
345     {
346
347       BKE_animdata_fix_paths_rename_all(&arm->id, "pose.bones", oldname, newname);
348     }
349
350     /* correct view locking */
351     {
352       bScreen *screen;
353       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
354         ScrArea *sa;
355         /* add regions */
356         for (sa = screen->areabase.first; sa; sa = sa->next) {
357           SpaceLink *sl;
358           for (sl = sa->spacedata.first; sl; sl = sl->next) {
359             if (sl->spacetype == SPACE_VIEW3D) {
360               View3D *v3d = (View3D *)sl;
361               if (v3d->ob_centre && v3d->ob_centre->data == arm) {
362                 if (STREQ(v3d->ob_centre_bone, oldname)) {
363                   BLI_strncpy(v3d->ob_centre_bone, newname, MAXBONENAME);
364                 }
365               }
366             }
367           }
368         }
369       }
370     }
371   }
372 }
373
374 typedef struct BoneFlipNameData {
375   struct BoneFlipNameData *next, *prev;
376   char *name;
377   char name_flip[MAXBONENAME];
378 } BoneFlipNameData;
379
380 /**
381  * Renames (by flipping) all selected bones at once.
382  *
383  * This way if we are flipping related bones (e.g., Bone.L, Bone.R) at the same time
384  * all the bones are safely renamed, without conflicting with each other.
385  *
386  * \param arm: Armature the bones belong to
387  * \param bones_names: List of BoneConflict elems.
388  * \param do_strip_numbers: if set, try to get rid of dot-numbers at end of bone names.
389  */
390 void ED_armature_bones_flip_names(Main *bmain,
391                                   bArmature *arm,
392                                   ListBase *bones_names,
393                                   const bool do_strip_numbers)
394 {
395   ListBase bones_names_conflicts = {NULL};
396   BoneFlipNameData *bfn;
397
398   /* First pass: generate flip names, and blindly rename.
399    * If rename did not yield expected result,
400    * store both bone's name and expected flipped one into temp list for second pass. */
401   for (LinkData *link = bones_names->first; link; link = link->next) {
402     char name_flip[MAXBONENAME];
403     char *name = link->data;
404
405     /* WARNING: if do_strip_numbers is set, expect completely mismatched names in cases like
406      * Bone.R, Bone.R.001, Bone.R.002, etc. */
407     BLI_string_flip_side_name(name_flip, name, do_strip_numbers, sizeof(name_flip));
408
409     ED_armature_bone_rename(bmain, arm, name, name_flip);
410
411     if (!STREQ(name, name_flip)) {
412       bfn = alloca(sizeof(BoneFlipNameData));
413       bfn->name = name;
414       BLI_strncpy(bfn->name_flip, name_flip, sizeof(bfn->name_flip));
415       BLI_addtail(&bones_names_conflicts, bfn);
416     }
417   }
418
419   /* Second pass to handle the bones that have naming conflicts with other bones.
420    * Note that if the other bone was not selected, its name was not flipped,
421    * so conflict remains and that second rename simply generates a new numbered alternative name.
422    */
423   for (bfn = bones_names_conflicts.first; bfn; bfn = bfn->next) {
424     ED_armature_bone_rename(bmain, arm, bfn->name, bfn->name_flip);
425   }
426 }
427
428 /* ************************************************** */
429 /* Bone Renaming - EditMode */
430
431 static int armature_flip_names_exec(bContext *C, wmOperator *op)
432 {
433   Main *bmain = CTX_data_main(C);
434   ViewLayer *view_layer = CTX_data_view_layer(C);
435   Object *ob_active = CTX_data_edit_object(C);
436
437   const bool do_strip_numbers = RNA_boolean_get(op->ptr, "do_strip_numbers");
438
439   uint objects_len = 0;
440   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
441       view_layer, CTX_wm_view3d(C), &objects_len);
442   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
443     Object *ob = objects[ob_index];
444     bArmature *arm = ob->data;
445
446     /* Paranoia check. */
447     if (ob_active->pose == NULL) {
448       continue;
449     }
450
451     ListBase bones_names = {NULL};
452
453     for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
454       if (EBONE_VISIBLE(arm, ebone)) {
455         if (ebone->flag & BONE_SELECTED) {
456           BLI_addtail(&bones_names, BLI_genericNodeN(ebone->name));
457
458           if (arm->flag & ARM_MIRROR_EDIT) {
459             EditBone *flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
460             if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
461               BLI_addtail(&bones_names, BLI_genericNodeN(flipbone->name));
462             }
463           }
464         }
465       }
466     }
467
468     if (BLI_listbase_is_empty(&bones_names)) {
469       continue;
470     }
471
472     ED_armature_bones_flip_names(bmain, arm, &bones_names, do_strip_numbers);
473
474     BLI_freelistN(&bones_names);
475
476     /* since we renamed stuff... */
477     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
478
479     /* copied from #rna_Bone_update_renamed */
480     /* redraw view */
481     WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
482
483     /* update animation channels */
484     WM_event_add_notifier(C, NC_ANIMATION | ND_ANIMCHAN, ob->data);
485   }
486   MEM_freeN(objects);
487
488   return OPERATOR_FINISHED;
489 }
490
491 void ARMATURE_OT_flip_names(wmOperatorType *ot)
492 {
493   /* identifiers */
494   ot->name = "Flip Names";
495   ot->idname = "ARMATURE_OT_flip_names";
496   ot->description = "Flips (and corrects) the axis suffixes of the names of selected bones";
497
498   /* api callbacks */
499   ot->exec = armature_flip_names_exec;
500   ot->poll = ED_operator_editarmature;
501
502   /* flags */
503   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
504
505   RNA_def_boolean(ot->srna,
506                   "do_strip_numbers",
507                   false,
508                   "Strip Numbers",
509                   "Try to remove right-most dot-number from flipped names "
510                   "(WARNING: may result in incoherent naming in some cases)");
511 }
512
513 static int armature_autoside_names_exec(bContext *C, wmOperator *op)
514 {
515   ViewLayer *view_layer = CTX_data_view_layer(C);
516   Main *bmain = CTX_data_main(C);
517   char newname[MAXBONENAME];
518   const short axis = RNA_enum_get(op->ptr, "type");
519   bool changed_multi = false;
520
521   uint objects_len = 0;
522   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
523       view_layer, CTX_wm_view3d(C), &objects_len);
524   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
525     Object *ob = objects[ob_index];
526     bArmature *arm = ob->data;
527     bool changed = false;
528
529     /* Paranoia checks. */
530     if (ELEM(NULL, ob, ob->pose)) {
531       continue;
532     }
533
534     for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
535       if (EBONE_EDITABLE(ebone)) {
536
537         /* We first need to do the flipped bone, then the original one.
538          * Otherwise we can't find the flipped one because of the bone name change. */
539         if (arm->flag & ARM_MIRROR_EDIT) {
540           EditBone *flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
541           if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
542             BLI_strncpy(newname, flipbone->name, sizeof(newname));
543             if (bone_autoside_name(newname, 1, axis, flipbone->head[axis], flipbone->tail[axis])) {
544               ED_armature_bone_rename(bmain, arm, flipbone->name, newname);
545               changed = true;
546             }
547           }
548         }
549
550         BLI_strncpy(newname, ebone->name, sizeof(newname));
551         if (bone_autoside_name(newname, 1, axis, ebone->head[axis], ebone->tail[axis])) {
552           ED_armature_bone_rename(bmain, arm, ebone->name, newname);
553           changed = true;
554         }
555       }
556     }
557
558     if (!changed) {
559       continue;
560     }
561
562     changed_multi = true;
563
564     /* Since we renamed stuff... */
565     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
566
567     /* Note, notifier might evolve. */
568     WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
569   }
570   MEM_freeN(objects);
571   return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
572 }
573
574 void ARMATURE_OT_autoside_names(wmOperatorType *ot)
575 {
576   static const EnumPropertyItem axis_items[] = {
577       {0, "XAXIS", 0, "X-Axis", "Left/Right"},
578       {1, "YAXIS", 0, "Y-Axis", "Front/Back"},
579       {2, "ZAXIS", 0, "Z-Axis", "Top/Bottom"},
580       {0, NULL, 0, NULL, NULL},
581   };
582
583   /* identifiers */
584   ot->name = "AutoName by Axis";
585   ot->idname = "ARMATURE_OT_autoside_names";
586   ot->description =
587       "Automatically renames the selected bones according to which side of the target axis they "
588       "fall on";
589
590   /* api callbacks */
591   ot->invoke = WM_menu_invoke;
592   ot->exec = armature_autoside_names_exec;
593   ot->poll = ED_operator_editarmature;
594
595   /* flags */
596   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
597
598   /* settings */
599   ot->prop = RNA_def_enum(ot->srna, "type", axis_items, 0, "Axis", "Axis tag names with");
600 }