rigify/ui.py

   1 #====================== BEGIN GPL LICENSE BLOCK ======================
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 2
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 #======================= END GPL LICENSE BLOCK ========================
  18
  19 # <pep8 compliant>
  20
  21 import bpy
  22 from bpy.props import StringProperty
  23 from mathutils import Color
  24
  25 from .utils import get_rig_type, MetarigError
  26 from .utils import write_metarig, write_widget
  27 from .utils import unique_name
  28 from .utils import upgradeMetarigTypes, outdated_types
  29 from .utils import get_keyed_frames, bones_in_frame
  30 from .utils import overwrite_prop_animation
  31 from .rigs.utils import get_limb_generated_names
  32 from . import rig_lists
  33 from . import generate
  34 from . import rot_mode
  35
  36
  37 class DATA_PT_rigify_buttons(bpy.types.Panel):
  38     bl_label = "Rigify Buttons"
  39     bl_space_type = 'PROPERTIES'
  40     bl_region_type = 'WINDOW'
  41     bl_context = "data"
  42
  43     @classmethod
  44     def poll(cls, context):
  45         return context.object.type == 'ARMATURE' and context.active_object.data.get("rig_id") is None
  46
  47     def draw(self, context):
  48         C = context
  49         layout = self.layout
  50         obj = context.object
  51         id_store = C.window_manager
  52
  53         if obj.mode in {'POSE', 'OBJECT'}:
  54
  55             WARNING = "Warning: Some features may change after generation"
  56             show_warning = False
  57             show_update_metarig = False
  58             show_not_updatable = False
  59
  60             check_props = ['IK_follow', 'root/parent', 'FK_limb_follow', 'IK_Stretch']
  61
  62             for obj in bpy.data.objects:
  63                 if type(obj.data) != bpy.types.Armature:
  64                     continue
  65                 for bone in obj.pose.bones:
  66                     if bone.bone.layers[30] and (list(set(bone.keys()) & set(check_props))):
  67                         show_warning = True
  68                         break
  69                 for b in obj.pose.bones:
  70                     if b.rigify_type in outdated_types.keys():
  71                         if outdated_types[b.rigify_type]:
  72                             show_update_metarig = True
  73                         else:
  74                             show_update_metarig = False
  75                             show_not_updatable = True
  76                             break
  77
  78             if show_warning:
  79                 layout.label(text=WARNING, icon='ERROR')
  80
  81             if show_not_updatable:
  82                 layout.label(text="WARNING: This metarig contains deprecated rigify rig-types and cannot be upgraded automatically.", icon='ERROR')
  83                 layout.label(text="If you want to use it anyway try enabling the legacy mode before generating again.")
  84
  85                 layout.operator("pose.rigify_switch_to_legacy", text="Switch to Legacy")
  86
  87             enable_generate_and_advanced = not (show_not_updatable or show_update_metarig)
  88
  89             if show_update_metarig:
  90
  91                 layout.label(text="This metarig contains old rig-types that can be automatically upgraded to benefit of rigify's new features.", icon='ERROR')
  92                 layout.label(text= "To use it as-is you need to enable legacy mode.",)
  93                 layout.operator("pose.rigify_upgrade_types", text="Upgrade Metarig")
  94
  95             row = layout.row()
  96             row.operator("pose.rigify_generate", text="Generate Rig", icon='POSE_HLT')
  97             row.enabled = enable_generate_and_advanced
  98
  99             if id_store.rigify_advanced_generation:
 100                 icon = 'UNLOCKED'
 101             else:
 102                 icon = 'LOCKED'
 103
 104             col = layout.column()
 105             col.enabled = enable_generate_and_advanced
 106             row = col.row()
 107             row.prop(id_store, "rigify_advanced_generation", toggle=True, icon=icon)
 108
 109             if id_store.rigify_advanced_generation:
 110
 111                 row = col.row(align=True)
 112                 row.prop(id_store, "rigify_generate_mode", expand=True)
 113
 114                 main_row = col.row(align=True).split(percentage=0.3)
 115                 col1 = main_row.column()
 116                 col2 = main_row.column()
 117                 col1.label(text="Rig Name")
 118                 row = col1.row()
 119                 row.label(text="Target Rig")
 120                 row.enabled = (id_store.rigify_generate_mode == "overwrite")
 121                 row = col1.row()
 122                 row.label(text="Target UI")
 123                 row.enabled = (id_store.rigify_generate_mode == "overwrite")
 124
 125                 row = col2.row(align=True)
 126                 row.prop(id_store, "rigify_rig_basename", text="", icon="SORTALPHA")
 127
 128                 row = col2.row(align=True)
 129                 for i in range(0, len(id_store.rigify_target_rigs)):
 130                     id_store.rigify_target_rigs.remove(0)
 131
 132                 for ob in context.scene.objects:
 133                     if type(ob.data) == bpy.types.Armature and "rig_id" in ob.data:
 134                         id_store.rigify_target_rigs.add()
 135                         id_store.rigify_target_rigs[-1].name = ob.name
 136
 137                 row.prop_search(id_store, "rigify_target_rig", id_store, "rigify_target_rigs", text="",
 138                                 icon='OUTLINER_OB_ARMATURE')
 139                 row.enabled = (id_store.rigify_generate_mode == "overwrite")
 140
 141                 for i in range(0, len(id_store.rigify_rig_uis)):
 142                     id_store.rigify_rig_uis.remove(0)
 143
 144                 for t in bpy.data.texts:
 145                     id_store.rigify_rig_uis.add()
 146                     id_store.rigify_rig_uis[-1].name = t.name
 147
 148                 row = col2.row()
 149                 row.prop_search(id_store, "rigify_rig_ui", id_store, "rigify_rig_uis", text="", icon='TEXT')
 150                 row.enabled = (id_store.rigify_generate_mode == "overwrite")
 151
 152                 row = col.row()
 153                 row.prop(id_store, "rigify_force_widget_update")
 154                 if id_store.rigify_generate_mode == 'new':
 155                     row.enabled = False
 156
 157         elif obj.mode == 'EDIT':
 158             # Build types list
 159             collection_name = str(id_store.rigify_collection).replace(" ", "")
 160
 161             for i in range(0, len(id_store.rigify_types)):
 162                 id_store.rigify_types.remove(0)
 163
 164             for r in rig_lists.rig_list:
 165
 166                 if collection_name == "All":
 167                     a = id_store.rigify_types.add()
 168                     a.name = r
 169                 elif r.startswith(collection_name + '.'):
 170                     a = id_store.rigify_types.add()
 171                     a.name = r
 172                 elif (collection_name == "None") and ("." not in r):
 173                     a = id_store.rigify_types.add()
 174                     a.name = r
 175
 176             # Rig type list
 177             row = layout.row()
 178             row.template_list("UI_UL_list", "rigify_types", id_store, "rigify_types", id_store, 'rigify_active_type')
 179
 180             props = layout.operator("armature.metarig_sample_add", text="Add sample")
 181             props.metarig_type = id_store.rigify_types[id_store.rigify_active_type].name
 182
 183
 184 class DATA_PT_rigify_layer_names(bpy.types.Panel):
 185     bl_label = "Rigify Layer Names"
 186     bl_space_type = 'PROPERTIES'
 187     bl_region_type = 'WINDOW'
 188     bl_context = "data"
 189     bl_options = {'DEFAULT_CLOSED'}
 190
 191     @classmethod
 192     def poll(cls, context):
 193         return context.object.type == 'ARMATURE' and context.active_object.data.get("rig_id") is None
 194
 195     def draw(self, context):
 196         layout = self.layout
 197         obj = context.object
 198         arm = obj.data
 199
 200         # Ensure that the layers exist
 201         if 0:
 202             for i in range(1 + len(arm.rigify_layers), 29):
 203                 arm.rigify_layers.add()
 204         else:
 205             # Can't add while drawing, just use button
 206             if len(arm.rigify_layers) < 29:
 207                 layout.operator("pose.rigify_layer_init")
 208                 return
 209
 210         # UI
 211         main_row = layout.row(align=True).split(0.05)
 212         col1 = main_row.column()
 213         col2 = main_row.column()
 214         col1.label()
 215         for i in range(32):
 216             if i == 16 or i == 29:
 217                 col1.label()
 218             col1.label(str(i+1) + '.')
 219
 220         for i, rigify_layer in enumerate(arm.rigify_layers):
 221             # note: rigify_layer == arm.rigify_layers[i]
 222             if (i % 16) == 0:
 223                 col = col2.column()
 224                 if i == 0:
 225                     col.label(text="Top Row:")
 226                 else:
 227                     col.label(text="Bottom Row:")
 228             if (i % 8) == 0:
 229                 col = col2.column()
 230             if i != 28:
 231                 row = col.row(align=True)
 232                 icon = 'RESTRICT_VIEW_OFF' if arm.layers[i] else 'RESTRICT_VIEW_ON'
 233                 row.prop(arm, "layers", index=i, text="", toggle=True, icon=icon)
 234                 #row.prop(arm, "layers", index=i, text="Layer %d" % (i + 1), toggle=True, icon=icon)
 235                 row.prop(rigify_layer, "name", text="")
 236                 row.prop(rigify_layer, "row", text="UI Row")
 237                 icon = 'RADIOBUT_ON' if rigify_layer.set else 'RADIOBUT_OFF'
 238                 row.prop(rigify_layer, "set", text="", toggle=True, icon=icon)
 239                 row.prop(rigify_layer, "group", text="Bone Group")
 240             else:
 241                 row = col.row(align=True)
 242
 243                 icon = 'RESTRICT_VIEW_OFF' if arm.layers[i] else 'RESTRICT_VIEW_ON'
 244                 row.prop(arm, "layers", index=i, text="", toggle=True, icon=icon)
 245                 # row.prop(arm, "layers", index=i, text="Layer %d" % (i + 1), toggle=True, icon=icon)
 246                 row1 = row.split(align=True).row(align=True)
 247                 row1.prop(rigify_layer, "name", text="")
 248                 row1.prop(rigify_layer, "row", text="UI Row")
 249                 row1.enabled = False
 250                 icon = 'RADIOBUT_ON' if rigify_layer.set else 'RADIOBUT_OFF'
 251                 row.prop(rigify_layer, "set", text="", toggle=True, icon=icon)
 252                 row.prop(rigify_layer, "group", text="Bone Group")
 253             if rigify_layer.group == 0:
 254                 row.label(text='None')
 255             else:
 256                 row.label(text=arm.rigify_colors[rigify_layer.group-1].name)
 257
 258         col = col2.column()
 259         col.label(text="Reserved:")
 260         # reserved_names = {28: 'Root', 29: 'DEF', 30: 'MCH', 31: 'ORG'}
 261         reserved_names = {29: 'DEF', 30: 'MCH', 31: 'ORG'}
 262         # for i in range(28, 32):
 263         for i in range(29, 32):
 264             row = col.row(align=True)
 265             icon = 'RESTRICT_VIEW_OFF' if arm.layers[i] else 'RESTRICT_VIEW_ON'
 266             row.prop(arm, "layers", index=i, text="", toggle=True, icon=icon)
 267             row.label(text=reserved_names[i])
 268
 269
 270 class DATA_OT_rigify_add_bone_groups(bpy.types.Operator):
 271     bl_idname = "armature.rigify_add_bone_groups"
 272     bl_label = "Rigify Add Standard Bone Groups"
 273
 274     @classmethod
 275     def poll(cls, context):
 276         return context.object.type == 'ARMATURE'
 277
 278     def execute(self, context):
 279         obj = context.object
 280         armature = obj.data
 281         if not hasattr(armature, 'rigify_colors'):
 282             return {'FINISHED'}
 283
 284         groups = ['Root', 'IK', 'Special', 'Tweak', 'FK', 'Extra']
 285
 286         for g in groups:
 287             if g in armature.rigify_colors.keys():
 288                 continue
 289
 290             armature.rigify_colors.add()
 291             armature.rigify_colors[-1].name = g
 292
 293             armature.rigify_colors[g].select = Color((0.3140000104904175, 0.7839999794960022, 1.0))
 294             armature.rigify_colors[g].active = Color((0.5490000247955322, 1.0, 1.0))
 295             armature.rigify_colors[g].standard_colors_lock = True
 296
 297             if g == "Root":
 298                 armature.rigify_colors[g].normal = Color((0.43529415130615234, 0.18431372940540314, 0.41568630933761597))
 299             if g == "IK":
 300                 armature.rigify_colors[g].normal = Color((0.6039215922355652, 0.0, 0.0))
 301             if g== "Special":
 302                 armature.rigify_colors[g].normal = Color((0.9568628072738647, 0.7882353663444519, 0.0470588281750679))
 303             if g== "Tweak":
 304                 armature.rigify_colors[g].normal = Color((0.03921568766236305, 0.21176472306251526, 0.5803921818733215))
 305             if g== "FK":
 306                 armature.rigify_colors[g].normal = Color((0.11764706671237946, 0.5686274766921997, 0.03529411926865578))
 307             if g== "Extra":
 308                 armature.rigify_colors[g].normal = Color((0.9686275124549866, 0.250980406999588, 0.0941176563501358))
 309
 310         return {'FINISHED'}
 311
 312
 313 class DATA_OT_rigify_use_standard_colors(bpy.types.Operator):
 314     bl_idname = "armature.rigify_use_standard_colors"
 315     bl_label = "Rigify Get active/select colors from current theme"
 316
 317     @classmethod
 318     def poll(cls, context):
 319         return context.object.type == 'ARMATURE'
 320
 321     def execute(self, context):
 322         obj = context.object
 323         armature = obj.data
 324         if not hasattr(armature, 'rigify_colors'):
 325             return {'FINISHED'}
 326
 327         current_theme = bpy.context.user_preferences.themes.items()[0][0]
 328         theme = bpy.context.user_preferences.themes[current_theme]
 329
 330         armature.rigify_selection_colors.select = theme.view_3d.bone_pose
 331         armature.rigify_selection_colors.active = theme.view_3d.bone_pose_active
 332
 333         # for col in armature.rigify_colors:
 334         #     col.select = theme.view_3d.bone_pose
 335         #     col.active = theme.view_3d.bone_pose_active
 336
 337         return {'FINISHED'}
 338
 339
 340 class DATA_OT_rigify_apply_selection_colors(bpy.types.Operator):
 341     bl_idname = "armature.rigify_apply_selection_colors"
 342     bl_label = "Rigify Apply user defined active/select colors"
 343
 344     @classmethod
 345     def poll(cls, context):
 346         return context.object.type == 'ARMATURE'
 347
 348     def execute(self, context):
 349         obj = context.object
 350         armature = obj.data
 351         if not hasattr(armature, 'rigify_colors'):
 352             return {'FINISHED'}
 353
 354         #current_theme = bpy.context.user_preferences.themes.items()[0][0]
 355         #theme = bpy.context.user_preferences.themes[current_theme]
 356
 357         for col in armature.rigify_colors:
 358             col.select = armature.rigify_selection_colors.select
 359             col.active = armature.rigify_selection_colors.active
 360
 361         return {'FINISHED'}
 362
 363
 364 class DATA_OT_rigify_bone_group_add(bpy.types.Operator):
 365     bl_idname = "armature.rigify_bone_group_add"
 366     bl_label = "Rigify Add Bone Group color set"
 367
 368     @classmethod
 369     def poll(cls, context):
 370         return context.object.type == 'ARMATURE'
 371
 372     def execute(self, context):
 373         obj = context.object
 374         armature = obj.data
 375
 376         if hasattr(armature, 'rigify_colors'):
 377             armature.rigify_colors.add()
 378             armature.rigify_colors[-1].name = unique_name(armature.rigify_colors, 'Group')
 379
 380             current_theme = bpy.context.user_preferences.themes.items()[0][0]
 381             theme = bpy.context.user_preferences.themes[current_theme]
 382
 383             armature.rigify_colors[-1].normal = theme.view_3d.wire
 384             armature.rigify_colors[-1].normal.hsv = theme.view_3d.wire.hsv
 385             armature.rigify_colors[-1].select = theme.view_3d.bone_pose
 386             armature.rigify_colors[-1].select.hsv = theme.view_3d.bone_pose.hsv
 387             armature.rigify_colors[-1].active = theme.view_3d.bone_pose_active
 388             armature.rigify_colors[-1].active.hsv = theme.view_3d.bone_pose_active.hsv
 389
 390         return {'FINISHED'}
 391
 392
 393 class DATA_OT_rigify_bone_group_add_theme(bpy.types.Operator):
 394     bl_idname = "armature.rigify_bone_group_add_theme"
 395     bl_label = "Rigify Add Bone Group color set from Theme"
 396     bl_options = {"REGISTER", "UNDO"}
 397
 398     theme = bpy.props.EnumProperty(items=(('THEME01', 'THEME01', ''),
 399                                           ('THEME02', 'THEME02', ''),
 400                                           ('THEME03', 'THEME03', ''),
 401                                           ('THEME04', 'THEME04', ''),
 402                                           ('THEME05', 'THEME05', ''),
 403                                           ('THEME06', 'THEME06', ''),
 404                                           ('THEME07', 'THEME07', ''),
 405                                           ('THEME08', 'THEME08', ''),
 406                                           ('THEME09', 'THEME09', ''),
 407                                           ('THEME10', 'THEME10', ''),
 408                                           ('THEME11', 'THEME11', ''),
 409                                           ('THEME12', 'THEME12', ''),
 410                                           ('THEME13', 'THEME13', ''),
 411                                           ('THEME14', 'THEME14', ''),
 412                                           ('THEME15', 'THEME15', ''),
 413                                           ('THEME16', 'THEME16', ''),
 414                                           ('THEME17', 'THEME17', ''),
 415                                           ('THEME18', 'THEME18', ''),
 416                                           ('THEME19', 'THEME19', ''),
 417                                           ('THEME20', 'THEME20', '')
 418                                           ),
 419                                    name='Theme')
 420
 421     @classmethod
 422     def poll(cls, context):
 423         return context.object.type == 'ARMATURE'
 424
 425     def execute(self, context):
 426         obj = context.object
 427         armature = obj.data
 428
 429         if hasattr(armature, 'rigify_colors'):
 430
 431             if self.theme in armature.rigify_colors.keys():
 432                 return {'FINISHED'}
 433             armature.rigify_colors.add()
 434             armature.rigify_colors[-1].name = self.theme
 435
 436             id = int(self.theme[-2:]) - 1
 437
 438             theme_color_set = bpy.context.user_preferences.themes[0].bone_color_sets[id]
 439
 440             armature.rigify_colors[-1].normal = theme_color_set.normal
 441             armature.rigify_colors[-1].select = theme_color_set.select
 442             armature.rigify_colors[-1].active = theme_color_set.active
 443
 444         return {'FINISHED'}
 445
 446
 447 class DATA_OT_rigify_bone_group_remove(bpy.types.Operator):
 448     bl_idname = "armature.rigify_bone_group_remove"
 449     bl_label = "Rigify Remove Bone Group color set"
 450
 451     idx = bpy.props.IntProperty()
 452
 453     @classmethod
 454     def poll(cls, context):
 455         return context.object.type == 'ARMATURE'
 456
 457     def execute(self, context):
 458         obj = context.object
 459         obj.data.rigify_colors.remove(self.idx)
 460
 461         # set layers references to 0
 462         for l in obj.data.rigify_layers:
 463             if l.group == self.idx + 1:
 464                 l.group = 0
 465             elif l.group > self.idx + 1:
 466                 l.group -= 1
 467
 468         return {'FINISHED'}
 469
 470
 471 class DATA_OT_rigify_bone_group_remove_all(bpy.types.Operator):
 472     bl_idname = "armature.rigify_bone_group_remove_all"
 473     bl_label = "Rigify Remove All Bone Groups"
 474
 475     @classmethod
 476     def poll(cls, context):
 477         return context.object.type == 'ARMATURE'
 478
 479     def execute(self, context):
 480         obj = context.object
 481
 482         for i, col in enumerate(obj.data.rigify_colors):
 483             obj.data.rigify_colors.remove(0)
 484             # set layers references to 0
 485             for l in obj.data.rigify_layers:
 486                 if l.group == i + 1:
 487                     l.group = 0
 488
 489         return {'FINISHED'}
 490
 491
 492 class DATA_UL_rigify_bone_groups(bpy.types.UIList):
 493     def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
 494         row = layout.row(align=True)
 495         row = row.split(percentage=0.1)
 496         row.label(text=str(index+1))
 497         row = row.split(percentage=0.7)
 498         row.prop(item, "name", text='', emboss=False)
 499         row = row.row(align=True)
 500         icon = 'LOCKED' if item.standard_colors_lock else 'UNLOCKED'
 501         #row.prop(item, "standard_colors_lock", text='', icon=icon)
 502         row.prop(item, "normal", text='')
 503         row2 = row.row(align=True)
 504         row2.prop(item, "select", text='')
 505         row2.prop(item, "active", text='')
 506         #row2.enabled = not item.standard_colors_lock
 507         row2.enabled = not bpy.context.object.data.rigify_colors_lock
 508
 509
 510 class DATA_MT_rigify_bone_groups_specials(bpy.types.Menu):
 511     bl_label = 'Rigify Bone Groups Specials'
 512
 513     def draw(self, context):
 514         layout = self.layout
 515
 516         layout.operator('armature.rigify_bone_group_remove_all')
 517
 518
 519 class DATA_PT_rigify_bone_groups(bpy.types.Panel):
 520     bl_label = "Rigify Bone Groups"
 521     bl_space_type = 'PROPERTIES'
 522     bl_region_type = 'WINDOW'
 523     bl_context = "data"
 524     bl_options = {'DEFAULT_CLOSED'}
 525
 526     @classmethod
 527     def poll(cls, context):
 528         return context.object.type == 'ARMATURE' and context.active_object.data.get("rig_id") is None
 529
 530     def draw(self, context):
 531         obj = context.object
 532         armature = obj.data
 533         color_sets = obj.data.rigify_colors
 534         idx = obj.data.rigify_colors_index
 535
 536         layout = self.layout
 537         row = layout.row()
 538         row.operator("armature.rigify_use_standard_colors", icon='FILE_REFRESH', text='')
 539         row = row.row(align=True)
 540         row.prop(armature.rigify_selection_colors, 'select', text='')
 541         row.prop(armature.rigify_selection_colors, 'active', text='')
 542         row = layout.row(align=True)
 543         icon = 'LOCKED' if armature.rigify_colors_lock else 'UNLOCKED'
 544         row.prop(armature, 'rigify_colors_lock', text = 'Unified select/active colors', icon=icon)
 545         row.operator("armature.rigify_apply_selection_colors", icon='FILE_REFRESH', text='Apply')
 546         row = layout.row()
 547         row.template_list("DATA_UL_rigify_bone_groups", "", obj.data, "rigify_colors", obj.data, "rigify_colors_index")
 548
 549         col = row.column(align=True)
 550         col.operator("armature.rigify_bone_group_add", icon='ZOOMIN', text="")
 551         col.operator("armature.rigify_bone_group_remove", icon='ZOOMOUT', text="").idx = obj.data.rigify_colors_index
 552         col.menu("DATA_MT_rigify_bone_groups_specials", icon='DOWNARROW_HLT', text="")
 553         row = layout.row()
 554         row.prop(armature, 'rigify_theme_to_add', text = 'Theme')
 555         op = row.operator("armature.rigify_bone_group_add_theme", text="Add From Theme")
 556         op.theme = armature.rigify_theme_to_add
 557         row = layout.row()
 558         row.operator("armature.rigify_add_bone_groups", text="Add Standard")
 559
 560
 561 class BONE_PT_rigify_buttons(bpy.types.Panel):
 562     bl_label = "Rigify Type"
 563     bl_space_type = 'PROPERTIES'
 564     bl_region_type = 'WINDOW'
 565     bl_context = "bone"
 566     #bl_options = {'DEFAULT_OPEN'}
 567
 568     @classmethod
 569     def poll(cls, context):
 570
 571         return context.object.type == 'ARMATURE' and context.active_pose_bone\
 572                and context.active_object.data.get("rig_id") is None
 573
 574     def draw(self, context):
 575         C = context
 576         id_store = C.window_manager
 577         bone = context.active_pose_bone
 578         collection_name = str(id_store.rigify_collection).replace(" ", "")
 579         rig_name = str(context.active_pose_bone.rigify_type).replace(" ", "")
 580
 581         layout = self.layout
 582
 583         # Build types list
 584         for i in range(0, len(id_store.rigify_types)):
 585             id_store.rigify_types.remove(0)
 586
 587         for r in rig_lists.rig_list:
 588             if r in rig_lists.implementation_rigs:
 589                 continue
 590             # collection = r.split('.')[0]  # UNUSED
 591             if collection_name == "All":
 592                 a = id_store.rigify_types.add()
 593                 a.name = r
 594             elif r.startswith(collection_name + '.'):
 595                 a = id_store.rigify_types.add()
 596                 a.name = r
 597             elif collection_name == "None" and len(r.split('.')) == 1:
 598                 a = id_store.rigify_types.add()
 599                 a.name = r
 600
 601         # Rig type field
 602         row = layout.row()
 603         row.prop_search(bone, "rigify_type", id_store, "rigify_types", text="Rig type:")
 604
 605         # Rig type parameters / Rig type non-exist alert
 606         if rig_name != "":
 607             try:
 608                 rig = get_rig_type(rig_name)
 609                 rig.Rig
 610             except (ImportError, AttributeError):
 611                 row = layout.row()
 612                 box = row.box()
 613                 box.label(text="ALERT: type \"%s\" does not exist!" % rig_name)
 614             else:
 615                 try:
 616                     rig.parameters_ui
 617                 except AttributeError:
 618                     col = layout.column()
 619                     col.label(text="No options")
 620                 else:
 621                     col = layout.column()
 622                     col.label(text="Options:")
 623                     box = layout.box()
 624                     rig.parameters_ui(box, bone.rigify_parameters)
 625
 626
 627 class VIEW3D_PT_tools_rigify_dev(bpy.types.Panel):
 628     bl_label = "Rigify Dev Tools"
 629     bl_category = 'Tools'
 630     bl_space_type = 'VIEW_3D'
 631     bl_region_type = 'TOOLS'
 632
 633     @classmethod
 634     def poll(cls, context):
 635         return context.mode in ['EDIT_ARMATURE', 'EDIT_MESH']
 636
 637     def draw(self, context):
 638         obj = context.active_object
 639         if obj is not None:
 640             if context.mode == 'EDIT_ARMATURE':
 641                 r = self.layout.row()
 642                 r.operator("armature.rigify_encode_metarig", text="Encode Metarig to Python")
 643                 r = self.layout.row()
 644                 r.operator("armature.rigify_encode_metarig_sample", text="Encode Sample to Python")
 645
 646             if context.mode == 'EDIT_MESH':
 647                 r = self.layout.row()
 648                 r.operator("mesh.rigify_encode_mesh_widget", text="Encode Mesh Widget to Python")
 649
 650
 651 class VIEW3D_PT_rigify_animation_tools(bpy.types.Panel):
 652     bl_label = "Rigify Animation Tools"
 653     bl_category = 'Tools'
 654     bl_context = "posemode"
 655     bl_space_type = 'VIEW_3D'
 656     bl_region_type = 'TOOLS'
 657
 658     @classmethod
 659     def poll(cls, context):
 660         return context.object.type == 'ARMATURE' and context.active_object.data.get("rig_id") is not None
 661
 662     def draw(self, context):
 663         obj = context.active_object
 664         id_store = context.window_manager
 665         if obj is not None:
 666             row = self.layout.row()
 667
 668             if id_store.rigify_transfer_only_selected:
 669                 icon = 'OUTLINER_DATA_ARMATURE'
 670             else:
 671                 icon = 'ARMATURE_DATA'
 672
 673             row.prop(id_store, 'rigify_transfer_only_selected', toggle=True, icon=icon)
 674
 675             row = self.layout.row(align=True)
 676             row.operator("rigify.ik2fk", text='IK2FK Pose', icon='SNAP_ON')
 677             row.operator("rigify.fk2ik", text='FK2IK Pose', icon='SNAP_ON')
 678
 679             row = self.layout.row(align=True)
 680             row.operator("rigify.transfer_fk_to_ik", text='IK2FK Action', icon='ACTION_TWEAK')
 681             row.operator("rigify.transfer_ik_to_fk", text='FK2IK Action', icon='ACTION_TWEAK')
 682
 683             row = self.layout.row(align=True)
 684             row.operator("rigify.clear_animation", text="Clear IK Action", icon='CANCEL').type = "IK"
 685             row.operator("rigify.clear_animation", text="Clear FK Action", icon='CANCEL').type = "FK"
 686
 687             row = self.layout.row(align=True)
 688             op = row.operator("rigify.rotation_pole", icon='FORCE_HARMONIC', text='Switch to pole')
 689             op.value = True
 690             op.toggle = False
 691             op.bake = True
 692             op = row.operator("rigify.rotation_pole", icon='FORCE_MAGNETIC', text='Switch to rotation')
 693             op.value = False
 694             op.toggle = False
 695             op.bake = True
 696             row = self.layout.row(align=True)
 697             row.prop(id_store, 'rigify_transfer_start_frame')
 698             row.prop(id_store, 'rigify_transfer_end_frame')
 699             row.operator("rigify.get_frame_range", icon='TIME', text='')
 700
 701
 702 def rigify_report_exception(operator, exception):
 703     import traceback
 704     import sys
 705     import os
 706     # find the module name where the error happened
 707     # hint, this is the metarig type!
 708     exceptionType, exceptionValue, exceptionTraceback = sys.exc_info()
 709     fn = traceback.extract_tb(exceptionTraceback)[-1][0]
 710     fn = os.path.basename(fn)
 711     fn = os.path.splitext(fn)[0]
 712     message = []
 713     if fn.startswith("__"):
 714         message.append("Incorrect armature...")
 715     else:
 716         message.append("Incorrect armature for type '%s'" % fn)
 717     message.append(exception.message)
 718
 719     message.reverse()  # XXX - stupid! menu's are upside down!
 720
 721     operator.report({'INFO'}, '\n'.join(message))
 722
 723
 724 class LayerInit(bpy.types.Operator):
 725     """Initialize armature rigify layers"""
 726
 727     bl_idname = "pose.rigify_layer_init"
 728     bl_label = "Add Rigify Layers"
 729     bl_options = {'UNDO'}
 730
 731     def execute(self, context):
 732         obj = context.object
 733         arm = obj.data
 734         for i in range(1 + len(arm.rigify_layers), 30):
 735             arm.rigify_layers.add()
 736         arm.rigify_layers[28].name = 'Root'
 737         arm.rigify_layers[28].row = 14
 738         return {'FINISHED'}
 739
 740
 741 class Generate(bpy.types.Operator):
 742     """Generates a rig from the active metarig armature"""
 743
 744     bl_idname = "pose.rigify_generate"
 745     bl_label = "Rigify Generate Rig"
 746     bl_options = {'UNDO'}
 747     bl_description = 'Generates a rig from the active metarig armature'
 748
 749     def execute(self, context):
 750         import importlib
 751         importlib.reload(generate)
 752
 753         use_global_undo = context.user_preferences.edit.use_global_undo
 754         context.user_preferences.edit.use_global_undo = False
 755         try:
 756             generate.generate_rig(context, context.object)
 757         except MetarigError as rig_exception:
 758             rigify_report_exception(self, rig_exception)
 759         finally:
 760             context.user_preferences.edit.use_global_undo = use_global_undo
 761
 762         return {'FINISHED'}
 763
 764
 765 class UpgradeMetarigTypes(bpy.types.Operator):
 766     """Upgrades metarig bones rigify_types"""
 767
 768     bl_idname = "pose.rigify_upgrade_types"
 769     bl_label = "Rigify Upgrade Metarig Types"
 770     bl_description = 'Upgrades the rigify types on the active metarig armature'
 771     bl_options = {'UNDO'}
 772
 773     def execute(self, context):
 774         for obj in bpy.data.objects:
 775             if type(obj.data) == bpy.types.Armature:
 776                 upgradeMetarigTypes(obj)
 777         return {'FINISHED'}
 778
 779
 780 class SwitchToLegacy(bpy.types.Operator):
 781     """Switch to Legacy mode"""
 782
 783     bl_idname = "pose.rigify_switch_to_legacy"
 784     bl_label = "Legacy Mode will disable Rigify new features"
 785     bl_description = 'Switches Rigify to Legacy Mode'
 786     bl_options = {'UNDO'}
 787
 788     def invoke(self, context, event):
 789         return context.window_manager.invoke_confirm(self, event)
 790
 791     def execute(self, context):
 792         bpy.context.user_preferences.addons['rigify'].preferences.legacy_mode = True
 793         return {'FINISHED'}
 794
 795
 796 class Sample(bpy.types.Operator):
 797     """Create a sample metarig to be modified before generating """ \
 798     """the final rig"""
 799
 800     bl_idname = "armature.metarig_sample_add"
 801     bl_label = "Add a sample metarig for a rig type"
 802     bl_options = {'UNDO'}
 803
 804     metarig_type = StringProperty(
 805             name="Type",
 806             description="Name of the rig type to generate a sample of",
 807             maxlen=128,
 808             )
 809
 810     def execute(self, context):
 811         if context.mode == 'EDIT_ARMATURE' and self.metarig_type != "":
 812             use_global_undo = context.user_preferences.edit.use_global_undo
 813             context.user_preferences.edit.use_global_undo = False
 814             try:
 815                 rig = get_rig_type(self.metarig_type)
 816                 create_sample = rig.create_sample
 817             except (ImportError, AttributeError):
 818                 raise Exception("rig type '" + self.metarig_type + "' has no sample.")
 819             else:
 820                 create_sample(context.active_object)
 821             finally:
 822                 context.user_preferences.edit.use_global_undo = use_global_undo
 823                 bpy.ops.object.mode_set(mode='EDIT')
 824
 825         return {'FINISHED'}
 826
 827
 828 class EncodeMetarig(bpy.types.Operator):
 829     """ Creates Python code that will generate the selected metarig.
 830     """
 831     bl_idname = "armature.rigify_encode_metarig"
 832     bl_label = "Rigify Encode Metarig"
 833     bl_options = {'UNDO'}
 834
 835     @classmethod
 836     def poll(self, context):
 837         return context.mode == 'EDIT_ARMATURE'
 838
 839     def execute(self, context):
 840         name = "metarig.py"
 841
 842         if name in bpy.data.texts:
 843             text_block = bpy.data.texts[name]
 844             text_block.clear()
 845         else:
 846             text_block = bpy.data.texts.new(name)
 847
 848         text = write_metarig(context.active_object, layers=True, func_name="create", groups=True)
 849         text_block.write(text)
 850         bpy.ops.object.mode_set(mode='EDIT')
 851
 852         return {'FINISHED'}
 853
 854
 855 class EncodeMetarigSample(bpy.types.Operator):
 856     """ Creates Python code that will generate the selected metarig
 857         as a sample.
 858     """
 859     bl_idname = "armature.rigify_encode_metarig_sample"
 860     bl_label = "Rigify Encode Metarig Sample"
 861     bl_options = {'UNDO'}
 862
 863     @classmethod
 864     def poll(self, context):
 865         return context.mode == 'EDIT_ARMATURE'
 866
 867     def execute(self, context):
 868         name = "metarig_sample.py"
 869
 870         if name in bpy.data.texts:
 871             text_block = bpy.data.texts[name]
 872             text_block.clear()
 873         else:
 874             text_block = bpy.data.texts.new(name)
 875
 876         text = write_metarig(context.active_object, layers=False, func_name="create_sample")
 877         text_block.write(text)
 878         bpy.ops.object.mode_set(mode='EDIT')
 879
 880         return {'FINISHED'}
 881
 882
 883 class EncodeWidget(bpy.types.Operator):
 884     """ Creates Python code that will generate the selected metarig.
 885     """
 886     bl_idname = "mesh.rigify_encode_mesh_widget"
 887     bl_label = "Rigify Encode Widget"
 888     bl_options = {'UNDO'}
 889
 890     @classmethod
 891     def poll(self, context):
 892         return context.mode == 'EDIT_MESH'
 893
 894     def execute(self, context):
 895         name = "widget.py"
 896
 897         if name in bpy.data.texts:
 898             text_block = bpy.data.texts[name]
 899             text_block.clear()
 900         else:
 901             text_block = bpy.data.texts.new(name)
 902
 903         text = write_widget(context.active_object)
 904         text_block.write(text)
 905         bpy.ops.object.mode_set(mode='EDIT')
 906
 907         return {'FINISHED'}
 908
 909
 910 class OBJECT_OT_GetFrameRange(bpy.types.Operator):
 911     """Get start and end frame range"""
 912     bl_idname = "rigify.get_frame_range"
 913     bl_label = "Get Frame Range"
 914
 915     def execute(self, context):
 916         scn = context.scene
 917         id_store = context.window_manager
 918
 919         id_store.rigify_transfer_start_frame = scn.frame_start
 920         id_store.rigify_transfer_end_frame = scn.frame_end
 921
 922         return {'FINISHED'}
 923
 924
 925 def FktoIk(rig, window='ALL'):
 926
 927     scn = bpy.context.scene
 928     id_store = bpy.context.window_manager
 929
 930     rig_id = rig.data['rig_id']
 931     leg_ik2fk = eval('bpy.ops.pose.rigify_leg_ik2fk_' + rig_id)
 932     arm_ik2fk = eval('bpy.ops.pose.rigify_arm_ik2fk_' + rig_id)
 933     limb_generated_names = get_limb_generated_names(rig)
 934
 935     if window == 'ALL':
 936         frames = get_keyed_frames(rig)
 937         frames = [f for f in frames if f in range(id_store.rigify_transfer_start_frame, id_store.rigify_transfer_end_frame+1)]
 938     elif window == 'CURRENT':
 939         frames = [scn.frame_current]
 940     else:
 941         frames = [scn.frame_current]
 942
 943     if not id_store.rigify_transfer_only_selected:
 944         pbones = rig.pose.bones
 945         bpy.ops.pose.select_all(action='DESELECT')
 946     else:
 947         pbones = bpy.context.selected_pose_bones
 948         bpy.ops.pose.select_all(action='DESELECT')
 949
 950     for b in pbones:
 951         for group in limb_generated_names:
 952             if b.name in limb_generated_names[group].values() or b.name in limb_generated_names[group]['controls']\
 953                     or b.name in limb_generated_names[group]['ik_ctrl']:
 954                 names = limb_generated_names[group]
 955                 if names['limb_type'] == 'arm':
 956                     func = arm_ik2fk
 957                     controls = names['controls']
 958                     ik_ctrl = names['ik_ctrl']
 959                     fk_ctrl = names['fk_ctrl']
 960                     parent = names['parent']
 961                     pole = names['pole']
 962                     rig.pose.bones[controls[0]].bone.select = True
 963                     rig.pose.bones[controls[4]].bone.select = True
 964                     rig.pose.bones[pole].bone.select = True
 965                     rig.pose.bones[parent].bone.select = True
 966                     kwargs = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
 967                               'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1], 'hand_ik': controls[4],
 968                               'pole': pole, 'main_parent': parent}
 969                     args = (controls[0], controls[1], controls[2], controls[3],
 970                             controls[4], pole, parent)
 971                 else:
 972                     func = leg_ik2fk
 973                     controls = names['controls']
 974                     ik_ctrl = names['ik_ctrl']
 975                     fk_ctrl = names['fk_ctrl']
 976                     parent = names['parent']
 977                     pole = names['pole']
 978                     rig.pose.bones[controls[0]].bone.select = True
 979                     rig.pose.bones[controls[6]].bone.select = True
 980                     rig.pose.bones[controls[5]].bone.select = True
 981                     rig.pose.bones[pole].bone.select = True
 982                     rig.pose.bones[parent].bone.select = True
 983                     kwargs = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
 984                               'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
 985                               'foot_ik': controls[6], 'pole': pole, 'footroll': controls[5], 'mfoot_ik': ik_ctrl[2],
 986                               'main_parent': parent}
 987                     args = (controls[0], controls[1], controls[2], controls[3],
 988                             controls[6], controls[5], pole, parent)
 989
 990                 for f in frames:
 991                     if not bones_in_frame(f, rig, *args):
 992                         continue
 993                     scn.frame_set(f)
 994                     func(**kwargs)
 995                     bpy.ops.anim.keyframe_insert_menu(type='BUILTIN_KSI_VisualLocRot')
 996                     bpy.ops.anim.keyframe_insert_menu(type='Scaling')
 997
 998                 bpy.ops.pose.select_all(action='DESELECT')
 999                 limb_generated_names.pop(group)
