@tushar-br/editing-pack 1.0.188 → 1.0.190

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

@@ -1,1445 +0,0 @@
-# SPDX-FileCopyrightText: 2010-2022 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-import bpy
-
-from collections import OrderedDict
-from typing import Union, Optional, Any
-
-from .utils.animation import SCRIPT_REGISTER_BAKE, SCRIPT_UTILITIES_BAKE
-from .utils.mechanism import quote_property
-
-from . import base_generate
-
-from rna_prop_ui import rna_idprop_quote_path
-
-
-UI_IMPORTS = [
-    'import bpy',
-    'import math',
-    'import json',
-    'import collections',
-    'import traceback',
-    'from math import pi',
-    'from bpy.props import StringProperty',
-    'from mathutils import Euler, Matrix, Quaternion, Vector',
-    'from rna_prop_ui import rna_idprop_quote_path',
-]
-
-
-UI_BASE_UTILITIES = '''
-rig_id = "%s"
-
-
-############################
-## Math utility functions ##
-############################
-
-def perpendicular_vector(v):
-    """ Returns a vector that is perpendicular to the one given.
-        The returned vector is _not_ guaranteed to be normalized.
-    """
-    # Create a vector that is not aligned with v.
-    # It doesn't matter what vector.  Just any vector
-    # that's guaranteed to not be pointing in the same
-    # direction.
-    if abs(v[0]) < abs(v[1]):
-        tv = Vector((1,0,0))
-    else:
-        tv = Vector((0,1,0))
-
-    # Use cross product to generate a vector perpendicular to
-    # both tv and (more importantly) v.
-    return v.cross(tv)
-
-
-def rotation_difference(mat1, mat2):
-    """ Returns the shortest-path rotational difference between two
-        matrices.
-    """
-    q1 = mat1.to_quaternion()
-    q2 = mat2.to_quaternion()
-    angle = math.acos(min(1,max(-1,q1.dot(q2)))) * 2
-    if angle > pi:
-        angle = -angle + (2*pi)
-    return angle
-
-def find_min_range(f,start_angle,delta=pi/8):
-    """ finds the range where lies the minimum of function f applied on bone_ik and bone_fk
-        at a certain angle.
-    """
-    angle = start_angle
-    while (angle > (start_angle - 2*pi)) and (angle < (start_angle + 2*pi)):
-        l_dist = f(angle-delta)
-        c_dist = f(angle)
-        r_dist = f(angle+delta)
-        if min((l_dist,c_dist,r_dist)) == c_dist:
-            return (angle-delta,angle+delta)
-        else:
-            angle=angle+delta
-
-def ternarySearch(f, left, right, absolutePrecision):
-    """
-    Find minimum of uni-modal function f() within [left, right]
-    To find the maximum, revert the if/else statement or revert the comparison.
-    """
-    while True:
-        #left and right are the current bounds; the maximum is between them
-        if abs(right - left) < absolutePrecision:
-            return (left + right)/2
-
-        leftThird = left + (right - left)/3
-        rightThird = right - (right - left)/3
-
-        if f(leftThird) > f(rightThird):
-            left = leftThird
-        else:
-            right = rightThird
-
-def flatten_children(iterable):
-    """Enumerate the iterator items as well as their children in the tree order."""
-    for item in iterable:
-        yield item
-        yield from flatten_children(item.children)
-
-'''
-
-UTILITIES_FUNC_COMMON_IK_FK = ['''
-#########################################
-## "Visual Transform" helper functions ##
-#########################################
-
-def get_pose_matrix_in_other_space(mat, pose_bone):
-    """ Returns the transform matrix relative to pose_bone's current
-        transform space.  In other words, presuming that mat is in
-        armature space, slapping the returned matrix onto pose_bone
-        should give it the armature-space transforms of mat.
-    """
-    return pose_bone.id_data.convert_space(matrix=mat, pose_bone=pose_bone, from_space='POSE', to_space='LOCAL')
-
-
-def convert_pose_matrix_via_rest_delta(mat, from_bone, to_bone):
-    """Convert pose of one bone to another bone, preserving the rest pose difference between them."""
-    return mat @ from_bone.bone.matrix_local.inverted() @ to_bone.bone.matrix_local
-
-
-def convert_pose_matrix_via_pose_delta(mat, from_bone, to_bone):
-    """Convert pose of one bone to another bone, preserving the current pose difference between them."""
-    return mat @ from_bone.matrix.inverted() @ to_bone.matrix
-
-
-def get_local_pose_matrix(pose_bone):
-    """ Returns the local transform matrix of the given pose bone.
-    """
-    return get_pose_matrix_in_other_space(pose_bone.matrix, pose_bone)
-
-
-def set_pose_translation(pose_bone, mat):
-    """ Sets the pose bone's translation to the same translation as the given matrix.
-        Matrix should be given in bone's local space.
-    """
-    pose_bone.location = mat.to_translation()
-
-
-def set_pose_rotation(pose_bone, mat):
-    """ Sets the pose bone's rotation to the same rotation as the given matrix.
-        Matrix should be given in bone's local space.
-    """
-    q = mat.to_quaternion()
-
-    if pose_bone.rotation_mode == 'QUATERNION':
-        pose_bone.rotation_quaternion = q
-    elif pose_bone.rotation_mode == 'AXIS_ANGLE':
-        pose_bone.rotation_axis_angle[0] = q.angle
-        pose_bone.rotation_axis_angle[1] = q.axis[0]
-        pose_bone.rotation_axis_angle[2] = q.axis[1]
-        pose_bone.rotation_axis_angle[3] = q.axis[2]
-    else:
-        pose_bone.rotation_euler = q.to_euler(pose_bone.rotation_mode)
-
-
-def set_pose_scale(pose_bone, mat):
-    """ Sets the pose bone's scale to the same scale as the given matrix.
-        Matrix should be given in bone's local space.
-    """
-    pose_bone.scale = mat.to_scale()
-
-
-def match_pose_translation(pose_bone, target_bone):
-    """ Matches pose_bone's visual translation to target_bone's visual
-        translation.
-        This function assumes you are in pose mode on the relevant armature.
-    """
-    mat = get_pose_matrix_in_other_space(target_bone.matrix, pose_bone)
-    set_pose_translation(pose_bone, mat)
-
-
-def match_pose_rotation(pose_bone, target_bone):
-    """ Matches pose_bone's visual rotation to target_bone's visual
-        rotation.
-        This function assumes you are in pose mode on the relevant armature.
-    """
-    mat = get_pose_matrix_in_other_space(target_bone.matrix, pose_bone)
-    set_pose_rotation(pose_bone, mat)
-
-
-def match_pose_scale(pose_bone, target_bone):
-    """ Matches pose_bone's visual scale to target_bone's visual
-        scale.
-        This function assumes you are in pose mode on the relevant armature.
-    """
-    mat = get_pose_matrix_in_other_space(target_bone.matrix, pose_bone)
-    set_pose_scale(pose_bone, mat)
-
-
-##############################
-## IK/FK snapping functions ##
-##############################
-
-def correct_rotation(view_layer, bone_ik, target_matrix, *, ctrl_ik=None):
-    """ Corrects the ik rotation in ik2fk snapping functions
-    """
-
-    axis = target_matrix.to_3x3().col[1].normalized()
-    ctrl_ik = ctrl_ik or bone_ik
-
-    def distance(angle):
-        # Rotate the bone and return the actual angle between bones
-        ctrl_ik.rotation_euler[1] = angle
-        view_layer.update()
-
-        return -(bone_ik.vector.normalized().dot(axis))
-
-    if ctrl_ik.rotation_mode in {'QUATERNION', 'AXIS_ANGLE'}:
-        ctrl_ik.rotation_mode = 'ZXY'
-
-    start_angle = ctrl_ik.rotation_euler[1]
-
-    alpha_range = find_min_range(distance, start_angle)
-    alpha_min = ternarySearch(distance, alpha_range[0], alpha_range[1], pi / 180)
-
-    ctrl_ik.rotation_euler[1] = alpha_min
-    view_layer.update()
-
-
-def correct_scale(view_layer, bone_ik, target_matrix, *, ctrl_ik=None):
-    """ Correct the scale of the base IK bone. """
-    input_scale = target_matrix.to_scale()
-    ctrl_ik = ctrl_ik or bone_ik
-
-    for i in range(3):
-        cur_scale = bone_ik.matrix.to_scale()
-
-        ctrl_ik.scale = [
-            v * i / c for v, i, c in zip(bone_ik.scale, input_scale, cur_scale)
-        ]
-
-        view_layer.update()
-
-        if all(abs((c - i)/i) < 0.01 for i, c in zip(input_scale, cur_scale)):
-            break
-
-
-def match_pole_target(view_layer, ik_first, ik_last, pole, match_bone_matrix, length):
-    """ Places an IK chain's pole target to match ik_first's
-        transforms to match_bone.  All bones should be given as pose bones.
-        You need to be in pose mode on the relevant armature object.
-        ik_first: first bone in the IK chain
-        ik_last:  last bone in the IK chain
-        pole:  pole target bone for the IK chain
-        match_bone:  bone to match ik_first to (probably first bone in a matching FK chain)
-        length:  distance pole target should be placed from the chain center
-    """
-    a = ik_first.matrix.to_translation()
-    b = ik_last.matrix.to_translation() + ik_last.vector
-
-    # Vector from the head of ik_first to the
-    # tip of ik_last
-    ikv = b - a
-
-    # Get a vector perpendicular to ikv
-    pv = perpendicular_vector(ikv).normalized() * length
-
-    def set_pole(pvi):
-        """ Set pole target's position based on a vector
-            from the arm center line.
-        """
-        # Translate pvi into armature space
-        pole_loc = a + (ikv/2) + pvi
-
-        # Set pole target to location
-        mat = get_pose_matrix_in_other_space(Matrix.Translation(pole_loc), pole)
-        set_pose_translation(pole, mat)
-
-        view_layer.update()
-
-    set_pole(pv)
-
-    # Get the rotation difference between ik_first and match_bone
-    angle = rotation_difference(ik_first.matrix, match_bone_matrix)
-
-    # Try compensating for the rotation difference in both directions
-    pv1 = Matrix.Rotation(angle, 4, ikv) @ pv
-    set_pole(pv1)
-    ang1 = rotation_difference(ik_first.matrix, match_bone_matrix)
-
-    pv2 = Matrix.Rotation(-angle, 4, ikv) @ pv
-    set_pole(pv2)
-    ang2 = rotation_difference(ik_first.matrix, match_bone_matrix)
-
-    # Do the one with the smaller angle
-    if ang1 < ang2:
-        set_pole(pv1)
-
-##########
-## Misc ##
-##########
-
-def parse_bone_names(names_string):
-    if names_string[0] == '[' and names_string[-1] == ']':
-        return eval(names_string)
-    else:
-        return names_string
-
-''']
-
-# noinspection SpellCheckingInspection
-UTILITIES_FUNC_OLD_ARM_FKIK = ['''
-######################
-## IK Arm functions ##
-######################
-
-def fk2ik_arm(obj, fk, ik):
-    """ Matches the fk bones in an arm rig to the ik bones.
-        obj: armature object
-        fk:  list of fk bone names
-        ik:  list of ik bone names
-    """
-    view_layer = bpy.context.view_layer
-    uarm  = obj.pose.bones[fk[0]]
-    farm  = obj.pose.bones[fk[1]]
-    hand  = obj.pose.bones[fk[2]]
-    uarmi = obj.pose.bones[ik[0]]
-    farmi = obj.pose.bones[ik[1]]
-    handi = obj.pose.bones[ik[2]]
-
-    if 'auto_stretch' in handi.keys():
-        # This is kept for compatibility with legacy rigify Human
-        # Stretch
-        if handi['auto_stretch'] == 0.0:
-            uarm['stretch_length'] = handi['stretch_length']
-        else:
-            diff = (uarmi.vector.length + farmi.vector.length) / (uarm.vector.length + farm.vector.length)
-            uarm['stretch_length'] *= diff
-
-        # Upper arm position
-        match_pose_rotation(uarm, uarmi)
-        match_pose_scale(uarm, uarmi)
-        view_layer.update()
-
-        # Forearm position
-        match_pose_rotation(farm, farmi)
-        match_pose_scale(farm, farmi)
-        view_layer.update()
-
-        # Hand position
-        match_pose_rotation(hand, handi)
-        match_pose_scale(hand, handi)
-        view_layer.update()
-    else:
-        # Upper arm position
-        match_pose_translation(uarm, uarmi)
-        match_pose_rotation(uarm, uarmi)
-        match_pose_scale(uarm, uarmi)
-        view_layer.update()
-
-        # Forearm position
-        #match_pose_translation(hand, handi)
-        match_pose_rotation(farm, farmi)
-        match_pose_scale(farm, farmi)
-        view_layer.update()
-
-        # Hand position
-        match_pose_translation(hand, handi)
-        match_pose_rotation(hand, handi)
-        match_pose_scale(hand, handi)
-        view_layer.update()
-
-
-def ik2fk_arm(obj, fk, ik):
-    """ Matches the ik bones in an arm rig to the fk bones.
-        obj: armature object
-        fk:  list of fk bone names
-        ik:  list of ik bone names
-    """
-    view_layer = bpy.context.view_layer
-    uarm  = obj.pose.bones[fk[0]]
-    farm  = obj.pose.bones[fk[1]]
-    hand  = obj.pose.bones[fk[2]]
-    uarmi = obj.pose.bones[ik[0]]
-    farmi = obj.pose.bones[ik[1]]
-    handi = obj.pose.bones[ik[2]]
-
-    main_parent = obj.pose.bones[ik[4]]
-
-    if ik[3] != "" and main_parent['pole_vector']:
-        pole  = obj.pose.bones[ik[3]]
-    else:
-        pole = None
-
-
-    if pole:
-        # Stretch
-        # handi['stretch_length'] = uarm['stretch_length']
-
-        # Hand position
-        match_pose_translation(handi, hand)
-        match_pose_rotation(handi, hand)
-        match_pose_scale(handi, hand)
-        view_layer.update()
-
-        # Pole target position
-        match_pole_target(view_layer, uarmi, farmi, pole, uarm.matrix, (uarmi.length + farmi.length))
-
-    else:
-        # Hand position
-        match_pose_translation(handi, hand)
-        match_pose_rotation(handi, hand)
-        match_pose_scale(handi, hand)
-        view_layer.update()
-
-        # Upper Arm position
-        match_pose_translation(uarmi, uarm)
-        #match_pose_rotation(uarmi, uarm)
-        set_pose_rotation(uarmi, Matrix())
-        match_pose_scale(uarmi, uarm)
-        view_layer.update()
-
-        # Rotation Correction
-        correct_rotation(view_layer, uarmi, uarm.matrix)
-
-    correct_scale(view_layer, uarmi, uarm.matrix)
-''']
-
-# noinspection SpellCheckingInspection
-UTILITIES_FUNC_OLD_LEG_FKIK = ['''
-######################
-## IK Leg functions ##
-######################
-
-def fk2ik_leg(obj, fk, ik):
-    """ Matches the fk bones in a leg rig to the ik bones.
-        obj: armature object
-        fk:  list of fk bone names
-        ik:  list of ik bone names
-    """
-    view_layer = bpy.context.view_layer
-    thigh  = obj.pose.bones[fk[0]]
-    shin   = obj.pose.bones[fk[1]]
-    foot   = obj.pose.bones[fk[2]]
-    mfoot  = obj.pose.bones[fk[3]]
-    thighi = obj.pose.bones[ik[0]]
-    shini  = obj.pose.bones[ik[1]]
-    footi  = obj.pose.bones[ik[2]]
-    mfooti = obj.pose.bones[ik[3]]
-
-    if 'auto_stretch' in footi.keys():
-        # This is kept for compatibility with legacy rigify Human
-        # Stretch
-        if footi['auto_stretch'] == 0.0:
-            thigh['stretch_length'] = footi['stretch_length']
-        else:
-            diff = (thighi.vector.length + shini.vector.length) / (thigh.vector.length + shin.vector.length)
-            thigh['stretch_length'] *= diff
-
-        # Thigh position
-        match_pose_rotation(thigh, thighi)
-        match_pose_scale(thigh, thighi)
-        view_layer.update()
-
-        # Shin position
-        match_pose_rotation(shin, shini)
-        match_pose_scale(shin, shini)
-        view_layer.update()
-
-        # Foot position
-        footmat = get_pose_matrix_in_other_space(mfooti.matrix, foot)
-        footmat = convert_pose_matrix_via_rest_delta(footmat, mfoot, foot)
-        set_pose_rotation(foot, footmat)
-        set_pose_scale(foot, footmat)
-        view_layer.update()
-
-    else:
-        # Thigh position
-        match_pose_translation(thigh, thighi)
-        match_pose_rotation(thigh, thighi)
-        match_pose_scale(thigh, thighi)
-        view_layer.update()
-
-        # Shin position
-        match_pose_rotation(shin, shini)
-        match_pose_scale(shin, shini)
-        view_layer.update()
-
-        # Foot position
-        footmat = get_pose_matrix_in_other_space(mfooti.matrix, foot)
-        footmat = convert_pose_matrix_via_rest_delta(footmat, mfoot, foot)
-        set_pose_rotation(foot, footmat)
-        set_pose_scale(foot, footmat)
-        view_layer.update()
-
-
-def ik2fk_leg(obj, fk, ik):
-    """ Matches the ik bones in a leg rig to the fk bones.
-        obj: armature object
-        fk:  list of fk bone names
-        ik:  list of ik bone names
-    """
-    view_layer = bpy.context.view_layer
-    thigh    = obj.pose.bones[fk[0]]
-    shin     = obj.pose.bones[fk[1]]
-    mfoot    = obj.pose.bones[fk[2]]
-    if fk[3] != "":
-        foot      = obj.pose.bones[fk[3]]
-    else:
-        foot = None
-    thighi   = obj.pose.bones[ik[0]]
-    shini    = obj.pose.bones[ik[1]]
-    footi    = obj.pose.bones[ik[2]]
-    footroll = obj.pose.bones[ik[3]]
-
-    main_parent = obj.pose.bones[ik[6]]
-
-    if ik[4] != "" and main_parent['pole_vector']:
-        pole     = obj.pose.bones[ik[4]]
-    else:
-        pole = None
-    mfooti   = obj.pose.bones[ik[5]]
-
-    if (not pole) and (foot):
-
-        # Clear footroll
-        set_pose_rotation(footroll, Matrix())
-        view_layer.update()
-
-        # Foot position
-        footmat = get_pose_matrix_in_other_space(foot.matrix, footi)
-        footmat = convert_pose_matrix_via_rest_delta(footmat, mfooti, footi)
-        set_pose_translation(footi, footmat)
-        set_pose_rotation(footi, footmat)
-        set_pose_scale(footi, footmat)
-        view_layer.update()
-
-        # Thigh position
-        match_pose_translation(thighi, thigh)
-        #match_pose_rotation(thighi, thigh)
-        set_pose_rotation(thighi, Matrix())
-        match_pose_scale(thighi, thigh)
-        view_layer.update()
-
-        # Rotation Correction
-        correct_rotation(view_layer, thighi, thigh.matrix)
-
-    else:
-        # Stretch
-        if 'stretch_length' in footi.keys() and 'stretch_length' in thigh.keys():
-            # Kept for compat with legacy rigify Human
-            footi['stretch_length'] = thigh['stretch_length']
-
-        # Clear footroll
-        set_pose_rotation(footroll, Matrix())
-        view_layer.update()
-
-        # Foot position
-        footmat = get_pose_matrix_in_other_space(mfoot.matrix, footi)
-        footmat = convert_pose_matrix_via_rest_delta(footmat, mfooti, footi)
-        set_pose_translation(footi, footmat)
-        set_pose_rotation(footi, footmat)
-        set_pose_scale(footi, footmat)
-        view_layer.update()
-
-        # Pole target position
-        match_pole_target(view_layer, thighi, shini, pole, thigh.matrix, (thighi.length + shini.length))
-
-    correct_scale(view_layer, thighi, thigh.matrix)
-''']
-
-# noinspection SpellCheckingInspection
-UTILITIES_FUNC_OLD_POLE = ['''
-################################
-## IK Rotation-Pole functions ##
-################################
-
-def rotPoleToggle(rig, limb_type, controls, ik_ctrl, fk_ctrl, parent, pole):
-
-    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)
-
-    controls = parse_bone_names(controls)
-    ik_ctrl = parse_bone_names(ik_ctrl)
-    fk_ctrl = parse_bone_names(fk_ctrl)
-    parent = parse_bone_names(parent)
-    pole = parse_bone_names(pole)
-
-    pbones = bpy.context.selected_pose_bones
-    bpy.ops.pose.select_all(action='DESELECT')
-
-    for b in pbones:
-
-        new_pole_vector_value = not rig.pose.bones[parent]['pole_vector']
-
-        if b.name in controls or b.name in ik_ctrl:
-            if limb_type == 'arm':
-                func1 = arm_fk2ik
-                func2 = arm_ik2fk
-                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}
-            else:
-                func1 = leg_fk2ik
-                func2 = leg_ik2fk
-                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
-
-                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]}
-                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}
-
-            func1(**kwargs1)
-            rig.pose.bones[parent]['pole_vector'] = new_pole_vector_value
-            func2(**kwargs2)
-
-            bpy.ops.pose.select_all(action='DESELECT')
-''']
-
-# noinspection SpellCheckingInspection
-REGISTER_OP_OLD_ARM_FKIK = ['Rigify_Arm_FK2IK', 'Rigify_Arm_IK2FK']
-
-# noinspection SpellCheckingInspection
-UTILITIES_OP_OLD_ARM_FKIK = ['''
-##################################
-## IK/FK Arm snapping operators ##
-##################################
-
-class Rigify_Arm_FK2IK(bpy.types.Operator):
-    """ Snaps an FK arm to an IK arm.
-    """
-    bl_idname = "pose.rigify_arm_fk2ik_" + rig_id
-    bl_label = "Rigify Snap FK arm to IK"
-    bl_options = {'UNDO', 'INTERNAL'}
-
-    uarm_fk: StringProperty(name="Upper Arm FK Name")
-    farm_fk: StringProperty(name="Forerm FK Name")
-    hand_fk: StringProperty(name="Hand FK Name")
-
-    uarm_ik: StringProperty(name="Upper Arm IK Name")
-    farm_ik: StringProperty(name="Forearm IK Name")
-    hand_ik: StringProperty(name="Hand IK Name")
-
-    @classmethod
-    def poll(cls, context):
-        return (context.active_object != None and context.mode == 'POSE')
-
-    def execute(self, context):
-        fk2ik_arm(context.active_object, fk=[self.uarm_fk, self.farm_fk, self.hand_fk],
-                  ik=[self.uarm_ik, self.farm_ik, self.hand_ik])
-        return {'FINISHED'}
-
-
-class Rigify_Arm_IK2FK(bpy.types.Operator):
-    """ Snaps an IK arm to an FK arm.
-    """
-    bl_idname = "pose.rigify_arm_ik2fk_" + rig_id
-    bl_label = "Rigify Snap IK arm to FK"
-    bl_options = {'UNDO', 'INTERNAL'}
-
-    uarm_fk: StringProperty(name="Upper Arm FK Name")
-    farm_fk: StringProperty(name="Forerm FK Name")
-    hand_fk: StringProperty(name="Hand FK Name")
-
-    uarm_ik: StringProperty(name="Upper Arm IK Name")
-    farm_ik: StringProperty(name="Forearm IK Name")
-    hand_ik: StringProperty(name="Hand IK Name")
-    pole   : StringProperty(name="Pole IK Name")
-
-    main_parent: StringProperty(name="Main Parent", default="")
-
-    @classmethod
-    def poll(cls, context):
-        return (context.active_object != None and context.mode == 'POSE')
-
-    def execute(self, context):
-        ik2fk_arm(context.active_object, fk=[self.uarm_fk, self.farm_fk, self.hand_fk],
-                  ik=[self.uarm_ik, self.farm_ik, self.hand_ik, self.pole, self.main_parent])
-        return {'FINISHED'}
-''']
-
-# noinspection SpellCheckingInspection
-REGISTER_OP_OLD_LEG_FKIK = ['Rigify_Leg_FK2IK', 'Rigify_Leg_IK2FK']
-
-# noinspection SpellCheckingInspection
-UTILITIES_OP_OLD_LEG_FKIK = ['''
-##################################
-## IK/FK Leg snapping operators ##
-##################################
-
-class Rigify_Leg_FK2IK(bpy.types.Operator):
-    """ Snaps an FK leg to an IK leg.
-    """
-    bl_idname = "pose.rigify_leg_fk2ik_" + rig_id
-    bl_label = "Rigify Snap FK leg to IK"
-    bl_options = {'UNDO', 'INTERNAL'}
-
-    thigh_fk: StringProperty(name="Thigh FK Name")
-    shin_fk:  StringProperty(name="Shin FK Name")
-    foot_fk:  StringProperty(name="Foot FK Name")
-    mfoot_fk: StringProperty(name="MFoot FK Name")
-
-    thigh_ik: StringProperty(name="Thigh IK Name")
-    shin_ik:  StringProperty(name="Shin IK Name")
-    foot_ik:  StringProperty(name="Foot IK Name")
-    mfoot_ik: StringProperty(name="MFoot IK Name")
-
-    @classmethod
-    def poll(cls, context):
-        return (context.active_object != None and context.mode == 'POSE')
-
-    def execute(self, context):
-        fk2ik_leg(context.active_object,
-                  fk=[self.thigh_fk, self.shin_fk, self.foot_fk, self.mfoot_fk],
-                  ik=[self.thigh_ik, self.shin_ik, self.foot_ik, self.mfoot_ik])
-        return {'FINISHED'}
-
-
-class Rigify_Leg_IK2FK(bpy.types.Operator):
-    """ Snaps an IK leg to an FK leg.
-    """
-    bl_idname = "pose.rigify_leg_ik2fk_" + rig_id
-    bl_label = "Rigify Snap IK leg to FK"
-    bl_options = {'UNDO', 'INTERNAL'}
-
-    thigh_fk: StringProperty(name="Thigh FK Name")
-    shin_fk:  StringProperty(name="Shin FK Name")
-    mfoot_fk: StringProperty(name="MFoot FK Name")
-    foot_fk:  StringProperty(name="Foot FK Name", default="")
-    thigh_ik: StringProperty(name="Thigh IK Name")
-    shin_ik:  StringProperty(name="Shin IK Name")
-    foot_ik:  StringProperty(name="Foot IK Name")
-    footroll: StringProperty(name="Foot Roll Name")
-    pole:     StringProperty(name="Pole IK Name")
-    mfoot_ik: StringProperty(name="MFoot IK Name")
-
-    main_parent: StringProperty(name="Main Parent", default="")
-
-    @classmethod
-    def poll(cls, context):
-        return (context.active_object != None and context.mode == 'POSE')
-
-    def execute(self, context):
-        ik2fk_leg(context.active_object,
-                  fk=[self.thigh_fk, self.shin_fk, self.mfoot_fk, self.foot_fk],
-                  ik=[self.thigh_ik, self.shin_ik, self.foot_ik, self.footroll, self.pole,
-                      self.mfoot_ik, self.main_parent])
-        return {'FINISHED'}
-''']
-
-REGISTER_OP_OLD_POLE = ['Rigify_Rot2PoleSwitch']
-
-UTILITIES_OP_OLD_POLE = ['''
-###########################
-## IK Rotation Pole Snap ##
-###########################
-
-class Rigify_Rot2PoleSwitch(bpy.types.Operator):
-    bl_idname = "pose.rigify_rot2pole_" + rig_id
-    bl_label = "Rotation - Pole toggle"
-    bl_description = "Toggles IK chain between rotation and pole target"
-
-    bone_name: StringProperty(default='')
-    limb_type: StringProperty(name="Limb Type")
-    controls: StringProperty(name="Controls string")
-    ik_ctrl: StringProperty(name="IK Controls string")
-    fk_ctrl: StringProperty(name="FK Controls string")
-    parent: StringProperty(name="Parent name")
-    pole: StringProperty(name="Pole name")
-
-    def execute(self, context):
-        rig = context.object
-
-        if self.bone_name:
-            bpy.ops.pose.select_all(action='DESELECT')
-            rig.pose.bones[self.bone_name].select = True
-
-        rotPoleToggle(rig, self.limb_type, self.controls, self.ik_ctrl, self.fk_ctrl,
-                      self.parent, self.pole)
-        return {'FINISHED'}
-''']
-
-REGISTER_RIG_OLD_ARM = REGISTER_OP_OLD_ARM_FKIK + REGISTER_OP_OLD_POLE
-
-UTILITIES_RIG_OLD_ARM = [
-    *UTILITIES_FUNC_COMMON_IK_FK,
-    *UTILITIES_FUNC_OLD_ARM_FKIK,
-    *UTILITIES_FUNC_OLD_POLE,
-    *UTILITIES_OP_OLD_ARM_FKIK,
-    *UTILITIES_OP_OLD_POLE,
-]
-
-REGISTER_RIG_OLD_LEG = REGISTER_OP_OLD_LEG_FKIK + REGISTER_OP_OLD_POLE
-
-UTILITIES_RIG_OLD_LEG = [
-    *UTILITIES_FUNC_COMMON_IK_FK,
-    *UTILITIES_FUNC_OLD_LEG_FKIK,
-    *UTILITIES_FUNC_OLD_POLE,
-    *UTILITIES_OP_OLD_LEG_FKIK,
-    *UTILITIES_OP_OLD_POLE,
-]
-
-############################
-# Default set of utilities #
-############################
-
-UI_REGISTER = [
-    'RigUI',
-    'RigLayers',
-]
-
-UI_UTILITIES = [
-]
-
-UI_SLIDERS = '''
-###################
-## Rig UI Panels ##
-###################
-
-class RigUI(bpy.types.Panel):
-    bl_space_type = 'VIEW_3D'
-    bl_region_type = 'UI'
-    bl_label = "Rig Main Properties"
-    bl_idname = "VIEW3D_PT_rig_ui_" + rig_id
-    bl_category = 'Item'
-
-    @classmethod
-    def poll(cls, context):
-        if context.mode != 'POSE':
-            return False
-        try:
-            return (context.active_object.data.get("rig_id") == rig_id)
-        except (AttributeError, KeyError, TypeError):
-            return False
-
-    def draw(self, context):
-        layout = self.layout
-        pose_bones = context.active_object.pose.bones
-        try:
-            selected_bones = set(bone.name for bone in context.selected_pose_bones)
-            selected_bones.add(context.active_pose_bone.name)
-        except (AttributeError, TypeError):
-            return
-
-        def is_selected(names):
-            # Returns whether any of the named bones are selected.
-            if isinstance(names, list) or isinstance(names, set):
-                return not selected_bones.isdisjoint(names)
-            elif names in selected_bones:
-                return True
-            return False
-
-        num_rig_separators = [-1]
-
-        def emit_rig_separator():
-            if num_rig_separators[0] >= 0:
-                layout.separator()
-            num_rig_separators[0] += 1
-'''
-
-UI_REGISTER_BAKE_SETTINGS = ['RigBakeSettings']
-
-UI_BAKE_SETTINGS = '''
-class RigBakeSettings(bpy.types.Panel):
-    bl_space_type = 'VIEW_3D'
-    bl_region_type = 'UI'
-    bl_label = "Rig Bake Settings"
-    bl_idname = "VIEW3D_PT_rig_bake_settings_" + rig_id
-    bl_category = 'Item'
-
-    @classmethod
-    def poll(cls, context):
-        return RigUI.poll(context) and find_action(context.active_object) is not None
-
-    def draw(self, context):
-        RigifyBakeKeyframesMixin.draw_common_bake_ui(context, self.layout)
-'''
-
-
-UI_LAYERS_PANEL = '''
-class RigLayers(bpy.types.Panel):
-    bl_space_type = 'VIEW_3D'
-    bl_region_type = 'UI'
-    bl_label = "Rig Layers"
-    bl_idname = "VIEW3D_PT_rig_layers_" + rig_id
-    bl_category = 'Item'
-
-    @classmethod
-    def poll(cls, context):
-        try:
-            return (context.active_object.data.get("rig_id") == rig_id)
-        except (AttributeError, KeyError, TypeError):
-            return False
-
-    def draw(self, context):
-        layout = self.layout
-        row_table = collections.defaultdict(list)
-        for coll in flatten_children(context.active_object.data.collections):
-            row_id = coll.rigify_ui_row
-            if row_id > 0:
-                row_table[row_id].append(coll)
-        col = layout.column()
-        for row_id in range(min(row_table.keys()), 1 + max(row_table.keys())):
-            row = col.row()
-            row_buttons = row_table[row_id]
-            if row_buttons:
-                for coll in row_buttons:
-                    title = coll.rigify_ui_title or coll.name
-                    row2 = row.row()
-                    row2.active = coll.is_visible_ancestors
-                    row2.prop(coll, 'is_visible', toggle=True, text=title, translate=False)
-            else:
-                row.separator()
-'''
-
-
-class PanelExpression(object):
-    """A runtime expression involving bone properties"""
-
-    _rigify_expr: str
-
-    def __init__(self, expr: str):
-        self._rigify_expr = expr
-
-    def __repr__(self):
-        return self._rigify_expr
-
-    def __add__(self, other):
-        return PanelExpression(f"({self._rigify_expr} + {repr(other)})")
-
-    def __sub__(self, other):
-        return PanelExpression(f"({self._rigify_expr} - {repr(other)})")
-
-    def __mul__(self, other):
-        return PanelExpression(f"({self._rigify_expr} * {repr(other)})")
-
-    def __matmul__(self, other):
-        return PanelExpression(f"({self._rigify_expr} @ {repr(other)})")
-
-    def __truediv__(self, other):
-        return PanelExpression(f"({self._rigify_expr} / {repr(other)})")
-
-    def __floordiv__(self, other):
-        return PanelExpression(f"({self._rigify_expr} // {repr(other)})")
-
-    def __mod__(self, other):
-        return PanelExpression(f"({self._rigify_expr} % {repr(other)})")
-
-    def __lshift__(self, other):
-        return PanelExpression(f"({self._rigify_expr} << {repr(other)})")
-
-    def __rshift__(self, other):
-        return PanelExpression(f"({self._rigify_expr} >> {repr(other)})")
-
-    def __and__(self, other):
-        return PanelExpression(f"({self._rigify_expr} & {repr(other)})")
-
-    def __xor__(self, other):
-        return PanelExpression(f"({self._rigify_expr} ^ {repr(other)})")
-
-    def __or__(self, other):
-        return PanelExpression(f"({self._rigify_expr} | {repr(other)})")
-
-    def __radd__(self, other):
-        return PanelExpression(f"({repr(other)} + {self._rigify_expr})")
-
-    def __rsub__(self, other):
-        return PanelExpression(f"({repr(other)} - {self._rigify_expr})")
-
-    def __rmul__(self, other):
-        return PanelExpression(f"({repr(other)} * {self._rigify_expr})")
-
-    def __rmatmul__(self, other):
-        return PanelExpression(f"({repr(other)} @ {self._rigify_expr})")
-
-    def __rtruediv__(self, other):
-        return PanelExpression(f"({repr(other)} / {self._rigify_expr})")
-
-    def __rfloordiv__(self, other):
-        return PanelExpression(f"({repr(other)} // {self._rigify_expr})")
-
-    def __rmod__(self, other):
-        return PanelExpression(f"({repr(other)} % {self._rigify_expr})")
-
-    def __rlshift__(self, other):
-        return PanelExpression(f"({repr(other)} << {self._rigify_expr})")
-
-    def __rrshift__(self, other):
-        return PanelExpression(f"({repr(other)} >> {self._rigify_expr})")
-
-    def __rand__(self, other):
-        return PanelExpression(f"({repr(other)} & {self._rigify_expr})")
-
-    def __rxor__(self, other):
-        return PanelExpression(f"({repr(other)} ^ {self._rigify_expr})")
-
-    def __ror__(self, other):
-        return PanelExpression(f"({repr(other)} | {self._rigify_expr})")
-
-    def __neg__(self):
-        return PanelExpression(f"-{self._rigify_expr}")
-
-    def __pos__(self):
-        return PanelExpression(f"+{self._rigify_expr}")
-
-    def __abs__(self):
-        return PanelExpression(f"abs({self._rigify_expr})")
-
-    def __invert__(self):
-        return PanelExpression(f"~{self._rigify_expr}")
-
-    def __round__(self, digits=None):
-        return PanelExpression(f"round({self._rigify_expr}, {digits})")
-
-    def __trunc__(self):
-        return PanelExpression(f"trunc({self._rigify_expr})")
-
-    def __floor__(self):
-        return PanelExpression(f"floor({self._rigify_expr})")
-
-    def __ceil__(self):
-        return PanelExpression(f"ceil({self._rigify_expr})")
-
-    def __lt__(self, other):
-        return PanelExpression(f"({self._rigify_expr} < {repr(other)})")
-
-    def __le__(self, other):
-        return PanelExpression(f"({self._rigify_expr} <= {repr(other)})")
-
-    def __eq__(self, other):
-        return PanelExpression(f"({self._rigify_expr} == {repr(other)})")
-
-    def __ne__(self, other):
-        return PanelExpression(f"({self._rigify_expr} != {repr(other)})")
-
-    def __gt__(self, other):
-        return PanelExpression(f"({self._rigify_expr} > {repr(other)})")
-
-    def __ge__(self, other):
-        return PanelExpression(f"({self._rigify_expr} >= {repr(other)})")
-
-    def __bool__(self):
-        raise NotImplementedError("This object wraps an expression, not a value; casting to boolean is meaningless")
-
-
-class PanelReferenceExpression(PanelExpression):
-    """
-    A runtime expression referencing an object.
-    @DynamicAttrs
-    """
-
-    def __getitem__(self, item):
-        return PanelReferenceExpression(f"{self._rigify_expr}[{repr(item)}]")
-
-    def __getattr__(self, item):
-        return PanelReferenceExpression(f"{self._rigify_expr}.{item}")
-
-    def get(self, item, default=None):
-        return PanelReferenceExpression(f"{self._rigify_expr}.get({repr(item)}, {repr(default)})")
-
-
-def quote_parameters(positional: list[Any], named: dict[str, Any]):
-    """Quote the given positional and named parameters as a code string."""
-    positional_list = [repr(v) for v in positional]
-    named_list = ["%s=%r" % (k, v) for k, v in named.items()]
-    return ', '.join(positional_list + named_list)
-
-
-def indent_lines(lines: list[str], indent=4):
-    if indent > 0:
-        prefix = ' ' * indent
-        return [prefix + line for line in lines]
-    else:
-        return lines
-
-
-class PanelLayout(object):
-    """Utility class that builds code for creating a layout."""
-
-    parent: Optional['PanelLayout']
-    script: 'ScriptGenerator'
-
-    header: list[str]
-    items: list[Union[str, 'PanelLayout']]
-
-    def __init__(self, parent: Union['PanelLayout', 'ScriptGenerator'], index=0):
-        if isinstance(parent, PanelLayout):
-            self.parent = parent
-            self.script = parent.script
-        else:
-            self.parent = None
-            self.script = parent
-
-        self.header = []
-        self.items = []
-        self.indent = 0
-        self.index = index
-        self.layout = self._get_layout_var(index)
-        self.is_empty = True
-
-    @staticmethod
-    def _get_layout_var(index):
-        return 'layout' if index == 0 else 'group' + str(index)
-
-    def clear_empty(self):
-        self.is_empty = False
-
-        if self.parent:
-            self.parent.clear_empty()
-
-    def get_lines(self) -> list[str]:
-        lines = []
-
-        for item in self.items:
-            if isinstance(item, PanelLayout):
-                lines += item.get_lines()
-            else:
-                lines.append(item)
-
-        if len(lines) > 0:
-            return self.wrap_lines(lines)
-        else:
-            return []
-
-    def wrap_lines(self, lines):
-        return self.header + indent_lines(lines, self.indent)
-
-    def add_line(self, line: str):
-        assert isinstance(line, str)
-
-        self.items.append(line)
-
-        if self.is_empty:
-            self.clear_empty()
-
-    def use_bake_settings(self):
-        """This panel contains operators that need the common Bake settings."""
-        self.parent.use_bake_settings()
-
-    def custom_prop(self, bone_name: str, prop_name: str, **params):
-        """Add a custom property input field to the panel."""
-        param_str = quote_parameters([rna_idprop_quote_path(prop_name)], params)
-        self.add_line(
-            "%s.prop(pose_bones[%r], %s)" % (self.layout, bone_name, param_str)
-        )
-
-    def operator(self, operator_name: str, *,
-                 properties: Optional[dict[str, Any]] = None,
-                 **params):
-        """Add an operator call button to the panel."""
-        name = operator_name.format_map(self.script.format_args)
-        param_str = quote_parameters([name], params)
-        call_str = "%s.operator(%s)" % (self.layout, param_str)
-        if properties:
-            self.add_line("props = " + call_str)
-            for k, v in properties.items():
-                self.add_line("props.%s = %r" % (k, v))
-        else:
-            self.add_line(call_str)
-
-    def add_nested_layout(self, method_name: str, params: dict[str, Any]) -> 'PanelLayout':
-        param_str = quote_parameters([], params)
-        sub_panel = PanelLayout(self, self.index + 1)
-        sub_panel.header.append(f'{sub_panel.layout} = {self.layout}.{method_name}({param_str})')
-        self.items.append(sub_panel)
-        return sub_panel
-
-    def row(self, **params):
-        """Add a nested row layout to the panel."""
-        return self.add_nested_layout('row', params)
-
-    def column(self, **params):
-        """Add a nested column layout to the panel."""
-        return self.add_nested_layout('column', params)
-
-    def split(self, **params):
-        """Add a split layout to the panel."""
-        return self.add_nested_layout('split', params)
-
-    @staticmethod
-    def expr_bone(bone_name):
-        """Returns an expression referencing the specified pose bone."""
-        return PanelReferenceExpression(f"pose_bones[%r]" % bone_name)
-
-    @staticmethod
-    def expr_and(*expressions):
-        """Returns a boolean and expression of its parameters."""
-        return PanelExpression("(" + " and ".join(repr(e) for e in expressions) + ")")
-
-    @staticmethod
-    def expr_or(*expressions):
-        """Returns a boolean or expression of its parameters."""
-        return PanelExpression("(" + " or ".join(repr(e) for e in expressions) + ")")
-
-    @staticmethod
-    def expr_if_else(condition, true_expr, false_expr):
-        """Returns a conditional expression."""
-        return PanelExpression(f"({repr(true_expr)} if {repr(condition)} else {repr(false_expr)})")
-
-    @staticmethod
-    def expr_call(func: str, *expressions):
-        """Returns an expression calling the specified function with given parameters."""
-        return PanelExpression(func + "(" + ", ".join(repr(e) for e in expressions) + ")")
-
-    def set_layout_property(self, prop_name: str, prop_value: Any):
-        assert self.index > 0  # Don't change properties on the root layout
-        self.add_line("%s.%s = %r" % (self.layout, prop_name, prop_value))
-
-    @property
-    def active(self):
-        raise NotImplementedError("This is a write only property")
-
-    @active.setter
-    def active(self, value):
-        self.set_layout_property('active', value)
-
-    @property
-    def enabled(self):
-        raise NotImplementedError("This is a write only property")
-
-    @enabled.setter
-    def enabled(self, value):
-        self.set_layout_property('enabled', value)
-
-
-class BoneSetPanelLayout(PanelLayout):
-    """Panel restricted to a certain set of bones."""
-
-    parent: 'RigPanelLayout'
-
-    def __init__(self, rig_panel: 'RigPanelLayout', bones: frozenset[str]):
-        assert isinstance(bones, frozenset)
-        super().__init__(rig_panel)
-        self.bones = bones
-        self.show_bake_settings = False
-
-    def clear_empty(self):
-        self.parent.bones |= self.bones
-
-        super().clear_empty()
-
-    def wrap_lines(self, lines):
-        if self.bones != self.parent.bones:
-            header = ["if is_selected(%r):" % (set(self.bones))]
-            return header + indent_lines(lines)
-        else:
-            return lines
-
-    def use_bake_settings(self):
-        self.show_bake_settings = True
-        if not self.script.use_bake_settings:
-            self.script.use_bake_settings = True
-            self.script.add_utilities(SCRIPT_UTILITIES_BAKE)
-            self.script.register_classes(SCRIPT_REGISTER_BAKE)
-
-
-class RigPanelLayout(PanelLayout):
-    """Panel owned by a certain rig."""
-
-    def __init__(self, script: 'ScriptGenerator', _rig):
-        super().__init__(script)
-        self.bones = set()
-        self.sub_panels = OrderedDict()
-
-    def wrap_lines(self, lines):
-        header = ["if is_selected(%r):" % (set(self.bones))]
-        prefix = ["emit_rig_separator()"]
-        return header + indent_lines(prefix + lines)
-
-    def panel_with_selected_check(self, control_names):
-        selected_set = frozenset(control_names)
-
-        if selected_set in self.sub_panels:
-            return self.sub_panels[selected_set]
-        else:
-            panel = BoneSetPanelLayout(self, selected_set)
-            self.sub_panels[selected_set] = panel
-            self.items.append(panel)
-            return panel
-
-
-class ScriptGenerator(base_generate.GeneratorPlugin):
-    """Generator plugin that builds the python script attached to the rig."""
-
-    priority = -100
-
-    format_args: dict[str, str]
-
-    def __init__(self, generator):
-        super().__init__(generator)
-
-        self.ui_scripts = []
-        self.ui_imports = UI_IMPORTS.copy()
-        self.ui_utilities = UI_UTILITIES.copy()
-        self.ui_register = UI_REGISTER.copy()
-        self.ui_register_drivers = []
-        self.ui_register_props = []
-
-        self.ui_rig_panels = OrderedDict()
-
-        self.use_bake_settings = False
-
-    # Structured panel code generation
-    def panel_with_selected_check(self, rig, control_names):
-        """Add a panel section with restricted selection."""
-        rig_key = id(rig)
-
-        if rig_key in self.ui_rig_panels:
-            panel = self.ui_rig_panels[rig_key]
-        else:
-            panel = RigPanelLayout(self, rig)
-            self.ui_rig_panels[rig_key] = panel
-
-        return panel.panel_with_selected_check(control_names)
-
-    # Raw output
-    def add_panel_code(self, str_list: list[str]):
-        """Add raw code to the panel."""
-        self.ui_scripts += str_list
-
-    def add_imports(self, str_list: list[str]):
-        self.ui_imports += str_list
-
-    def add_utilities(self, str_list: list[str]):
-        self.ui_utilities += str_list
-
-    def register_classes(self, str_list: list[str]):
-        self.ui_register += str_list
-
-    def register_driver_functions(self, str_list: list[str]):
-        self.ui_register_drivers += str_list
-
-    def register_property(self, name: str, definition):
-        self.ui_register_props.append((name, definition))
-
-    def initialize(self):
-        self.format_args = {
-            'rig_id': self.generator.rig_id,
-        }
-
-    def finalize(self):
-        metarig = self.generator.metarig
-        rig_id = self.generator.rig_id
-
-        # Generate the UI script
-        script = metarig.data.rigify_rig_ui
-
-        if script:
-            script.clear()
-        else:
-            script_name = self.generator.obj.name + "_ui.py"
-            script = bpy.data.texts.new(script_name)
-            metarig.data.rigify_rig_ui = script
-
-        for s in OrderedDict.fromkeys(self.ui_imports):
-            script.write(s + "\n")
-
-        script.write(UI_BASE_UTILITIES % rig_id)
-
-        for s in OrderedDict.fromkeys(self.ui_utilities):
-            script.write(s + "\n")
-
-        script.write(UI_SLIDERS)
-
-        for s in self.ui_scripts:
-            script.write("\n        " + s.replace("\n", "\n        ") + "\n")
-
-        if len(self.ui_scripts) > 0:
-            script.write("\n        num_rig_separators[0] = 0\n")
-
-        for panel in self.ui_rig_panels.values():
-            lines = panel.get_lines()
-            if len(lines) > 1:
-                script.write("\n        ".join([''] + lines) + "\n")
-
-        if self.use_bake_settings:
-            self.ui_register = UI_REGISTER_BAKE_SETTINGS + self.ui_register
-            script.write(UI_BAKE_SETTINGS)
-
-        script.write(UI_LAYERS_PANEL)
-
-        # Inject the RNA property (un)register functions.
-        self._write_rna_prop_register_funcs(script)
-
-        script.write("\ndef register():\n")
-
-        ui_register = OrderedDict.fromkeys(self.ui_register)
-        for s in ui_register:
-            script.write("    bpy.utils.register_class(" + s + ")\n")
-
-        ui_register_drivers = OrderedDict.fromkeys(self.ui_register_drivers)
-        for s in ui_register_drivers:
-            script.write("    bpy.app.driver_namespace['" + s + "'] = " + s + "\n")
-
-        ui_register_props = OrderedDict.fromkeys(self.ui_register_props)
-        for classname, text in ui_register_props:
-            script.write(f"    bpy.types.{classname} = {text}\n ")
-
-        script.write("\ndef unregister():\n")
-
-        for s in ui_register_props:
-            script.write("    del bpy.types.%s\n" % s[0])
-
-        for s in ui_register:
-            script.write("    bpy.utils.unregister_class(" + s + ")\n")
-
-        for s in ui_register_drivers:
-            script.write("    del bpy.app.driver_namespace['" + s + "']\n")
-
-        script.write("\nregister()\n")
-        script.use_module = True
-
-        # Run UI script
-        exec(script.as_string(), {})
-
-        # Attach the script to the rig
-        self.obj['rig_ui'] = script
-
-    def _write_rna_prop_register_funcs(self, script: bpy.types.Text) -> None:
-        """Inject the (un)register_rna_properties functions into the script."""
-        import inspect
-        from . import register_rna_properties, unregister_rna_properties
-
-        register_func_src = inspect.getsource(register_rna_properties)
-        unregister_func_src = inspect.getsource(unregister_rna_properties)
-
-        script.write("\n\n")
-        script.write(register_func_src)
-        script.write("\n\n")
-        script.write(unregister_func_src)
-        script.write("\n")