archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Initial revision

Browse Source
This commit is contained in:
Hans Lambermont
2002-10-12 11:37:38 +00:00
commit 12315f4d0e
1699 changed files with 444708 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

675
source/gameengine/GameLogic/SCA_KeyboardSensor.cpp Normal file
View File

@@ -0,0 +1,675 @@
/**
* $Id$
*
* ***** BEGIN GPL/BL DUAL 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. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* 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.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
* Sensor for keyboard input
*/
#include "SCA_KeyboardSensor.h"
#include "SCA_KeyboardManager.h"
#include "SCA_LogicManager.h"
#include "StringValue.h"
#include "SCA_IInputDevice.h"
/* ------------------------------------------------------------------------- */
/* Native functions */
/* ------------------------------------------------------------------------- */
SCA_KeyboardSensor::SCA_KeyboardSensor(SCA_KeyboardManager* keybdmgr,
short int hotkey,
short int qual,
short int qual2,
bool bAllKeys,
const STR_String& targetProp,
const STR_String& toggleProp,
SCA_IObject* gameobj,
PyTypeObject* T )
:SCA_ISensor(gameobj,keybdmgr,T),
m_pKeyboardMgr(keybdmgr),
m_hotkey(hotkey),
m_qual(qual),
m_qual2(qual2),
m_bAllKeys(bAllKeys),
m_targetprop(targetProp),
m_toggleprop(toggleProp)
{
// SetDrawColor(0xff0000ff);
m_val=0;
}
SCA_KeyboardSensor::~SCA_KeyboardSensor()
{
}
CValue* SCA_KeyboardSensor::GetReplica()
{
CValue* replica = new SCA_KeyboardSensor(*this);
// this will copy properties and so on...
CValue::AddDataToReplica(replica);
return replica;
}
short int SCA_KeyboardSensor::GetHotkey()
{
return m_hotkey;
}
bool SCA_KeyboardSensor::IsPositiveTrigger()
{
bool result = (m_val != 0);
if (m_invert)
result = !result;
return result;
}
bool SCA_KeyboardSensor::TriggerOnAllKeys()
{
return m_bAllKeys;
}
bool SCA_KeyboardSensor::Evaluate(CValue* eventval)
{
bool result = false;
SCA_IInputDevice* inputdev = m_pKeyboardMgr->GetInputDevice();
// cerr << "SCA_KeyboardSensor::Eval event, sensing for "<< m_hotkey << " at device " << inputdev << "\n";
/* See if we need to do logging: togPropState exists and is
* different from 0 */
CValue* myparent = GetParent();
CValue* togPropState = myparent->GetProperty(m_toggleprop);
if (togPropState &&
(((int)togPropState->GetNumber()) != 0) )
{
LogKeystrokes();
}
/* Now see whether events must be bounced. */
if (m_bAllKeys)
{
bool justactivated = false;
bool justreleased = false;
for (int i=SCA_IInputDevice::KX_BEGINKEY ; i< SCA_IInputDevice::KX_ENDKEY;i++)
{
const SCA_InputEvent & inevent = inputdev->GetEventValue((SCA_IInputDevice::KX_EnumInputs) i);
if (inevent.m_status == SCA_InputEvent::KX_JUSTACTIVATED)
{
justactivated = true;
}
if (inevent.m_status == SCA_InputEvent::KX_JUSTRELEASED)
{
justreleased = true;
}
}
if (justactivated)
{
m_val=1;
result = true;
} else
{
if (justreleased)
{
m_val=0;
result = true;
}
}
} else
{
// cerr << "======= SCA_KeyboardSensor::Evaluate:: peeking at key status" << endl;
const SCA_InputEvent & inevent = inputdev->GetEventValue((SCA_IInputDevice::KX_EnumInputs) m_hotkey);
// cerr << "======= SCA_KeyboardSensor::Evaluate:: status: " << inevent.m_status << endl;
if (inevent.m_status == SCA_InputEvent::KX_NO_INPUTSTATUS)
{
int i=4;
} else
{
if (inevent.m_status == SCA_InputEvent::KX_JUSTACTIVATED)
{
m_val=1;
result = true;
} else
{
if (inevent.m_status == SCA_InputEvent::KX_JUSTRELEASED)
{
m_val = 0;
result = true;
}
}
}
}
return result;
}
void SCA_KeyboardSensor::AddToTargetProp(int keyIndex)
{
if (IsPrintable(keyIndex)) {
CValue* tprop = GetParent()->GetProperty(m_targetprop);
if (tprop) {
/* overwrite the old property */
if (IsDelete(keyIndex)) {
/* strip one char, if possible */
STR_String newprop = tprop->GetText();
int oldlength = newprop.Length();
if (oldlength >= 1 ) {
newprop.SetLength(oldlength - 1);
CStringValue * newstringprop = new CStringValue(newprop, m_targetprop);
GetParent()->SetProperty(m_targetprop, newstringprop);
}
} else {
/* append */
char pchar = ToCharacter(keyIndex, IsShifted());
STR_String newprop = tprop->GetText() + pchar;
CStringValue * newstringprop = new CStringValue(newprop, m_targetprop);
GetParent()->SetProperty(m_targetprop, newstringprop);
}
} else {
if (!IsDelete(keyIndex)) {
/* Make a new property. Deletes can be ignored. */
char pchar = ToCharacter(keyIndex, IsShifted());
STR_String newprop = pchar;
CStringValue * newstringprop = new CStringValue(newprop, m_targetprop);
GetParent()->SetProperty(m_targetprop, newstringprop);
}
}
}
}
/**
* Determine whether this character can be printed. We cannot use
* the library functions here, because we need to test our own
* keycodes. */
bool SCA_KeyboardSensor::IsPrintable(int keyIndex)
{
/* only print
* - numerals: KX_ZEROKEY to KX_NINEKEY
* - alphas: KX_AKEY to KX_ZKEY.
* - specials: KX_RETKEY, KX_PADASTERKEY, KX_PADCOMMAKEY to KX_PERIODKEY,
* KX_TABKEY , KX_SEMICOLONKEY to KX_RIGHTBRACKETKEY,
* KX_PAD2 to KX_PADPLUSKEY
* - delete and backspace: also printable in the sense that they modify
* the string
* - retkey: should this be printable?
* - virgule: prints a space... don't know which key that's supposed
* to be...
*/
if ( ((keyIndex >= SCA_IInputDevice::KX_ZEROKEY)
&& (keyIndex <= SCA_IInputDevice::KX_NINEKEY))
|| ((keyIndex >= SCA_IInputDevice::KX_AKEY)
&& (keyIndex <= SCA_IInputDevice::KX_ZKEY))
|| (keyIndex == SCA_IInputDevice::KX_SPACEKEY)
/* || (keyIndex == KX_RETKEY) */
|| (keyIndex == SCA_IInputDevice::KX_PADASTERKEY)
|| (keyIndex == SCA_IInputDevice::KX_TABKEY)
|| ((keyIndex >= SCA_IInputDevice::KX_COMMAKEY)
&& (keyIndex <= SCA_IInputDevice::KX_PERIODKEY))
|| ((keyIndex >= SCA_IInputDevice::KX_SEMICOLONKEY)
&& (keyIndex <= SCA_IInputDevice::KX_RIGHTBRACKETKEY))
|| ((keyIndex >= SCA_IInputDevice::KX_PAD2)
&& (keyIndex <= SCA_IInputDevice::KX_PADPLUSKEY))
|| (keyIndex == SCA_IInputDevice::KX_DELKEY)
|| (keyIndex == SCA_IInputDevice::KX_BACKSPACEKEY)
)
{
return true;
} else {
return false;
}
}
// this code looks ugly, please use an ordinary hashtable
char SCA_KeyboardSensor::ToCharacter(int keyIndex, bool shifted)
{
/* numerals */
if ( (keyIndex >= SCA_IInputDevice::KX_ZEROKEY)
&& (keyIndex <= SCA_IInputDevice::KX_NINEKEY) ) {
if (shifted) {
char numshift[] = ")!@#$%^&*(";
return numshift[keyIndex - '0'];
} else {
return keyIndex - SCA_IInputDevice::KX_ZEROKEY + '0';
}
}
/* letters... always lowercase... is that desirable? */
if ( (keyIndex >= SCA_IInputDevice::KX_AKEY)
&& (keyIndex <= SCA_IInputDevice::KX_ZKEY) ) {
if (shifted) {
return keyIndex - SCA_IInputDevice::KX_AKEY + 'A';
} else {
return keyIndex - SCA_IInputDevice::KX_AKEY + 'a';
}
}
if (keyIndex == SCA_IInputDevice::KX_SPACEKEY) {
return ' ';
}
/* || (keyIndex == SCA_IInputDevice::KX_RETKEY) */
if (keyIndex == SCA_IInputDevice::KX_PADASTERKEY) {
return '*';
}
if (keyIndex == SCA_IInputDevice::KX_TABKEY) {
return '\t';
}
/* comma to period */
char commatoperiod[] = ",-.";
char commatoperiodshifted[] = "<_>";
if (keyIndex == SCA_IInputDevice::KX_COMMAKEY) {
if (shifted) {
return commatoperiodshifted[0];
} else {
return commatoperiod[0];
}
}
if (keyIndex == SCA_IInputDevice::KX_MINUSKEY) {
if (shifted) {
return commatoperiodshifted[1];
} else {
return commatoperiod[1];
}
}
if (keyIndex == SCA_IInputDevice::KX_PERIODKEY) {
if (shifted) {
return commatoperiodshifted[2];
} else {
return commatoperiod[2];
}
}
/* semicolon to rightbracket */
char semicolontorightbracket[] = ";\'` /\\=[]";
char semicolontorightbracketshifted[] = ":\"~ \?|+{}";
if ((keyIndex >= SCA_IInputDevice::KX_SEMICOLONKEY)
&& (keyIndex <= SCA_IInputDevice::KX_RIGHTBRACKETKEY)) {
if (shifted) {
return semicolontorightbracketshifted[keyIndex - SCA_IInputDevice::KX_SEMICOLONKEY];
} else {
return semicolontorightbracket[keyIndex - SCA_IInputDevice::KX_SEMICOLONKEY];
}
}
/* keypad2 to padplus */
char pad2topadplus[] = "246813579. 0- +";
if ((keyIndex >= SCA_IInputDevice::KX_PAD2)
&& (keyIndex <= SCA_IInputDevice::KX_PADPLUSKEY)) {
return pad2topadplus[keyIndex - SCA_IInputDevice::KX_PAD2];
}
return '!';
}
/**
* Tests whether this is a delete key.
*/
bool SCA_KeyboardSensor::IsDelete(int keyIndex)
{
if ( (keyIndex == SCA_IInputDevice::KX_DELKEY)
|| (keyIndex == SCA_IInputDevice::KX_BACKSPACEKEY) ) {
return true;
} else {
return false;
}
}
/**
* Tests whether shift is pressed
*/
bool SCA_KeyboardSensor::IsShifted(void)
{
SCA_IInputDevice* inputdev = m_pKeyboardMgr->GetInputDevice();
if ( (inputdev->GetEventValue(SCA_IInputDevice::KX_RIGHTSHIFTKEY).m_status
== SCA_InputEvent::KX_ACTIVE)
|| (inputdev->GetEventValue(SCA_IInputDevice::KX_RIGHTSHIFTKEY).m_status
== SCA_InputEvent::KX_JUSTACTIVATED)
|| (inputdev->GetEventValue(SCA_IInputDevice::KX_LEFTSHIFTKEY).m_status
== SCA_InputEvent::KX_ACTIVE)
|| (inputdev->GetEventValue(SCA_IInputDevice::KX_LEFTSHIFTKEY).m_status
== SCA_InputEvent::KX_JUSTACTIVATED)
) {
return true;
} else {
return false;
}
}
void SCA_KeyboardSensor::LogKeystrokes(void)
{
SCA_IInputDevice* inputdev = m_pKeyboardMgr->GetInputDevice();
int num = inputdev->GetNumActiveEvents();
/* weird loop, this one... */
if (num > 0)
{
int index = 0;
/* Check on all keys whether they were pushed. This does not
* untangle the ordering, so don't type too fast :) */
for (int i=SCA_IInputDevice::KX_BEGINKEY ; i< SCA_IInputDevice::KX_ENDKEY;i++)
{
const SCA_InputEvent & inevent = inputdev->GetEventValue((SCA_IInputDevice::KX_EnumInputs) i);
if (inevent.m_status == SCA_InputEvent::KX_JUSTACTIVATED) //NO_INPUTSTATUS)
{
if (index < num)
{
AddToTargetProp(i);
index++;
}
}
}
}
}
/* ------------------------------------------------------------------------- */
/* Python functions : specific */
/* ------------------------------------------------------------------------- */
PyObject* SCA_KeyboardSensor::PySetAllMode(PyObject* self,
PyObject* args,
PyObject* kwds)
{
bool allkeys;
if (!PyArg_ParseTuple(args, "i", &allkeys))
{
return NULL;
}
m_bAllKeys = allkeys;
Py_Return
}
PyObject* SCA_KeyboardSensor::sPySetAllMode(PyObject* self,
PyObject* args,
PyObject* kwds)
{
// printf("sPyIsPositive\n");
return ((SCA_KeyboardSensor*) self)->PyIsPositive(self, args, kwds);
}
/** 1. GetKey : check which key this sensor looks at */
char SCA_KeyboardSensor::GetKey_doc[] =
"getKey()\n"
"\tReturn the code of the key this sensor is listening to.\n" ;
PyObject* SCA_KeyboardSensor::PyGetKey(PyObject* self, PyObject* args, PyObject* kwds)
{
return PyInt_FromLong(m_hotkey);
}
/** 2. SetKey: change the key to look at */
char SCA_KeyboardSensor::SetKey_doc[] =
"setKey(keycode)\n"
"\t- keycode: any code from GameKeys\n"
"\tSet the key this sensor should listen to.\n" ;
PyObject* SCA_KeyboardSensor::PySetKey(PyObject* self, PyObject* args, PyObject* kwds)
{
int keyCode;
if(!PyArg_ParseTuple(args, "i", &keyCode)) {
return NULL;
}
/* Since we have symbolic constants for this in Python, we don't guard */
/* anything. It's up to the user to provide a sensible number. */
m_hotkey = keyCode;
Py_Return;
}
/** 3. GetHold1 : set the first bucky bit */
char SCA_KeyboardSensor::GetHold1_doc[] =
"getHold1()\n"
"\tReturn the code of the first key modifier to the key this \n"
"\tsensor is listening to.\n" ;
PyObject* SCA_KeyboardSensor::PyGetHold1(PyObject* self, PyObject* args, PyObject* kwds)
{
return PyInt_FromLong(m_qual);
}
/** 4. SetHold1: change the first bucky bit */
char SCA_KeyboardSensor::SetHold1_doc[] =
"setHold1(keycode)\n"
"\t- keycode: any code from GameKeys\n"
"\tSet the first modifier to the key this sensor should listen to.\n" ;
PyObject* SCA_KeyboardSensor::PySetHold1(PyObject* self, PyObject* args, PyObject* kwds)
{
int keyCode;
if(!PyArg_ParseTuple(args, "i", &keyCode)) {
return NULL;
}
/* Since we have symbolic constants for this in Python, we don't guard */
/* anything. It's up to the user to provide a sensible number. */
m_qual = keyCode;
Py_Return;
}
/** 5. GetHold2 : get the second bucky bit */
char SCA_KeyboardSensor::GetHold2_doc[] =
"getHold2()\n"
"\tReturn the code of the second key modifier to the key this \n"
"\tsensor is listening to.\n" ;
PyObject* SCA_KeyboardSensor::PyGetHold2(PyObject* self, PyObject* args, PyObject* kwds)
{
return PyInt_FromLong(m_qual2);
}
/** 6. SetHold2: change the second bucky bit */
char SCA_KeyboardSensor::SetHold2_doc[] =
"setHold2(keycode)\n"
"\t- keycode: any code from GameKeys\n"
"\tSet the first modifier to the key this sensor should listen to.\n" ;
PyObject* SCA_KeyboardSensor::PySetHold2(PyObject* self, PyObject* args, PyObject* kwds)
{
int keyCode;
if(!PyArg_ParseTuple(args, "i", &keyCode)) {
return NULL;
}
/* Since we have symbolic constants for this in Python, we don't guard */
/* anything. It's up to the user to provide a sensible number. */
m_qual2 = keyCode;
Py_Return;
}
char SCA_KeyboardSensor::GetPressedKeys_doc[] =
"getPressedKeys()\n"
"\tGet a list of pressed keys that have either been pressed, or just released this frame.\n" ;
PyObject* SCA_KeyboardSensor::PyGetPressedKeys(PyObject* self, PyObject* args, PyObject* kwds)
{
SCA_IInputDevice* inputdev = m_pKeyboardMgr->GetInputDevice();
int num = inputdev->GetNumJustEvents();
PyObject* resultlist = PyList_New(num);
if (num > 0)
{
int index = 0;
for (int i=SCA_IInputDevice::KX_BEGINKEY ; i< SCA_IInputDevice::KX_ENDKEY;i++)
{
const SCA_InputEvent & inevent = inputdev->GetEventValue((SCA_IInputDevice::KX_EnumInputs) i);
if ((inevent.m_status == SCA_InputEvent::KX_JUSTACTIVATED)
|| (inevent.m_status == SCA_InputEvent::KX_JUSTRELEASED))
{
if (index < num)
{
PyObject* keypair = PyList_New(2);
PyList_SetItem(keypair,0,PyInt_FromLong(i));
PyList_SetItem(keypair,1,PyInt_FromLong(inevent.m_status));
PyList_SetItem(resultlist,index,keypair);
index++;
}
}
}
if (index>0) return resultlist;
}
Py_Return;
}
char SCA_KeyboardSensor::GetCurrentlyPressedKeys_doc[] =
"getCurrentlyPressedKeys()\n"
"\tGet a list of keys that are currently pressed.\n" ;
PyObject* SCA_KeyboardSensor::PyGetCurrentlyPressedKeys(PyObject* self, PyObject* args, PyObject* kwds)
{
SCA_IInputDevice* inputdev = m_pKeyboardMgr->GetInputDevice();
int num = inputdev->GetNumActiveEvents();
PyObject* resultlist = PyList_New(num);
if (num > 0)
{
int index = 0;
for (int i=SCA_IInputDevice::KX_BEGINKEY ; i< SCA_IInputDevice::KX_ENDKEY;i++)
{
const SCA_InputEvent & inevent = inputdev->GetEventValue((SCA_IInputDevice::KX_EnumInputs) i);
if ( (inevent.m_status == SCA_InputEvent::KX_ACTIVE)
|| (inevent.m_status == SCA_InputEvent::KX_JUSTACTIVATED))
{
if (index < num)
{
PyObject* keypair = PyList_New(2);
PyList_SetItem(keypair,0,PyInt_FromLong(i));
PyList_SetItem(keypair,1,PyInt_FromLong(inevent.m_status));
PyList_SetItem(resultlist,index,keypair);
index++;
}
}
}
/* why?*/
if (index > 0) return resultlist;
}
Py_Return;
}
/* ------------------------------------------------------------------------- */
/* Python functions : integration hooks */
/* ------------------------------------------------------------------------- */
PyTypeObject SCA_KeyboardSensor::Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
"SCA_KeyboardSensor",
sizeof(SCA_KeyboardSensor),
0,
PyDestructor,
0,
__getattr,
__setattr,
0, //&MyPyCompare,
__repr,
0, //&cvalue_as_number,
0,
0,
0,
0
};
PyParentObject SCA_KeyboardSensor::Parents[] = {
&SCA_KeyboardSensor::Type,
&SCA_ISensor::Type,
&SCA_ILogicBrick::Type,
&CValue::Type,
NULL
};
PyMethodDef SCA_KeyboardSensor::Methods[] = {
{"getKey", (PyCFunction) SCA_KeyboardSensor::sPyGetKey, METH_VARARGS, GetKey_doc},
{"setKey", (PyCFunction) SCA_KeyboardSensor::sPySetKey, METH_VARARGS, SetKey_doc},
{"getHold1", (PyCFunction) SCA_KeyboardSensor::sPyGetHold1, METH_VARARGS, GetHold1_doc},
{"setHold1", (PyCFunction) SCA_KeyboardSensor::sPySetHold1, METH_VARARGS, SetHold1_doc},
{"getHold2", (PyCFunction) SCA_KeyboardSensor::sPyGetHold2, METH_VARARGS, GetHold2_doc},
{"setHold2", (PyCFunction) SCA_KeyboardSensor::sPySetHold2, METH_VARARGS, SetHold2_doc},
// {"getUseAllKeys", (PyCFunction) SCA_KeyboardSensor::sPyGetUseAllKeys, METH_VARARGS, GetUseAllKeys_doc},
// {"setUseAllKeys", (PyCFunction) SCA_KeyboardSensor::sPySetUseAllKeys, METH_VARARGS, SetUseAllKeys_doc},
{"getPressedKeys", (PyCFunction) SCA_KeyboardSensor::sPyGetPressedKeys, METH_VARARGS, GetPressedKeys_doc},
{"getCurrentlyPressedKeys", (PyCFunction) SCA_KeyboardSensor::sPyGetCurrentlyPressedKeys, METH_VARARGS, GetCurrentlyPressedKeys_doc},
// {"getKeyEvents", (PyCFunction) SCA_KeyboardSensor::sPyGetKeyEvents, METH_VARARGS, GetKeyEvents_doc},
{NULL,NULL} //Sentinel
};
PyObject*
SCA_KeyboardSensor::_getattr(char* attr)
{
_getattr_up(SCA_ISensor);
}