rename and negate DISABLE_PYTHON --> WITH_PYTHON
[blender.git] / source / gameengine / GameLogic / SCA_MouseSensor.cpp
index 8f56d153f02211439decb3269e6ab0a00f39b2ae..af11353c93e0672f5b7e37789e60e4d54d61f215 100644 (file)
  *
  * 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.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): José I. Romero (cleanup and fixes)
  *
  * ***** END GPL LICENSE BLOCK *****
  */
 #include "ConstExpr.h"
 #include <iostream>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 /* ------------------------------------------------------------------------- */
 /* Native functions                                                          */
 /* ------------------------------------------------------------------------- */
 SCA_MouseSensor::SCA_MouseSensor(SCA_MouseManager* eventmgr, 
                                                                 int startx,int starty,
                                                                 short int mousemode,
-                                                                SCA_IObject* gameobj, 
-                                                                PyTypeObject* T)
-    : SCA_ISensor(gameobj,eventmgr, T),
-       m_pMouseMgr(eventmgr),
+                                                                SCA_IObject* gameobj)
+    : SCA_ISensor(gameobj,eventmgr),
        m_x(startx),
        m_y(starty)
 {
        m_mousemode   = mousemode;
        m_triggermode = true;
 
-       switch (m_mousemode) {
-       case KX_MOUSESENSORMODE_LEFTBUTTON:
-               m_hotkey = SCA_IInputDevice::KX_LEFTMOUSE;
-               break;
-       case KX_MOUSESENSORMODE_MIDDLEBUTTON:
-               m_hotkey = SCA_IInputDevice::KX_MIDDLEMOUSE;
-               break;
-       case KX_MOUSESENSORMODE_RIGHTBUTTON:
-               m_hotkey = SCA_IInputDevice::KX_RIGHTMOUSE;
-               break;
-       case KX_MOUSESENSORMODE_WHEELUP:
-               m_hotkey = SCA_IInputDevice::KX_WHEELUPMOUSE;
-               break;
-       case KX_MOUSESENSORMODE_WHEELDOWN:
-               m_hotkey = SCA_IInputDevice::KX_WHEELDOWNMOUSE;
-               break;
-       default:
-               ; /* ignore, no hotkey */
-       }
+       UpdateHotkey(this);
        Init();
 }
 
@@ -92,13 +68,41 @@ SCA_MouseSensor::~SCA_MouseSensor()
     /* Nothing to be done here. */
 }
 
