Remove menu handler and refactor add/replace menu

__init__.py

@@ -1,5 +1,6 @@
 import bpy
-from . import gui, operators, common, keymaps
+from . import gui, operators, common
+from typing import List, Tuple
 bl_info = \
     {
         "name": "Damn Simple Pose Library",
@@ -18,9 +19,12 @@ if _need_reload:
 
     gui = importlib.reload(gui)
     common = importlib.reload(common)
-    keymaps = importlib.reload(keymaps)
+    # keymaps = importlib.reload(keymaps)
     operators = importlib.reload(operators)
 
+# addon_keymaps: List[Tuple[bpy.types.KeyMap, bpy.types.KeyMapItem]] = []
+# addon_keymaps = []
+
 
 class dsplObj(bpy.types.PropertyGroup):
     pose_library: bpy.props.PointerProperty(
@@ -36,6 +40,9 @@ class dsplVars(bpy.types.PropertyGroup):
     pose_new_name: bpy.props.StringProperty(
         name="Pose Name", description="New name for pose",
         default="Pose", override={'LIBRARY_OVERRIDABLE'})
+    only_selected: bpy.props.BoolProperty(
+        name="Only selected Bones", description="Process only selected bones",
+        default=False, options={'HIDDEN'}, override={'LIBRARY_OVERRIDABLE'})
     numero: bpy.props.IntProperty(
         name='Numero', default=666, override={'LIBRARY_OVERRIDABLE'})
 
@@ -59,7 +66,7 @@ def register():
 
     # bpy.types.Object.pose_library = bpy.props.PointerProperty(
     #     type=bpy.types.Action, options={'LIBRARY_EDITABLE'}, override={'LIBRARY_OVERRIDABLE'})
-
+        
     bpy.types.Object.dspl = bpy.props.PointerProperty(
         type=dsplObj, override={'LIBRARY_OVERRIDABLE'})
     bpy.types.Object.dsplvars = bpy.props.PointerProperty(
@@ -69,7 +76,15 @@ def register():
 
     gui.register()
     operators.register()
-    keymaps.register()
+
+    # kc = bpy.context.window_manager.keyconfigs.addon
+    # km = kc.keymaps.new(name='3D View', space_type='VIEW_3D')
+    # kmi = [
+    #     km.keymap_items.new("dspl.add_pose", type='L', value='PRESS', shift=True),
+    #     km.keymap_items.new("dspl.browse_poses", type='L', value='PRESS', alt=True),
+    # ]
+    # addon_keymaps.append((km, kmi))
+
 
 def unregister() -> None:
     from bpy.utils import unregister_class
@@ -80,9 +95,14 @@ def unregister() -> None:
     del bpy.types.Object.dsplvars
     del bpy.types.Scene.dsplSettings
 
-    keymaps.unregister()
-    operators.unregister()
     gui.unregister()
+    operators.unregister()
+
+    # for km, kmi in addon_keymaps:
+    #     km.keymap_items.remove(kmi)
+    # addon_keymaps.clear()
+
 
 if __name__ == "__main__":
-    register()
+    register()
+    

common.py

@@ -1,5 +1,4 @@
 import bpy
-import mathutils
 
 
 def getArmatureObject(context):
@@ -97,14 +96,10 @@ def createKeyframe(context, bone_name, transform, index_int, new_marker, loc):
         pass
 
 
-def setKeyframesFromBones(context, arm_object, new_marker):
-    none_selected = True
+def setKeyframesFromBones(context, new_marker):
+    arm_object = getArmatureObject(context)
     for bone in arm_object.pose.bones:
-        if bone.bone.select:
-            none_selected = False
-
-    for bone in arm_object.pose.bones:
-        if bone.bone.select or none_selected == True:
+        if bone.bone.select or arm_object.dsplvars.only_selected == False:
             bone_name = bone.name
 
             if bone.rotation_mode == "XYZ":
@@ -162,61 +157,3 @@ def setKeyframesFromBones(context, arm_object, new_marker):
             createKeyframe(context, bone_name, "scale", 2, new_marker, scl_z)
 
 
-def setBonesfromKeyframes(context, arm_object, active_marker):
-    none_selected = True
-    for bone in arm_object.pose.bones:
-        if bone.bone.select:
-            none_selected = False
-
-    for bone in arm_object.pose.bones:
-        if bone.bone.select or none_selected == True:
-            bone_name = bone.name
-
-            if bone.rotation_mode == "XYZ":
-                rot_mode = "rotation_euler"
-            elif bone.rotation_mode == "YZX":
-                rot_mode = "rotation_euler"
-            elif bone.rotation_mode == "ZXY":
-                rot_mode = "rotation_euler"
-            elif bone.rotation_mode == "QUATERNION":
-                rot_mode = "rotation_quaternion"
-            else:
-                self.report({'WARNING'}, "DSPL: Unsupported bone: " + bone.name + ": " + bone.rotation_mode)
-                rot_mode = None
-
-            loc_x = findFcurve(context, bone_name, "location", 0) or 0.0
-            loc_y = findFcurve(context, bone_name, "location", 1) or 0.0
-            loc_z = findFcurve(context, bone_name, "location", 2) or 0.0
-            if rot_mode == "rotation_quaternion":
-                rot_w = findFcurve(context, bone_name, rot_mode, 0) or 1.0
-                rot_x = findFcurve(context, bone_name, rot_mode, 1) or 0.0
-                rot_y = findFcurve(context, bone_name, rot_mode, 2) or 0.0
-                rot_z = findFcurve(context, bone_name, rot_mode, 3) or 0.0
-            elif rot_mode == "rotation_euler":
-                rot_x = findFcurve(context, bone_name, rot_mode, 0) or 0.0
-                rot_y = findFcurve(context, bone_name, rot_mode, 1) or 0.0
-                rot_z = findFcurve(context, bone_name, rot_mode, 2) or 0.0
-            scl_x = findFcurve(context, bone_name, "scale", 0) or 1.0
-            scl_y = findFcurve(context, bone_name, "scale", 1) or 1.0
-            scl_z = findFcurve(context, bone_name, "scale", 2) or 1.0
-
-            bone.location = mathutils.Vector((loc_x, loc_y, loc_z))
-            if bone.rotation_mode == "XYZ":
-                bone.rotation_euler = mathutils.Euler(
-                    (rot_x, rot_y, rot_z))
-            elif bone.rotation_mode == "YZX":
-                bone.rotation_euler = mathutils.Euler(
-                    (rot_x, rot_y, rot_z))
-            elif bone.rotation_mode == "ZXY":
-                bone.rotation_euler = mathutils.Euler(
-                    (rot_z, rot_x, rot_y))
-            elif bone.rotation_mode == "YXZ":
-                bone.rotation_euler = mathutils.Euler(
-                    (rot_y, rot_x, rot_z))
-            elif bone.rotation_mode == "XZY":
-                bone.rotation_euler = mathutils.Euler(
-                    (rot_x, rot_z, rot_y))
-            elif rot_mode == "rotation_quaternion":
-                bone.rotation_quaternion = mathutils.Quaternion(
-                    (rot_w, rot_x, rot_y, rot_z))
-            bone.scale = mathutils.Vector((scl_x, scl_y, scl_z))

gui.py

@@ -75,6 +75,8 @@ class DATA_PT_DSPLPanel(bpy.types.Panel):
                     if active_pose_library.pose_markers.active:
                         quick_apply_layout = quick_pose_controls_layout.split(
                             align=True)
+                        quick_apply_layout.prop(arm_object.dsplvars,
+                            "only_selected", icon='GROUP_BONE', text="Selected", toggle=True)
                         quick_apply_layout.operator(
                             "dspl.browse_poses", icon='CON_ARMATURE', text="Browse")
                         if dsplsettings.new_menu == False:

keymaps.py

@@ -1,30 +1,28 @@
+# SPDX-FileCopyrightText: 2010-2023 Blender Foundation
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
 import bpy
+from .operators import *
+from typing import List, Tuple
 
 
 addon_keymaps = []
 
 
-def register_keymaps():
-	wm = bpy.context.window_manager
+def register() -> None:
+    wm = bpy.context.window_manager
+    kc = wm.keyconfigs.addon
+    if kc is None:
+        return
+    
+    km = kc.keymaps.new(name="File Browser Main")
+    kmi = km.keymap_items.new("dspl.browse_poses", type="L", value="PRESS", alt=True)
+    kmi.active = True
+    addon_keymaps.append((km, kmi))
 
-	# Add Pose
-	km = wm.keyconfigs.addon.keymaps.new(name='Pose', space_type='EMPTY')
-	kmi = km.keymap_items.new('wm.call_menu', 'L', 'PRESS', shift=True)
-	kmi.properties.name = "OBJECT_MT_AddPoseMenu"
-	addon_keymaps.append((km, kmi))
 
-	# Browse Poses
-	km = wm.keyconfigs.addon.keymaps.new(name='Pose', space_type='EMPTY')
-	kmi = km.keymap_items.new('dspl.browse_poses', 'L', 'PRESS', alt=True)
-	addon_keymaps.append((km, kmi))
-
-def unregister_keymaps():
-	for km, kmi in addon_keymaps:
-		km.keymap_items.remove(kmi)
-	addon_keymaps.clear()
-
-def register():
-    register_keymaps()
-
-def unregister():
-    unregister_keymaps()
+def unregister() -> None:
+    for km, kmi in addon_keymaps:
+        km.keymap_items.remove(kmi)
+    addon_keymaps.clear()

operators.py

@@ -1,4 +1,5 @@
 import bpy
+import mathutils
 import blf
 from .common import *
 
@@ -114,7 +115,7 @@ class DSPL_OT_AddPose(bpy.types.Operator):
             pose_markers.new(name=pose_name)
             pose_markers[pose_name].frame = new_marker
 
-            setKeyframesFromBones(context, arm_object, new_marker)
+            setKeyframesFromBones(context, new_marker)
 
             action_object.pose_markers.active = pose_markers[pose_name]
             bpy.context.area.tag_redraw()
@@ -141,7 +142,7 @@ class DSPL_OT_AddPose(bpy.types.Operator):
 
             new_marker = target_frame
 
-            setKeyframesFromBones(context, arm_object, new_marker)
+            setKeyframesFromBones(context, new_marker)
 
             self.report({'INFO'}, "DSPL: Replaced " + pose_markers[new_name].name + " on frame " + str(pose_markers[new_name].frame))
 
@@ -317,7 +318,58 @@ class DSPL_OT_ApplyPose(bpy.types.Operator):
             active_frame = active_marker.frame
             active_posename = active_marker.name
 
-        setBonesfromKeyframes(context, arm_object, active_marker)
+        for bone in arm_object.pose.bones:
+            if bone.bone.select or arm_object.dsplvars.only_selected == False:
+                bone_name = bone.name
+
+                if bone.rotation_mode == "XYZ":
+                    rot_mode = "rotation_euler"
+                elif bone.rotation_mode == "YZX":
+                    rot_mode = "rotation_euler"
+                elif bone.rotation_mode == "ZXY":
+                    rot_mode = "rotation_euler"
+                elif bone.rotation_mode == "QUATERNION":
+                    rot_mode = "rotation_quaternion"
+                else:
+                    self.report({'WARNING'}, "DSPL: Unsupported bone: " + bone.name + ": " + bone.rotation_mode)
+                    rot_mode = None
+
+                loc_x = findFcurve(context, bone_name, "location", 0) or 0.0
+                loc_y = findFcurve(context, bone_name, "location", 1) or 0.0
+                loc_z = findFcurve(context, bone_name, "location", 2) or 0.0
+                if rot_mode == "rotation_quaternion":
+                    rot_w = findFcurve(context, bone_name, rot_mode, 0) or 1.0
+                    rot_x = findFcurve(context, bone_name, rot_mode, 1) or 0.0
+                    rot_y = findFcurve(context, bone_name, rot_mode, 2) or 0.0
+                    rot_z = findFcurve(context, bone_name, rot_mode, 3) or 0.0
+                elif rot_mode == "rotation_euler":
+                    rot_x = findFcurve(context, bone_name, rot_mode, 0) or 0.0
+                    rot_y = findFcurve(context, bone_name, rot_mode, 1) or 0.0
+                    rot_z = findFcurve(context, bone_name, rot_mode, 2) or 0.0
+                scl_x = findFcurve(context, bone_name, "scale", 0) or 1.0
+                scl_y = findFcurve(context, bone_name, "scale", 1) or 1.0
+                scl_z = findFcurve(context, bone_name, "scale", 2) or 1.0
+
+                bone.location = mathutils.Vector((loc_x, loc_y, loc_z))
+                if bone.rotation_mode == "XYZ":
+                    bone.rotation_euler = mathutils.Euler(
+                        (rot_x, rot_y, rot_z))
+                elif bone.rotation_mode == "YZX":
+                    bone.rotation_euler = mathutils.Euler(
+                        (rot_x, rot_y, rot_z))
+                elif bone.rotation_mode == "ZXY":
+                    bone.rotation_euler = mathutils.Euler(
+                        (rot_z, rot_x, rot_y))
+                elif bone.rotation_mode == "YXZ":
+                    bone.rotation_euler = mathutils.Euler(
+                        (rot_y, rot_x, rot_z))
+                elif bone.rotation_mode == "XZY":
+                    bone.rotation_euler = mathutils.Euler(
+                        (rot_x, rot_z, rot_y))
+                elif rot_mode == "rotation_quaternion":
+                    bone.rotation_quaternion = mathutils.Quaternion(
+                        (rot_w, rot_x, rot_y, rot_z))
+                bone.scale = mathutils.Vector((scl_x, scl_y, scl_z))
 
         self.report({'INFO'}, "DSPL: Applied " + active_posename)