space_view3d_copy_attributes.py 28.56 KiB
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
# <pep8 compliant>
bl_info = {
"name": "Copy Attributes Menu",
"author": "Bassam Kurdali, Fabian Fricke, Adam Wiseman",
"version": (0, 4, 7),
"blender": (2, 63, 0),
"location": "View3D > Ctrl-C",
"description": "Copy Attributes Menu from Blender 2.4",
"wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
"Scripts/3D_interaction/Copy_Attributes_Menu",
"tracker_url": "https://developer.blender.org/T22588",
"category": "3D View"}
import bpy
from mathutils import Matrix
def build_exec(loopfunc, func):
"""Generator function that returns exec functions for operators """
def exec_func(self, context):
loopfunc(self, context, func)
return {'FINISHED'}
return exec_func
def build_invoke(loopfunc, func):
"""Generator function that returns invoke functions for operators"""
def invoke_func(self, context, event):
loopfunc(self, context, func)
return {'FINISHED'}
return invoke_func
def build_op(idname, label, description, fpoll, fexec, finvoke):
"""Generator function that returns the basic operator"""
class myopic(bpy.types.Operator):
bl_idname = idname
bl_label = label
bl_description = description
execute = fexec
poll = fpoll
invoke = finvoke
return myopic
def genops(copylist, oplist, prefix, poll_func, loopfunc):
"""Generate ops from the copy list and its associated functions """
for op in copylist:
exec_func = build_exec(loopfunc, op[3])
invoke_func = build_invoke(loopfunc, op[3])
opclass = build_op(prefix + op[0], "Copy " + op[1], op[2],
poll_func, exec_func, invoke_func)
oplist.append(opclass)
def generic_copy(source, target, string=""):
""" copy attributes from source to target that have string in them """
for attr in dir(source):
if attr.find(string) > -1:
try:
setattr(target, attr, getattr(source, attr))
except:
pass
return
def getmat(bone, active, context, ignoreparent):
"""Helper function for visual transform copy,
gets the active transform in bone space
"""
obj_act = context.active_object
data_bone = obj_act.data.bones[bone.name]
#all matrices are in armature space unless commented otherwise
otherloc = active.matrix # final 4x4 mat of target, location.
bonemat_local = data_bone.matrix_local.copy() # self rest matrix
if data_bone.parent:
parentposemat = obj_act.pose.bones[data_bone.parent.name].matrix.copy()
parentbonemat = data_bone.parent.matrix_local.copy()
else:
parentposemat = parentbonemat = Matrix()
if parentbonemat == parentposemat or ignoreparent:
newmat = bonemat_local.inverted() * otherloc
else:
bonemat = parentbonemat.inverted() * bonemat_local
newmat = bonemat.inverted() * parentposemat.inverted() * otherloc
return newmat
def rotcopy(item, mat):
"""copy rotation to item from matrix mat depending on item.rotation_mode"""
if item.rotation_mode == 'QUATERNION':
item.rotation_quaternion = mat.to_3x3().to_quaternion()
elif item.rotation_mode == 'AXIS_ANGLE':
quat = mat.to_3x3().to_quaternion()
item.rotation_axis_angle = quat.axis[:] + (quat.angle, )
else:
item.rotation_euler = mat.to_3x3().to_euler(item.rotation_mode)
def pLoopExec(self, context, funk):
"""Loop over selected bones and execute funk on them"""
active = context.active_pose_bone
selected = context.selected_pose_bones
selected.remove(active)
for bone in selected:
funk(bone, active, context)
#The following functions are used o copy attributes frome active to bone
def pLocLocExec(bone, active, context):
bone.location = active.location
def pLocRotExec(bone, active, context):
rotcopy(bone, active.matrix_basis.to_3x3())
def pLocScaExec(bone, active, context):
bone.scale = active.scale
def pVisLocExec(bone, active, context):
bone.location = getmat(bone, active, context, False).to_translation()
def pVisRotExec(bone, active, context):
rotcopy(bone, getmat(bone, active,
context, not context.active_object.data.bones[bone.name].use_inherit_rotation))
def pVisScaExec(bone, active, context):
bone.scale = getmat(bone, active, context,
not context.active_object.data.bones[bone.name].use_inherit_scale)\
.to_scale()
def pDrwExec(bone, active, context):
bone.custom_shape = active.custom_shape
def pLokExec(bone, active, context):
for index, state in enumerate(active.lock_location):
bone.lock_location[index] = state
for index, state in enumerate(active.lock_rotation):
bone.lock_rotation[index] = state
bone.lock_rotations_4d = active.lock_rotations_4d
bone.lock_rotation_w = active.lock_rotation_w
for index, state in enumerate(active.lock_scale):
bone.lock_scale[index] = state
def pConExec(bone, active, context):
for old_constraint in active.constraints.values():
new_constraint = bone.constraints.new(old_constraint.type)
generic_copy(old_constraint, new_constraint)
def pIKsExec(bone, active, context):
generic_copy(active, bone, "ik_")
pose_copies = (('pose_loc_loc', "Local Location",
"Copy Location from Active to Selected", pLocLocExec),
('pose_loc_rot', "Local Rotation",
"Copy Rotation from Active to Selected", pLocRotExec),
('pose_loc_sca', "Local Scale",
"Copy Scale from Active to Selected", pLocScaExec),
('pose_vis_loc', "Visual Location",
"Copy Location from Active to Selected", pVisLocExec),
('pose_vis_rot', "Visual Rotation",
"Copy Rotation from Active to Selected", pVisRotExec),
('pose_vis_sca', "Visual Scale",
"Copy Scale from Active to Selected", pVisScaExec),
('pose_drw', "Bone Shape",
"Copy Bone Shape from Active to Selected", pDrwExec),
('pose_lok', "Protected Transform",
"Copy Protected Tranforms from Active to Selected", pLokExec),
('pose_con', "Bone Constraints",
"Copy Object Constraints from Active to Selected", pConExec),
('pose_iks', "IK Limits",
"Copy IK Limits from Active to Selected", pIKsExec))
@classmethod
def pose_poll_func(cls, context):
return(context.mode == 'POSE')
def pose_invoke_func(self, context, event):
wm = context.window_manager
wm.invoke_props_dialog(self)
return {'RUNNING_MODAL'}
class CopySelectedPoseConstraints(bpy.types.Operator):
"""Copy Chosen constraints from active to selected"""
bl_idname = "pose.copy_selected_constraints"
bl_label = "Copy Selected Constraints"
selection = bpy.props.BoolVectorProperty(size=32)
poll = pose_poll_func
invoke = pose_invoke_func
def draw(self, context):
layout = self.layout
for idx, const in enumerate(context.active_pose_bone.constraints):
layout.prop(self, "selection", index=idx, text=const.name,
toggle=True)
def execute(self, context):
active = context.active_pose_bone
selected = context.selected_pose_bones[:]
selected.remove(active)
for bone in selected:
for index, flag in enumerate(self.selection):
if flag:
old_constraint = active.constraints[index]
new_constraint = bone.constraints.new(\
active.constraints[index].type)
generic_copy(old_constraint, new_constraint)
return {'FINISHED'}
pose_ops = [] # list of pose mode copy operators
genops(pose_copies, pose_ops, "pose.copy_", pose_poll_func, pLoopExec)
class VIEW3D_MT_posecopypopup(bpy.types.Menu):
bl_label = "Copy Attributes"
def draw(self, context):
layout = self.layout
layout.operator_context = 'INVOKE_REGION_WIN'
for op in pose_copies:
layout.operator("pose.copy_" + op[0])
layout.operator("pose.copy_selected_constraints")
layout.operator("pose.copy", text="copy pose")
def obLoopExec(self, context, funk):
"""Loop over selected objects and execute funk on them"""
active = context.active_object
selected = context.selected_objects[:]
selected.remove(active)
for obj in selected:
msg = funk(obj, active, context)
if msg:
self.report({msg[0]}, msg[1])
def world_to_basis(active, ob, context):
"""put world coords of active as basis coords of ob"""
local = ob.parent.matrix_world.inverted() * active.matrix_world
P = ob.matrix_basis * ob.matrix_local.inverted()
mat = P * local
return(mat)
#The following functions are used o copy attributes from
#active to selected object
def obLoc(ob, active, context):
ob.location = active.location
def obRot(ob, active, context):
rotcopy(ob, active.matrix_local.to_3x3())
def obSca(ob, active, context):
ob.scale = active.scale
def obVisLoc(ob, active, context):
if ob.parent:
mat = world_to_basis(active, ob, context)
ob.location = mat.to_translation()
else:
ob.location = active.matrix_world.to_translation()
def obVisRot(ob, active, context):
if ob.parent:
mat = world_to_basis(active, ob, context)
rotcopy(ob, mat.to_3x3())
else:
rotcopy(ob, active.matrix_world.to_3x3())
def obVisSca(ob, active, context):
if ob.parent:
mat = world_to_basis(active, ob, context)
ob.scale = mat.to_scale()
else:
ob.scale = active.matrix_world.to_scale()
def obDrw(ob, active, context):
ob.draw_type = active.draw_type
ob.show_axis = active.show_axis
ob.show_bounds = active.show_bounds
ob.draw_bounds_type = active.draw_bounds_type
ob.show_name = active.show_name
ob.show_texture_space = active.show_texture_space
ob.show_transparent = active.show_transparent
ob.show_wire = active.show_wire
ob.show_x_ray = active.show_x_ray
ob.empty_draw_type = active.empty_draw_type
ob.empty_draw_size = active.empty_draw_size
def obOfs(ob, active, context):
ob.time_offset = active.time_offset
return('INFO', "time offset copied")
def obDup(ob, active, context):
generic_copy(active, ob, "dupli")
return('INFO', "duplication method copied")
def obCol(ob, active, context):
ob.color = active.color
def obMas(ob, active, context):
ob.game.mass = active.game.mass
return('INFO', "mass copied")
def obLok(ob, active, context):
for index, state in enumerate(active.lock_location):
ob.lock_location[index] = state
for index, state in enumerate(active.lock_rotation):
ob.lock_rotation[index] = state
ob.lock_rotations_4d = active.lock_rotations_4d
ob.lock_rotation_w = active.lock_rotation_w
for index, state in enumerate(active.lock_scale):
ob.lock_scale[index] = state
return('INFO', "transform locks copied")
def obCon(ob, active, context):
#for consistency with 2.49, delete old constraints first
for removeconst in ob.constraints:
ob.constraints.remove(removeconst)
for old_constraint in active.constraints.values():
new_constraint = ob.constraints.new(old_constraint.type)
generic_copy(old_constraint, new_constraint)
return('INFO', "constraints copied")
def obTex(ob, active, context):
if 'texspace_location' in dir(ob.data) and 'texspace_location' in dir(
active.data):
ob.data.texspace_location[:] = active.data.texspace_location[:]
if 'texspace_size' in dir(ob.data) and 'texspace_size' in dir(active.data):
ob.data.texspace_size[:] = active.data.texspace_size[:]
return('INFO', "texture space copied")
def obIdx(ob, active, context):
ob.pass_index = active.pass_index
return('INFO', "pass index copied")
def obMod(ob, active, context):
for modifier in ob.modifiers:
#remove existing before adding new:
ob.modifiers.remove(modifier)
for old_modifier in active.modifiers.values():
new_modifier = ob.modifiers.new(name=old_modifier.name,
type=old_modifier.type)
generic_copy(old_modifier, new_modifier)
return('INFO', "modifiers copied")
def obGrp(ob, active, context):
for grp in bpy.data.groups:
if active.name in grp.objects and ob.name not in grp.objects:
grp.objects.link(ob)
return('INFO', "groups copied")
def obWei(ob, active, context):
me_source = active.data
me_target = ob.data
# sanity check: do source and target have the same amount of verts?
if len(me_source.vertices) != len(me_target.vertices):
return('ERROR', "objects have different vertex counts, doing nothing")
vgroups_IndexName = {}
for i in range(0, len(active.vertex_groups)):
groups = active.vertex_groups[i]
vgroups_IndexName[groups.index] = groups.name
data = {} # vert_indices, [(vgroup_index, weights)]
for v in me_source.vertices:
vg = v.groups
vi = v.index
if len(vg) > 0:
vgroup_collect = []
for i in range(0, len(vg)):
vgroup_collect.append((vg[i].group, vg[i].weight))
data[vi] = vgroup_collect
# write data to target
if ob != active:
# add missing vertex groups
for vgroup_name in vgroups_IndexName.values():
#check if group already exists...
already_present = 0
for i in range(0, len(ob.vertex_groups)):
if ob.vertex_groups[i].name == vgroup_name:
already_present = 1
# ... if not, then add
if already_present == 0:
ob.vertex_groups.new(name=vgroup_name)
# write weights
for v in me_target.vertices:
for vi_source, vgroupIndex_weight in data.items():
if v.index == vi_source:
for i in range(0, len(vgroupIndex_weight)):
groupName = vgroups_IndexName[vgroupIndex_weight[i][0]]
groups = ob.vertex_groups
for vgs in range(0, len(groups)):
if groups[vgs].name == groupName:
groups[vgs].add((v.index,),
vgroupIndex_weight[i][1], "REPLACE")
return('INFO', "weights copied")
object_copies = (
#('obj_loc', "Location",
#"Copy Location from Active to Selected", obLoc),
#('obj_rot', "Rotation",
#"Copy Rotation from Active to Selected", obRot),
#('obj_sca', "Scale",
#"Copy Scale from Active to Selected", obSca),
('obj_vis_loc', "Location",
"Copy Location from Active to Selected", obVisLoc),
('obj_vis_rot', "Rotation",
"Copy Rotation from Active to Selected", obVisRot),
('obj_vis_sca', "Scale",
"Copy Scale from Active to Selected", obVisSca),
('obj_drw', "Draw Options",
"Copy Draw Options from Active to Selected", obDrw),
('obj_ofs', "Time Offset",
"Copy Time Offset from Active to Selected", obOfs),
('obj_dup', "Dupli",
"Copy Dupli from Active to Selected", obDup),
('obj_col', "Object Color",
"Copy Object Color from Active to Selected", obCol),
('obj_mas', "Mass",
"Copy Mass from Active to Selected", obMas),
#('obj_dmp', "Damping",
#"Copy Damping from Active to Selected"),
#('obj_all', "All Physical Attributes",
#"Copy Physical Atributes from Active to Selected"),
#('obj_prp', "Properties",
#"Copy Properties from Active to Selected"),
#('obj_log', "Logic Bricks",
#"Copy Logic Bricks from Active to Selected"),
('obj_lok', "Protected Transform",
"Copy Protected Tranforms from Active to Selected", obLok),
('obj_con', "Object Constraints",
"Copy Object Constraints from Active to Selected", obCon),
#('obj_nla', "NLA Strips",
#"Copy NLA Strips from Active to Selected"),
#('obj_tex', "Texture Space",
#"Copy Texture Space from Active to Selected", obTex),
#('obj_sub', "Subsurf Settings",
#"Copy Subsurf Setings from Active to Selected"),
#('obj_smo', "AutoSmooth",
#"Copy AutoSmooth from Active to Selected"),
('obj_idx', "Pass Index",
"Copy Pass Index from Active to Selected", obIdx),
('obj_mod', "Modifiers",
"Copy Modifiers from Active to Selected", obMod),
('obj_wei', "Vertex Weights",
"Copy vertex weights based on indices", obWei),
('obj_grp', "Group Links",
"Copy selected into active object's groups", obGrp))
@classmethod
def object_poll_func(cls, context):
return(len(context.selected_objects) > 1)
def object_invoke_func(self, context, event):
wm = context.window_manager
wm.invoke_props_dialog(self)
return {'RUNNING_MODAL'}
class CopySelectedObjectConstraints(bpy.types.Operator):
"""Copy Chosen constraints from active to selected"""
bl_idname = "object.copy_selected_constraints"
bl_label = "Copy Selected Constraints"
selection = bpy.props.BoolVectorProperty(size=32)
poll = object_poll_func
invoke = object_invoke_func
def draw(self, context):
layout = self.layout
for idx, const in enumerate(context.active_object.constraints):
layout.prop(self, "selection", index=idx, text=const.name,
toggle=True)
def execute(self, context):
active = context.active_object
selected = context.selected_objects[:]
selected.remove(active)
for obj in selected:
for index, flag in enumerate(self.selection):
if flag:
old_constraint = active.constraints[index]
new_constraint = obj.constraints.new(\
active.constraints[index].type)
generic_copy(old_constraint, new_constraint)
return{'FINISHED'}
class CopySelectedObjectModifiers(bpy.types.Operator):
"""Copy Chosen modifiers from active to selected"""
bl_idname = "object.copy_selected_modifiers"
bl_label = "Copy Selected Modifiers"
selection = bpy.props.BoolVectorProperty(size=32)
poll = object_poll_func
invoke = object_invoke_func
def draw(self, context):
layout = self.layout
for idx, const in enumerate(context.active_object.modifiers):
layout.prop(self, 'selection', index=idx, text=const.name,
toggle=True)
def execute(self, context):
active = context.active_object
selected = context.selected_objects[:]
selected.remove(active)
for obj in selected:
for index, flag in enumerate(self.selection):
if flag:
old_modifier = active.modifiers[index]
new_modifier = obj.modifiers.new(\
type=active.modifiers[index].type,
name=active.modifiers[index].name)
generic_copy(old_modifier, new_modifier)
return{'FINISHED'}
object_ops = []
genops(object_copies, object_ops, "object.copy_", object_poll_func, obLoopExec)
class VIEW3D_MT_copypopup(bpy.types.Menu):
bl_label = "Copy Attributes"
def draw(self, context):
layout = self.layout
layout.operator_context = 'INVOKE_REGION_WIN'
for op in object_copies:
layout.operator("object.copy_" + op[0])
layout.operator("object.copy_selected_constraints")
layout.operator("object.copy_selected_modifiers")
#Begin Mesh copy settings:
class MESH_MT_CopyFaceSettings(bpy.types.Menu):
bl_label = "Copy Face Settings"
@classmethod
def poll(cls, context):
return context.mode == 'EDIT_MESH'
def draw(self, context):
mesh = context.object.data
uv = len(mesh.uv_textures) > 1
vc = len(mesh.vertex_colors) > 1
layout = self.layout
op = layout.operator(MESH_OT_CopyFaceSettings.bl_idname,
text="Copy Material")
op['layer'] = ''
op['mode'] = 'MAT'
if mesh.uv_textures.active:
op = layout.operator(MESH_OT_CopyFaceSettings.bl_idname,
text="Copy Image")
op['layer'] = ''
op['mode'] = 'IMAGE'
op = layout.operator(MESH_OT_CopyFaceSettings.bl_idname,
text="Copy UV Coords")
op['layer'] = ''
op['mode'] = 'UV'
if mesh.vertex_colors.active:
op = layout.operator(MESH_OT_CopyFaceSettings.bl_idname,
text="Copy Vertex Colors")
op['layer'] = ''
op['mode'] = 'VCOL'
if uv or vc:
layout.separator()
if uv:
layout.menu("MESH_MT_CopyImagesFromLayer")
layout.menu("MESH_MT_CopyUVCoordsFromLayer")
if vc:
layout.menu("MESH_MT_CopyVertexColorsFromLayer")
def _buildmenu(self, mesh, mode):
layout = self.layout
if mode == 'VCOL':
layers = mesh.vertex_colors
else:
layers = mesh.uv_textures
for layer in layers:
if not layer.active:
op = layout.operator(MESH_OT_CopyFaceSettings.bl_idname,
text=layer.name)
op['layer'] = layer.name
op['mode'] = mode
@classmethod
def _poll_layer_uvs(cls, context):
return context.mode == "EDIT_MESH" and len(
context.object.data.uv_layers) > 1
@classmethod
def _poll_layer_vcols(cls, context):
return context.mode == "EDIT_MESH" and len(
context.object.data.vertex_colors) > 1
def _build_draw(mode):
return (lambda self, context: _buildmenu(self, context.object.data, mode))
_layer_menu_data = (("UV Coords", _build_draw("UV"), _poll_layer_uvs),
("Images", _build_draw("IMAGE"), _poll_layer_uvs),
("Vertex Colors", _build_draw("VCOL"), _poll_layer_vcols))
_layer_menus = []
for name, draw_func, poll_func in _layer_menu_data:
classname = "MESH_MT_Copy" + "".join(name.split()) + "FromLayer"
menuclass = type(classname, (bpy.types.Menu,),
dict(bl_label="Copy " + name + " from layer",
bl_idname=classname,
draw=draw_func,
poll=poll_func))
_layer_menus.append(menuclass)
class MESH_OT_CopyFaceSettings(bpy.types.Operator):
"""Copy settings from active face to all selected faces"""
bl_idname = 'mesh.copy_face_settings'
bl_label = "Copy Face Settings"
bl_options = {'REGISTER', 'UNDO'}
mode = bpy.props.StringProperty(name="mode")
layer = bpy.props.StringProperty(name="layer")
@classmethod
def poll(cls, context):
return context.mode == 'EDIT_MESH'
def execute(self, context):
mode = getattr(self, 'mode', '')
if not mode in {'MAT', 'VCOL', 'IMAGE', 'UV'}:
self.report({'ERROR'}, "No mode specified or invalid mode.")
return self._end(context, {'CANCELLED'})
layername = getattr(self, 'layer', '')
mesh = context.object.data
# Switching out of edit mode updates the selected state of faces and
# makes the data from the uv texture and vertex color layers available.
bpy.ops.object.editmode_toggle()
polys = mesh.polygons
if mode == 'MAT':
to_data = from_data = polys
else:
if mode == 'VCOL':
layers = mesh.vertex_colors
act_layer = mesh.vertex_colors.active
elif mode == 'IMAGE':
layers = mesh.uv_textures
act_layer = mesh.uv_textures.active
elif mode == 'UV':
layers = mesh.uv_layers
act_layer = mesh.uv_layers.active
if not layers or (layername and not layername in layers):
self.report({'ERROR'}, "Invalid UV or color layer.")
return self._end(context, {'CANCELLED'})
from_data = layers[layername or act_layer.name].data
to_data = act_layer.data
from_index = polys.active
for f in polys:
if f.select:
if to_data != from_data:
# Copying from another layer.
# from_face is to_face's counterpart from other layer.
from_index = f.index
elif f.index == from_index:
# Otherwise skip copying a face to itself.
continue
if mode == 'MAT':
f.material_index = polys[from_index].material_index
continue
elif mode == 'IMAGE':
to_data[f.index].image = from_data[from_index].image
continue
if len(f.loop_indices) != len(polys[from_index].loop_indices):
self.report({'WARNING'}, "Different number of vertices.")
for i in range(len(f.loop_indices)):
to_vertex = f.loop_indices[i]
from_vertex = polys[from_index].loop_indices[i]
if mode == 'VCOL':
to_data[to_vertex].color = from_data[from_vertex].color
elif mode == 'UV':
to_data[to_vertex].uv = from_data[from_vertex].uv
return self._end(context, {'FINISHED'})
def _end(self, context, retval):
if context.mode != 'EDIT_MESH':
# Clean up by returning to edit mode like it was before.
bpy.ops.object.editmode_toggle()
return(retval)
def register():
bpy.utils.register_module(__name__)
''' mostly to get the keymap working '''
kc = bpy.context.window_manager.keyconfigs.addon
if kc:
km = kc.keymaps.new(name="Object Mode")
kmi = km.keymap_items.new('wm.call_menu', 'C', 'PRESS', ctrl=True)
kmi.properties.name = 'VIEW3D_MT_copypopup'
km = kc.keymaps.new(name="Pose")
kmi = km.keymap_items.get("pose.copy")
if kmi is not None:
kmi.idname = 'wm.call_menu'
else:
kmi = km.keymap_items.new('wm.call_menu', 'C', 'PRESS', ctrl=True)
kmi.properties.name = 'VIEW3D_MT_posecopypopup'
for menu in _layer_menus:
bpy.utils.register_class(menu)
km = kc.keymaps.new(name="Mesh")
kmi = km.keymap_items.new('wm.call_menu', 'C', 'PRESS')
kmi.ctrl = True
kmi.properties.name = 'MESH_MT_CopyFaceSettings'
def unregister():
bpy.utils.unregister_module(__name__)
''' mostly to remove the keymap '''
kc = bpy.context.window_manager.keyconfigs.addon
if kc:
kms = kc.keymaps['Pose']
for item in kms.keymap_items:
if item.name == 'Call Menu' and item.idname == 'wm.call_menu' and \
item.properties.name == 'VIEW3D_MT_posecopypopup':
item.idname = 'pose.copy'
break
for menu in _layer_menus:
bpy.utils.unregister_class(menu)
km = kc.keymaps['Mesh']
for kmi in km.keymap_items:
if kmi.idname == 'wm.call_menu':
if kmi.properties.name == 'MESH_MT_CopyFaceSettings':
km.keymap_items.remove(kmi)
km = kc.keymaps['Object Mode']
for kmi in km.keymap_items:
if kmi.idname == 'wm.call_menu':
if kmi.properties.name == 'VIEW3D_MT_copypopup':
km.keymap_items.remove(kmi)
if __name__ == "__main__":
register()