-
+void SCA_MouseSensor::UpdateHotkey(void *self)
+{
+       // gosh, this function is so damn stupid
+       // its here because of a design mistake in the mouse sensor, it should only
+       // have 3 trigger modes (button, wheel, move), and let the user set the 
+       // hotkey separately, like the other sensors. but instead it has a mode for 
+       // each friggin key and i have to update the hotkey based on it... genius!
+       SCA_MouseSensor* sensor = reinterpret_cast<SCA_MouseSensor*>(self);
+
+       switch (sensor->m_mousemode) {
+       case KX_MOUSESENSORMODE_LEFTBUTTON:
+               sensor->m_hotkey = SCA_IInputDevice::KX_LEFTMOUSE;
+               break;
+       case KX_MOUSESENSORMODE_MIDDLEBUTTON:
+               sensor->m_hotkey = SCA_IInputDevice::KX_MIDDLEMOUSE;
+               break;
+       case KX_MOUSESENSORMODE_RIGHTBUTTON:
+               sensor->m_hotkey = SCA_IInputDevice::KX_RIGHTMOUSE;
+               break;
+       case KX_MOUSESENSORMODE_WHEELUP:
+               sensor->m_hotkey = SCA_IInputDevice::KX_WHEELUPMOUSE;
+               break;
+       case KX_MOUSESENSORMODE_WHEELDOWN:
+               sensor->m_hotkey = SCA_IInputDevice::KX_WHEELDOWNMOUSE;
+               break;
+       default:
+               ; /* ignore, no hotkey */
+       }
+}
 
 CValue* SCA_MouseSensor::GetReplica()
 {
        SCA_MouseSensor* replica = new SCA_MouseSensor(*this);
        // this will copy properties and so on...
-       CValue::AddDataToReplica(replica);
+       replica->ProcessReplica();
        replica->Init();
 
        return replica;
@@ -131,21 +135,12 @@ SCA_IInputDevice::KX_EnumInputs SCA_MouseSensor::GetHotKey()
 
 
 
-bool SCA_MouseSensor::Evaluate(CValue* event)
+bool SCA_MouseSensor::Evaluate()
 {
        bool result = false;
        bool reset = m_reset && m_level;
-       SCA_IInputDevice* mousedev = m_pMouseMgr->GetInputDevice();
-
-
-
-//     SCA_ILogicBrick::RegisterEvent(event);
-//     if (m_mousemode == KX_MOUSESENSORMODE_MOVEMENT) cout << "\nChecking for movement...";
-//CValue* val = event->GetProperty("val");
+       SCA_IInputDevice* mousedev = ((SCA_MouseManager *)m_eventmgr)->GetInputDevice();
 
-       /* both MOUSEX and MOUSEY. Treat all of these as key-presses.            */
-       /* So, treat KX_MOUSESENSORMODE_POSITION as                              */
-       /* KX_MOUSESENSORMODE_POSITIONX || KX_MOUSESENSORMODE_POSITIONY          */
        m_reset = false;
        switch (m_mousemode) {
        case KX_MOUSESENSORMODE_LEFTBUTTON:
@@ -154,43 +149,35 @@ bool SCA_MouseSensor::Evaluate(CValue* event)
        case KX_MOUSESENSORMODE_WHEELUP:
        case KX_MOUSESENSORMODE_WHEELDOWN:
                {
-                       const SCA_InputEvent& event = mousedev->GetEventValue(m_hotkey);
-                       if (event.m_status == SCA_InputEvent::KX_JUSTACTIVATED)
-                       {
+                       const SCA_InputEvent& mevent = mousedev->GetEventValue(m_hotkey);
+                       switch (mevent.m_status){       
+                       case SCA_InputEvent::KX_JUSTACTIVATED:
                                m_val = 1;
                                result = true;
-                       } else
-                       {
-                               if (event.m_status == SCA_InputEvent::KX_JUSTRELEASED)
+                               break;
+                       case SCA_InputEvent::KX_JUSTRELEASED:
+                               m_val = 0;
+                               result = true;
+                               break;
+                       case SCA_InputEvent::KX_ACTIVE:
+                               if (m_val == 0)
+                               {
+                                       m_val = 1;
+                                       if (m_level)
+                                               result = true;
+                               }
+                               break;
+                       default:
+                               if (m_val == 1)
                                {
                                        m_val = 0;
                                        result = true;
-                               } else
-                               {
-                                       if (event.m_status == SCA_InputEvent::KX_ACTIVE)
-                                       {
-                                               if (m_val == 0)
-                                               {
-                                                       m_val = 1;
-                                                       if (m_level)
-                                                       {
-                                                               result = true;
-                                                       }
-                                               }
-                                       } else
-                                       {
-                                               if (m_val == 1)
-                                               {
-                                                       m_val = 0;
-                                                       result = true;
-                                               }
-                                       }
                                }
+                               break;
                        }
                        break;
                }
        case KX_MOUSESENSORMODE_MOVEMENT:
-               
                {
                        const SCA_InputEvent& eventX = mousedev->GetEventValue(SCA_IInputDevice::KX_MOUSEX);
                        const SCA_InputEvent& eventY = mousedev->GetEventValue(SCA_IInputDevice::KX_MOUSEY);
@@ -198,27 +185,26 @@ bool SCA_MouseSensor::Evaluate(CValue* event)
                        if (eventX.m_status == SCA_InputEvent::KX_JUSTACTIVATED ||
                                eventY.m_status == SCA_InputEvent::KX_JUSTACTIVATED ||
                                eventX.m_status == SCA_InputEvent::KX_ACTIVE ||
-                               eventY.m_status == SCA_InputEvent::KX_ACTIVE)
-                               
+                               eventY.m_status == SCA_InputEvent::KX_ACTIVE)   
                        {
                                m_val = 1;
                                result = true;
-                       } else
-                       {
-                               if (eventX.m_status == SCA_InputEvent::KX_JUSTRELEASED ||
+                       } 
+                       else if (eventX.m_status == SCA_InputEvent::KX_JUSTRELEASED ||
                                        eventY.m_status == SCA_InputEvent::KX_JUSTRELEASED )
+                       {
+                               m_val = 0;
+                               result = true;
+                       } 
+                       else //KX_NO_IMPUTSTATUS
+                       { 
+                               if (m_val == 1)
                                {
                                        m_val = 0;
                                        result = true;
-                               } else
-                               {
-                                       if (m_val == 1)
-                                       {
-                                               m_val = 0;
-                                               result = true;
-                                       }
                                }
                        }
+                       
                        break;
                }
        default:
@@ -243,77 +229,82 @@ void SCA_MouseSensor::setY(short y)
 
 bool SCA_MouseSensor::isValid(SCA_MouseSensor::KX_MOUSESENSORMODE m)
 {
-       bool res = false;
+       return ((m > KX_MOUSESENSORMODE_NODEF) && (m < KX_MOUSESENSORMODE_MAX));
+}
+
+#ifdef WITH_PYTHON
+
+/* ------------------------------------------------------------------------- */
+/* Python functions                                                          */
+/* ------------------------------------------------------------------------- */
 
-       res = ((m > KX_MOUSESENSORMODE_NODEF) && (m < KX_MOUSESENSORMODE_MAX));
+KX_PYMETHODDEF_DOC_O(SCA_MouseSensor, getButtonStatus,
+"getButtonStatus(button)\n"
+"\tGet the given button's status (KX_INPUT_NONE, KX_INPUT_NONE, KX_INPUT_JUST_ACTIVATED, KX_INPUT_ACTIVE, KX_INPUT_JUST_RELEASED).\n")
+{
+       if (PyLong_Check(value))
+       {
+               int button = PyLong_AsSsize_t(value);
+               
+               if ((button < SCA_IInputDevice::KX_LEFTMOUSE)
+                       || (button > SCA_IInputDevice::KX_RIGHTMOUSE)){
+                       PyErr_SetString(PyExc_ValueError, "sensor.getButtonStatus(int): Mouse Sensor, invalid button specified!");
+                       return NULL;
+               }
+               
+               SCA_IInputDevice* mousedev = ((SCA_MouseManager *)m_eventmgr)->GetInputDevice();
+               const SCA_InputEvent& event = mousedev->GetEventValue((SCA_IInputDevice::KX_EnumInputs) button);
+               return PyLong_FromSsize_t(event.m_status);
+       }
        
-       return res;
+       Py_RETURN_NONE;
 }
 
 /* ------------------------------------------------------------------------- */
-/* Python functions                                                          */
+/* Python Integration Hooks                                                  */
 /* ------------------------------------------------------------------------- */
 
-/* Integration hooks ------------------------------------------------------- */
 PyTypeObject SCA_MouseSensor::Type = {
-       PyObject_HEAD_INIT(&PyType_Type)
-       0,
+       PyVarObject_HEAD_INIT(NULL, 0)
        "SCA_MouseSensor",
-       sizeof(SCA_MouseSensor),
+       sizeof(PyObjectPlus_Proxy),
        0,
-       PyDestructor,
+       py_base_dealloc,
        0,
-       __getattr,
-       __setattr,
-       0, //&MyPyCompare,
-       __repr,
-       0, //&cvalue_as_number,
        0,
        0,
        0,
-       0
-};
-
-PyParentObject SCA_MouseSensor::Parents[] = {
-       &SCA_MouseSensor::Type,
+       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_ISensor::Type,
-       &SCA_ILogicBrick::Type,
-       &CValue::Type,
-       NULL
+       0,0,0,0,0,0,
+       py_base_new
 };
 
 PyMethodDef SCA_MouseSensor::Methods[] = {
-       {"getXPosition", (PyCFunction) SCA_MouseSensor::sPyGetXPosition, METH_VARARGS, GetXPosition_doc},
-       {"getYPosition", (PyCFunction) SCA_MouseSensor::sPyGetYPosition, METH_VARARGS, GetYPosition_doc},
+       KX_PYMETHODTABLE_O(SCA_MouseSensor, getButtonStatus),
        {NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_MouseSensor::_getattr(const STR_String& attr) {
-       _getattr_up(SCA_ISensor);
+int SCA_MouseSensor::UpdateHotkeyPy(void *self, const PyAttributeDef*)
+{
+       UpdateHotkey(self);
+       // return value is used in py_setattro(),
+       // 0=attribute checked ok (see Attributes array definition)
+       return 0;
 }
 
-/* get x position ---------------------------------------------------------- */
-const char SCA_MouseSensor::GetXPosition_doc[] = 
-"getXPosition\n"
-"\tReturns the x-coordinate of the mouse sensor, in frame coordinates.\n"
-"\tThe lower-left corner is the origin. The coordinate is given in\n"
-"\tpixels\n";
-PyObject* SCA_MouseSensor::PyGetXPosition(PyObject* self, 
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds) {
-       return PyInt_FromLong(m_x);
-}
+PyAttributeDef SCA_MouseSensor::Attributes[] = {
+       KX_PYATTRIBUTE_SHORT_RW_CHECK("mode",KX_MOUSESENSORMODE_NODEF,KX_MOUSESENSORMODE_MAX-1,true,SCA_MouseSensor,m_mousemode,UpdateHotkeyPy),
+       KX_PYATTRIBUTE_SHORT_LIST_RO("position",SCA_MouseSensor,m_x,2),
+       { NULL }        //Sentinel
+};
 
-/* get y position ---------------------------------------------------------- */
-const char SCA_MouseSensor::GetYPosition_doc[] = 
-"getYPosition\n"
-"\tReturns the y-coordinate of the mouse sensor, in frame coordinates.\n"
-"\tThe lower-left corner is the origin. The coordinate is given in\n"
-"\tpixels\n";
-PyObject* SCA_MouseSensor::PyGetYPosition(PyObject* self, 
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds) {
-       return PyInt_FromLong(m_y);
-}
+#endif // WITH_PYTHON
 
 /* eof */