2.5

Put back Armature/Pose code, including 'heat weight'.
I've added reeb.h to get things compile, but Martin will
cleanup files and put back?

Now where to put all vertexgroup code.... I guess mesh?

Note for msvc: yep, another new dir to add! :)

1 files changed, 1681 insertions, 0 deletions

diff --git a/source/blender/editors/armature/poseobject.c b/source/blender/editors/armature/poseobject.c
new file mode 100644
index 00000000000..14e571219ff
--- /dev/null
+++ b/source/blender/editors/armature/poseobject.c
@@ -0,0 +1,1681 @@
+/**
+ * $Id$
+ *
+ * ***** 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Ton Roosendaal, Blender Foundation '05, full recode.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ * support for animation modes - Reevan McKay
+ */
+
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_arithb.h"
+#include "BLI_blenlib.h"
+#include "BLI_dynstr.h"
+
+#include "DNA_action_types.h"
+#include "DNA_armature_types.h"
+#include "DNA_constraint_types.h"
+#include "DNA_curve_types.h"
+#include "DNA_mesh_types.h"
+#include "DNA_meshdata_types.h"
+#include "DNA_modifier_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_view3d_types.h"
+#include "DNA_userdef_types.h"
+
+#include "BKE_action.h"
+#include "BKE_armature.h"
+#include "BKE_blender.h"
+#include "BKE_constraint.h"
+#include "BKE_deform.h"
+#include "BKE_depsgraph.h"
+#include "BKE_displist.h"
+#include "BKE_global.h"
+#include "BKE_modifier.h"
+#include "BKE_object.h"
+#include "BKE_utildefines.h"
+#include "BKE_ipo.h"
+
+#include "BIF_transform.h" /* for autokey TFM_TRANSLATION, etc */
+#include "BIF_gl.h"
+
+#include "ED_armature.h"
+#include "ED_keyframing.h"
+#include "ED_object.h"
+#include "ED_view3d.h"
+
+#include "armature_intern.h"
+
+/* ************* XXX *************** */
+static int movetolayer_short_buts() {return 1;}
+static int okee() {return 0;}
+static int pupmenu() {return 0;}
+static void waitcursor() {};
+static void error() {};
+static void BIF_undo_push() {}
+static void countall() {}
+static void add_constraint() {}
+static void vertexgroup_select_by_name() {}
+static int screen_view3d_layers() {return 0;}
+static void select_actionchannel_by_name() {}
+static int autokeyframe_cfra_can_key() {return 0;}
+static void autokeyframe_pose_cb_func() {}
+/* ************* XXX *************** */
+
+
+void enter_posemode(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Base *base;
+	Object *ob;
+	
+	if(scene->id.lib) return;
+	base= BASACT;
+	if(base==NULL) return;
+	
+	ob= base->object;
+	
+	if (ob->id.lib){
+		error ("Can't pose libdata");
+		return;
+	}
+
+	switch (ob->type){
+	case OB_ARMATURE:
+		
+		ob->flag |= OB_POSEMODE;
+		base->flag= ob->flag;
+		
+		break;
+	default:
+		return;
+	}
+
+	if (obedit) {
+		ED_armature_from_edit(scene, obedit);
+		ED_armature_edit_free(obedit);
+	}
+	G.f &= ~(G_VERTEXPAINT | G_TEXTUREPAINT | G_WEIGHTPAINT | G_SCULPTMODE);
+}
+
+void set_pose_keys (Object *ob)
+{
+	bArmature *arm= ob->data;
+	bPoseChannel *chan;
+
+	if (ob->pose){
+		for (chan=ob->pose->chanbase.first; chan; chan=chan->next){
+			Bone *bone= chan->bone;
+			if(bone && (bone->flag & BONE_SELECTED) && (arm->layer & bone->layer)) {
+				chan->flag |= POSE_KEY;		
+			}
+			else {
+				chan->flag &= ~POSE_KEY;
+			}
+		}
+	}
+}
+
+
+void exit_posemode(Scene *scene)
+{
+	Object *ob= OBACT;
+	Base *base= BASACT;
+
+	if(ob==NULL) return;
+	
+	ob->flag &= ~OB_POSEMODE;
+	base->flag= ob->flag;
+	
+	countall();
+
+}
+
+/* called by buttons to find a bone to display/edit values for */
+bPoseChannel *get_active_posechannel (Object *ob)
+{
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	
+	if ELEM(NULL, ob, ob->pose)
+		return NULL;
+	
+	/* find active */
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if(pchan->bone && (pchan->bone->flag & BONE_ACTIVE) && (pchan->bone->layer & arm->layer))
+			return pchan;
+	}
+	
+	return NULL;
+}
+
+/* if a selected or active bone is protected, throw error (oonly if warn==1) and return 1 */
+/* only_selected==1 : the active bone is allowed to be protected */
+static short pose_has_protected_selected(Object *ob, short only_selected, short warn)
+{
+	/* check protection */
+	if (ob->proxy) {
+		bPoseChannel *pchan;
+		bArmature *arm= ob->data;
+		
+		for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if (pchan->bone && (pchan->bone->layer & arm->layer)) {
+				if (pchan->bone->layer & arm->layer_protected) {
+					if (only_selected && (pchan->bone->flag & BONE_ACTIVE));
+					else if (pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) 
+					   break;
+				}
+			}
+		}
+		if (pchan) {
+			if (warn) error("Cannot change Proxy protected bones");
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/* only for real IK, not for auto-IK */
+int pose_channel_in_IK_chain(Object *ob, bPoseChannel *pchan)
+{
+	bConstraint *con;
+	Bone *bone;
+	
+	/* No need to check if constraint is active (has influence),
+	 * since all constraints with CONSTRAINT_IK_AUTO are active */
+	for(con= pchan->constraints.first; con; con= con->next) {
+		if(con->type==CONSTRAINT_TYPE_KINEMATIC) {
+			bKinematicConstraint *data= con->data;
+			if((data->flag & CONSTRAINT_IK_AUTO)==0)
+				return 1;
+		}
+	}
+	for(bone= pchan->bone->childbase.first; bone; bone= bone->next) {
+		pchan= get_pose_channel(ob->pose, bone->name);
+		if(pchan && pose_channel_in_IK_chain(ob, pchan))
+			return 1;
+	}
+	return 0;
+}
+
+/* ********************************************** */
+
+/* For the object with pose/action: create path curves for selected bones 
+ * This recalculates the WHOLE path within the pchan->pathsf and pchan->pathef range
+ */
+void pose_calculate_path(Scene *scene, Object *ob)
+{
+	bArmature *arm;
+	bPoseChannel *pchan;
+	Base *base;
+	float *fp;
+	int cfra;
+	int sfra, efra;
+	
+	if (ob==NULL || ob->pose==NULL)
+		return;
+	arm= ob->data;
+	
+	/* version patch for older files here (do_versions patch too complicated) */
+	if ((arm->pathsf == 0) || (arm->pathef == 0)) {
+		arm->pathsf = SFRA;
+		arm->pathef = EFRA;
+	}
+	if (arm->pathsize == 0) {
+		arm->pathsize = 1;
+	}
+	
+	/* set frame values */
+	cfra= CFRA;
+	sfra = arm->pathsf;
+	efra = arm->pathef;
+	if (efra <= sfra) {
+		error("Can't calculate paths when pathlen <= 0");
+		return;
+	}
+	
+	waitcursor(1);
+	
+	/* hack: for unsaved files, set OB_RECALC so that paths can get calculated */
+	if ((ob->recalc & OB_RECALC)==0) {
+		ob->recalc |= OB_RECALC;
+		DAG_object_update_flags(scene, ob, screen_view3d_layers());
+	}
+	else
+		DAG_object_update_flags(scene, ob, screen_view3d_layers());
+	
+	
+	/* malloc the path blocks */
+	for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED)) {
+			if (arm->layer & pchan->bone->layer) {
+				pchan->pathlen= efra-sfra+1;
+				pchan->pathsf= sfra;
+				pchan->pathef= efra+1;
+				if (pchan->path)
+					MEM_freeN(pchan->path);
+				pchan->path= MEM_callocN(3*pchan->pathlen*sizeof(float), "pchan path");
+			}
+		}
+	}
+	
+	for (CFRA=sfra; CFRA<=efra; CFRA++) {
+		/* do all updates */
+		for (base= FIRSTBASE; base; base= base->next) {
+			if (base->object->recalc) {
+				int temp= base->object->recalc;
+				object_handle_update(scene, base->object);
+				base->object->recalc= temp;
+			}
+		}
+		
+		for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED)) {
+				if (arm->layer & pchan->bone->layer) {
+					if (pchan->path) {
+						fp= pchan->path+3*(CFRA-sfra);
+						
+						if (arm->pathflag & ARM_PATH_HEADS) { 
+							VECCOPY(fp, pchan->pose_head);
+						}
+						else {
+							VECCOPY(fp, pchan->pose_tail);
+						}
+						
+						Mat4MulVecfl(ob->obmat, fp);
+					}
+				}
+			}
+		}
+	}
+	
+	waitcursor(0);
+	
+	CFRA= cfra;
+}
+
+/* For the object with pose/action: update paths for those that have got them
+ * This should selectively update paths that exist...
+ */
+void pose_recalculate_paths(Scene *scene, Object *ob)
+{
+	bArmature *arm;
+	bPoseChannel *pchan;
+	Base *base;
+	float *fp;
+	int cfra;
+	int sfra, efra;
+	
+	if (ob==NULL || ob->pose==NULL)
+		return;
+	arm= ob->data;
+	
+	/* set frame values */
+	cfra = CFRA;
+	sfra = efra = cfra; 
+	for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if ((pchan->bone) && (arm->layer & pchan->bone->layer)) {
+			if (pchan->path) {
+				/* if the pathsf and pathef aren't initialised, abort! */
+				if (ELEM(0, pchan->pathsf, pchan->pathef))	
+					return;
+				
+				/* try to increase area to do (only as much as needed) */
+				sfra= MIN2(sfra, pchan->pathsf);
+				efra= MAX2(efra, pchan->pathef);
+			}
+		}
+	}
+	if (efra <= sfra) return;
+	
+	waitcursor(1);
+	
+	/* hack: for unsaved files, set OB_RECALC so that paths can get calculated */
+	if ((ob->recalc & OB_RECALC)==0) {
+		ob->recalc |= OB_RECALC;
+		DAG_object_update_flags(scene, ob, screen_view3d_layers());
+	}
+	else
+		DAG_object_update_flags(scene, ob, screen_view3d_layers());
+	
+	for (CFRA=sfra; CFRA<=efra; CFRA++) {
+		/* do all updates */
+		for (base= FIRSTBASE; base; base= base->next) {
+			if (base->object->recalc) {
+				int temp= base->object->recalc;
+				object_handle_update(scene, base->object);
+				base->object->recalc= temp;
+			}
+		}
+		
+		for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if ((pchan->bone) && (arm->layer & pchan->bone->layer)) {
+				if (pchan->path) {
+					/* only update if:
+					 *	- in range of this pchan's existing path
+					 *	- ... insert evil filtering/optimising conditions here...
+					 */
+					if (IN_RANGE(CFRA, pchan->pathsf, pchan->pathef)) {
+						fp= pchan->path+3*(CFRA-sfra);
+						
+						if (arm->pathflag & ARM_PATH_HEADS) { 
+							VECCOPY(fp, pchan->pose_head);
+						}
+						else {
+							VECCOPY(fp, pchan->pose_tail);
+						}
+						
+						Mat4MulVecfl(ob->obmat, fp);
+					}
+				}
+			}
+		}
+	}
+	
+	waitcursor(0);
+	
+	CFRA= cfra;
+	ob->pose->flag &= ~POSE_RECALCPATHS;
+}
+
+/* for the object with pose/action: clear path curves for selected bones only */
+void pose_clear_paths(Object *ob)
+{
+	bPoseChannel *pchan;
+	
+	if (ob==NULL || ob->pose==NULL)
+		return;
+	
+	/* free the path blocks */
+	for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED)) {
+			if (pchan->path) {
+				MEM_freeN(pchan->path);
+				pchan->path= NULL;
+			}
+		}
+	}
+	
+}
+
+
+
+void pose_select_constraint_target(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	bConstraint *con;
+	
+	/* paranoia checks */
+	if (!ob && !ob->pose) return;
+	if (ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if (arm->layer & pchan->bone->layer) {
+			if (pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) {
+				for (con= pchan->constraints.first; con; con= con->next) {
+					bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+					ListBase targets = {NULL, NULL};
+					bConstraintTarget *ct;
+					
+					if (cti && cti->get_constraint_targets) {
+						cti->get_constraint_targets(con, &targets);
+						
+						for (ct= targets.first; ct; ct= ct->next) {
+							if ((ct->tar == ob) && (ct->subtarget[0])) {
+								bPoseChannel *pchanc= get_pose_channel(ob->pose, ct->subtarget);
+								if(pchanc)
+									pchanc->bone->flag |= BONE_SELECTED|BONE_TIPSEL|BONE_ROOTSEL;
+							}
+						}
+						
+						if (cti->flush_constraint_targets)
+							cti->flush_constraint_targets(con, &targets, 1);
+					}
+				}
+			}
+		}
+	}
+	
+	BIF_undo_push("Select constraint target");
+
+}
+
+void pose_select_hierarchy(Scene *scene, short direction, short add_to_sel)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	Bone *curbone, *pabone, *chbone;
+	
+	/* paranoia checks */
+	if (!ob && !ob->pose) return;
+	if (ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		curbone= pchan->bone;
+		
+		if (arm->layer & curbone->layer) {
+			if (curbone->flag & (BONE_ACTIVE)) {
+				if (direction == BONE_SELECT_PARENT) {
+				
+					if (pchan->parent == NULL) continue;
+					else pabone= pchan->parent->bone;
+					
+					if ((arm->layer & pabone->layer) && !(pabone->flag & BONE_HIDDEN_P)) {
+						
+						if (!add_to_sel) curbone->flag &= ~BONE_SELECTED;
+						curbone->flag &= ~BONE_ACTIVE;
+						pabone->flag |= (BONE_ACTIVE|BONE_SELECTED);
+						
+						select_actionchannel_by_name (ob->action, pchan->name, 0);
+						select_actionchannel_by_name (ob->action, pchan->parent->name, 1);
+						break;
+					}
+				} else { // BONE_SELECT_CHILD
+				
+					if (pchan->child == NULL) continue;
+					else chbone = pchan->child->bone;
+					
+					if ((arm->layer & chbone->layer) && !(chbone->flag & BONE_HIDDEN_P)) {
+					
+						if (!add_to_sel) curbone->flag &= ~BONE_SELECTED;
+						curbone->flag &= ~BONE_ACTIVE;
+						chbone->flag |= (BONE_ACTIVE|BONE_SELECTED);
+						
+						select_actionchannel_by_name (ob->action, pchan->name, 0);
+						select_actionchannel_by_name (ob->action, pchan->child->name, 1);
+						break;
+					}
+				}
+			}
+		}
+	}
+	
+	if (direction==BONE_SELECT_PARENT)
+		BIF_undo_push("Select pose bone parent");
+	if (direction==BONE_SELECT_CHILD)
+		BIF_undo_push("Select pose bone child");
+}
+
+
+void pose_add_IK(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	
+	/* paranoia checks */
+	if(!ob && !ob->pose) return;
+	if(ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	add_constraint(1);	/* 1 means only IK */
+}
+
+/* context: all selected channels */
+void pose_clear_IK(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	bConstraint *con;
+	bConstraint *next;
+	
+	/* paranoia checks */
+	if(!ob && !ob->pose) return;
+	if(ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	if(pose_has_protected_selected(ob, 0, 1))
+		return;
+	
+	if(okee("Remove IK constraint(s)")==0) return;
+
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if(arm->layer & pchan->bone->layer) {
+			if(pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) {
+				
+				for(con= pchan->constraints.first; con; con= next) {
+					next= con->next;
+					if(con->type==CONSTRAINT_TYPE_KINEMATIC) {
+						BLI_remlink(&pchan->constraints, con);
+						free_constraint_data(con);
+						MEM_freeN(con);
+					}
+				}
+				pchan->constflag &= ~(PCHAN_HAS_IK|PCHAN_HAS_TARGET);
+			}
+		}
+	}
+	
+	DAG_object_flush_update(scene, ob, OB_RECALC_DATA);	// and all its relations
+	
+	BIF_undo_push("Remove IK constraint(s)");
+}
+
+void pose_clear_constraints(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	
+	/* paranoia checks */
+	if(!ob && !ob->pose) return;
+	if(ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	if(pose_has_protected_selected(ob, 0, 1))
+		return;
+	
+	if(okee("Remove Constraints")==0) return;
+	
+	/* find active */
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if(arm->layer & pchan->bone->layer) {
+			if(pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) {
+				free_constraints(&pchan->constraints);
+				pchan->constflag= 0;
+			}
+		}
+	}
+	
+	DAG_object_flush_update(scene, ob, OB_RECALC_DATA);	// and all its relations
+	
+	BIF_undo_push("Remove Constraint(s)");
+	
+}
+
+
+void pose_copy_menu(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan, *pchanact;
+	short nr=0;
+	int i=0;
+	
+	/* paranoia checks */
+	if (ELEM(NULL, ob, ob->pose)) return;
+	if ((ob==obedit) || (ob->flag & OB_POSEMODE)==0) return;
+	
+	/* find active */
+	for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if (pchan->bone->flag & BONE_ACTIVE) 
+			break;
+	}
+	
+	if (pchan==NULL) return;
+	pchanact= pchan;
+	
+	/* if proxy-protected bones selected, some things (such as locks + displays) shouldn't be changable, 
+	 * but for constraints (just add local constraints)
+	 */
+	if (pose_has_protected_selected(ob, 1, 0)) {
+		i= BLI_countlist(&(pchanact->constraints)); /* if there are 24 or less, allow for the user to select constraints */
+		if (i < 25)
+			nr= pupmenu("Copy Pose Attributes %t|Local Location%x1|Local Rotation%x2|Local Size%x3|%l|Visual Location %x9|Visual Rotation%x10|Visual Size%x11|%l|Constraints (All)%x4|Constraints...%x5");
+		else
+			nr= pupmenu("Copy Pose Attributes %t|Local Location%x1|Local Rotation%x2|Local Size%x3|%l|Visual Location %x9|Visual Rotation%x10|Visual Size%x11|%l|Constraints (All)%x4");
+	}
+	else {
+		i= BLI_countlist(&(pchanact->constraints)); /* if there are 24 or less, allow for the user to select constraints */
+		if (i < 25)
+			nr= pupmenu("Copy Pose Attributes %t|Local Location%x1|Local Rotation%x2|Local Size%x3|%l|Visual Location %x9|Visual Rotation%x10|Visual Size%x11|%l|Constraints (All)%x4|Constraints...%x5|%l|Transform Locks%x6|IK Limits%x7|Bone Shape%x8");
+		else
+			nr= pupmenu("Copy Pose Attributes %t|Local Location%x1|Local Rotation%x2|Local Size%x3|%l|Visual Location %x9|Visual Rotation%x10|Visual Size%x11|%l|Constraints (All)%x4|%l|Transform Locks%x6|IK Limits%x7|Bone Shape%x8");
+	}
+	
+	if (nr <= 0) 
+		return;
+	
+	if (nr != 5)  {
+		for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if ( (arm->layer & pchan->bone->layer) &&
+				 (pchan->bone->flag & BONE_SELECTED) &&
+				 (pchan != pchanact) ) 
+			{
+				switch (nr) {
+					case 1: /* Local Location */
+						VECCOPY(pchan->loc, pchanact->loc);
+						break;
+					case 2: /* Local Rotation */
+						QUATCOPY(pchan->quat, pchanact->quat);
+						break;
+					case 3: /* Local Size */
+						VECCOPY(pchan->size, pchanact->size);
+						break;
+					case 4: /* All Constraints */
+					{
+						ListBase tmp_constraints = {NULL, NULL};
+						
+						/* copy constraints to tmpbase and apply 'local' tags before 
+						 * appending to list of constraints for this channel
+						 */
+						copy_constraints(&tmp_constraints, &pchanact->constraints);
+						if ((ob->proxy) && (pchan->bone->layer & arm->layer_protected)) {
+							bConstraint *con;
+							
+							/* add proxy-local tags */
+							for (con= tmp_constraints.first; con; con= con->next)
+								con->flag |= CONSTRAINT_PROXY_LOCAL;
+						}
+						addlisttolist(&pchan->constraints, &tmp_constraints);
+						
+						/* update flags (need to add here, not just copy) */
+						pchan->constflag |= pchanact->constflag;
+						
+						if (ob->pose)
+							ob->pose->flag |= POSE_RECALC;
+					}
+						break;
+					case 6: /* Transform Locks */
+						pchan->protectflag = pchanact->protectflag;
+						break;
+					case 7: /* IK (DOF) settings */
+					{
+						pchan->ikflag = pchanact->ikflag;
+						VECCOPY(pchan->limitmin, pchanact->limitmin);
+						VECCOPY(pchan->limitmax, pchanact->limitmax);
+						VECCOPY(pchan->stiffness, pchanact->stiffness);
+						pchan->ikstretch= pchanact->ikstretch;
+					}
+						break;
+					case 8: /* Custom Bone Shape */
+						pchan->custom = pchanact->custom;
+						break;
+					case 9: /* Visual Location */
+						armature_loc_pose_to_bone(pchan, pchanact->pose_mat[3], pchan->loc);
+						break;
+					case 10: /* Visual Rotation */
+					{
+						float delta_mat[4][4], quat[4];
+						
+						armature_mat_pose_to_bone(pchan, pchanact->pose_mat, delta_mat);
+						Mat4ToQuat(delta_mat, quat);
+						QUATCOPY(pchan->quat, quat);
+					}
+						break;
+					case 11: /* Visual Size */
+					{
+						float delta_mat[4][4], size[4];
+						
+						armature_mat_pose_to_bone(pchan, pchanact->pose_mat, delta_mat);
+						Mat4ToSize(delta_mat, size);
+						VECCOPY(pchan->size, size);
+					}
+				}
+			}
+		}
+	} 
+	else { /* constraints, optional (note: max we can have is 24 constraints) */
+		bConstraint *con, *con_back;
+		int const_toggle[24];
+		ListBase const_copy = {NULL, NULL};
+		
+		BLI_duplicatelist(&const_copy, &(pchanact->constraints));
+		
+		/* build the puplist of constraints */
+		for (con = pchanact->constraints.first, i=0; con; con=con->next, i++){
+			const_toggle[i]= 1;
+//			add_numbut(i, TOG|INT, con->name, 0, 0, &(const_toggle[i]), "");
+		}
+		
+//		if (!do_clever_numbuts("Select Constraints", i, REDRAW)) {
+//			BLI_freelistN(&const_copy);
+//			return;
+//		}
+		
+		/* now build a new listbase from the options selected */
+		for (i=0, con=const_copy.first; con; i++) {
+			/* if not selected, free/remove it from the list */
+			if (!const_toggle[i]) {
+				con_back= con->next;
+				BLI_freelinkN(&const_copy, con);
+				con= con_back;
+			} 
+			else
+				con= con->next;
+		}
+		
+		/* Copy the temo listbase to the selected posebones */
+		for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if ( (arm->layer & pchan->bone->layer) &&
+				 (pchan->bone->flag & BONE_SELECTED) &&
+				 (pchan!=pchanact) ) 
+			{
+				ListBase tmp_constraints = {NULL, NULL};
+				
+				/* copy constraints to tmpbase and apply 'local' tags before 
+				 * appending to list of constraints for this channel
+				 */
+				copy_constraints(&tmp_constraints, &const_copy);
+				if ((ob->proxy) && (pchan->bone->layer & arm->layer_protected)) {
+					bConstraint *con;
+					
+					/* add proxy-local tags */
+					for (con= tmp_constraints.first; con; con= con->next)
+						con->flag |= CONSTRAINT_PROXY_LOCAL;
+				}
+				addlisttolist(&pchan->constraints, &tmp_constraints);
+				
+				/* update flags (need to add here, not just copy) */
+				pchan->constflag |= pchanact->constflag;
+			}
+		}
+		BLI_freelistN(&const_copy);
+		update_pose_constraint_flags(ob->pose); /* we could work out the flags but its simpler to do this */
+		
+		if (ob->pose)
+			ob->pose->flag |= POSE_RECALC;
+	}
+	
+	DAG_object_flush_update(scene, ob, OB_RECALC_DATA);	// and all its relations
+	
+	BIF_undo_push("Copy Pose Attributes");
+	
+}
+
+/* ******************** copy/paste pose ********************** */
+
+static bPose	*g_posebuf=NULL;
+
+void free_posebuf(void) 
+{
+	if (g_posebuf) {
+		// was copied without constraints
+		BLI_freelistN (&g_posebuf->chanbase);
+		MEM_freeN (g_posebuf);
+	}
+	g_posebuf=NULL;
+}
+
+void copy_posebuf (Scene *scene)
+{
+	Object *ob= OBACT;
+
+	if (!ob || !ob->pose){
+		error ("No Pose");
+		return;
+	}
+
+	free_posebuf();
+	
+	set_pose_keys(ob);  // sets chan->flag to POSE_KEY if bone selected
+	copy_pose(&g_posebuf, ob->pose, 0);
+
+}
+
+void paste_posebuf (Scene *scene, int flip)
+{
+	Object *ob= OBACT;
+	bPoseChannel *chan, *pchan;
+	float eul[4];
+	char name[32];
+	
+	if (!ob || !ob->pose)
+		return;
+
+	if (!g_posebuf){
+		error ("Copy buffer is empty");
+		return;
+	}
+	
+	/*
+	// disabled until protected bones in proxies follow the rules everywhere else!
+	if(pose_has_protected_selected(ob, 1, 1))
+		return;
+	*/
+	
+	/* Safely merge all of the channels in this pose into
+	any existing pose */
+	for (chan=g_posebuf->chanbase.first; chan; chan=chan->next) {
+		if (chan->flag & POSE_KEY) {
+			BLI_strncpy(name, chan->name, sizeof(name));
+			if (flip)
+				bone_flip_name (name, 0);		// 0 = don't strip off number extensions
+				
+			/* only copy when channel exists, poses are not meant to add random channels to anymore */
+			pchan= get_pose_channel(ob->pose, name);
+			
+			if (pchan) {
+				/* only loc rot size */
+				/* only copies transform info for the pose */
+				VECCOPY(pchan->loc, chan->loc);
+				VECCOPY(pchan->size, chan->size);
+				QUATCOPY(pchan->quat, chan->quat);
+				pchan->flag= chan->flag;
+				
+				if (flip) {
+					pchan->loc[0]*= -1;
+					
+					QuatToEul(pchan->quat, eul);
+					eul[1]*= -1;
+					eul[2]*= -1;
+					EulToQuat(eul, pchan->quat);
+				}
+				
+				if (autokeyframe_cfra_can_key(ob)) {
+					ID *id= &ob->id;
+					
+					/* Set keys on pose */
+					if (chan->flag & POSE_ROT) {
+						insertkey(id, ID_PO, pchan->name, NULL, AC_QUAT_X, 0);
+						insertkey(id, ID_PO, pchan->name, NULL, AC_QUAT_Y, 0);
+						insertkey(id, ID_PO, pchan->name, NULL, AC_QUAT_Z, 0);
+						insertkey(id, ID_PO, pchan->name, NULL, AC_QUAT_W, 0);
+					}
+					if (chan->flag & POSE_SIZE) {
+						insertkey(id, ID_PO, pchan->name, NULL, AC_SIZE_X, 0);
+						insertkey(id, ID_PO, pchan->name, NULL, AC_SIZE_Y, 0);
+						insertkey(id, ID_PO, pchan->name, NULL, AC_SIZE_Z, 0);
+					}
+					if (chan->flag & POSE_LOC) {
+						insertkey(id, ID_PO, pchan->name, NULL, AC_LOC_X, 0);
+						insertkey(id, ID_PO, pchan->name, NULL, AC_LOC_Y, 0);
+						insertkey(id, ID_PO, pchan->name, NULL, AC_LOC_Z, 0);
+					}
+					
+					/* clear any unkeyed tags */
+					if (chan->bone)
+						chan->bone->flag &= ~BONE_UNKEYED;
+				}
+				else {
+					/* add unkeyed tags */
+					if (chan->bone)
+						chan->bone->flag |= BONE_UNKEYED;
+				}
+			}
+		}
+	}
+
+	/* Update event for pose and deformation children */
+	DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
+	
+	if (IS_AUTOKEY_ON) {
+// XXX		remake_action_ipos(ob->action);
+	}
+	else {
+		/* need to trick depgraph, action is not allowed to execute on pose */
+		where_is_pose(scene, ob);
+		ob->recalc= 0;
+	}
+
+	BIF_undo_push("Paste Action Pose");
+}
+
+/* ********************************************** */
+
+/* context weightpaint and deformer in posemode */
+void pose_adds_vgroups(Scene *scene, Object *meshobj, int heatweights)
+{
+// XXX	extern VPaint Gwp;         /* from vpaint */
+	Object *poseobj= modifiers_isDeformedByArmature(meshobj);
+
+	if(poseobj==NULL || (poseobj->flag & OB_POSEMODE)==0) {
+		error("The active object must have a deforming armature in pose mode");
+		return;
+	}
+
+// XXX	add_verts_to_dgroups(meshobj, poseobj, heatweights, (Gwp.flag & VP_MIRROR_X));
+
+	if(heatweights)
+		BIF_undo_push("Apply Bone Heat Weights to Vertex Groups");
+	else
+		BIF_undo_push("Apply Bone Envelopes to Vertex Groups");
+
+	
+	// and all its relations
+	DAG_object_flush_update(scene, meshobj, OB_RECALC_DATA);
+}
+
+/* ********************************************** */
+
+/* adds a new pose-group */
+void pose_add_posegroup (Scene *scene)
+{
+	Object *ob= OBACT;
+	bPose *pose= (ob) ? ob->pose : NULL;
+	bActionGroup *grp;
+	
+	if (ELEM(NULL, ob, ob->pose))
+		return;
+	
+	grp= MEM_callocN(sizeof(bActionGroup), "PoseGroup");
+	strcpy(grp->name, "Group");
+	BLI_addtail(&pose->agroups, grp);
+	BLI_uniquename(&pose->agroups, grp, "Group", offsetof(bActionGroup, name), 32);
+	
+	pose->active_group= BLI_countlist(&pose->agroups);
+	
+	BIF_undo_push("Add Bone Group");
+	
+}
+
+/* Remove the active bone-group */
+void pose_remove_posegroup (Scene *scene)
+{
+	Object *ob= OBACT;
+	bPose *pose= (ob) ? ob->pose : NULL;
+	bActionGroup *grp = NULL;
+	bPoseChannel *pchan;
+	
+	/* sanity checks */
+	if (ELEM(NULL, ob, pose))
+		return;
+	if (pose->active_group <= 0)
+		return;
+	
+	/* get group to remove */
+	grp= BLI_findlink(&pose->agroups, pose->active_group-1);
+	if (grp) {
+		/* adjust group references (the trouble of using indices!):
+		 *	- firstly, make sure nothing references it 
+		 *	- also, make sure that those after this item get corrected
+		 */
+		for (pchan= pose->chanbase.first; pchan; pchan= pchan->next) {
+			if (pchan->agrp_index == pose->active_group)
+				pchan->agrp_index= 0;
+			else if (pchan->agrp_index > pose->active_group)
+				pchan->agrp_index--;
+		}
+		
+		/* now, remove it from the pose */
+		BLI_freelinkN(&pose->agroups, grp);
+		pose->active_group= 0;
+		
+		BIF_undo_push("Remove Bone Group");
+	}
+	
+}
+
+char *build_posegroups_menustr (bPose *pose, short for_pupmenu)
+{
+	DynStr *pupds= BLI_dynstr_new();
+	bActionGroup *grp;
+	char *str;
+	char buf[16];
+	int i;
+	
+	/* add title first (and the "none" entry) */
+	BLI_dynstr_append(pupds, "Bone Group%t|");
+	if (for_pupmenu)
+		BLI_dynstr_append(pupds, "Add New%x0|");
+	else
+		BLI_dynstr_append(pupds, "BG: [None]%x0|");
+	
+	/* loop through groups, adding them */
+	for (grp= pose->agroups.first, i=1; grp; grp=grp->next, i++) {
+		if (for_pupmenu == 0)
+			BLI_dynstr_append(pupds, "BG: ");
+		BLI_dynstr_append(pupds, grp->name);
+		
+		sprintf(buf, "%%x%d", i);
+		BLI_dynstr_append(pupds, buf);
+		
+		if (grp->next)
+			BLI_dynstr_append(pupds, "|");
+	}
+	
+	/* convert to normal MEM_malloc'd string */
+	str= BLI_dynstr_get_cstring(pupds);
+	BLI_dynstr_free(pupds);
+	
+	return str;
+}
+
+/* Assign selected pchans to the bone group that the user selects */
+void pose_assign_to_posegroup (Scene *scene, short active)
+{
+	Object *ob= OBACT;
+	bArmature *arm= (ob) ? ob->data : NULL;
+	bPose *pose= (ob) ? ob->pose : NULL;
+	bPoseChannel *pchan;
+	char *menustr;
+	int nr;
+	short done= 0;
+	
+	/* sanity checks */
+	if (ELEM3(NULL, ob, pose, arm))
+		return;
+
+	/* get group to affect */
+	if ((active==0) || (pose->active_group <= 0)) {
+		menustr= build_posegroups_menustr(pose, 1);
+		nr= 0; // XXX pupmenu_col(menustr, 20);
+		MEM_freeN(menustr);
+		
+		if (nr < 0) 
+			return;
+		else if (nr == 0) {
+			/* add new - note: this does an undo push and sets active group */
+			pose_add_posegroup(scene);
+		}
+		else
+			pose->active_group= nr;
+	}
+	
+	/* add selected bones to group then */
+	for (pchan= pose->chanbase.first; pchan; pchan= pchan->next) {
+		if ((pchan->bone->flag & BONE_SELECTED) && (pchan->bone->layer & arm->layer)) {
+			pchan->agrp_index= pose->active_group;
+			done= 1;
+		}
+	}
+	
+	if (done)
+		BIF_undo_push("Add Bones To Group");
+		
+}
+
+/* Remove selected pchans from their bone groups */
+void pose_remove_from_posegroups (Scene *scene)
+{
+	Object *ob= OBACT;
+	bArmature *arm= (ob) ? ob->data : NULL;
+	bPose *pose= (ob) ? ob->pose : NULL;
+	bPoseChannel *pchan;
+	short done= 0;
+	
+	/* sanity checks */
+	if (ELEM3(NULL, ob, pose, arm))
+		return;
+	
+	/* remove selected bones from their groups */
+	for (pchan= pose->chanbase.first; pchan; pchan= pchan->next) {
+		if ((pchan->bone->flag & BONE_SELECTED) && (pchan->bone->layer & arm->layer)) {
+			if (pchan->agrp_index) {
+				pchan->agrp_index= 0;
+				done= 1;
+			}
+		}
+	}
+	
+	if (done)
+		BIF_undo_push("Remove Bones From Groups");
+		
+}
+
+/* Ctrl-G in 3D-View while in PoseMode */
+void pgroup_operation_with_menu (Scene *scene)
+{
+	Object *ob= OBACT;
+	bArmature *arm= (ob) ? ob->data : NULL;
+	bPose *pose= (ob) ? ob->pose : NULL;
+	bPoseChannel *pchan= NULL;
+	int mode;
+	
+	/* sanity checks */
+	if (ELEM3(NULL, ob, pose, arm))
+		return;
+	
+	/* check that something is selected */
+	for (pchan= pose->chanbase.first; pchan; pchan= pchan->next) {
+		if ((pchan->bone->flag & BONE_SELECTED) && (pchan->bone->layer & arm->layer)) 
+			break;
+	}
+	if (pchan == NULL)
+		return;
+	
+	/* get mode of action */
+	if (pchan)
+		mode= pupmenu("Bone Groups%t|Add Selected to Active Group%x1|Add Selected to Group%x2|%|Remove Selected From Groups%x3|Remove Active Group%x4");
+	else
+		mode= pupmenu("Bone Groups%t|Add New Group%x5|Remove Active Group%x4");
+		
+	/* handle mode */
+	switch (mode) {
+		case 1:
+			pose_assign_to_posegroup(scene, 1);
+			break;
+		case 2:
+			pose_assign_to_posegroup(scene, 0);
+			break;
+		case 5:
+			pose_add_posegroup(scene);
+			break;
+		case 3:
+			pose_remove_from_posegroups(scene);
+			break;
+		case 4:
+			pose_remove_posegroup(scene);
+			break;
+	}
+}
+
+/* ********************************************** */
+
+static short pose_select_same_group (Object *ob)
+{
+	bPose *pose= (ob)? ob->pose : NULL;
+	bArmature *arm= (ob)? ob->data : NULL;
+	bPoseChannel *pchan, *chan;
+	short changed= 0;
+	
+	if (ELEM3(NULL, ob, pose, arm))
+		return 0;
+	
+	/* loop in loop... bad and slow! */
+	for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if (arm->layer & pchan->bone->layer) {
+			if (pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) {
+				
+				/* only if group matches (and is not selected or current bone) */
+				for (chan= ob->pose->chanbase.first; chan; chan= chan->next) {
+					if (arm->layer & chan->bone->layer) {
+						if (pchan->agrp_index == chan->agrp_index) {
+							chan->bone->flag |= BONE_SELECTED;
+							changed= 1;
+						}
+					}
+				}
+				
+			}
+		}
+	}
+	
+	return changed;
+}
+
+static short pose_select_same_layer (Object *ob)
+{
+	bPose *pose= (ob)? ob->pose : NULL;
+	bArmature *arm= (ob)? ob->data : NULL;
+	bPoseChannel *pchan;
+	short layers= 0, changed= 0;
+	
+	if (ELEM3(NULL, ob, pose, arm))
+		return 0;
+	
+	/* figure out what bones are selected */
+	for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if (arm->layer & pchan->bone->layer) {
+			if (pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) {
+				layers |= pchan->bone->layer;
+			}
+		}
+	}
+	if (layers == 0) 
+		return 0;
+		
+	/* select bones that are on same layers as layers flag */
+	for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if (arm->layer & pchan->bone->layer) {
+			if (layers & pchan->bone->layer) {
+				pchan->bone->flag |= BONE_SELECTED;
+				changed= 1;
+			}
+		}
+	}
+	
+	return changed;
+}
+
+
+void pose_select_grouped (Scene *scene, short nr)
+{
+	short changed = 0;
+	
+	if (nr == 1) 		changed= pose_select_same_group(OBACT);
+	else if (nr == 2)	changed= pose_select_same_layer(OBACT);
+	
+	if (changed) {
+		countall();
+		BIF_undo_push("Select Grouped");
+	}
+}
+
+/* Shift-G in 3D-View while in PoseMode */
+void pose_select_grouped_menu (Scene *scene)
+{
+	short nr;
+	
+	/* here we go */
+	nr= pupmenu("Select Grouped%t|In Same Group%x1|In Same Layer%x2");
+	pose_select_grouped(scene, nr);
+}
+
+/* ********************************************** */
+
+/* context active object */
+void pose_flip_names(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	char newname[32];
+	
+	/* paranoia checks */
+	if(!ob && !ob->pose) return;
+	if(ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	if(pose_has_protected_selected(ob, 0, 1))
+		return;
+	
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if(arm->layer & pchan->bone->layer) {
+			if(pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) {
+				BLI_strncpy(newname, pchan->name, sizeof(newname));
+				bone_flip_name(newname, 1);	// 1 = do strip off number extensions
+				armature_bone_rename(ob, pchan->name, newname);
+			}
+		}
+	}
+	
+	BIF_undo_push("Flip names");
+}
+
+/* context active object */
+void pose_autoside_names(Scene *scene, short axis)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	char newname[32];
+	
+	/* paranoia checks */
+	if (ELEM(NULL, ob, ob->pose)) return;
+	if (ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	if (pose_has_protected_selected(ob, 0, 1))
+		return;
+	
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if(arm->layer & pchan->bone->layer) {
+			if(pchan->bone->flag & (BONE_ACTIVE|BONE_SELECTED)) {
+				BLI_strncpy(newname, pchan->name, sizeof(newname));
+				bone_autoside_name(newname, 1, axis, pchan->bone->head[axis], pchan->bone->tail[axis]);
+				armature_bone_rename(ob, pchan->name, newname);
+			}
+		}
+	}
+	
+	BIF_undo_push("Flip names");
+}
+
+/* context active object, or weightpainted object with armature in posemode */
+void pose_activate_flipped_bone(Scene *scene)
+{
+	Object *ob= OBACT;
+	bArmature *arm= ob->data;
+	
+	if(ob==NULL) return;
+
+	if(G.f & G_WEIGHTPAINT) {
+		ob= modifiers_isDeformedByArmature(ob);
+	}
+	if(ob && (ob->flag & OB_POSEMODE)) {
+		bPoseChannel *pchan, *pchanf;
+		
+		for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if(arm->layer & pchan->bone->layer) {
+				if(pchan->bone->flag & BONE_ACTIVE)
+					break;
+			}
+		}
+		if(pchan) {
+			char name[32];
+			
+			BLI_strncpy(name, pchan->name, 32);
+			bone_flip_name(name, 1);	// 0 = do not strip off number extensions
+			
+			pchanf= get_pose_channel(ob->pose, name);
+			if(pchanf && pchanf!=pchan) {
+				pchan->bone->flag &= ~(BONE_SELECTED|BONE_ACTIVE);
+				pchanf->bone->flag |= (BONE_SELECTED|BONE_ACTIVE);
+			
+				/* in weightpaint we select the associated vertex group too */
+				if(G.f & G_WEIGHTPAINT) {
+					vertexgroup_select_by_name(OBACT, name);
+					DAG_object_flush_update(scene, OBACT, OB_RECALC_DATA);
+				}
+				
+				select_actionchannel_by_name(ob->action, name, 1);
+				
+			}			
+		}
+	}
+}
+
+/* This function pops up the move-to-layer popup widgets when the user
+ * presses either SHIFT-MKEY or MKEY in PoseMode OR EditMode (for Armatures)
+ */
+void pose_movetolayer(Scene *scene)
+{
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	bArmature *arm;
+	short lay= 0;
+	short shift= 0; // XXX
+	
+	if (ob==NULL) return;
+	arm= ob->data;
+	
+	if (shift) {
+		/* armature layers */
+		lay= arm->layer;
+		if ( movetolayer_short_buts(&lay, "Armature Layers")==0 ) return;
+		if (lay==0) return;
+		arm->layer= lay;
+		if(ob->pose)
+			ob->pose->proxy_layer= lay;
+		
+	}
+	else if (obedit) {
+		/* the check for editbone layer moving needs to occur before posemode one to work */
+		EditBone *ebo;
+		EditBone *flipBone;
+		
+		for (ebo= arm->edbo->first; ebo; ebo= ebo->next) {
+			if (arm->layer & ebo->layer) {
+				if (ebo->flag & BONE_SELECTED)
+					lay |= ebo->layer;
+			}
+		}
+		if (lay==0) return;
+		
+		if ( movetolayer_short_buts(&lay, "Bone Layers")==0 ) return;
+		if (lay==0) return;
+		
+		for (ebo= arm->edbo->first; ebo; ebo= ebo->next) {
+			if (arm->layer & ebo->layer) {
+				if (ebo->flag & BONE_SELECTED) {
+					ebo->layer= lay;
+					if (arm->flag & ARM_MIRROR_EDIT) {
+						flipBone = armature_bone_get_mirrored(arm->edbo, ebo);
+						if (flipBone)
+							flipBone->layer = lay;
+					}
+				}
+			}
+		}
+		
+		BIF_undo_push("Move Bone Layer");
+	}
+	else if (ob->flag & OB_POSEMODE) {
+		/* pose-channel layers */
+		bPoseChannel *pchan;
+		
+		if (pose_has_protected_selected(ob, 0, 1))
+			return;
+		
+		for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if (arm->layer & pchan->bone->layer) {
+				if (pchan->bone->flag & BONE_SELECTED)
+					lay |= pchan->bone->layer;
+			}
+		}
+		if (lay==0) return;
+		
+		if ( movetolayer_short_buts(&lay, "Bone Layers")==0 ) return;
+		if (lay==0) return;
+		
+		for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+			if (arm->layer & pchan->bone->layer) {
+				if (pchan->bone->flag & BONE_SELECTED)
+					pchan->bone->layer= lay;
+			}
+		}
+		
+		BIF_undo_push("Move Bone Layer");
+	}
+}
+
+
+/* for use with pose_relax only */
+static int pose_relax_icu(struct IpoCurve *icu, float framef, float *val, float *frame_prev, float *frame_next)
+{
+	if (!icu) {
+		return 0;
+	} 
+	else {
+		BezTriple *bezt = icu->bezt;
+		
+		BezTriple *bezt_prev=NULL, *bezt_next=NULL;
+		float w1, w2, wtot;
+		int i;
+		
+		for (i=0; i < icu->totvert; i++, bezt++) {
+			if (bezt->vec[1][0] < framef - 0.5) {
+				bezt_prev = bezt;
+			} else {
+				break;
+			}
+		}
+		
+		if (bezt_prev==NULL) return 0;
+		
+		/* advance to the next, dont need to advance i */
+		bezt = bezt_prev+1;
+		
+		for (; i < icu->totvert; i++, bezt++) {
+			if (bezt->vec[1][0] > framef + 0.5) {
+				bezt_next = bezt;
+						break;
+			}
+		}
+		
+		if (bezt_next==NULL) return 0;
+	
+		if (val) {
+			w1 = framef - bezt_prev->vec[1][0];
+			w2 = bezt_next->vec[1][0] - framef;
+			wtot = w1 + w2;
+			w1=w1/wtot;
+			w2=w2/wtot;
+#if 0
+			val = (bezt_prev->vec[1][1] * w2) + (bezt_next->vec[1][1] * w1);
+#else
+			/* apply the value with a hard coded 6th */
+			*val = (((bezt_prev->vec[1][1] * w2) + (bezt_next->vec[1][1] * w1)) + (*val * 5.0f)) / 6.0f;
+#endif
+		}
+		
+		if (frame_prev)	*frame_prev = bezt_prev->vec[1][0];
+		if (frame_next)	*frame_next = bezt_next->vec[1][0];
+		
+		return 1;
+	}
+}
+
+void pose_relax(Scene *scene)
+{
+	Object *ob = OBACT;
+	bPose *pose;
+	bAction *act;
+	bArmature *arm;
+	
+	IpoCurve *icu_w, *icu_x, *icu_y, *icu_z;
+	
+	bPoseChannel *pchan;
+	bActionChannel *achan;
+	float framef = F_CFRA;
+	float frame_prev, frame_next;
+	float quat_prev[4], quat_next[4], quat_interp[4], quat_orig[4];
+	
+	int do_scale = 0;
+	int do_loc = 0;
+	int do_quat = 0;
+	int flag = 0;
+	int do_x, do_y, do_z;
+	
+	if (!ob) return;
+	
+	pose = ob->pose;
+	act = ob->action;
+	arm = (bArmature *)ob->data;
+	
+	if (!pose || !act || !arm) return;
+	
+	for (pchan=pose->chanbase.first; pchan; pchan= pchan->next) {
+		
+		pchan->bone->flag &= ~BONE_TRANSFORM;
+		
+		if (pchan->bone->layer & arm->layer) {
+			if (pchan->bone->flag & BONE_SELECTED) {
+				/* do we have an ipo curve? */
+				achan= get_action_channel(act, pchan->name);
+				
+				if (achan && achan->ipo) {
+					/*calc_ipo(achan->ipo, ctime);*/
+					
+					do_x = pose_relax_icu(find_ipocurve(achan->ipo, AC_LOC_X), framef, &pchan->loc[0], NULL, NULL);
+					do_y = pose_relax_icu(find_ipocurve(achan->ipo, AC_LOC_Y), framef, &pchan->loc[1], NULL, NULL);
+					do_z = pose_relax_icu(find_ipocurve(achan->ipo, AC_LOC_Z), framef, &pchan->loc[2], NULL, NULL);
+					do_loc += do_x + do_y + do_z;
+					
+					do_x = pose_relax_icu(find_ipocurve(achan->ipo, AC_SIZE_X), framef, &pchan->size[0], NULL, NULL);
+					do_y = pose_relax_icu(find_ipocurve(achan->ipo, AC_SIZE_Y), framef, &pchan->size[1], NULL, NULL);
+					do_z = pose_relax_icu(find_ipocurve(achan->ipo, AC_SIZE_Z), framef, &pchan->size[2], NULL, NULL);
+					do_scale += do_x + do_y + do_z;
+						
+					if(	((icu_w = find_ipocurve(achan->ipo, AC_QUAT_W))) &&
+						((icu_x = find_ipocurve(achan->ipo, AC_QUAT_X))) &&
+						((icu_y = find_ipocurve(achan->ipo, AC_QUAT_Y))) &&
+						((icu_z = find_ipocurve(achan->ipo, AC_QUAT_Z))) )
+					{
+						/* use the quatw keyframe as a basis for others */
+						if (pose_relax_icu(icu_w, framef, NULL, &frame_prev, &frame_next)) {
+							/* get 2 quats */
+							quat_prev[0] = eval_icu(icu_w, frame_prev);
+							quat_prev[1] = eval_icu(icu_x, frame_prev);
+							quat_prev[2] = eval_icu(icu_y, frame_prev);
+							quat_prev[3] = eval_icu(icu_z, frame_prev);
+							
+							quat_next[0] = eval_icu(icu_w, frame_next);
+							quat_next[1] = eval_icu(icu_x, frame_next);
+							quat_next[2] = eval_icu(icu_y, frame_next);
+							quat_next[3] = eval_icu(icu_z, frame_next);
+							
+#if 0
+							/* apply the setting, completely smooth */
+							QuatInterpol(pchan->quat, quat_prev, quat_next, (framef-frame_prev) / (frame_next-frame_prev) );
+#else
+							/* tricky interpolation */
+							QuatInterpol(quat_interp, quat_prev, quat_next, (framef-frame_prev) / (frame_next-frame_prev) );
+							QUATCOPY(quat_orig, pchan->quat);
+							QuatInterpol(pchan->quat, quat_orig, quat_interp, 1.0f/6.0f);
+							/* done */
+#endif
+							do_quat++;
+						}
+					}
+					
+					/* apply BONE_TRANSFORM tag so that autokeying will pick it up */
+					pchan->bone->flag |= BONE_TRANSFORM;
+				}
+			}
+		}
+	}
+	
+	ob->pose->flag |= (POSE_LOCKED|POSE_DO_UNLOCK);
+	
+	/* do auto-keying */
+	if (do_loc)		flag |= TFM_TRANSLATION;
+	if (do_scale)	flag |= TFM_RESIZE;
+	if (do_quat)	flag |= TFM_ROTATION;
+	autokeyframe_pose_cb_func(ob, flag, 0);
+	 
+	/* clear BONE_TRANSFORM flags */
+	for (pchan=pose->chanbase.first; pchan; pchan= pchan->next)
+		pchan->bone->flag &= ~ BONE_TRANSFORM;
+	
+	/* do depsgraph flush */
+	DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
+	BIF_undo_push("Relax Pose");
+}
+
+/* for use in insertkey, ensure rotation goes other way around */
+void pose_flipquats(Scene *scene)
+{
+	Object *ob = OBACT;
+	bArmature *arm= ob->data;
+	bPoseChannel *pchan;
+	
+	if(ob->pose==NULL)
+		return;
+	
+	/* find sel bones */
+	for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
+		if(pchan->bone && (pchan->bone->flag & BONE_SELECTED) && (pchan->bone->layer & arm->layer)) {
+			/* quaternions have 720 degree range */
+			pchan->quat[0]= -pchan->quat[0];
+			pchan->quat[1]= -pchan->quat[1];
+			pchan->quat[2]= -pchan->quat[2];
+			pchan->quat[3]= -pchan->quat[3];
+		}
+	}
+	
+	/* do autokey */
+	autokeyframe_pose_cb_func(ob, TFM_ROTATION, 0);
+}
+
+/* context: active channel */
+void pose_special_editmenu(Scene *scene)
+{
+#if 0
+	Object *obedit= scene->obedit; // XXX context
+	Object *ob= OBACT;
+	short nr;
+	
+	/* paranoia checks */
+	if(!ob && !ob->pose) return;
+	if(ob==obedit || (ob->flag & OB_POSEMODE)==0) return;
+	
+	nr= pupmenu("Specials%t|Select Constraint Target%x1|Flip Left-Right Names%x2|Calculate Paths%x3|Clear Paths%x4|Clear User Transform %x5|Relax Pose %x6|%l|AutoName Left-Right%x7|AutoName Front-Back%x8|AutoName Top-Bottom%x9");
+	if(nr==1) {
+		pose_select_constraint_target(scene);
+	}
+	else if(nr==2) {
+		pose_flip_names();
+	}
+	else if(nr==3) {
+		pose_calculate_path(ob);
+	}
+	else if(nr==4) {
+		pose_clear_paths(ob);
+	}
+	else if(nr==5) {
+		rest_pose(ob->pose);
+		DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
+		BIF_undo_push("Clear User Transform Pose");
+	}
+	else if(nr==6) {
+		pose_relax();
+	}
+	else if(ELEM3(nr, 7, 8, 9)) {
+		pose_autoside_names(nr-7);
+	}
+#endif
+}
+