Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / source / gameengine / Converter / BL_ActionActuator.cpp
index ce4311f..2f0e3e9 100644 (file)
@@ -436,367 +436,8 @@ bool BL_ActionActuator::Update(double curtime, bool frame)
 /* Python functions                                                          */
 /* ------------------------------------------------------------------------- */
 
-/*     setStart                                                              */
-const char BL_ActionActuator::GetAction_doc[] = 
-"getAction()\n"
-"\tReturns a string containing the name of the current action.\n";
-
-PyObject* BL_ActionActuator::PyGetAction(PyObject* args, 
-                                                                                PyObject* kwds) {
-       ShowDeprecationWarning("getAction()", "the action property");
-
-       if (m_action){
-               return PyString_FromString(m_action->id.name+2);
-       }
-       Py_RETURN_NONE;
-}
-
-/*     getProperty                                                             */
-const char BL_ActionActuator::GetProperty_doc[] = 
-"getProperty()\n"
-"\tReturns the name of the property to be used in FromProp mode.\n";
-
-PyObject* BL_ActionActuator::PyGetProperty(PyObject* args, 
-                                                                                  PyObject* kwds) {
-       ShowDeprecationWarning("getProperty()", "the property property");
-
-       PyObject *result;
-       
-       result = Py_BuildValue("s", (const char *)m_propname);
-       
-       return result;
-}
-
-/*     getProperty                                                             */
-const char BL_ActionActuator::GetFrameProperty_doc[] = 
-"getFrameProperty()\n"
-"\tReturns the name of the property, that is set to the current frame number.\n";
-
-PyObject* BL_ActionActuator::PyGetFrameProperty(PyObject* args, 
-                                                                                  PyObject* kwds) {
-       ShowDeprecationWarning("getFrameProperty()", "the frameProperty property");
-
-       PyObject *result;
-       
-       result = Py_BuildValue("s", (const char *)m_framepropname);
-       
-       return result;
-}
-
-/*     getFrame                                                              */
-const char BL_ActionActuator::GetFrame_doc[] = 
-"getFrame()\n"
-"\tReturns the current frame number.\n";
-
-PyObject* BL_ActionActuator::PyGetFrame(PyObject* args, 
-                                                                               PyObject* kwds) {
-       ShowDeprecationWarning("getFrame()", "the frame property");
-
-       PyObject *result;
-       
-       result = Py_BuildValue("f", m_localtime);
-       
-       return result;
-}
-
-/*     getEnd                                                                */
-const char BL_ActionActuator::GetEnd_doc[] = 
-"getEnd()\n"
-"\tReturns the last frame of the action.\n";
-
-PyObject* BL_ActionActuator::PyGetEnd(PyObject* args, 
-                                                                         PyObject* kwds) {
-       ShowDeprecationWarning("getEnd()", "the end property");
-
-       PyObject *result;
-       
-       result = Py_BuildValue("f", m_endframe);
-       
-       return result;
-}
-
-/*     getStart                                                              */
-const char BL_ActionActuator::GetStart_doc[] = 
-"getStart()\n"
-"\tReturns the starting frame of the action.\n";
-
-PyObject* BL_ActionActuator::PyGetStart(PyObject* args, 
-                                                                               PyObject* kwds) {
-       ShowDeprecationWarning("getStart()", "the start property");
-
-       PyObject *result;
-       
-       result = Py_BuildValue("f", m_startframe);
-       
-       return result;
-}
-
-/*     getBlendin                                                            */
-const char BL_ActionActuator::GetBlendin_doc[] = 
-"getBlendin()\n"
-"\tReturns the number of interpolation animation frames to be\n"
-"\tgenerated when this actuator is triggered.\n";
-
-PyObject* BL_ActionActuator::PyGetBlendin(PyObject* args, 
-                                                                                 PyObject* kwds) {
-       ShowDeprecationWarning("getBlendin()", "the blendin property");
-
-       PyObject *result;
-       
-       result = Py_BuildValue("f", m_blendin);
-       
-       return result;
-}
-
-/*     getPriority                                                           */
-const char BL_ActionActuator::GetPriority_doc[] = 
-"getPriority()\n"
-"\tReturns the priority for this actuator.  Actuators with lower\n"
-"\tPriority numbers will override actuators with higher numbers.\n";
-
-PyObject* BL_ActionActuator::PyGetPriority(PyObject* args, 
-                                                                                  PyObject* kwds) {
-       ShowDeprecationWarning("getPriority()", "the priority property");
-
-       PyObject *result;
-       
-       result = Py_BuildValue("i", m_priority);
-       
-       return result;
-}
-
-/*     setAction                                                             */
-const char BL_ActionActuator::SetAction_doc[] = 
-"setAction(action, (reset))\n"
-"\t - action    : The name of the action to set as the current action.\n"
-"\t - reset     : Optional parameter indicating whether to reset the\n"
-"\t               blend timer or not.  A value of 1 indicates that the\n"
-"\t               timer should be reset.  A value of 0 will leave it\n"
-"\t               unchanged.  If reset is not specified, the timer will"
-"\t                  be reset.\n";
-
-PyObject* BL_ActionActuator::PySetAction(PyObject* args, 
-                                                                                PyObject* kwds) {
-       ShowDeprecationWarning("setAction()", "the action property");
-
-       char *string;
-       int     reset = 1;
-
-       if (PyArg_ParseTuple(args,"s|i:setAction",&string, &reset))
-       {
-               bAction *action;
-               
-               action = (bAction*)SCA_ILogicBrick::m_sCurrentLogicManager->GetActionByName(STR_String(string));
-               
-               if (!action){
-                       /* NOTE!  Throw an exception or something */
-                       //                      printf ("setAction failed: Action not found\n", string);
-               }
-               else{
-                       m_action=action;
-                       if (reset)
-                               m_blendframe = 0;
-               }
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setStart                                                              */
-const char BL_ActionActuator::SetStart_doc[] = 
-"setStart(start)\n"
-"\t - start     : Specifies the starting frame of the animation.\n";
-
-PyObject* BL_ActionActuator::PySetStart(PyObject* args, 
-                                                                               PyObject* kwds) {
-       ShowDeprecationWarning("setStart()", "the start property");
-
-       float start;
-       
-       if (PyArg_ParseTuple(args,"f:setStart",&start))
-       {
-               m_startframe = start;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setEnd                                                                */
-const char BL_ActionActuator::SetEnd_doc[] = 
-"setEnd(end)\n"
-"\t - end       : Specifies the ending frame of the animation.\n";
-
-PyObject* BL_ActionActuator::PySetEnd(PyObject* args, 
-                                                                         PyObject* kwds) {
-       ShowDeprecationWarning("setEnd()", "the end property");
-
-       float end;
-       
-       if (PyArg_ParseTuple(args,"f:setEnd",&end))
-       {
-               m_endframe = end;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setBlendin                                                            */
-const char BL_ActionActuator::SetBlendin_doc[] = 
-"setBlendin(blendin)\n"
-"\t - blendin   : Specifies the number of frames of animation to generate\n"
-"\t               when making transitions between actions.\n";
-
-PyObject* BL_ActionActuator::PySetBlendin(PyObject* args, 
-                                                                                 PyObject* kwds) {
-       ShowDeprecationWarning("setBlendin()", "the blendin property");
-
-       float blendin;
-       
-       if (PyArg_ParseTuple(args,"f:setBlendin",&blendin))
-       {
-               m_blendin = blendin;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setBlendtime                                                          */
-const char BL_ActionActuator::SetBlendtime_doc[] = 
-"setBlendtime(blendtime)\n"
-"\t - blendtime : Allows the script to directly modify the internal timer\n"
-"\t               used when generating transitions between actions.  This\n"
-"\t               parameter must be in the range from 0.0 to 1.0.\n";
-
-PyObject* BL_ActionActuator::PySetBlendtime(PyObject* args, 
-                                                                                 PyObject* kwds) {
-       ShowDeprecationWarning("setBlendtime()", "the blendtime property");
-
-       float blendframe;
-       
-       if (PyArg_ParseTuple(args,"f:setBlendtime",&blendframe))
-       {
-               m_blendframe = blendframe * m_blendin;
-               if (m_blendframe<0)
-                       m_blendframe = 0;
-               if (m_blendframe>m_blendin)
-                       m_blendframe = m_blendin;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setPriority                                                           */
-const char BL_ActionActuator::SetPriority_doc[] = 
-"setPriority(priority)\n"
-"\t - priority  : Specifies the new priority.  Actuators will lower\n"
-"\t               priority numbers will override actuators with higher\n"
-"\t               numbers.\n";
-
-PyObject* BL_ActionActuator::PySetPriority(PyObject* args, 
-                                                                                  PyObject* kwds) {
-       ShowDeprecationWarning("setPriority()", "the priority property");
-
-       int priority;
-       
-       if (PyArg_ParseTuple(args,"i:setPriority",&priority))
-       {
-               m_priority = priority;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setFrame                                                              */
-const char BL_ActionActuator::SetFrame_doc[] = 
-"setFrame(frame)\n"
-"\t - frame     : Specifies the new current frame for the animation\n";
-
-PyObject* BL_ActionActuator::PySetFrame(PyObject* args, 
-                                                                               PyObject* kwds) {
-       ShowDeprecationWarning("setFrame()", "the frame property");
-
-       float frame;
-       
-       if (PyArg_ParseTuple(args,"f:setFrame",&frame))
-       {
-               m_localtime = frame;
-               if (m_localtime<m_startframe)
-                       m_localtime=m_startframe;
-               else if (m_localtime>m_endframe)
-                       m_localtime=m_endframe;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setProperty                                                           */
-const char BL_ActionActuator::SetProperty_doc[] = 
-"setProperty(prop)\n"
-"\t - prop      : A string specifying the property name to be used in\n"
-"\t               FromProp playback mode.\n";
-
-PyObject* BL_ActionActuator::PySetProperty(PyObject* args, 
-                                                                                  PyObject* kwds) {
-       ShowDeprecationWarning("setProperty()", "the property property");
-
-       char *string;
-       
-       if (PyArg_ParseTuple(args,"s:setProperty",&string))
-       {
-               m_propname = string;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
-/*     setFrameProperty                                                          */
-const char BL_ActionActuator::SetFrameProperty_doc[] = 
-"setFrameProperty(prop)\n"
-"\t - prop      : A string specifying the property of the frame set up update.\n";
-
-PyObject* BL_ActionActuator::PySetFrameProperty(PyObject* args, 
-                                                                                  PyObject* kwds) {
-       ShowDeprecationWarning("setFrameProperty()", "the frameProperty property");
-
-       char *string;
-       
-       if (PyArg_ParseTuple(args,"s:setFrameProperty",&string))
-       {
-               m_framepropname = string;
-       }
-       else {
-               return NULL;
-       }
-       
-       Py_RETURN_NONE;
-}
-
 PyObject* BL_ActionActuator::PyGetChannel(PyObject* value) {
-       char *string= PyString_AsString(value);
+       char *string= _PyUnicode_AsString(value);
        
        if (!string) {
                PyErr_SetString(PyExc_TypeError, "expected a single string");
@@ -805,6 +446,10 @@ PyObject* BL_ActionActuator::PyGetChannel(PyObject* value) {
        
        bPoseChannel *pchan;
        
+       if(m_userpose==NULL && m_pose==NULL) {
+               BL_ArmatureObject *obj = (BL_ArmatureObject*)GetParent();
+               obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
+       }
        
        // get_pose_channel accounts for NULL pose, run on both incase one exists but
        // the channel doesnt
@@ -845,72 +490,6 @@ PyObject* BL_ActionActuator::PyGetChannel(PyObject* value) {
 */
 }
 
-/* getType */
-const char BL_ActionActuator::GetType_doc[] =
-"getType()\n"
-"\tReturns the operation mode of the actuator.\n";
-PyObject* BL_ActionActuator::PyGetType(PyObject* args, 
-                                       PyObject* kwds) {
-       ShowDeprecationWarning("getType()", "the type property");
-
-    return Py_BuildValue("h", m_playtype);
-}
-
-/* setType */
-const char BL_ActionActuator::SetType_doc[] =
-"setType(mode)\n"
-"\t - mode: Play (0), Flipper (2), LoopStop (3), LoopEnd (4) or Property (6)\n"
-"\tSet the operation mode of the actuator.\n";
-PyObject* BL_ActionActuator::PySetType(PyObject* args,
-                                       PyObject* kwds) {
-       ShowDeprecationWarning("setType()", "the type property");
-
-       short typeArg;
-                                                                                                             
-    if (!PyArg_ParseTuple(args, "h:setType", &typeArg)) {
-        return NULL;
-    }
-
-       switch (typeArg) {
-       case ACT_ACTION_PLAY:
-       case ACT_ACTION_FLIPPER:
-       case ACT_ACTION_LOOP_STOP:
-       case ACT_ACTION_LOOP_END:
-       case ACT_ACTION_FROM_PROP:
-               m_playtype = typeArg;
-               break;
-       default:
-               printf("Invalid type for action actuator: %d\n", typeArg); /* error */
-    }
-       Py_RETURN_NONE;
-}
-
-PyObject* BL_ActionActuator::PyGetContinue() {
-       ShowDeprecationWarning("getContinue()", "the continue property");
-
-    return PyInt_FromLong((long)(m_end_reset==0));
-}
-
-PyObject* BL_ActionActuator::PySetContinue(PyObject* value) {
-       ShowDeprecationWarning("setContinue()", "the continue property");
-
-       int param = PyObject_IsTrue( value );
-       
-       if( param == -1 ) {
-               PyErr_SetString( PyExc_TypeError, "expected True/False or 0/1" );
-               return NULL;
-       }
-
-       if (param) {
-               m_end_reset = 0;
-       } else {
-               m_end_reset = 1;
-       }
-    Py_RETURN_NONE;
-}
-
-//<-----Deprecated
-
 /*     setChannel                                                         */
 KX_PYMETHODDEF_DOC(BL_ActionActuator, setChannel,
 "setChannel(channel, matrix)\n"
@@ -947,17 +526,20 @@ KX_PYMETHODDEF_DOC(BL_ActionActuator, setChannel,
                mat.setValue((const float *)matrix);
                
                BL_ArmatureObject *obj = (BL_ArmatureObject*)GetParent();
-               obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
                
                if (!m_userpose) {
-                       obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
-                       game_copy_pose(&m_userpose, m_pose);
+                       if(!m_pose)
+                               obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
+                       game_copy_pose(&m_userpose, m_pose, 0);
                }
-               pchan= verify_pose_channel(m_userpose, string); // adds the channel if its not there.
+               // pchan= verify_pose_channel(m_userpose, string); // adds the channel if its not there.
+               pchan= get_pose_channel(m_userpose, string); // adds the channel if its not there.
                
-               VECCOPY (pchan->loc, matrix[3]);
-               Mat4ToSize(matrix, pchan->size);
-               Mat4ToQuat(matrix, pchan->quat);
+               if(pchan) {
+                       VECCOPY (pchan->loc, matrix[3]);
+                       Mat4ToSize(matrix, pchan->size);
+                       Mat4ToQuat(matrix, pchan->quat);
+               }
        }
        else {
                MT_Vector3 loc;
@@ -969,18 +551,26 @@ KX_PYMETHODDEF_DOC(BL_ActionActuator, setChannel,
                
                // same as above
                if (!m_userpose) {
-                       obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
-                       game_copy_pose(&m_userpose, m_pose);
+                       if(!m_pose)
+                               obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
+                       game_copy_pose(&m_userpose, m_pose, 0);
                }
-               pchan= verify_pose_channel(m_userpose, string);
+               // pchan= verify_pose_channel(m_userpose, string);
+               pchan= get_pose_channel(m_userpose, string); // adds the channel if its not there.
                
                // for some reason loc.setValue(pchan->loc) fails
-               pchan->loc[0]= loc[0]; pchan->loc[1]= loc[1]; pchan->loc[2]= loc[2];
-               pchan->size[0]= size[0]; pchan->size[1]= size[1]; pchan->size[2]= size[2];
-               pchan->quat[0]= quat[3]; pchan->quat[1]= quat[0]; pchan->quat[2]= quat[1]; pchan->quat[3]= quat[2]; /* notice xyzw -> wxyz is intentional */
+               if(pchan) {
+                       pchan->loc[0]= loc[0]; pchan->loc[1]= loc[1]; pchan->loc[2]= loc[2];
+                       pchan->size[0]= size[0]; pchan->size[1]= size[1]; pchan->size[2]= size[2];
+                       pchan->quat[0]= quat[3]; pchan->quat[1]= quat[0]; pchan->quat[2]= quat[1]; pchan->quat[3]= quat[2]; /* notice xyzw -> wxyz is intentional */
+               }
+       }
+       
+       if(pchan==NULL) {
+               PyErr_SetString(PyExc_ValueError, "Channel could not be found, use the 'channelNames' attribute to get a list of valid channels");
+               return NULL;
        }
        
-       pchan->flag |= POSE_ROT|POSE_LOC|POSE_SIZE;
        Py_RETURN_NONE;
 }
 
@@ -989,63 +579,29 @@ KX_PYMETHODDEF_DOC(BL_ActionActuator, setChannel,
 /* ------------------------------------------------------------------------- */
 
 PyTypeObject BL_ActionActuator::Type = {
-#if (PY_VERSION_HEX >= 0x02060000)
        PyVarObject_HEAD_INIT(NULL, 0)
-#else
-       /* python 2.5 and below */
-       PyObject_HEAD_INIT( NULL )  /* required py macro */
-       0,                          /* ob_size */
-#endif
-               "BL_ActionActuator",
-               sizeof(PyObjectPlus_Proxy),
-               0,
-               py_base_dealloc,
-               0,
-               0,
-               0,
-               0,
-               py_base_repr,
-               0,0,0,0,0,0,
-               py_base_getattro,
-               py_base_setattro,
-               0,0,0,0,0,0,0,0,0,
-               Methods
-};
-
-PyParentObject BL_ActionActuator::Parents[] = {
-       &BL_ActionActuator::Type,
-               &SCA_IActuator::Type,
-               &SCA_ILogicBrick::Type,
-               &CValue::Type,
-               NULL
+       "BL_ActionActuator",
+       sizeof(PyObjectPlus_Proxy),
+       0,
+       py_base_dealloc,
+       0,
+       0,
+       0,
+       0,
+       py_base_repr,
+       0,0,0,0,0,0,0,0,0,
+       Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+       0,0,0,0,0,0,0,
+       Methods,
+       0,
+       0,
+       &SCA_IActuator::Type,
+       0,0,0,0,0,0,
+       py_base_new
 };
 
 PyMethodDef BL_ActionActuator::Methods[] = {
-       //Deprecated ----->
-       {"setAction", (PyCFunction) BL_ActionActuator::sPySetAction, METH_VARARGS, (PY_METHODCHAR)SetAction_doc},
-       {"setStart", (PyCFunction) BL_ActionActuator::sPySetStart, METH_VARARGS, (PY_METHODCHAR)SetStart_doc},
-       {"setEnd", (PyCFunction) BL_ActionActuator::sPySetEnd, METH_VARARGS, (PY_METHODCHAR)SetEnd_doc},
-       {"setBlendin", (PyCFunction) BL_ActionActuator::sPySetBlendin, METH_VARARGS, (PY_METHODCHAR)SetBlendin_doc},
-       {"setPriority", (PyCFunction) BL_ActionActuator::sPySetPriority, METH_VARARGS, (PY_METHODCHAR)SetPriority_doc},
-       {"setFrame", (PyCFunction) BL_ActionActuator::sPySetFrame, METH_VARARGS, (PY_METHODCHAR)SetFrame_doc},
-       {"setProperty", (PyCFunction) BL_ActionActuator::sPySetProperty, METH_VARARGS, (PY_METHODCHAR)SetProperty_doc},
-       {"setFrameProperty", (PyCFunction) BL_ActionActuator::sPySetFrameProperty, METH_VARARGS, (PY_METHODCHAR)SetFrameProperty_doc},
-       {"setBlendtime", (PyCFunction) BL_ActionActuator::sPySetBlendtime, METH_VARARGS, (PY_METHODCHAR)SetBlendtime_doc},
-
-       {"getAction", (PyCFunction) BL_ActionActuator::sPyGetAction, METH_VARARGS, (PY_METHODCHAR)GetAction_doc},
-       {"getStart", (PyCFunction) BL_ActionActuator::sPyGetStart, METH_VARARGS, (PY_METHODCHAR)GetStart_doc},
-       {"getEnd", (PyCFunction) BL_ActionActuator::sPyGetEnd, METH_VARARGS, (PY_METHODCHAR)GetEnd_doc},
-       {"getBlendin", (PyCFunction) BL_ActionActuator::sPyGetBlendin, METH_VARARGS, (PY_METHODCHAR)GetBlendin_doc},
-       {"getPriority", (PyCFunction) BL_ActionActuator::sPyGetPriority, METH_VARARGS, (PY_METHODCHAR)GetPriority_doc},
-       {"getFrame", (PyCFunction) BL_ActionActuator::sPyGetFrame, METH_VARARGS, (PY_METHODCHAR)GetFrame_doc},
-       {"getProperty", (PyCFunction) BL_ActionActuator::sPyGetProperty, METH_VARARGS, (PY_METHODCHAR)GetProperty_doc},
-       {"getFrameProperty", (PyCFunction) BL_ActionActuator::sPyGetFrameProperty, METH_VARARGS, (PY_METHODCHAR)GetFrameProperty_doc},
        {"getChannel", (PyCFunction) BL_ActionActuator::sPyGetChannel, METH_O},
-       {"getType", (PyCFunction) BL_ActionActuator::sPyGetType, METH_VARARGS, (PY_METHODCHAR)GetType_doc},
-       {"setType", (PyCFunction) BL_ActionActuator::sPySetType, METH_VARARGS, (PY_METHODCHAR)SetType_doc},
-       {"getContinue", (PyCFunction) BL_ActionActuator::sPyGetContinue, METH_NOARGS, 0},       
-       {"setContinue", (PyCFunction) BL_ActionActuator::sPySetContinue, METH_O, 0},
-       //<------
        KX_PYMETHODTABLE(BL_ActionActuator, setChannel),
        {NULL,NULL} //Sentinel
 };
@@ -1055,6 +611,7 @@ PyAttributeDef BL_ActionActuator::Attributes[] = {
        KX_PYATTRIBUTE_FLOAT_RW("frameEnd", 0, MAXFRAMEF, BL_ActionActuator, m_endframe),
        KX_PYATTRIBUTE_FLOAT_RW("blendIn", 0, MAXFRAMEF, BL_ActionActuator, m_blendin),
        KX_PYATTRIBUTE_RW_FUNCTION("action", BL_ActionActuator, pyattr_get_action, pyattr_set_action),
+       KX_PYATTRIBUTE_RO_FUNCTION("channelNames", BL_ActionActuator, pyattr_get_channel_names),
        KX_PYATTRIBUTE_SHORT_RW("priority", 0, 100, false, BL_ActionActuator, m_priority),
        KX_PYATTRIBUTE_FLOAT_RW_CHECK("frame", 0, MAXFRAMEF, BL_ActionActuator, m_localtime, CheckFrame),
        KX_PYATTRIBUTE_STRING_RW("propName", 0, 31, false, BL_ActionActuator, m_propname),
@@ -1065,37 +622,24 @@ PyAttributeDef BL_ActionActuator::Attributes[] = {
        { NULL }        //Sentinel
 };
 
-PyObject* BL_ActionActuator::py_getattro(PyObject *attr) {
-       py_getattro_up(SCA_IActuator);
-}
-
-PyObject* BL_ActionActuator::py_getattro_dict() {
-       py_getattro_dict_up(SCA_IActuator);
-}
-
-int BL_ActionActuator::py_setattro(PyObject *attr, PyObject* value) {
-       py_setattro_up(SCA_IActuator);
-}
-
-
 PyObject* BL_ActionActuator::pyattr_get_action(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 {
        BL_ActionActuator* self= static_cast<BL_ActionActuator*>(self_v);
-       return PyString_FromString(self->GetAction() ? self->GetAction()->id.name+2 : "");
+       return PyUnicode_FromString(self->GetAction() ? self->GetAction()->id.name+2 : "");
 }
 
 int BL_ActionActuator::pyattr_set_action(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
 {
        BL_ActionActuator* self= static_cast<BL_ActionActuator*>(self_v);
        
-       if (!PyString_Check(value))
+       if (!PyUnicode_Check(value))
        {
                PyErr_SetString(PyExc_ValueError, "actuator.action = val: Action Actuator, expected the string name of the action");
                return PY_SET_ATTR_FAIL;
        }
 
        bAction *action= NULL;
-       STR_String val = PyString_AsString(value);
+       STR_String val = _PyUnicode_AsString(value);
        
        if (val != "")
        {
@@ -1111,3 +655,23 @@ int BL_ActionActuator::pyattr_set_action(void *self_v, const KX_PYATTRIBUTE_DEF
        return PY_SET_ATTR_SUCCESS;
 
 }
+
+PyObject* BL_ActionActuator::pyattr_get_channel_names(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       BL_ActionActuator* self= static_cast<BL_ActionActuator*>(self_v);
+       PyObject *ret= PyList_New(0);
+       PyObject *item;
+       
+       bPose *pose= ((BL_ArmatureObject*)self->GetParent())->GetOrigPose();
+       
+       if(pose) {
+               bPoseChannel *pchan;
+               for(pchan= (bPoseChannel *)pose->chanbase.first; pchan; pchan= (bPoseChannel *)pchan->next) {
+                       item= PyUnicode_FromString(pchan->name);
+                       PyList_Append(ret, item);
+                       Py_DECREF(item);
+               }
+       }
+       
+       return ret;
+}