1000                 break
1001
1002
1003 def IktoFk(rig, window='ALL'):
1004
1005     scn = bpy.context.scene
1006     id_store = bpy.context.window_manager
1007
1008     rig_id = rig.data['rig_id']
1009     leg_fk2ik = eval('bpy.ops.pose.rigify_leg_fk2ik_' + rig_id)
1010     arm_fk2ik = eval('bpy.ops.pose.rigify_arm_fk2ik_' + rig_id)
1011     limb_generated_names = get_limb_generated_names(rig)
1012
1013     if window == 'ALL':
1014         frames = get_keyed_frames(rig)
1015         frames = [f for f in frames if f in range(id_store.rigify_transfer_start_frame, id_store.rigify_transfer_end_frame+1)]
1016     elif window == 'CURRENT':
1017         frames = [scn.frame_current]
1018     else:
1019         frames = [scn.frame_current]
1020
1021     if not id_store.rigify_transfer_only_selected:
1022         bpy.ops.pose.select_all(action='DESELECT')
1023         pbones = rig.pose.bones
1024     else:
1025         pbones = bpy.context.selected_pose_bones
1026         bpy.ops.pose.select_all(action='DESELECT')
1027
1028     for b in pbones:
1029         for group in limb_generated_names:
1030             if b.name in limb_generated_names[group].values() or b.name in limb_generated_names[group]['controls']\
1031                     or b.name in limb_generated_names[group]['ik_ctrl']:
1032                 names = limb_generated_names[group]
1033                 if names['limb_type'] == 'arm':
1034                     func = arm_fk2ik
1035                     controls = names['controls']
1036                     ik_ctrl = names['ik_ctrl']
1037                     fk_ctrl = names['fk_ctrl']
1038                     parent = names['parent']
1039                     pole = names['pole']
1040                     rig.pose.bones[controls[1]].bone.select = True
1041                     rig.pose.bones[controls[2]].bone.select = True
1042                     rig.pose.bones[controls[3]].bone.select = True
1043                     kwargs = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
1044                               'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1],
1045                               'hand_ik': controls[4]}
1046                     args = (controls[0], controls[1], controls[2], controls[3],
1047                             controls[4], pole, parent)
1048                 else:
1049                     func = leg_fk2ik
1050                     controls = names['controls']
1051                     ik_ctrl = names['ik_ctrl']
1052                     fk_ctrl = names['fk_ctrl']
1053                     parent = names['parent']
1054                     pole = names['pole']
1055                     rig.pose.bones[controls[1]].bone.select = True
1056                     rig.pose.bones[controls[2]].bone.select = True
1057                     rig.pose.bones[controls[3]].bone.select = True
1058                     kwargs = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
1059                               'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
1060                               'foot_ik': ik_ctrl[2], 'mfoot_ik': ik_ctrl[2]}
1061                     args = (controls[0], controls[1], controls[2], controls[3],
1062                             controls[6], controls[5], pole, parent)
1063
1064                 for f in frames:
1065                     if not bones_in_frame(f, rig, *args):
1066                         continue
1067                     scn.frame_set(f)
1068                     func(**kwargs)
1069                     bpy.ops.anim.keyframe_insert_menu(type='BUILTIN_KSI_VisualLocRot')
1070                     bpy.ops.anim.keyframe_insert_menu(type='Scaling')
1071
1072                 bpy.ops.pose.select_all(action='DESELECT')
1073                 limb_generated_names.pop(group)
1074                 break
1075
1076
1077 def clearAnimation(act, type, names):
1078
1079     bones = []
1080     for group in names:
1081         if names[group]['limb_type'] == 'arm':
1082             if type == 'IK':
1083                 bones.extend([names[group]['controls'][0], names[group]['controls'][4]])
1084             elif type == 'FK':
1085                 bones.extend([names[group]['controls'][1], names[group]['controls'][2], names[group]['controls'][3]])
1086         else:
1087             if type == 'IK':
1088                 bones.extend([names[group]['controls'][0], names[group]['controls'][6], names[group]['controls'][5],
1089                               names[group]['controls'][4]])
1090             elif type == 'FK':
1091                 bones.extend([names[group]['controls'][1], names[group]['controls'][2], names[group]['controls'][3],
1092                               names[group]['controls'][4]])
1093     FCurves = []
1094     for fcu in act.fcurves:
1095         words = fcu.data_path.split('"')
1096         if (words[0] == "pose.bones[" and
1097                     words[1] in bones):
1098             FCurves.append(fcu)
1099
1100     if FCurves == []:
1101         return
1102
1103     for fcu in FCurves:
1104         act.fcurves.remove(fcu)
1105
1106     # Put cleared bones back to rest pose
1107     bpy.ops.pose.loc_clear()
1108     bpy.ops.pose.rot_clear()
1109     bpy.ops.pose.scale_clear()
1110
1111     # updateView3D()
1112
1113
1114 def rotPoleToggle(rig, window='ALL', value=False, toggle=False, bake=False):
1115
1116     scn = bpy.context.scene
1117     id_store = bpy.context.window_manager
1118
1119     rig_id = rig.data['rig_id']
1120     leg_fk2ik = eval('bpy.ops.pose.rigify_leg_fk2ik_' + rig_id)
1121     arm_fk2ik = eval('bpy.ops.pose.rigify_arm_fk2ik_' + rig_id)
1122     leg_ik2fk = eval('bpy.ops.pose.rigify_leg_ik2fk_' + rig_id)
1123     arm_ik2fk = eval('bpy.ops.pose.rigify_arm_ik2fk_' + rig_id)
1124     limb_generated_names = get_limb_generated_names(rig)
1125
1126     if window == 'ALL':
1127         frames = get_keyed_frames(rig)
1128         frames = [f for f in frames if f in range(id_store.rigify_transfer_start_frame, id_store.rigify_transfer_end_frame+1)]
1129     elif window == 'CURRENT':
1130         frames = [scn.frame_current]
1131     else:
1132         frames = [scn.frame_current]
1133
1134     if not id_store.rigify_transfer_only_selected:
1135         bpy.ops.pose.select_all(action='DESELECT')
1136         pbones = rig.pose.bones
1137     else:
1138         pbones = bpy.context.selected_pose_bones
1139         bpy.ops.pose.select_all(action='DESELECT')
1140
1141     for b in pbones:
1142         for group in limb_generated_names:
1143             names = limb_generated_names[group]
1144
1145             if toggle:
1146                 new_pole_vector_value = not rig.pose.bones[names['parent']]['pole_vector']
1147             else:
1148                 new_pole_vector_value = value
1149
1150             if b.name in names.values() or b.name in names['controls'] or b.name in names['ik_ctrl']:
1151                 if names['limb_type'] == 'arm':
1152                     func1 = arm_fk2ik
1153                     func2 = arm_ik2fk
1154                     controls = names['controls']
1155                     ik_ctrl = names['ik_ctrl']
1156                     fk_ctrl = names['fk_ctrl']
1157                     parent = names['parent']
1158                     pole = names['pole']
1159                     rig.pose.bones[controls[0]].bone.select = not new_pole_vector_value
1160                     rig.pose.bones[controls[4]].bone.select = not new_pole_vector_value
1161                     rig.pose.bones[parent].bone.select = not new_pole_vector_value
1162                     rig.pose.bones[pole].bone.select = new_pole_vector_value
1163
1164                     kwargs1 = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
1165                               'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1],
1166                               'hand_ik': controls[4]}
1167                     kwargs2 = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
1168                               'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1], 'hand_ik': controls[4],
1169                               'pole': pole, 'main_parent': parent}
1170                     args = (controls[0], controls[4], pole, parent)
1171                 else:
1172                     func1 = leg_fk2ik
1173                     func2 = leg_ik2fk
1174                     controls = names['controls']
1175                     ik_ctrl = names['ik_ctrl']
1176                     fk_ctrl = names['fk_ctrl']
1177                     parent = names['parent']
1178                     pole = names['pole']
1179                     rig.pose.bones[controls[0]].bone.select = not new_pole_vector_value
1180                     rig.pose.bones[controls[6]].bone.select = not new_pole_vector_value
1181                     rig.pose.bones[controls[5]].bone.select = not new_pole_vector_value
1182                     rig.pose.bones[parent].bone.select = not new_pole_vector_value
1183                     rig.pose.bones[pole].bone.select = new_pole_vector_value
1184
1185                     kwargs1 = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
1186                               'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
1187                               'foot_ik': ik_ctrl[2], 'mfoot_ik': ik_ctrl[2]}
1188                     kwargs2 = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
1189                               'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
1190                               'foot_ik': controls[6], 'pole': pole, 'footroll': controls[5], 'mfoot_ik': ik_ctrl[2],
1191                               'main_parent': parent}
1192                     args = (controls[0], controls[6], controls[5], pole, parent)
1193
1194                 for f in frames:
1195                     if bake and not bones_in_frame(f, rig, *args):
1196                         continue
1197                     scn.frame_set(f)
1198                     func1(**kwargs1)
1199                     rig.pose.bones[names['parent']]['pole_vector'] = new_pole_vector_value
1200                     func2(**kwargs2)
1201                     if bake:
1202                         bpy.ops.anim.keyframe_insert_menu(type='BUILTIN_KSI_VisualLocRot')
1203                         bpy.ops.anim.keyframe_insert_menu(type='Scaling')
1204                         overwrite_prop_animation(rig, rig.pose.bones[parent], 'pole_vector', new_pole_vector_value, [f])
1205
1206                 bpy.ops.pose.select_all(action='DESELECT')
1207                 limb_generated_names.pop(group)
1208                 break
1209     scn.frame_set(0)
1210
1211
1212 class OBJECT_OT_IK2FK(bpy.types.Operator):
1213     """ Snaps IK limb on FK limb at current frame"""
1214     bl_idname = "rigify.ik2fk"
1215     bl_label = "IK2FK"
1216     bl_description = "Snaps IK limb on FK"
1217
1218     def execute(self,context):
1219         rig = context.object
1220         id_store = context.window_manager
1221
1222         FktoIk(rig, window='CURRENT')
1223
1224         return {'FINISHED'}
1225
1226
1227 class OBJECT_OT_FK2IK(bpy.types.Operator):
1228     """ Snaps FK limb on IK limb at current frame"""
1229     bl_idname = "rigify.fk2ik"
1230     bl_label = "FK2IK"
1231     bl_description = "Snaps FK limb on IK"
1232
1233     def execute(self,context):
1234         rig = context.object
1235
1236         IktoFk(rig, window='CURRENT')
1237
1238         return {'FINISHED'}
1239
1240
1241 class OBJECT_OT_TransferFKtoIK(bpy.types.Operator):
1242     """Transfers FK animation to IK"""
1243     bl_idname = "rigify.transfer_fk_to_ik"
1244     bl_label = "Transfer FK anim to IK"
1245     bl_description = "Transfer FK animation to IK bones"
1246
1247     def execute(self, context):
1248         rig = context.object
1249         id_store = context.window_manager
1250
1251         FktoIk(rig)
1252
1253         return {'FINISHED'}
1254
1255
1256 class OBJECT_OT_TransferIKtoFK(bpy.types.Operator):
1257     """Transfers FK animation to IK"""
1258     bl_idname = "rigify.transfer_ik_to_fk"
1259     bl_label = "Transfer IK anim to FK"
1260     bl_description = "Transfer IK animation to FK bones"
1261
1262     def execute(self, context):
1263         rig = context.object
1264
1265         IktoFk(rig)
1266
1267         return {'FINISHED'}
1268
1269
1270 class OBJECT_OT_ClearAnimation(bpy.types.Operator):
1271     bl_idname = "rigify.clear_animation"
1272     bl_label = "Clear Animation"
1273     bl_description = "Clear Animation For FK or IK Bones"
1274     type = StringProperty()
1275
1276     def execute(self, context):
1277
1278         use_global_undo = context.user_preferences.edit.use_global_undo
1279         context.user_preferences.edit.use_global_undo = False
1280         try:
1281             rig = context.object
1282             scn = context.scene
1283             if not rig.animation_data:
1284                 return {'FINISHED'}
1285             act = rig.animation_data.action
1286             if not act:
1287                 return {'FINISHED'}
1288
1289             clearAnimation(act, self.type, names=get_limb_generated_names(rig))
1290         finally:
1291             context.user_preferences.edit.use_global_undo = use_global_undo
1292         return {'FINISHED'}
1293
1294
1295 class OBJECT_OT_Rot2Pole(bpy.types.Operator):
1296     bl_idname = "rigify.rotation_pole"
1297     bl_label = "Rotation - Pole toggle"
1298     bl_description = "Toggles IK chain between rotation and pole target"
1299     bone_name = bpy.props.StringProperty(default='')
1300     window = bpy.props.StringProperty(default='ALL')
1301     toggle = bpy.props.BoolProperty(default=True)
1302     value = bpy.props.BoolProperty(default=True)
1303     bake = bpy.props.BoolProperty(default=True)
1304
1305     def execute(self, context):
1306         rig = context.object
1307
1308         if self.bone_name:
1309             bpy.ops.pose.select_all(action='DESELECT')
1310             rig.pose.bones[self.bone_name].bone.select = True
1311
1312         rotPoleToggle(rig, window=self.window, toggle=self.toggle, value=self.value, bake=self.bake)
1313         return {'FINISHED'}
1314
1315
1316 def register():
1317
1318     bpy.utils.register_class(DATA_OT_rigify_add_bone_groups)
1319     bpy.utils.register_class(DATA_OT_rigify_use_standard_colors)
1320     bpy.utils.register_class(DATA_OT_rigify_apply_selection_colors)
1321     bpy.utils.register_class(DATA_OT_rigify_bone_group_add)
1322     bpy.utils.register_class(DATA_OT_rigify_bone_group_add_theme)
1323     bpy.utils.register_class(DATA_OT_rigify_bone_group_remove)
1324     bpy.utils.register_class(DATA_OT_rigify_bone_group_remove_all)
1325     bpy.utils.register_class(DATA_UL_rigify_bone_groups)
1326     bpy.utils.register_class(DATA_MT_rigify_bone_groups_specials)
1327     bpy.utils.register_class(DATA_PT_rigify_bone_groups)
1328     bpy.utils.register_class(DATA_PT_rigify_layer_names)
1329     bpy.utils.register_class(DATA_PT_rigify_buttons)
1330     bpy.utils.register_class(BONE_PT_rigify_buttons)
1331     bpy.utils.register_class(VIEW3D_PT_rigify_animation_tools)
1332     bpy.utils.register_class(VIEW3D_PT_tools_rigify_dev)
1333     bpy.utils.register_class(LayerInit)
1334     bpy.utils.register_class(Generate)
1335     bpy.utils.register_class(UpgradeMetarigTypes)
1336     bpy.utils.register_class(SwitchToLegacy)
1337     bpy.utils.register_class(Sample)
1338     bpy.utils.register_class(EncodeMetarig)
1339     bpy.utils.register_class(EncodeMetarigSample)
1340     bpy.utils.register_class(EncodeWidget)
1341     bpy.utils.register_class(OBJECT_OT_GetFrameRange)
1342     bpy.utils.register_class(OBJECT_OT_FK2IK)
1343     bpy.utils.register_class(OBJECT_OT_IK2FK)
1344     bpy.utils.register_class(OBJECT_OT_TransferFKtoIK)
1345     bpy.utils.register_class(OBJECT_OT_TransferIKtoFK)
1346     bpy.utils.register_class(OBJECT_OT_ClearAnimation)
1347     bpy.utils.register_class(OBJECT_OT_Rot2Pole)
1348
1349     rot_mode.register()
1350
1351
1352 def unregister():
1353
1354     bpy.utils.unregister_class(DATA_OT_rigify_add_bone_groups)
1355     bpy.utils.unregister_class(DATA_OT_rigify_use_standard_colors)
1356     bpy.utils.unregister_class(DATA_OT_rigify_apply_selection_colors)
1357     bpy.utils.unregister_class(DATA_OT_rigify_bone_group_add)
1358     bpy.utils.unregister_class(DATA_OT_rigify_bone_group_add_theme)
1359     bpy.utils.unregister_class(DATA_OT_rigify_bone_group_remove)
1360     bpy.utils.unregister_class(DATA_OT_rigify_bone_group_remove_all)
1361     bpy.utils.unregister_class(DATA_UL_rigify_bone_groups)
1362     bpy.utils.unregister_class(DATA_MT_rigify_bone_groups_specials)
1363     bpy.utils.unregister_class(DATA_PT_rigify_bone_groups)
1364     bpy.utils.unregister_class(DATA_PT_rigify_layer_names)
1365     bpy.utils.unregister_class(DATA_PT_rigify_buttons)
1366     bpy.utils.unregister_class(BONE_PT_rigify_buttons)
1367     bpy.utils.unregister_class(VIEW3D_PT_rigify_animation_tools)
1368     bpy.utils.unregister_class(VIEW3D_PT_tools_rigify_dev)
1369     bpy.utils.unregister_class(LayerInit)
1370     bpy.utils.unregister_class(Generate)
1371     bpy.utils.unregister_class(UpgradeMetarigTypes)
1372     bpy.utils.unregister_class(SwitchToLegacy)
1373     bpy.utils.unregister_class(Sample)
1374     bpy.utils.unregister_class(EncodeMetarig)
1375     bpy.utils.unregister_class(EncodeMetarigSample)
1376     bpy.utils.unregister_class(EncodeWidget)
1377     bpy.utils.unregister_class(OBJECT_OT_GetFrameRange)
1378     bpy.utils.unregister_class(OBJECT_OT_FK2IK)
1379     bpy.utils.unregister_class(OBJECT_OT_IK2FK)
1380     bpy.utils.unregister_class(OBJECT_OT_TransferFKtoIK)
1381     bpy.utils.unregister_class(OBJECT_OT_TransferIKtoFK)
1382     bpy.utils.unregister_class(OBJECT_OT_ClearAnimation)
1383     bpy.utils.unregister_class(OBJECT_OT_Rot2Pole)
1384
1385     rot_mode.unregister()
1386