@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/rigify/ui.py

@@ -1,1834 +0,0 @@
-# SPDX-FileCopyrightText: 2010-2022 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-import bpy
-from bpy.types import UIList, UILayout, Armature
-from bpy.props import (
-    BoolProperty,
-    IntProperty,
-    EnumProperty,
-    StringProperty
-)
-from bpy.app.translations import (
-    pgettext_n as n_,
-    pgettext_iface as iface_,
-    pgettext_rpt as rpt_,
-    contexts as i18n_contexts,
-)
-from bpy_extras import anim_utils
-
-from collections import defaultdict
-from typing import TYPE_CHECKING, Callable, Any
-from mathutils import Color
-
-from .utils.errors import MetarigError
-from .utils.layers import ROOT_COLLECTION, SPECIAL_COLLECTIONS, validate_collection_references
-from .utils.rig import write_metarig, get_rigify_type, get_rigify_target_rig, \
-    get_rigify_colors, get_rigify_params
-from .utils.widgets import write_widget
-from .utils.naming import unique_name
-from .utils.rig import upgrade_metarig_types, outdated_types, upgrade_metarig_layers, \
-    is_valid_metarig, metarig_needs_upgrade
-from .utils.misc import verify_armature_obj, ArmatureObject, IdPropSequence, flatten_children
-
-from .rigs.utils import get_limb_generated_names
-
-from .utils.animation import get_keyed_frames_in_range, bones_in_frame, overwrite_prop_animation
-from .utils.animation import RIGIFY_OT_get_frame_range
-
-from .utils.animation import register as animation_register
-from .utils.animation import unregister as animation_unregister
-
-from . import base_rig
-from . import rig_lists
-from . import generate
-from . import rot_mode
-from . import feature_set_list
-
-if TYPE_CHECKING:
-    from . import RigifyName, RigifySelectionColors
-
-
-def get_rigify_types(id_store: bpy.types.WindowManager) -> IdPropSequence['RigifyName']:
-    return id_store.rigify_types  # noqa
-
-
-def get_transfer_only_selected(id_store: bpy.types.WindowManager) -> bool:
-    return id_store.rigify_transfer_only_selected  # noqa
-
-
-def get_selection_colors(armature: bpy.types.Armature) -> 'RigifySelectionColors':
-    return armature.rigify_selection_colors  # noqa
-
-
-def get_colors_lock(armature: bpy.types.Armature) -> bool:
-    return armature.rigify_colors_lock  # noqa
-
-
-def get_colors_index(armature: bpy.types.Armature) -> int:
-    return armature.rigify_colors_index  # noqa
-
-
-def get_theme_to_add(armature: bpy.types.Armature) -> str:
-    return armature.rigify_theme_to_add  # noqa
-
-
-def build_type_list(context, rigify_types: IdPropSequence['RigifyName']):
-    rigify_types.clear()
-
-    for r in sorted(rig_lists.rigs):
-        if (context.object.data.active_feature_set in ('all', rig_lists.rigs[r]['feature_set'])
-                or len(feature_set_list.get_enabled_modules_names()) == 0):
-            a = rigify_types.add()
-            a.name = r
-
-
-# noinspection PyPep8Naming
-class DATA_PT_rigify(bpy.types.Panel):
-    bl_label = "Rigify"
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_context = "data"
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context, allow_needs_upgrade=True)
-
-    def draw(self, context):
-        C = context
-        layout = self.layout
-        obj = verify_armature_obj(C.object)
-
-        if metarig_needs_upgrade(obj):
-            layout.label(text="This metarig requires upgrading to Bone Collections", icon='ERROR')
-            layout.operator("armature.rigify_upgrade_layers", text="Upgrade Metarig")
-            return
-
-        WARNING = n_("Warning: Some features may change after generation")
-        show_warning = False
-        show_update_metarig = False
-        show_not_updatable = False
-        show_upgrade_face = False
-
-        check_props = ['IK_follow', 'root/parent', 'FK_limb_follow', 'IK_Stretch']
-
-        for pose_bone in obj.pose.bones:
-            bone = pose_bone.bone
-            if not bone:
-                # If we are in edit mode and the bone was just created,
-                # a pose bone won't exist yet.
-                continue
-            if list(set(pose_bone.keys()) & set(check_props)):  # bone.layers[30] and
-                show_warning = True
-                break
-
-        old_rig = ''
-        old_bone = ''
-
-        for b in obj.pose.bones:
-            old_rig = get_rigify_type(b)
-            if old_rig in outdated_types:
-                old_bone = b.name
-                if outdated_types[old_rig]:
-                    show_update_metarig = True
-                else:
-                    show_update_metarig = False
-                    show_not_updatable = True
-                    break
-            elif old_rig == 'faces.super_face':
-                show_upgrade_face = True
-
-        if show_warning:
-            layout.label(text=WARNING, icon='ERROR')
-
-        enable_generate = not (show_not_updatable or show_update_metarig)
-
-        if show_not_updatable:
-            layout.label(text="WARNING: This metarig contains deprecated Rigify rig-types and "
-                              "cannot be upgraded automatically.", icon='ERROR')
-            text = iface_("({:s} on bone {:s})").format(old_rig, old_bone)
-            layout.label(text=text, translate=False)
-        elif show_update_metarig:
-            layout.label(text="This metarig contains old rig-types that can be automatically "
-                              "upgraded to benefit from new rigify features.", icon='ERROR')
-            text = iface_("({:s} on bone {:s})").format(old_rig, old_bone)
-            layout.label(text=text, translate=False)
-            layout.operator("pose.rigify_upgrade_types", text="Upgrade Metarig")
-        elif show_upgrade_face:
-            layout.label(text="This metarig uses the old face rig.", icon='INFO')
-            layout.operator("pose.rigify_upgrade_face")
-
-        # Rig type field
-
-        col = layout.column(align=True)
-        col.active = ('rig_id' not in C.object.data)
-
-        col.separator()
-        row = col.row()
-        text = (
-            n_("Re-Generate Rig", i18n_contexts.operator_default) if get_rigify_target_rig(obj.data)
-            else n_("Generate Rig", i18n_contexts.operator_default)
-        )
-        row.operator("pose.rigify_generate", text=text, icon='POSE_HLT')
-        row.enabled = enable_generate
-
-
-# noinspection PyPep8Naming
-class DATA_PT_rigify_advanced(bpy.types.Panel):
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_context = "data"
-    bl_label = "Advanced"
-    bl_parent_id = 'DATA_PT_rigify'
-    bl_options = {'DEFAULT_CLOSED'}
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.use_property_split = True
-        layout.use_property_decorate = False
-
-        armature_id_store = verify_armature_obj(context.object).data
-
-        col = layout.column()
-
-        row = col.row()
-        row.active = not get_rigify_target_rig(armature_id_store)
-        row.prop(armature_id_store, "rigify_rig_basename", text="Rig Name")
-
-        col.separator()
-
-        col2 = col.box().column()
-        col2.label(text="Overwrite Existing:")
-        col2.row().prop(armature_id_store, "rigify_target_rig", text="Target Rig")
-        col2.row().prop(armature_id_store, "rigify_rig_ui", text="Rig UI Script")
-        col2.row().prop(armature_id_store, "rigify_widgets_collection")
-
-        col.separator()
-        col.row().prop(armature_id_store, "rigify_force_widget_update")
-        col.row().prop(armature_id_store, "rigify_mirror_widgets")
-        col.separator()
-        col.row().prop(armature_id_store, "rigify_finalize_script", text="Run Script")
-
-
-# noinspection PyPep8Naming
-class DATA_PT_rigify_samples(bpy.types.Panel):
-    bl_label = "Samples"
-    bl_translation_context = i18n_contexts.id_armature
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_context = "data"
-    bl_parent_id = "DATA_PT_rigify"
-    bl_options = {'DEFAULT_CLOSED'}
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context) and context.object.mode == 'EDIT'
-
-    def draw(self, context):
-        layout = self.layout
-        layout.use_property_split = True
-        layout.use_property_decorate = False
-        id_store = context.window_manager
-
-        # Build types list
-        rigify_types = get_rigify_types(id_store)
-        build_type_list(context, rigify_types)
-
-        if id_store.rigify_active_type > len(rigify_types):
-            id_store.rigify_active_type = 0
-
-        # Rig type list
-        if len(feature_set_list.get_enabled_modules_names()) > 0:
-            row = layout.row()
-            row.prop(context.object.data, "active_feature_set")
-        row = layout.row()
-        row.template_list("UI_UL_list", "rigify_types", id_store, "rigify_types", id_store, 'rigify_active_type')
-
-        props = layout.operator("armature.metarig_sample_add", text="Add sample")
-        props.metarig_type = rigify_types[id_store.rigify_active_type].name
-
-
-# noinspection SpellCheckingInspection
-# noinspection PyPep8Naming
-class DATA_UL_rigify_bone_collections(UIList):
-    def filter_items(self, _context, data, propname):
-        assert propname == 'collections_all'
-        collections = data.collections_all
-        flags = []
-
-        # Filtering by name
-        if self.filter_name:
-            print(self.filter_name, self.use_filter_invert)
-            flags = bpy.types.UI_UL_list.filter_items_by_name(
-                self.filter_name, self.bitflag_filter_item, collections, "name")
-        if not flags:
-            flags = [self.bitflag_filter_item] * len(collections)
-
-        # Reorder by name.
-        if self.use_filter_sort_alpha:
-            indices = bpy.types.UI_UL_list.sort_items_by_name(collections, "name")
-        # Sort by tree order
-        else:
-            index_map = {c.name: i for i, c in enumerate(flatten_children(data.collections))}
-            indices = [index_map[c.name] for c in collections]
-
-        return flags, indices
-
-    def draw_item(self, _context, layout, armature, bcoll, _icon, _active_data,
-                  _active_prop_name, _index=0, _flt_flag=0):
-        active_bone = armature.edit_bones.active or armature.bones.active
-        has_active_bone = active_bone and bcoll.name in active_bone.collections
-
-        split = layout.split(factor=0.7)
-
-        split.prop(bcoll, "name", text="", emboss=False,
-                   icon='DOT' if has_active_bone else 'BLANK1')
-
-        if cset := bcoll.rigify_color_set_name:
-            split.label(text=cset, icon="COLOR", translate=False)
-
-        icons = layout.row(align=True)
-
-        icons.prop(bcoll, "rigify_sel_set", text="", toggle=True, emboss=False,
-                   icon='RADIOBUT_ON' if bcoll.rigify_sel_set else 'RADIOBUT_OFF')
-        icons.label(text="", icon='RESTRICT_SELECT_OFF' if bcoll.rigify_ui_row > 0 else 'RESTRICT_SELECT_ON')
-        icons.prop(bcoll, "is_visible", text="", emboss=False,
-                   icon='HIDE_OFF' if bcoll.is_visible else 'HIDE_ON')
-
-
-# noinspection PyPep8Naming
-class DATA_PT_rigify_collection_list(bpy.types.Panel):
-    bl_label = "Bone Collection UI"
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_context = "data"
-    bl_options = {'DEFAULT_CLOSED'}
-    bl_parent_id = "DATA_PT_rigify"
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context)
-
-    def draw(self, context):
-        layout = self.layout
-        obj = verify_armature_obj(context.object)
-        arm = obj.data
-
-        # Copy the bone collection list
-        active_coll = arm.collections.active
-
-        row = layout.row()
-
-        row.template_list(
-            "DATA_UL_rigify_bone_collections",
-            "",
-            arm,
-            "collections_all",
-            arm.collections,
-            "active_index",
-            rows=(4 if active_coll else 1),
-        )
-
-        col = row.column(align=True)
-        col.operator("armature.collection_add", icon='ADD', text="")
-        col.operator("armature.collection_remove", icon='REMOVE', text="")
-        if active_coll:
-            col.separator()
-            col.operator("armature.collection_move", icon='TRIA_UP', text="").direction = 'UP'
-            col.operator("armature.collection_move", icon='TRIA_DOWN', text="").direction = 'DOWN'
-
-        layout.operator(operator='armature.rigify_validate_layers')
-
-        if active_coll:
-            col = layout.column()
-            col.use_property_split = True
-            col.use_property_decorate = False
-
-            col.prop(active_coll, "rigify_color_set_name", icon="COLOR")
-            col.prop(active_coll, "rigify_sel_set")
-            col.separator()
-
-            col.prop(active_coll, "rigify_ui_row", )
-            row = col.row()
-            row.active = active_coll.rigify_ui_row > 0  # noqa
-            row.prop(active_coll, "rigify_ui_title")
-
-        if ROOT_COLLECTION not in arm.collections_all:
-            text = iface_("The '{:s}' collection will be added upon generation").format(ROOT_COLLECTION)
-            layout.label(text=text, translate=False, icon='INFO')
-
-
-# noinspection PyPep8Naming
-class DATA_PT_rigify_collection_ui(bpy.types.Panel):
-    bl_label = "UI Layout"
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_context = "data"
-    bl_options = set()
-    bl_parent_id = "DATA_PT_rigify_collection_list"
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context) and len(verify_armature_obj(context.object).data.collections_all)
-
-    @staticmethod
-    def draw_btn_block(arm: Armature, parent: UILayout, bcoll_id: int, loose=False):
-        bcoll = arm.collections_all[bcoll_id]
-        block = parent.row(align=True)
-
-        if bcoll == arm.collections.active:
-            block.prop(bcoll, "rigify_ui_title_name", text="", emboss=True)
-
-            if not loose:
-                props = block.operator(text="", icon="X", operator="armature.rigify_collection_set_ui_row")
-                props.index = bcoll_id
-                props.row = 0
-        else:
-            props = block.operator(text=bcoll.rigify_ui_title_name, operator="armature.rigify_collection_select")
-            props.index = bcoll_id
-
-    def draw(self, context):
-        layout = self.layout
-        obj = verify_armature_obj(context.object)
-        arm = obj.data
-
-        # Sort into button rows
-        row_table = defaultdict(list)
-        has_buttons = False
-
-        index_map = {c.name: i for i, c in enumerate(arm.collections_all)}
-
-        for bcoll in flatten_children(arm.collections):
-            row_table[bcoll.rigify_ui_row].append(index_map[bcoll.name])
-
-            if bcoll.rigify_ui_row > 0:
-                has_buttons = True
-
-        active_bcoll_idx = arm.collections.active_index
-
-        if active_bcoll_idx < 0:
-            layout.label(text="Click a button to select a collection:", icon="INFO")
-
-        box = layout.box()
-        last_row = max(row_table.keys())
-
-        for row_id in range(1, last_row + 2):
-            row = box.row()
-            row_items = row_table[row_id]
-
-            if row_id == 1 and not has_buttons:
-                row.label(text="Click to assign the button here:", icon="INFO")
-
-            grid = row.grid_flow(row_major=True, columns=len(row_items), even_columns=True)
-            for bcoll_id in row_items:
-                self.draw_btn_block(arm, grid, bcoll_id)
-
-            btn_row = row.row(align=True)
-
-            if active_bcoll_idx >= 0:
-                props = btn_row.operator(text="", icon="TRIA_LEFT", operator="armature.rigify_collection_set_ui_row")
-                props.index = active_bcoll_idx
-                props.row = row_id
-
-            if row_id < last_row + 1:
-                props = btn_row.operator(text="", icon="ADD", operator="armature.rigify_collection_add_ui_row")
-                props.row = row_id
-                props.add = True
-            else:
-                btn_row.label(text="", icon="BLANK1")
-
-            if row_id < last_row:
-                props = btn_row.operator(text="", icon="REMOVE", operator="armature.rigify_collection_add_ui_row")
-                props.row = row_id + 1
-                props.add = False
-            else:
-                btn_row.label(text="", icon="BLANK1")
-
-        if 0 in row_table:
-            box = layout.box()
-            box.label(text="Permanently hidden collections:")
-
-            grid = box.grid_flow(row_major=True, columns=2, even_columns=True)
-
-            for i, bcoll_id in enumerate(row_table[0]):
-                self.draw_btn_block(arm, grid, bcoll_id, loose=True)
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_collection_select(bpy.types.Operator):
-    bl_idname = "armature.rigify_collection_select"
-    bl_label = "Make Collection Active"
-    bl_description = "Make this collection active"
-    bl_options = {'UNDO_GROUPED'}
-
-    index: IntProperty(name="Index")
-
-    @staticmethod
-    def button(layout, *, index, **kwargs):
-        props = layout.operator(**kwargs)
-        props.index = index
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        obj.data.collections.active_index = self.index
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_collection_set_ui_row(bpy.types.Operator):
-    bl_idname = "armature.rigify_collection_set_ui_row"
-    bl_label = "Move Between UI Rows"
-    bl_options = {'UNDO'}
-
-    index: IntProperty(name="Index")
-    row: IntProperty(name="Row")
-    select: BoolProperty(name="Select")
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    @classmethod
-    def description(cls, context, properties: Any):
-        if properties.row == 0:
-            return "Remove this button from the UI panel"
-        else:
-            return "Move the active button to this UI panel row"
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        if self.select:
-            obj.data.collections.active_index = self.index
-        obj.data.collections_all[self.index].rigify_ui_row = self.row
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_collection_add_ui_row(bpy.types.Operator):
-    bl_idname = "armature.rigify_collection_add_ui_row"
-    bl_label = "Add/Remove UI Rows"
-    bl_options = {'UNDO'}
-
-    row: IntProperty(name="Row")
-    add: BoolProperty(name="Add")
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    @classmethod
-    def description(cls, context, properties: Any):
-        if properties.add:
-            return "Insert a new row before this one, shifting buttons down"
-        else:
-            return "Remove this row, shifting buttons up"
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        for coll in obj.data.collections_all:
-            if coll.rigify_ui_row >= self.row:
-                coll.rigify_ui_row += (1 if self.add else -1)
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_add_color_sets(bpy.types.Operator):
-    bl_idname = "armature.rigify_add_color_sets"
-    bl_label = "Rigify Add Standard Color Sets"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        armature = obj.data
-
-        if not hasattr(armature, 'rigify_colors'):
-            return {'FINISHED'}
-
-        rigify_colors = get_rigify_colors(armature)
-        groups = ['Root', 'IK', 'Special', 'Tweak', 'FK', 'Extra']
-
-        for g in groups:
-            if g in rigify_colors:
-                continue
-
-            color = rigify_colors.add()
-            color.name = g
-
-            color.select = Color((0.3140000104904175, 0.7839999794960022, 1.0))
-            color.active = Color((0.5490000247955322, 1.0, 1.0))
-            color.standard_colors_lock = True
-
-            if g == "Root":
-                color.normal = Color((0.43529415130615234, 0.18431372940540314, 0.41568630933761597))
-            if g == "IK":
-                color.normal = Color((0.6039215922355652, 0.0, 0.0))
-            if g == "Special":
-                color.normal = Color((0.9568628072738647, 0.7882353663444519, 0.0470588281750679))
-            if g == "Tweak":
-                color.normal = Color((0.03921568766236305, 0.21176472306251526, 0.5803921818733215))
-            if g == "FK":
-                color.normal = Color((0.11764706671237946, 0.5686274766921997, 0.03529411926865578))
-            if g == "Extra":
-                color.normal = Color((0.9686275124549866, 0.250980406999588, 0.0941176563501358))
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_use_standard_colors(bpy.types.Operator):
-    bl_idname = "armature.rigify_use_standard_colors"
-    bl_label = "Rigify Get active/select colors from current theme"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        armature = obj.data
-        if not hasattr(armature, 'rigify_colors'):
-            return {'FINISHED'}
-
-        current_theme = bpy.context.preferences.themes.items()[0][0]
-        theme = bpy.context.preferences.themes[current_theme]
-
-        selection_colors = get_selection_colors(armature)
-        selection_colors.select = theme.view_3d.bone_pose
-        selection_colors.active = theme.view_3d.bone_pose_active
-
-        # for col in armature.rigify_colors:
-        #     col.select = theme.view_3d.bone_pose
-        #     col.active = theme.view_3d.bone_pose_active
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_apply_selection_colors(bpy.types.Operator):
-    bl_idname = "armature.rigify_apply_selection_colors"
-    bl_label = "Rigify Apply user defined active/select colors"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        armature = obj.data
-
-        if not hasattr(armature, 'rigify_colors'):
-            return {'FINISHED'}
-
-        # current_theme = bpy.context.preferences.themes.items()[0][0]
-        # theme = bpy.context.preferences.themes[current_theme]
-
-        rigify_colors = get_rigify_colors(armature)
-        selection_colors = get_selection_colors(armature)
-
-        for col in rigify_colors:
-            col.select = selection_colors.select
-            col.active = selection_colors.active
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_color_set_add(bpy.types.Operator):
-    bl_idname = "armature.rigify_color_set_add"
-    bl_label = "Rigify Add Color Set"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = context.object
-        armature = obj.data
-
-        if hasattr(armature, 'rigify_colors'):
-            armature.rigify_colors.add()
-            armature.rigify_colors[-1].name = unique_name(armature.rigify_colors, 'Group')
-
-            current_theme = bpy.context.preferences.themes.items()[0][0]
-            theme = bpy.context.preferences.themes[current_theme]
-
-            armature.rigify_colors[-1].normal = theme.view_3d.wire
-            armature.rigify_colors[-1].normal.hsv = theme.view_3d.wire.hsv
-            armature.rigify_colors[-1].select = theme.view_3d.bone_pose
-            armature.rigify_colors[-1].select.hsv = theme.view_3d.bone_pose.hsv
-            armature.rigify_colors[-1].active = theme.view_3d.bone_pose_active
-            armature.rigify_colors[-1].active.hsv = theme.view_3d.bone_pose_active.hsv
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_color_set_add_theme(bpy.types.Operator):
-    bl_idname = "armature.rigify_color_set_add_theme"
-    bl_label = "Rigify Add Color Set from Theme"
-    bl_options = {"REGISTER", "UNDO"}
-
-    theme: EnumProperty(items=(
-        ('THEME01', 'THEME01', ''),
-        ('THEME02', 'THEME02', ''),
-        ('THEME03', 'THEME03', ''),
-        ('THEME04', 'THEME04', ''),
-        ('THEME05', 'THEME05', ''),
-        ('THEME06', 'THEME06', ''),
-        ('THEME07', 'THEME07', ''),
-        ('THEME08', 'THEME08', ''),
-        ('THEME09', 'THEME09', ''),
-        ('THEME10', 'THEME10', ''),
-        ('THEME11', 'THEME11', ''),
-        ('THEME12', 'THEME12', ''),
-        ('THEME13', 'THEME13', ''),
-        ('THEME14', 'THEME14', ''),
-        ('THEME15', 'THEME15', ''),
-        ('THEME16', 'THEME16', ''),
-        ('THEME17', 'THEME17', ''),
-        ('THEME18', 'THEME18', ''),
-        ('THEME19', 'THEME19', ''),
-        ('THEME20', 'THEME20', '')
-    ),
-        name='Theme')
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        armature = obj.data
-
-        if hasattr(armature, 'rigify_colors'):
-            rigify_colors = get_rigify_colors(armature)
-
-            if self.theme in rigify_colors.keys():
-                return {'FINISHED'}
-
-            rigify_colors.add()
-            rigify_colors[-1].name = self.theme
-
-            color_id = int(self.theme[-2:]) - 1
-
-            theme_color_set = bpy.context.preferences.themes[0].bone_color_sets[color_id]
-
-            rigify_colors[-1].normal = theme_color_set.normal
-            rigify_colors[-1].select = theme_color_set.select
-            rigify_colors[-1].active = theme_color_set.active
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_color_set_remove(bpy.types.Operator):
-    bl_idname = "armature.rigify_color_set_remove"
-    bl_label = "Rigify Remove Color Set"
-    bl_options = {'UNDO'}
-
-    idx: IntProperty()
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-
-        rigify_colors = get_rigify_colors(obj.data)
-        rigify_colors.remove(self.idx)
-
-        # set layers references to 0
-        for coll in obj.data.collections_all:
-            idx = coll.rigify_color_set_id
-
-            if idx == self.idx + 1:
-                coll.rigify_color_set_id = 0
-            elif idx > self.idx + 1:
-                coll.rigify_color_set_id = idx - 1
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_OT_rigify_color_set_remove_all(bpy.types.Operator):
-    bl_idname = "armature.rigify_color_set_remove_all"
-    bl_label = "Rigify Remove All Color Sets"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object and context.object.type == 'ARMATURE'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-
-        rigify_colors = get_rigify_colors(obj.data)
-        while len(rigify_colors) > 0:
-            rigify_colors.remove(0)
-
-        # set layers references to 0
-        for coll in obj.data.collections_all:
-            coll.rigify_color_set_id = 0
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class DATA_UL_rigify_color_sets(bpy.types.UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_prop_name, index=0, flt_flag=0):
-        row = layout.row(align=True)
-        row = row.split(factor=0.1)
-        row.label(text=str(index + 1))
-        row = row.split(factor=0.7)
-        row.prop(item, "name", text='', emboss=False)
-        row = row.row(align=True)
-        # icon = 'LOCKED' if item.standard_colors_lock else 'UNLOCKED'
-        # row.prop(item, "standard_colors_lock", text='', icon=icon)
-        row.prop(item, "normal", text='')
-        row2 = row.row(align=True)
-        row2.prop(item, "select", text='')
-        row2.prop(item, "active", text='')
-        # row2.enabled = not item.standard_colors_lock
-        arm = verify_armature_obj(context.object).data
-        row2.enabled = not get_colors_lock(arm)
-
-
-# noinspection PyPep8Naming
-class DATA_MT_rigify_color_sets_context_menu(bpy.types.Menu):
-    bl_label = 'Rigify Color Sets Specials'
-
-    def draw(self, context):
-        layout = self.layout
-
-        layout.operator('armature.rigify_color_set_remove_all')
-
-
-# noinspection SpellCheckingInspection
-# noinspection PyPep8Naming
-class DATA_PT_rigify_color_sets(bpy.types.Panel):
-    bl_label = "Color Sets"
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_context = "data"
-    bl_options = {'DEFAULT_CLOSED'}
-    bl_parent_id = "DATA_PT_rigify"
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context)
-
-    def draw(self, context):
-        obj = verify_armature_obj(context.object)
-        armature = obj.data
-        idx = get_colors_index(armature)
-        selection_colors = get_selection_colors(armature)
-        is_locked = get_colors_lock(armature)
-        theme = get_theme_to_add(armature)
-
-        layout = self.layout
-        row = layout.row()
-        row.operator("armature.rigify_use_standard_colors", icon='FILE_REFRESH', text='')
-        row = row.row(align=True)
-        row.prop(selection_colors, 'select', text='')
-        row.prop(selection_colors, 'active', text='')
-        row = layout.row(align=True)
-        icon = 'LOCKED' if is_locked else 'UNLOCKED'
-        row.prop(armature, 'rigify_colors_lock', text='Unified select/active colors', icon=icon)
-        row.operator("armature.rigify_apply_selection_colors", icon='FILE_REFRESH', text='Apply')
-        row = layout.row()
-        row.template_list("DATA_UL_rigify_color_sets", "", obj.data, "rigify_colors", obj.data, "rigify_colors_index")
-
-        col = row.column(align=True)
-        col.operator("armature.rigify_color_set_add", icon='ADD', text="")
-        col.operator("armature.rigify_color_set_remove", icon='REMOVE', text="").idx = idx
-        col.menu("DATA_MT_rigify_color_sets_context_menu", icon='DOWNARROW_HLT', text="")
-        row = layout.row()
-        row.prop(armature, 'rigify_theme_to_add', text='Theme')
-        op = row.operator("armature.rigify_color_set_add_theme", text="Add From Theme")
-        op.theme = theme
-        row = layout.row()
-        row.operator("armature.rigify_add_color_sets", text="Add Standard")
-
-
-# noinspection PyPep8Naming
-class BONE_PT_rigify_buttons(bpy.types.Panel):
-    bl_label = "Rigify Type"
-    bl_space_type = 'PROPERTIES'
-    bl_region_type = 'WINDOW'
-    bl_context = "bone"
-    # bl_options = {'DEFAULT_OPEN'}
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context) and context.active_pose_bone
-
-    def draw(self, context):
-        C = context
-        id_store = C.window_manager
-        bone = context.active_pose_bone
-        rig_name = get_rigify_type(bone)
-
-        layout = self.layout
-        rig_types = get_rigify_types(id_store)
-
-        # Build types list
-        build_type_list(context, rig_types)
-
-        # Rig type field
-        if len(feature_set_list.get_enabled_modules_names()) > 0:
-            row = layout.row()
-            row.prop(context.object.data, "active_feature_set")
-        row = layout.row()
-        row.prop_search(bone, "rigify_type", id_store, "rigify_types", text="Rig type")
-
-        # Rig type parameters / Rig type non-exist alert
-        if rig_name != "":
-            try:
-                rig = rig_lists.rigs[rig_name]['module']
-            except (ImportError, AttributeError, KeyError):
-                row = layout.row()
-                box = row.box()
-                text = rpt_("ERROR: type \"{:s}\" does not exist!").format(rig_name)
-                box.label(text=text, icon='ERROR', translate=False)
-            else:
-                if hasattr(rig.Rig, 'parameters_ui'):
-                    rig = rig.Rig
-
-                try:
-                    param_cb = rig.parameters_ui
-
-                    # Ignore the known empty base method
-                    if getattr(param_cb, '__func__', None) == \
-                            getattr(base_rig.BaseRig.parameters_ui, '__func__'):
-                        param_cb = None
-                except AttributeError:
-                    param_cb = None
-
-                if param_cb is None:
-                    col = layout.column()
-                    col.label(text="No options")
-                else:
-                    col = layout.column()
-                    col.label(text="Options:")
-                    box = layout.box()
-                    param_cb(box, get_rigify_params(bone))
-
-
-# noinspection PyPep8Naming
-class VIEW3D_PT_tools_rigify_dev(bpy.types.Panel):
-    bl_label = "Rigify Dev Tools"
-    bl_space_type = 'VIEW_3D'
-    bl_region_type = 'UI'
-    bl_category = "Rigify"
-
-    @classmethod
-    def poll(cls, context):
-        return context.mode in ['EDIT_ARMATURE', 'EDIT_MESH']
-
-    def draw(self, context):
-        obj = context.active_object
-        if obj is not None:
-            if context.mode == 'EDIT_ARMATURE':
-                r = self.layout.row()
-                r.operator("armature.rigify_encode_metarig", text="Encode Metarig to Python")
-                r = self.layout.row()
-                r.operator("armature.rigify_encode_metarig_sample", text="Encode Sample to Python")
-
-            if context.mode == 'EDIT_MESH':
-                r = self.layout.row()
-                r.operator("mesh.rigify_encode_mesh_widget", text="Encode Mesh Widget to Python")
-
-
-# noinspection PyPep8Naming
-class VIEW3D_PT_rigify_animation_tools(bpy.types.Panel):
-    bl_label = "Rigify Animation Tools"
-    bl_context = "posemode"  # noqa
-    bl_space_type = 'VIEW_3D'
-    bl_region_type = 'UI'
-    bl_category = "Rigify"
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        if not obj or obj.type != 'ARMATURE':
-            return False
-
-        rig_id = obj.data.get("rig_id", "")
-        if not rig_id:
-            return False
-
-        has_arm = hasattr(bpy.types, f'POSE_OT_rigify_arm_ik2fk_{rig_id}')
-        has_leg = hasattr(bpy.types, f'POSE_OT_rigify_leg_ik2fk_{rig_id}')
-        return has_arm or has_leg
-
-    def draw(self, context):
-        obj = context.active_object
-        id_store = context.window_manager
-        if obj is not None:
-            row = self.layout.row()
-
-            only_selected = get_transfer_only_selected(id_store)
-
-            if only_selected:
-                icon = 'OUTLINER_DATA_ARMATURE'
-            else:
-                icon = 'ARMATURE_DATA'
-
-            row.prop(id_store, 'rigify_transfer_only_selected', toggle=True, icon=icon)
-
-            row = self.layout.row(align=True)
-            row.operator("rigify.ik2fk", text='IK2FK Pose', icon='SNAP_ON')
-            row.operator("rigify.fk2ik", text='FK2IK Pose', icon='SNAP_ON')
-
-            row = self.layout.row(align=True)
-            row.operator("rigify.transfer_fk_to_ik", text='IK2FK Action', icon='ACTION_TWEAK')
-            row.operator("rigify.transfer_ik_to_fk", text='FK2IK Action', icon='ACTION_TWEAK')
-
-            row = self.layout.row(align=True)
-            row.operator("rigify.clear_animation", text="Clear IK Action", icon='CANCEL').anim_type = "IK"
-            row.operator("rigify.clear_animation", text="Clear FK Action", icon='CANCEL').anim_type = "FK"
-
-            row = self.layout.row(align=True)
-            op = row.operator("rigify.rotation_pole", icon='FORCE_HARMONIC', text='Switch to pole')
-            op.value = True
-            op.toggle = False
-            op.bake = True
-            op = row.operator("rigify.rotation_pole", icon='FORCE_MAGNETIC', text='Switch to rotation')
-            op.value = False
-            op.toggle = False
-            op.bake = True
-            RIGIFY_OT_get_frame_range.draw_range_ui(context, self.layout)
-
-
-def rigify_report_exception(operator, exception):
-    import traceback
-    import sys
-    import os
-    # find the non-utils module name where the error happened
-    # hint, this is the metarig type!
-    _exception_type, _exception_value, exception_traceback = sys.exc_info()
-    fns = [item.filename for item in traceback.extract_tb(exception_traceback)]
-    fns_rig = [fn for fn in fns if os.path.basename(os.path.dirname(fn)) != 'utils']
-    fn = fns_rig[-1]
-    fn = os.path.basename(fn)
-    fn = os.path.splitext(fn)[0]
-    message = []
-    if fn.startswith("__"):
-        message.append(rpt_("Incorrect armature..."))
-    else:
-        message.append(rpt_("Incorrect armature for type '{:s}'").format(fn))
-    message.append(exception.message)
-
-    message.reverse()  # XXX - stupid! menu's are upside down!
-
-    operator.report({'ERROR'}, '\n'.join(message))
-
-
-def is_metarig(obj):
-    if not (obj and obj.data and obj.type == 'ARMATURE'):
-        return False
-    if 'rig_id' in obj.data:
-        return False
-    for b in obj.pose.bones:
-        if b.rigify_type != "":
-            return True
-    return False
-
-
-class Generate(bpy.types.Operator):
-    bl_idname = "pose.rigify_generate"
-    bl_label = "Rigify Generate Rig"
-    bl_options = {'UNDO'}
-    bl_description = "Generate a rig from the active metarig armature"
-
-    @classmethod
-    def poll(cls, context):
-        return is_metarig(context.object)
-
-    def execute(self, context):
-        metarig = verify_armature_obj(context.object)
-
-        for bcoll in metarig.data.collections_all:
-            if bcoll.rigify_ui_row > 0 and bcoll.name not in SPECIAL_COLLECTIONS:
-                break
-        else:
-            self.report(
-                {'ERROR'},
-                'No bone collections have UI buttons assigned - please check the Bone Collections UI sub-panel'
-            )
-            return {'CANCELLED'}
-
-        try:
-            generate.generate_rig(context, metarig)
-        except MetarigError as rig_exception:
-            import traceback
-            traceback.print_exc()
-
-            rigify_report_exception(self, rig_exception)
-        except Exception as rig_exception:
-            import traceback
-            traceback.print_exc()
-
-            message = rpt_("Generation has thrown an exception: ") + str(rig_exception)
-            self.report({'ERROR'}, message)
-        else:
-            target_rig = get_rigify_target_rig(metarig.data)
-            message = rpt_('Successfully generated: "{:s}"').format(target_rig.name)
-            self.report({'INFO'}, message)
-        finally:
-            bpy.ops.object.mode_set(mode='OBJECT')
-
-        return {'FINISHED'}
-
-
-class UpgradeMetarigTypes(bpy.types.Operator):
-    bl_idname = "pose.rigify_upgrade_types"
-    bl_label = "Rigify Upgrade Metarig Types"
-    bl_description = "Upgrade the Rigify types on the active metarig armature"
-    bl_options = {'UNDO'}
-
-    def execute(self, context):
-        upgrade_metarig_types(verify_armature_obj(context.active_object))
-        return {'FINISHED'}
-
-
-class UpgradeMetarigLayers(bpy.types.Operator):
-    """Upgrades the metarig from bone layers to bone collections"""
-
-    bl_idname = "armature.rigify_upgrade_layers"
-    bl_label = "Rigify Upgrade Metarig Layers"
-    bl_description = "Upgrade the metarig from bone layers to bone collections"
-    bl_options = {'UNDO'}
-
-    def execute(self, context):
-        upgrade_metarig_layers(verify_armature_obj(context.active_object))
-        return {'FINISHED'}
-
-
-class ValidateMetarigLayers(bpy.types.Operator):
-    """Validates references from rig component settings to bone collections"""
-
-    bl_idname = "armature.rigify_validate_layers"
-    bl_label = "Validate Collection References"
-    bl_description = (
-        "Validate references from rig component settings to bone collections.\n"
-        "Always run this both before and after joining two metarig armature objects into one to avoid glitches"
-    )
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context) and context.object.mode != 'EDIT'
-
-    def execute(self, context):
-        obj = verify_armature_obj(context.object)
-        messages = validate_collection_references(obj)
-        for msg in messages:
-            self.report({'WARNING'}, msg)
-        if not messages:
-            self.report({'INFO'}, "No issues detected")
-        return {'FINISHED'}
-
-
-class Sample(bpy.types.Operator):
-    """Create a sample metarig to be modified before generating the final rig"""
-
-    bl_idname = "armature.metarig_sample_add"
-    bl_label = "Add Metarig Sample"
-    bl_options = {'UNDO'}
-
-    metarig_type: StringProperty(
-        name="Type",
-        description="Name of the rig type to generate a sample of",
-        maxlen=128,
-        options={'SKIP_SAVE'}
-    )
-
-    @classmethod
-    def poll(cls, context):
-        return context.mode == 'EDIT_ARMATURE'
-
-    def draw(self, context):
-        layout = self.layout
-        layout.use_property_split = True
-        layout.use_property_decorate = False
-        col = layout.column()
-        build_type_list(context, get_rigify_types(context.window_manager))
-        col.prop(context.object.data, "active_feature_set")
-        col.prop_search(self, "metarig_type", context.window_manager, "rigify_types")
-
-    def invoke(self, context, event):
-        if self.metarig_type == "":
-            return context.window_manager.invoke_props_dialog(self)
-        return self.execute(context)
-
-    def execute(self, context):
-        if self.metarig_type == "":
-            self.report({'ERROR'}, "You must select a rig type to create a sample of")
-            return {'CANCELLED'}
-        try:
-            rig = rig_lists.rigs[self.metarig_type]["module"]
-            create_sample = rig.create_sample
-        except (ImportError, AttributeError, KeyError):
-            raise Exception("rig type '" + self.metarig_type + "' has no sample.")
-        else:
-            create_sample(context.active_object)
-        finally:
-            bpy.ops.object.mode_set(mode='EDIT')
-
-        return {'FINISHED'}
-
-
-class EncodeMetarig(bpy.types.Operator):
-    """Create Python code that will generate the selected metarig"""
-    bl_idname = "armature.rigify_encode_metarig"
-    bl_label = "Rigify Encode Metarig"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.mode == 'EDIT_ARMATURE' and is_metarig(context.object)
-
-    def execute(self, context):
-        name = "metarig.py"
-
-        if name in bpy.data.texts:
-            text_block = bpy.data.texts[name]
-            text_block.clear()
-        else:
-            text_block = bpy.data.texts.new(name)
-
-        obj = verify_armature_obj(context.active_object)
-        text = write_metarig(obj, layers=True, func_name="create", groups=True, widgets=True)
-        text_block.write(text)
-        bpy.ops.object.mode_set(mode='EDIT')
-        message = rpt_("Metarig written to text datablock {:s}").format(text_block.name)
-        self.report({'INFO'}, message)
-        return {'FINISHED'}
-
-
-class EncodeMetarigSample(bpy.types.Operator):
-    """Create Python code that will generate the selected metarig as a sample"""
-    bl_idname = "armature.rigify_encode_metarig_sample"
-    bl_label = "Rigify Encode Metarig Sample"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.mode == 'EDIT_ARMATURE' and is_metarig(context.object)
-
-    def execute(self, context):
-        name = "metarig_sample.py"
-
-        if name in bpy.data.texts:
-            text_block = bpy.data.texts[name]
-            text_block.clear()
-        else:
-            text_block = bpy.data.texts.new(name)
-
-        obj = verify_armature_obj(context.active_object)
-        text = write_metarig(obj, layers=False, func_name="create_sample")
-        text_block.write(text)
-        bpy.ops.object.mode_set(mode='EDIT')
-
-        message = rpt_("Metarig Sample written to text datablock {:s}").format(text_block.name)
-        self.report({'INFO'}, message)
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class VIEW3D_MT_rigify(bpy.types.Menu):
-    bl_label = "Rigify"
-    bl_idname = "VIEW3D_MT_rigify"
-
-    append: Callable
-    remove: Callable
-
-    def draw(self, context):
-        layout = self.layout
-        obj = verify_armature_obj(context.object)
-        target_rig = get_rigify_target_rig(obj.data)
-
-        text = (
-            n_("Re-Generate Rig", i18n_contexts.operator_default) if target_rig
-            else n_("Generate Rig", i18n_contexts.operator_default)
-        )
-        layout.operator(Generate.bl_idname, text=text)
-
-        if context.mode == 'EDIT_ARMATURE':
-            layout.separator()
-            layout.operator(Sample.bl_idname)
-            layout.separator()
-            layout.operator(EncodeMetarig.bl_idname, text="Encode Metarig")
-            layout.operator(EncodeMetarigSample.bl_idname, text="Encode Metarig Sample")
-
-
-def draw_rigify_menu(self, context):
-    if is_metarig(context.object):
-        self.layout.menu(VIEW3D_MT_rigify.bl_idname)
-
-
-class EncodeWidget(bpy.types.Operator):
-    """Create Python code that will generate the selected metarig"""
-    bl_idname = "mesh.rigify_encode_mesh_widget"
-    bl_label = "Rigify Encode Widget"
-    bl_options = {'UNDO'}
-
-    @classmethod
-    def poll(cls, context):
-        return context.mode == 'EDIT_MESH'
-
-    def execute(self, context):
-        name = "widget.py"
-
-        if name in bpy.data.texts:
-            text_block = bpy.data.texts[name]
-            text_block.clear()
-        else:
-            text_block = bpy.data.texts.new(name)
-
-        text = write_widget(context.active_object)
-        text_block.write(text)
-        bpy.ops.object.mode_set(mode='EDIT')
-
-        return {'FINISHED'}
-
-
-def draw_mesh_edit_menu(self, _context: bpy.types.Context):
-    self.layout.operator(EncodeWidget.bl_idname)
-    self.layout.separator()
-
-
-def fk_to_ik(rig: ArmatureObject, window='ALL'):
-    scn = bpy.context.scene
-    id_store = bpy.context.window_manager
-
-    rig_id = rig.data['rig_id']
-    leg_ik2fk = eval('bpy.ops.pose.rigify_leg_ik2fk_' + rig_id)
-    arm_ik2fk = eval('bpy.ops.pose.rigify_arm_ik2fk_' + rig_id)
-    limb_generated_names = get_limb_generated_names(rig)
-
-    if window == 'ALL':
-        frames = get_keyed_frames_in_range(bpy.context, rig)
-    elif window == 'CURRENT':
-        frames = [scn.frame_current]
-    else:
-        frames = [scn.frame_current]
-
-    only_selected = get_transfer_only_selected(id_store)
-
-    if not only_selected:
-        pose_bones = rig.pose.bones
-        bpy.ops.pose.select_all(action='DESELECT')
-    else:
-        pose_bones = bpy.context.selected_pose_bones
-        bpy.ops.pose.select_all(action='DESELECT')
-
-    for b in pose_bones:
-        for group in limb_generated_names:
-            if b.name in limb_generated_names[group].values() or b.name in limb_generated_names[group]['controls']\
-                    or b.name in limb_generated_names[group]['ik_ctrl']:
-                names = limb_generated_names[group]
-                if names['limb_type'] == 'arm':
-                    func = arm_ik2fk
-                    controls = names['controls']
-                    ik_ctrl = names['ik_ctrl']
-                    # fk_ctrl = names['fk_ctrl']
-                    parent = names['parent']
-                    pole = names['pole']
-                    rig.pose.bones[controls[0]].select = True
-                    rig.pose.bones[controls[4]].select = True
-                    rig.pose.bones[pole].select = True
-                    rig.pose.bones[parent].select = True
-                    kwargs = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
-                              'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1], 'hand_ik': controls[4],
-                              'pole': pole, 'main_parent': parent}
-                    args = (controls[0], controls[1], controls[2], controls[3],
-                            controls[4], pole, parent)
-                else:
-                    func = leg_ik2fk
-                    controls = names['controls']
-                    ik_ctrl = names['ik_ctrl']
-                    # fk_ctrl = names['fk_ctrl']
-                    parent = names['parent']
-                    pole = names['pole']
-                    rig.pose.bones[controls[0]].select = True
-                    rig.pose.bones[controls[6]].select = True
-                    rig.pose.bones[controls[5]].select = True
-                    rig.pose.bones[pole].select = True
-                    rig.pose.bones[parent].select = True
-                    # noinspection SpellCheckingInspection
-                    kwargs = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
-                              'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
-                              'foot_ik': controls[6], 'pole': pole, 'footroll': controls[5], 'mfoot_ik': ik_ctrl[2],
-                              'main_parent': parent}
-                    args = (controls[0], controls[1], controls[2], controls[3],
-                            controls[6], controls[5], pole, parent)
-
-                for f in frames:
-                    if not bones_in_frame(f, rig, *args):
-                        continue
-                    scn.frame_set(f)
-                    func(**kwargs)
-                    bpy.ops.anim.keyframe_insert_menu(type='BUILTIN_KSI_VisualLocRot')
-                    bpy.ops.anim.keyframe_insert_menu(type='Scaling')
-
-                bpy.ops.pose.select_all(action='DESELECT')
-                limb_generated_names.pop(group)
-                break
-
-
-def ik_to_fk(rig: ArmatureObject, window='ALL'):
-    scn = bpy.context.scene
-    id_store = bpy.context.window_manager
-
-    rig_id = rig.data['rig_id']
-    leg_fk2ik = eval('bpy.ops.pose.rigify_leg_fk2ik_' + rig_id)
-    arm_fk2ik = eval('bpy.ops.pose.rigify_arm_fk2ik_' + rig_id)
-    limb_generated_names = get_limb_generated_names(rig)
-
-    if window == 'ALL':
-        frames = get_keyed_frames_in_range(bpy.context, rig)
-    elif window == 'CURRENT':
-        frames = [scn.frame_current]
-    else:
-        frames = [scn.frame_current]
-
-    only_selected = get_transfer_only_selected(id_store)
-
-    if not only_selected:
-        bpy.ops.pose.select_all(action='DESELECT')
-        pose_bones = rig.pose.bones
-    else:
-        pose_bones = bpy.context.selected_pose_bones
-        bpy.ops.pose.select_all(action='DESELECT')
-
-    for b in pose_bones:
-        for group in limb_generated_names:
-            if b.name in limb_generated_names[group].values() or b.name in limb_generated_names[group]['controls']\
-                    or b.name in limb_generated_names[group]['ik_ctrl']:
-                names = limb_generated_names[group]
-                if names['limb_type'] == 'arm':
-                    func = arm_fk2ik
-                    controls = names['controls']
-                    ik_ctrl = names['ik_ctrl']
-                    # fk_ctrl = names['fk_ctrl']
-                    parent = names['parent']
-                    pole = names['pole']
-                    rig.pose.bones[controls[1]].select = True
-                    rig.pose.bones[controls[2]].select = True
-                    rig.pose.bones[controls[3]].select = True
-                    kwargs = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
-                              'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1],
-                              'hand_ik': controls[4]}
-                    args = (controls[0], controls[1], controls[2], controls[3],
-                            controls[4], pole, parent)
-                else:
-                    func = leg_fk2ik
-                    controls = names['controls']
-                    ik_ctrl = names['ik_ctrl']
-                    # fk_ctrl = names['fk_ctrl']
-                    parent = names['parent']
-                    pole = names['pole']
-                    rig.pose.bones[controls[1]].select = True
-                    rig.pose.bones[controls[2]].select = True
-                    rig.pose.bones[controls[3]].select = True
-                    # noinspection SpellCheckingInspection
-                    kwargs = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
-                              'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
-                              'foot_ik': ik_ctrl[2], 'mfoot_ik': ik_ctrl[2]}
-                    args = (controls[0], controls[1], controls[2], controls[3],
-                            controls[6], controls[5], pole, parent)
-
-                for f in frames:
-                    if not bones_in_frame(f, rig, *args):
-                        continue
-                    scn.frame_set(f)
-                    func(**kwargs)
-                    bpy.ops.anim.keyframe_insert_menu(type='BUILTIN_KSI_VisualLocRot')
-                    bpy.ops.anim.keyframe_insert_menu(type='Scaling')
-
-                bpy.ops.pose.select_all(action='DESELECT')
-                limb_generated_names.pop(group)
-                break
-
-
-def clear_animation(channelbag, anim_type, names):
-    bones = []
-    for group in names:
-        if names[group]['limb_type'] == 'arm':
-            if anim_type == 'IK':
-                bones.extend([names[group]['controls'][0], names[group]['controls'][4]])
-            elif anim_type == 'FK':
-                bones.extend([names[group]['controls'][1], names[group]['controls'][2], names[group]['controls'][3]])
-        else:
-            if anim_type == 'IK':
-                bones.extend([names[group]['controls'][0], names[group]['controls'][6], names[group]['controls'][5],
-                              names[group]['controls'][4]])
-            elif anim_type == 'FK':
-                bones.extend([names[group]['controls'][1], names[group]['controls'][2], names[group]['controls'][3],
-                              names[group]['controls'][4]])
-    f_curves = []
-    for fcu in channelbag.fcurves:
-        words = fcu.data_path.split('"')
-        if words[0] == "pose.bones[" and words[1] in bones:
-            f_curves.append(fcu)
-
-    if not f_curves:
-        return
-
-    for fcu in f_curves:
-        channelbag.fcurves.remove(fcu)
-
-    # Put cleared bones back to rest pose
-    bpy.ops.pose.loc_clear()
-    bpy.ops.pose.rot_clear()
-    bpy.ops.pose.scale_clear()
-
-    # updateView3D()
-
-
-def rot_pole_toggle(rig: ArmatureObject, window='ALL', value=False, toggle=False, bake=False):
-    scn = bpy.context.scene
-    id_store = bpy.context.window_manager
-
-    rig_id = rig.data['rig_id']
-    leg_fk2ik = eval('bpy.ops.pose.rigify_leg_fk2ik_' + rig_id)
-    arm_fk2ik = eval('bpy.ops.pose.rigify_arm_fk2ik_' + rig_id)
-    leg_ik2fk = eval('bpy.ops.pose.rigify_leg_ik2fk_' + rig_id)
-    arm_ik2fk = eval('bpy.ops.pose.rigify_arm_ik2fk_' + rig_id)
-    limb_generated_names = get_limb_generated_names(rig)
-
-    if window == 'ALL':
-        frames = get_keyed_frames_in_range(bpy.context, rig)
-    elif window == 'CURRENT':
-        frames = [scn.frame_current]
-    else:
-        frames = [scn.frame_current]
-
-    only_selected = get_transfer_only_selected(id_store)
-
-    if not only_selected:
-        bpy.ops.pose.select_all(action='DESELECT')
-        pose_bones = rig.pose.bones
-    else:
-        pose_bones = bpy.context.selected_pose_bones
-        bpy.ops.pose.select_all(action='DESELECT')
-
-    for b in pose_bones:
-        for group in limb_generated_names:
-            names = limb_generated_names[group]
-
-            if toggle:
-                new_pole_vector_value = not rig.pose.bones[names['parent']]['pole_vector']
-            else:
-                new_pole_vector_value = value
-
-            if b.name in names.values() or b.name in names['controls'] or b.name in names['ik_ctrl']:
-                if names['limb_type'] == 'arm':
-                    func1 = arm_fk2ik
-                    func2 = arm_ik2fk
-                    controls = names['controls']
-                    ik_ctrl = names['ik_ctrl']
-                    # fk_ctrl = names['fk_ctrl']
-                    parent = names['parent']
-                    pole = names['pole']
-                    rig.pose.bones[controls[0]].select = not new_pole_vector_value
-                    rig.pose.bones[controls[4]].select = not new_pole_vector_value
-                    rig.pose.bones[parent].select = not new_pole_vector_value
-                    rig.pose.bones[pole].select = new_pole_vector_value
-
-                    kwargs1 = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
-                               'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1],
-                               'hand_ik': controls[4]}
-                    kwargs2 = {'uarm_fk': controls[1], 'farm_fk': controls[2], 'hand_fk': controls[3],
-                               'uarm_ik': controls[0], 'farm_ik': ik_ctrl[1], 'hand_ik': controls[4],
-                               'pole': pole, 'main_parent': parent}
-                    args = (controls[0], controls[4], pole, parent)
-                else:
-                    func1 = leg_fk2ik
-                    func2 = leg_ik2fk
-                    controls = names['controls']
-                    ik_ctrl = names['ik_ctrl']
-                    # fk_ctrl = names['fk_ctrl']
-                    parent = names['parent']
-                    pole = names['pole']
-                    rig.pose.bones[controls[0]].select = not new_pole_vector_value
-                    rig.pose.bones[controls[6]].select = not new_pole_vector_value
-                    rig.pose.bones[controls[5]].select = not new_pole_vector_value
-                    rig.pose.bones[parent].select = not new_pole_vector_value
-                    rig.pose.bones[pole].select = new_pole_vector_value
-
-                    # noinspection SpellCheckingInspection
-                    kwargs1 = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
-                               'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
-                               'foot_ik': ik_ctrl[2], 'mfoot_ik': ik_ctrl[2]}
-                    # noinspection SpellCheckingInspection
-                    kwargs2 = {'thigh_fk': controls[1], 'shin_fk': controls[2], 'foot_fk': controls[3],
-                               'mfoot_fk': controls[7], 'thigh_ik': controls[0], 'shin_ik': ik_ctrl[1],
-                               'foot_ik': controls[6], 'pole': pole, 'footroll': controls[5], 'mfoot_ik': ik_ctrl[2],
-                               'main_parent': parent}
-                    args = (controls[0], controls[6], controls[5], pole, parent)
-
-                for f in frames:
-                    if bake and not bones_in_frame(f, rig, *args):
-                        continue
-                    scn.frame_set(f)
-                    func1(**kwargs1)
-                    rig.pose.bones[names['parent']]['pole_vector'] = new_pole_vector_value
-                    func2(**kwargs2)
-                    if bake:
-                        bpy.ops.anim.keyframe_insert_menu(type='BUILTIN_KSI_VisualLocRot')
-                        bpy.ops.anim.keyframe_insert_menu(type='Scaling')
-                        overwrite_prop_animation(rig, rig.pose.bones[parent], 'pole_vector', new_pole_vector_value, [f])
-
-                bpy.ops.pose.select_all(action='DESELECT')
-                limb_generated_names.pop(group)
-                break
-    scn.frame_set(0)
-
-
-# noinspection PyPep8Naming
-class OBJECT_OT_IK2FK(bpy.types.Operator):
-    """ Snaps IK limb on FK limb at current frame"""
-    bl_idname = "rigify.ik2fk"
-    bl_label = "IK2FK"
-    bl_description = "Snaps IK limb on FK"
-    bl_options = {'INTERNAL'}
-
-    def execute(self, context):
-        rig = verify_armature_obj(context.object)
-
-        fk_to_ik(rig, window='CURRENT')
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class OBJECT_OT_FK2IK(bpy.types.Operator):
-    """ Snaps FK limb on IK limb at current frame"""
-    bl_idname = "rigify.fk2ik"
-    bl_label = "FK2IK"
-    bl_description = "Snaps FK limb on IK"
-    bl_options = {'INTERNAL'}
-
-    def execute(self, context):
-        rig = verify_armature_obj(context.object)
-
-        ik_to_fk(rig, window='CURRENT')
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class OBJECT_OT_TransferFKtoIK(bpy.types.Operator):
-    """Transfers FK animation to IK"""
-    bl_idname = "rigify.transfer_fk_to_ik"
-    bl_label = "Transfer FK anim to IK"
-    bl_description = "Transfer FK animation to IK bones"
-    bl_options = {'INTERNAL'}
-
-    def execute(self, context):
-        rig = verify_armature_obj(context.object)
-
-        fk_to_ik(rig)
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class OBJECT_OT_TransferIKtoFK(bpy.types.Operator):
-    """Transfers FK animation to IK"""
-    bl_idname = "rigify.transfer_ik_to_fk"
-    bl_label = "Transfer IK anim to FK"
-    bl_description = "Transfer IK animation to FK bones"
-    bl_options = {'INTERNAL'}
-
-    def execute(self, context):
-        rig = verify_armature_obj(context.object)
-
-        ik_to_fk(rig)
-
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class OBJECT_OT_ClearAnimation(bpy.types.Operator):
-    bl_idname = "rigify.clear_animation"
-    bl_label = "Clear Animation"
-    bl_description = "Clear animation for FK or IK bones"
-    bl_options = {'INTERNAL', 'UNDO'}
-
-    anim_type: StringProperty()
-
-    def execute(self, context):
-        rig = verify_armature_obj(context.object)
-
-        if not rig.animation_data:
-            return {'CANCELLED'}
-
-        channelbag = anim_utils.action_get_channelbag_for_slot(
-            rig.animation_data.action, rig.animation_data.action_slot)
-        if not channelbag:
-            return {'CANCELLED'}
-
-        clear_animation(channelbag, self.anim_type, names=get_limb_generated_names(rig))
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class OBJECT_OT_Rot2Pole(bpy.types.Operator):
-    bl_idname = "rigify.rotation_pole"
-    bl_label = "Rotation - Pole toggle"
-    bl_description = "Toggles IK chain between rotation and pole target"
-    bl_options = {'INTERNAL'}
-
-    bone_name: StringProperty(default='')
-    window: StringProperty(default='ALL')
-    toggle: BoolProperty(default=True)
-    value: BoolProperty(default=True)
-    bake: BoolProperty(default=True)
-
-    def execute(self, context):
-        rig = verify_armature_obj(context.object)
-
-        if self.bone_name:
-            bpy.ops.pose.select_all(action='DESELECT')
-            rig.pose.bones[self.bone_name].select = True
-
-        rot_pole_toggle(rig, window=self.window, toggle=self.toggle, value=self.value, bake=self.bake)
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class POSE_OT_rigify_collection_ref_add(bpy.types.Operator):
-    bl_idname = "pose.rigify_collection_ref_add"
-    bl_label = "Add Bone Collection Reference"
-    bl_description = "Add a new row to the bone collection reference list"
-    bl_options = {'UNDO'}
-
-    prop_name: StringProperty(name="Property Name")
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context) and context.active_pose_bone
-
-    def execute(self, context):
-        params = get_rigify_params(context.active_pose_bone)
-        getattr(params, self.prop_name).add()
-        return {'FINISHED'}
-
-
-# noinspection PyPep8Naming
-class POSE_OT_rigify_collection_ref_remove(bpy.types.Operator):
-    bl_idname = "pose.rigify_collection_ref_remove"
-    bl_label = "Remove Bone Collection Reference"
-    bl_description = "Remove this row from the bone collection reference list"
-    bl_options = {'UNDO'}
-
-    prop_name: StringProperty(name="Property Name")
-    index: IntProperty(name="Entry Index")
-
-    @classmethod
-    def poll(cls, context):
-        return is_valid_metarig(context) and context.active_pose_bone
-
-    def execute(self, context):
-        params = get_rigify_params(context.active_pose_bone)
-        getattr(params, self.prop_name).remove(self.index)
-        return {'FINISHED'}
-
-
-###############
-# Registering
-
-classes = (
-    DATA_OT_rigify_add_color_sets,
-    DATA_OT_rigify_use_standard_colors,
-    DATA_OT_rigify_apply_selection_colors,
-    DATA_OT_rigify_color_set_add,
-    DATA_OT_rigify_color_set_add_theme,
-    DATA_OT_rigify_color_set_remove,
-    DATA_OT_rigify_color_set_remove_all,
-    DATA_UL_rigify_color_sets,
-    DATA_MT_rigify_color_sets_context_menu,
-    DATA_PT_rigify,
-    DATA_PT_rigify_advanced,
-    DATA_PT_rigify_color_sets,
-    DATA_UL_rigify_bone_collections,
-    DATA_PT_rigify_collection_list,
-    DATA_PT_rigify_collection_ui,
-    DATA_OT_rigify_collection_select,
-    DATA_OT_rigify_collection_set_ui_row,
-    DATA_OT_rigify_collection_add_ui_row,
-    DATA_PT_rigify_samples,
-    BONE_PT_rigify_buttons,
-    VIEW3D_PT_rigify_animation_tools,
-    VIEW3D_PT_tools_rigify_dev,
-    Generate,
-    UpgradeMetarigTypes,
-    UpgradeMetarigLayers,
-    ValidateMetarigLayers,
-    Sample,
-    VIEW3D_MT_rigify,
-    EncodeMetarig,
-    EncodeMetarigSample,
-    EncodeWidget,
-    OBJECT_OT_FK2IK,
-    OBJECT_OT_IK2FK,
-    OBJECT_OT_TransferFKtoIK,
-    OBJECT_OT_TransferIKtoFK,
-    OBJECT_OT_ClearAnimation,
-    OBJECT_OT_Rot2Pole,
-    POSE_OT_rigify_collection_ref_add,
-    POSE_OT_rigify_collection_ref_remove,
-)
-
-
-def register():
-    from bpy.utils import register_class
-
-    animation_register()
-
-    # Classes.
-    for cls in classes:
-        register_class(cls)
-
-    bpy.types.VIEW3D_MT_editor_menus.append(draw_rigify_menu)
-    bpy.types.VIEW3D_MT_edit_mesh.prepend(draw_mesh_edit_menu)
-
-    # Sub-modules.
-    rot_mode.register()
-
-
-def unregister():
-    from bpy.utils import unregister_class
-
-    # Sub-modules.
-    rot_mode.unregister()
-
-    # Classes.
-    for cls in classes:
-        unregister_class(cls)
-
-    bpy.types.VIEW3D_MT_editor_menus.remove(draw_rigify_menu)
-    bpy.types.VIEW3D_MT_edit_mesh.remove(draw_mesh_edit_menu)
-
-    animation_unregister()