Cleanup: style, use braces for editors
[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         BLI_strncpy(bone->name, newname, MAXBONENAME);
184       }
185       else {
186         return;
187       }
188     }
189
190     /* force copy on write to update database */
191     DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
192
193     /* do entire dbase - objects */
194     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
195       ModifierData *md;
196
197       /* we have the object using the armature */
198       if (arm == ob->data) {
199         Object *cob;
200
201         /* Rename the pose channel, if it exists */
202         if (ob->pose) {
203           bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, oldname);
204           if (pchan) {
205             GHash *gh = ob->pose->chanhash;
206
207             /* remove the old hash entry, and replace with the new name */
208             if (gh) {
209               BLI_assert(BLI_ghash_haskey(gh, pchan->name));
210               BLI_ghash_remove(gh, pchan->name, NULL, NULL);
211             }
212
213             BLI_strncpy(pchan->name, newname, MAXBONENAME);
214
215             if (gh) {
216               BLI_ghash_insert(gh, pchan->name, pchan);
217             }
218           }
219
220           BLI_assert(BKE_pose_channels_is_valid(ob->pose) == true);
221         }
222
223         /* Update any object constraints to use the new bone name */
224         for (cob = bmain->objects.first; cob; cob = cob->id.next) {
225           if (cob->constraints.first) {
226             constraint_bone_name_fix(ob, &cob->constraints, oldname, newname);
227           }
228           if (cob->pose) {
229             bPoseChannel *pchan;
230             for (pchan = cob->pose->chanbase.first; pchan; pchan = pchan->next) {
231               constraint_bone_name_fix(ob, &pchan->constraints, oldname, newname);
232             }
233           }
234         }
235       }
236
237       /* See if an object is parented to this armature */
238       if (ob->parent && (ob->parent->data == arm)) {
239         if (ob->partype == PARBONE) {
240           /* bone name in object */
241           if (STREQ(ob->parsubstr, oldname)) {
242             BLI_strncpy(ob->parsubstr, newname, MAXBONENAME);
243           }
244         }
245       }
246
247       if (modifiers_usesArmature(ob, arm)) {
248         bDeformGroup *dg = defgroup_find_name(ob, oldname);
249         if (dg) {
250           BLI_strncpy(dg->name, newname, MAXBONENAME);
251         }
252       }
253
254       /* fix modifiers that might be using this name */
255       for (md = ob->modifiers.first; md; md = md->next) {
256         switch (md->type) {
257           case eModifierType_Hook: {
258             HookModifierData *hmd = (HookModifierData *)md;
259
260             if (hmd->object && (hmd->object->data == arm)) {
261               if (STREQ(hmd->subtarget, oldname)) {
262                 BLI_strncpy(hmd->subtarget, newname, MAXBONENAME);
263               }
264             }
265             break;
266           }
267           case eModifierType_UVWarp: {
268             UVWarpModifierData *umd = (UVWarpModifierData *)md;
269
270             if (umd->object_src && (umd->object_src->data == arm)) {
271               if (STREQ(umd->bone_src, oldname)) {
272                 BLI_strncpy(umd->bone_src, newname, MAXBONENAME);
273               }
274             }
275             if (umd->object_dst && (umd->object_dst->data == arm)) {
276               if (STREQ(umd->bone_dst, oldname)) {
277                 BLI_strncpy(umd->bone_dst, newname, MAXBONENAME);
278               }
279             }
280             break;
281           }
282           default:
283             break;
284         }
285       }
286
287       /* fix grease pencil modifiers and vertex groups */
288       if (ob->type == OB_GPENCIL) {
289
290         bGPdata *gpd = (bGPdata *)ob->data;
291         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
292           if ((gpl->parent != NULL) && (gpl->parent->data == arm)) {
293             if (STREQ(gpl->parsubstr, oldname)) {
294               BLI_strncpy(gpl->parsubstr, newname, MAXBONENAME);
295             }
296           }
297         }
298
299         for (GpencilModifierData *gp_md = ob->greasepencil_modifiers.first; gp_md;
300              gp_md = gp_md->next) {
301           switch (gp_md->type) {
302             case eGpencilModifierType_Armature: {
303               ArmatureGpencilModifierData *mmd = (ArmatureGpencilModifierData *)gp_md;
304               if (mmd->object && mmd->object->data == arm) {
305                 bDeformGroup *dg = defgroup_find_name(ob, oldname);
306                 if (dg) {
307                   BLI_strncpy(dg->name, newname, MAXBONENAME);
308                 }
309               }
310               break;
311             }
312             case eGpencilModifierType_Hook: {
313               HookGpencilModifierData *hgp_md = (HookGpencilModifierData *)gp_md;
314               if (hgp_md->object && (hgp_md->object->data == arm)) {
315                 if (STREQ(hgp_md->subtarget, oldname)) {
316                   BLI_strncpy(hgp_md->subtarget, newname, MAXBONENAME);
317                 }
318               }
319               break;
320             }
321             default:
322               break;
323           }
324         }
325       }
326       DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
327     }
328
329     /* Fix all animdata that may refer to this bone -
330      * we can't just do the ones attached to objects,
331      * since other ID-blocks may have drivers referring to this bone T29822.
332      */
333     // XXX: the ID here is for armatures, but most bone drivers are actually on the object instead...
334     {
335
336       BKE_animdata_fix_paths_rename_all(&arm->id, "pose.bones", oldname, newname);
337     }
338
339     /* correct view locking */
340     {
341       bScreen *screen;
342       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
343         ScrArea *sa;
344         /* add regions */
345         for (sa = screen->areabase.first; sa; sa = sa->next) {
346           SpaceLink *sl;
347           for (sl = sa->spacedata.first; sl; sl = sl->next) {
348             if (sl->spacetype == SPACE_VIEW3D) {
349               View3D *v3d = (View3D *)sl;
350               if (v3d->ob_centre && v3d->ob_centre->data == arm) {
351                 if (STREQ(v3d->ob_centre_bone, oldname)) {
352                   BLI_strncpy(v3d->ob_centre_bone, newname, MAXBONENAME);
353                 }
354               }
355             }
356           }
357         }
358       }
359     }
360   }
361 }
362
363 typedef struct BoneFlipNameData {
364   struct BoneFlipNameData *next, *prev;
365   char *name;
366   char name_flip[MAXBONENAME];
367 } BoneFlipNameData;
368
369 /**
370  * Renames (by flipping) all selected bones at once.
371  *
372  * This way if we are flipping related bones (e.g., Bone.L, Bone.R) at the same time
373  * all the bones are safely renamed, without conflicting with each other.
374  *
375  * \param arm: Armature the bones belong to
376  * \param bones_names: List of BoneConflict elems.
377  * \param do_strip_numbers: if set, try to get rid of dot-numbers at end of bone names.
378  */
379 void ED_armature_bones_flip_names(Main *bmain,
380                                   bArmature *arm,
381                                   ListBase *bones_names,
382                                   const bool do_strip_numbers)
383 {
384   ListBase bones_names_conflicts = {NULL};
385   BoneFlipNameData *bfn;
386
387   /* First pass: generate flip names, and blindly rename.
388    * If rename did not yield expected result,
389    * store both bone's name and expected flipped one into temp list for second pass. */
390   for (LinkData *link = bones_names->first; link; link = link->next) {
391     char name_flip[MAXBONENAME];
392     char *name = link->data;
393
394     /* WARNING: if do_strip_numbers is set, expect completely mismatched names in cases like
395      * Bone.R, Bone.R.001, Bone.R.002, etc. */
396     BLI_string_flip_side_name(name_flip, name, do_strip_numbers, sizeof(name_flip));
397
398     ED_armature_bone_rename(bmain, arm, name, name_flip);
399
400     if (!STREQ(name, name_flip)) {
401       bfn = alloca(sizeof(BoneFlipNameData));
402       bfn->name = name;
403       BLI_strncpy(bfn->name_flip, name_flip, sizeof(bfn->name_flip));
404       BLI_addtail(&bones_names_conflicts, bfn);
405     }
406   }
407
408   /* Second pass to handle the bones that have naming conflicts with other bones.
409    * Note that if the other bone was not selected, its name was not flipped,
410    * so conflict remains and that second rename simply generates a new numbered alternative name.
411    */
412   for (bfn = bones_names_conflicts.first; bfn; bfn = bfn->next) {
413     ED_armature_bone_rename(bmain, arm, bfn->name, bfn->name_flip);
414   }
415 }
416
417 /* ************************************************** */
418 /* Bone Renaming - EditMode */
419
420 static int armature_flip_names_exec(bContext *C, wmOperator *op)
421 {
422   Main *bmain = CTX_data_main(C);
423   ViewLayer *view_layer = CTX_data_view_layer(C);
424   Object *ob_active = CTX_data_edit_object(C);
425
426   const bool do_strip_numbers = RNA_boolean_get(op->ptr, "do_strip_numbers");
427
428   uint objects_len = 0;
429   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
430       view_layer, CTX_wm_view3d(C), &objects_len);
431   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
432     Object *ob = objects[ob_index];
433     bArmature *arm = ob->data;
434
435     /* Paranoia check. */
436     if (ob_active->pose == NULL) {
437       continue;
438     }
439
440     ListBase bones_names = {NULL};
441
442     for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
443       if (EBONE_VISIBLE(arm, ebone)) {
444         if (ebone->flag & BONE_SELECTED) {
445           BLI_addtail(&bones_names, BLI_genericNodeN(ebone->name));
446
447           if (arm->flag & ARM_MIRROR_EDIT) {
448             EditBone *flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
449             if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
450               BLI_addtail(&bones_names, BLI_genericNodeN(flipbone->name));
451             }
452           }
453         }
454       }
455     }
456
457     if (BLI_listbase_is_empty(&bones_names)) {
458       continue;
459     }
460
461     ED_armature_bones_flip_names(bmain, arm, &bones_names, do_strip_numbers);
462
463     BLI_freelistN(&bones_names);
464
465     /* since we renamed stuff... */
466     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
467
468     /* copied from #rna_Bone_update_renamed */
469     /* redraw view */
470     WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
471
472     /* update animation channels */
473     WM_event_add_notifier(C, NC_ANIMATION | ND_ANIMCHAN, ob->data);
474   }
475   MEM_freeN(objects);
476
477   return OPERATOR_FINISHED;
478 }
479
480 void ARMATURE_OT_flip_names(wmOperatorType *ot)
481 {
482   /* identifiers */
483   ot->name = "Flip Names";
484   ot->idname = "ARMATURE_OT_flip_names";
485   ot->description = "Flips (and corrects) the axis suffixes of the names of selected bones";
486
487   /* api callbacks */
488   ot->exec = armature_flip_names_exec;
489   ot->poll = ED_operator_editarmature;
490
491   /* flags */
492   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
493
494   RNA_def_boolean(ot->srna,
495                   "do_strip_numbers",
496                   false,
497                   "Strip Numbers",
498                   "Try to remove right-most dot-number from flipped names "
499                   "(WARNING: may result in incoherent naming in some cases)");
500 }
501
502 static int armature_autoside_names_exec(bContext *C, wmOperator *op)
503 {
504   ViewLayer *view_layer = CTX_data_view_layer(C);
505   Main *bmain = CTX_data_main(C);
506   char newname[MAXBONENAME];
507   const short axis = RNA_enum_get(op->ptr, "type");
508   bool changed_multi = false;
509
510   uint objects_len = 0;
511   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
512       view_layer, CTX_wm_view3d(C), &objects_len);
513   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
514     Object *ob = objects[ob_index];
515     bArmature *arm = ob->data;
516     bool changed = false;
517
518     /* Paranoia checks. */
519     if (ELEM(NULL, ob, ob->pose)) {
520       continue;
521     }
522
523     for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
524       if (EBONE_EDITABLE(ebone)) {
525
526         /* We first need to do the flipped bone, then the original one.
527          * Otherwise we can't find the flipped one because of the bone name change. */
528         if (arm->flag & ARM_MIRROR_EDIT) {
529           EditBone *flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
530           if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
531             BLI_strncpy(newname, flipbone->name, sizeof(newname));
532             if (bone_autoside_name(newname, 1, axis, flipbone->head[axis], flipbone->tail[axis])) {
533               ED_armature_bone_rename(bmain, arm, flipbone->name, newname);
534               changed = true;
535             }
536           }
537         }
538
539         BLI_strncpy(newname, ebone->name, sizeof(newname));
540         if (bone_autoside_name(newname, 1, axis, ebone->head[axis], ebone->tail[axis])) {
541           ED_armature_bone_rename(bmain, arm, ebone->name, newname);
542           changed = true;
543         }
544       }
545     }
546
547     if (!changed) {
548       continue;
549     }
550
551     changed_multi = true;
552
553     /* Since we renamed stuff... */
554     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
555
556     /* Note, notifier might evolve. */
557     WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
558   }
559   MEM_freeN(objects);
560   return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
561 }
562
563 void ARMATURE_OT_autoside_names(wmOperatorType *ot)
564 {
565   static const EnumPropertyItem axis_items[] = {
566       {0, "XAXIS", 0, "X-Axis", "Left/Right"},
567       {1, "YAXIS", 0, "Y-Axis", "Front/Back"},
568       {2, "ZAXIS", 0, "Z-Axis", "Top/Bottom"},
569       {0, NULL, 0, NULL, NULL},
570   };
571
572   /* identifiers */
573   ot->name = "AutoName by Axis";
574   ot->idname = "ARMATURE_OT_autoside_names";
575   ot->description =
576       "Automatically renames the selected bones according to which side of the target axis they "
577       "fall on";
578
579   /* api callbacks */
580   ot->invoke = WM_menu_invoke;
581   ot->exec = armature_autoside_names_exec;
582   ot->poll = ED_operator_editarmature;
583
584   /* flags */
585   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
586
587   /* settings */
588   ot->prop = RNA_def_enum(ot->srna, "type", axis_items, 0, "Axis", "Axis tag names with");
589 }