OIS-0.05/0000755000175000017500000000000011254006577012303 5ustar slanningslanningOIS-0.05/typemap0000644000175000017500000000527511253004757013713 0ustar slanningslanningTYPEMAP Axis * O_AXIS const Axis * O_AXIS EventArg * O_EVENTARG Exception * O_EXCEPTION InputManager * O_INPUTMANAGER JoyStick * O_JOYSTICK JoyStickEvent * O_JOYSTICKEVENT JoyStickListener * O_JOYSTICKLISTENER JoyStickState * O_JOYSTICKSTATE Keyboard * O_KEYBOARD KeyEvent * O_KEYEVENT KeyListener * O_KEYLISTENER Mouse * O_MOUSE MouseEvent * O_MOUSEEVENT MouseListener * O_MOUSELISTENER MouseState * O_MOUSESTATE const MouseState * O_MOUSESTATE Object * O_OBJECT string STRING uint16 T_UV OIS_ERROR T_IV Type T_IV ComponentType T_IV KeyCode T_IV TextTranslationMode T_IV Modifier T_IV INPUT STRING char * xstmpchr_$var = (char *) SvPV_nolen($arg); $var = xstmpchr_$var; O_AXIS TMOIS_IN($arg, $var, $type, $Package, $func_name, Axis) O_EVENTARG TMOIS_IN($arg, $var, $type, $Package, $func_name, EventArg) O_EXCEPTION TMOIS_IN($arg, $var, $type, $Package, $func_name, Exception) O_INPUTMANAGER TMOIS_IN($arg, $var, $type, $Package, $func_name, InputManager) O_JOYSTICK TMOIS_IN($arg, $var, $type, $Package, $func_name, JoyStick) O_JOYSTICKEVENT TMOIS_IN($arg, $var, $type, $Package, $func_name, JoyStickEvent) O_JOYSTICKLISTENER TMOIS_IN($arg, $var, $type, $Package, $func_name, JoyStickListener) O_JOYSTICKSTATE TMOIS_IN($arg, $var, $type, $Package, $func_name, JoyStickState) O_KEYBOARD TMOIS_IN($arg, $var, $type, $Package, $func_name, Keyboard) O_KEYEVENT TMOIS_IN($arg, $var, $type, $Package, $func_name, KeyEvent) O_KEYLISTENER TMOIS_IN($arg, $var, $type, $Package, $func_name, KeyListener) O_MOUSE TMOIS_IN($arg, $var, $type, $Package, $func_name, Mouse) O_MOUSEEVENT TMOIS_IN($arg, $var, $type, $Package, $func_name, MouseEvent) O_MOUSELISTENER TMOIS_IN($arg, $var, $type, $Package, $func_name, MouseListener) O_MOUSESTATE TMOIS_IN($arg, $var, $type, $Package, $func_name, MouseState) O_OBJECT TMOIS_IN($arg, $var, $type, $Package, $func_name, Object) OUTPUT STRING sv_setpvn((SV*)$arg, (char *) ($var.data()), ($var.size())); O_AXIS TMOIS_OUT($arg, $var, Axis) O_EVENTARG TMOIS_OUT($arg, $var, EventArg) O_EXCEPTION TMOIS_OUT($arg, $var, Exception) O_INPUTMANAGER TMOIS_OUT($arg, $var, InputManager) O_JOYSTICK TMOIS_OUT($arg, $var, JoyStick) O_JOYSTICKEVENT TMOIS_OUT($arg, $var, JoyStickEvent) O_JOYSTICKLISTENER TMOIS_OUT($arg, $var, JoyStickListener) O_JOYSTICKSTATE TMOIS_OUT($arg, $var, JoyStickState) O_KEYBOARD TMOIS_OUT($arg, $var, Keyboard) O_KEYEVENT TMOIS_OUT($arg, $var, KeyEvent) O_KEYLISTENER TMOIS_OUT($arg, $var, KeyListener) O_MOUSE TMOIS_OUT($arg, $var, Mouse) O_MOUSEEVENT TMOIS_OUT($arg, $var, MouseEvent) O_MOUSELISTENER TMOIS_OUT($arg, $var, MouseListener) O_MOUSESTATE TMOIS_OUT($arg, $var, MouseState) O_OBJECT TMOIS_OUT($arg, $var, Object) OIS-0.05/xs/0000755000175000017500000000000011254006577012735 5ustar slanningslanningOIS-0.05/xs/JoyStick.xs-disabled0000644000175000017500000000173210665066146016623 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::JoyStick ## This is a bit different than the C++ API, ## but not too much. You create a Perl class that ## implements the OIS::KeyListener interface (two methods), ## then pass an object of that class here. ## Behind the scenes, there is a C++ class PerlOISKeyListener ## that handles calling your Perl code from the C++ callback. ## (perlKeyListener below is instantiated "globally" in OIS.xs.) void JoyStick::setEventCallback(joyListener) SV * joyListener CODE: poisJoyStickListener.setPerlObject(joyListener); THIS->setEventCallback(&poisJoyStickListener); ## hmm, not sure why you would want to get this... JoyStickListener * JoyStick::getEventCallback() short JoyStick::buttons() short JoyStick::axes() short JoyStick::hats() JoyStickState * JoyStick::getJoyStickState() PREINIT: JoyStickState state; CODE: // xxx: I doubt this works... state = THIS->getJoyStickState(); RETVAL = &state; OUTPUT: RETVAL OIS-0.05/xs/JoyStickState.xs-disabled0000644000175000017500000000075311253007074017613 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::JoyStickState int JoyStickState::buttonDown(button) int button ## not sure how useful this is, but there you go ## (I think these are just not completely implemented in OIS yet) int JoyStickState::buttons() CODE: RETVAL = (*THIS).buttons; OUTPUT: RETVAL ## I think Axis, Pov, and Slider must not be completely ## implemented in OIS yet; the only way these are exposed ## are through member variables. ## So...I have not wrapped those yet. OIS-0.05/xs/Object.xs0000644000175000017500000000050610664560017014516 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::Object Type Object::type() string Object::vendor() bool Object::buffered() void Object::setBuffered(buffered) bool buffered InputManager * Object::getCreator() void Object::capture() int Object::getID() ## xxx: not yet wrapped: ## Interface * queryInterface(Interface::IType type) OIS-0.05/xs/MouseEvent.xs0000644000175000017500000000043410725106130015370 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::MouseEvent ## These are "public attributes", not methods. const MouseState * MouseEvent::state() CODE: // MouseState *state = new MouseState; // *state = THIS->state; // RETVAL = state; RETVAL = &(THIS->state); OUTPUT: RETVAL OIS-0.05/xs/MouseListener.xs0000644000175000017500000000005610664551454016113 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::MouseListener OIS-0.05/xs/KeyEvent.xs0000644000175000017500000000037410666517634015056 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::KeyEvent ## These are "public attributes", not methods. int KeyEvent::key() CODE: RETVAL = (*THIS).key; OUTPUT: RETVAL unsigned int KeyEvent::text() CODE: RETVAL = (*THIS).text; OUTPUT: RETVAL OIS-0.05/xs/Mouse.xs0000644000175000017500000000317110725106030014366 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::Mouse ## This is a bit different than the C++ API, ## but not too much. You create a Perl class that ## implements the OIS::KeyListener interface (two methods), ## then pass an object of that class here. ## Behind the scenes, there is a C++ class PerlOISKeyListener ## that handles calling your Perl code from the C++ callback. ## (perlKeyListener below is instantiated "globally" in OIS.xs.) void Mouse::setEventCallback(mouseListener) SV * mouseListener CODE: poisMouseListener.setPerlObject(mouseListener); THIS->setEventCallback(&poisMouseListener); ## hmm, not sure why you would want to get this... MouseListener * Mouse::getEventCallback() const MouseState * Mouse::getMouseState() CODE: // MouseState *state = new MouseState; // *state = THIS->getMouseState(); // RETVAL = state; // This is how you do it?!? RETVAL = &(THIS->getMouseState()); OUTPUT: RETVAL ## MouseButtonID enum static int Mouse::MB_Left() ALIAS: OIS::Mouse::MB_Right = 1 OIS::Mouse::MB_Middle = 2 OIS::Mouse::MB_Button3 = 3 OIS::Mouse::MB_Button4 = 4 OIS::Mouse::MB_Button5 = 5 OIS::Mouse::MB_Button6 = 6 OIS::Mouse::MB_Button7 = 7 CODE: switch (ix) { case 0: RETVAL = OIS::MB_Left; break; case 1: RETVAL = OIS::MB_Right; break; case 2: RETVAL = OIS::MB_Middle; break; case 3: RETVAL = OIS::MB_Button3; break; case 4: RETVAL = OIS::MB_Button4; break; case 5: RETVAL = OIS::MB_Button5; break; case 6: RETVAL = OIS::MB_Button6; break; case 7: RETVAL = OIS::MB_Button7; break; } OUTPUT: RETVAL OIS-0.05/xs/EventArg.xs0000644000175000017500000000005110664552227015022 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::EventArg OIS-0.05/xs/KeyListener.xs0000644000175000017500000000005410664551603015545 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::KeyListener OIS-0.05/xs/JoyStickEvent.xs-disabled0000644000175000017500000000005610664553023017615 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::JoyStickEvent OIS-0.05/xs/JoyStickListener.xs-disabled0000644000175000017500000000006210665011774020321 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::JoyStickListener OIS-0.05/xs/Axis.xs0000644000175000017500000000046610666403257014225 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::Axis ## These are "public attributes", not methods. int Axis::abs() CODE: RETVAL = (*THIS).abs; OUTPUT: RETVAL int Axis::rel() CODE: RETVAL = (*THIS).rel; OUTPUT: RETVAL bool Axis::absOnly() CODE: RETVAL = (*THIS).absOnly; OUTPUT: RETVAL OIS-0.05/xs/Keyboard.xs0000644000175000017500000003261610666557445015074 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::Keyboard bool Keyboard::isKeyDown(key) KeyCode key ## This is a bit different than the C++ API, ## but not too much. You create a Perl class that ## implements the OIS::KeyListener interface (two methods), ## then pass an object of that class here. ## Behind the scenes, there is a C++ class PerlOISKeyListener ## that handles calling your Perl code from the C++ callback. ## (perlKeyListener below is instantiated "globally" in OIS.xs.) void Keyboard::setEventCallback(keyListener) SV * keyListener CODE: poisKeyListener.setPerlObject(keyListener); THIS->setEventCallback(&poisKeyListener); ## hmm, not sure why you would want to get this... KeyListener * Keyboard::getEventCallback() void Keyboard::setTextTranslation(mode) int mode C_ARGS: (OIS::Keyboard::TextTranslationMode)mode int Keyboard::getTextTranslation() string Keyboard::getAsString(kc) KeyCode kc bool Keyboard::isModifierDown(mod) int mod C_ARGS: (OIS::Keyboard::Modifier)mod ## this is not wrapped: ## void OIS::Keyboard::copyKeyStates(char keys[256]) ## TextTranslationMode enum static int Keyboard::Off() ALIAS: OIS::Keyboard::Unicode = 1 OIS::Keyboard::Ascii = 2 CODE: switch (ix) { case 0: RETVAL = OIS::Keyboard::Off; break; case 1: RETVAL = OIS::Keyboard::Unicode; break; case 2: RETVAL = OIS::Keyboard::Ascii; break; } OUTPUT: RETVAL ## Modifier enum static int Keyboard::Shift() ALIAS: OIS::Keyboard::Ctrl = 1 OIS::Keyboard::Alt = 2 CODE: switch (ix) { case 0: RETVAL = OIS::Keyboard::Shift; break; case 1: RETVAL = OIS::Keyboard::Ctrl; break; case 2: RETVAL = OIS::Keyboard::Alt; break; } OUTPUT: RETVAL ## xxx: surely there is a better way than this... ## (technically, these are in OIS namespace, not OIS::Keyboard) ## KeyCode enum static int Keyboard::KC_UNASSIGNED() ALIAS: OIS::Keyboard::KC_ESCAPE = 1 OIS::Keyboard::KC_1 = 2 OIS::Keyboard::KC_2 = 3 OIS::Keyboard::KC_3 = 4 OIS::Keyboard::KC_4 = 5 OIS::Keyboard::KC_5 = 6 OIS::Keyboard::KC_6 = 7 OIS::Keyboard::KC_7 = 8 OIS::Keyboard::KC_8 = 9 OIS::Keyboard::KC_9 = 10 OIS::Keyboard::KC_0 = 11 OIS::Keyboard::KC_MINUS = 12 OIS::Keyboard::KC_EQUALS = 13 OIS::Keyboard::KC_BACK = 14 OIS::Keyboard::KC_TAB = 15 OIS::Keyboard::KC_Q = 16 OIS::Keyboard::KC_W = 17 OIS::Keyboard::KC_E = 18 OIS::Keyboard::KC_R = 19 OIS::Keyboard::KC_T = 20 OIS::Keyboard::KC_Y = 21 OIS::Keyboard::KC_U = 22 OIS::Keyboard::KC_I = 23 OIS::Keyboard::KC_O = 24 OIS::Keyboard::KC_P = 25 OIS::Keyboard::KC_LBRACKET = 26 OIS::Keyboard::KC_RBRACKET = 27 OIS::Keyboard::KC_RETURN = 28 OIS::Keyboard::KC_LCONTROL = 29 OIS::Keyboard::KC_A = 30 OIS::Keyboard::KC_S = 31 OIS::Keyboard::KC_D = 32 OIS::Keyboard::KC_F = 33 OIS::Keyboard::KC_G = 34 OIS::Keyboard::KC_H = 35 OIS::Keyboard::KC_J = 36 OIS::Keyboard::KC_K = 37 OIS::Keyboard::KC_L = 38 OIS::Keyboard::KC_SEMICOLON = 39 OIS::Keyboard::KC_APOSTROPHE = 40 OIS::Keyboard::KC_GRAVE = 41 OIS::Keyboard::KC_LSHIFT = 42 OIS::Keyboard::KC_BACKSLASH = 43 OIS::Keyboard::KC_Z = 44 OIS::Keyboard::KC_X = 45 OIS::Keyboard::KC_C = 46 OIS::Keyboard::KC_V = 47 OIS::Keyboard::KC_B = 48 OIS::Keyboard::KC_N = 49 OIS::Keyboard::KC_M = 50 OIS::Keyboard::KC_COMMA = 51 OIS::Keyboard::KC_PERIOD = 52 OIS::Keyboard::KC_SLASH = 53 OIS::Keyboard::KC_RSHIFT = 54 OIS::Keyboard::KC_MULTIPLY = 55 OIS::Keyboard::KC_LMENU = 56 OIS::Keyboard::KC_SPACE = 57 OIS::Keyboard::KC_CAPITAL = 58 OIS::Keyboard::KC_F1 = 59 OIS::Keyboard::KC_F2 = 60 OIS::Keyboard::KC_F3 = 61 OIS::Keyboard::KC_F4 = 62 OIS::Keyboard::KC_F5 = 63 OIS::Keyboard::KC_F6 = 64 OIS::Keyboard::KC_F7 = 65 OIS::Keyboard::KC_F8 = 66 OIS::Keyboard::KC_F9 = 67 OIS::Keyboard::KC_F10 = 68 OIS::Keyboard::KC_NUMLOCK = 69 OIS::Keyboard::KC_SCROLL = 70 OIS::Keyboard::KC_NUMPAD7 = 71 OIS::Keyboard::KC_NUMPAD8 = 72 OIS::Keyboard::KC_NUMPAD9 = 73 OIS::Keyboard::KC_SUBTRACT = 74 OIS::Keyboard::KC_NUMPAD4 = 75 OIS::Keyboard::KC_NUMPAD5 = 76 OIS::Keyboard::KC_NUMPAD6 = 77 OIS::Keyboard::KC_ADD = 78 OIS::Keyboard::KC_NUMPAD1 = 79 OIS::Keyboard::KC_NUMPAD2 = 80 OIS::Keyboard::KC_NUMPAD3 = 81 OIS::Keyboard::KC_NUMPAD0 = 82 OIS::Keyboard::KC_DECIMAL = 83 OIS::Keyboard::KC_OEM_102 = 84 OIS::Keyboard::KC_F11 = 85 OIS::Keyboard::KC_F12 = 86 OIS::Keyboard::KC_F13 = 87 OIS::Keyboard::KC_F14 = 88 OIS::Keyboard::KC_F15 = 89 OIS::Keyboard::KC_KANA = 90 OIS::Keyboard::KC_ABNT_C1 = 91 OIS::Keyboard::KC_CONVERT = 92 OIS::Keyboard::KC_NOCONVERT = 93 OIS::Keyboard::KC_YEN = 94 OIS::Keyboard::KC_ABNT_C2 = 95 OIS::Keyboard::KC_NUMPADEQUALS = 96 OIS::Keyboard::KC_PREVTRACK = 97 OIS::Keyboard::KC_AT = 98 OIS::Keyboard::KC_COLON = 99 OIS::Keyboard::KC_UNDERLINE = 100 OIS::Keyboard::KC_KANJI = 101 OIS::Keyboard::KC_STOP = 102 OIS::Keyboard::KC_AX = 103 OIS::Keyboard::KC_UNLABELED = 104 OIS::Keyboard::KC_NEXTTRACK = 105 OIS::Keyboard::KC_NUMPADENTER = 106 OIS::Keyboard::KC_RCONTROL = 107 OIS::Keyboard::KC_MUTE = 108 OIS::Keyboard::KC_CALCULATOR = 109 OIS::Keyboard::KC_PLAYPAUSE = 110 OIS::Keyboard::KC_MEDIASTOP = 111 OIS::Keyboard::KC_VOLUMEDOWN = 112 OIS::Keyboard::KC_VOLUMEUP = 113 OIS::Keyboard::KC_WEBHOME = 114 OIS::Keyboard::KC_NUMPADCOMMA = 115 OIS::Keyboard::KC_DIVIDE = 116 OIS::Keyboard::KC_SYSRQ = 117 OIS::Keyboard::KC_RMENU = 118 OIS::Keyboard::KC_PAUSE = 119 OIS::Keyboard::KC_HOME = 120 OIS::Keyboard::KC_UP = 121 OIS::Keyboard::KC_PGUP = 122 OIS::Keyboard::KC_LEFT = 123 OIS::Keyboard::KC_RIGHT = 124 OIS::Keyboard::KC_END = 125 OIS::Keyboard::KC_DOWN = 126 OIS::Keyboard::KC_PGDOWN = 127 OIS::Keyboard::KC_INSERT = 128 OIS::Keyboard::KC_DELETE = 129 OIS::Keyboard::KC_LWIN = 130 OIS::Keyboard::KC_RWIN = 131 OIS::Keyboard::KC_APPS = 132 OIS::Keyboard::KC_POWER = 133 OIS::Keyboard::KC_SLEEP = 134 OIS::Keyboard::KC_WAKE = 135 OIS::Keyboard::KC_WEBSEARCH = 136 OIS::Keyboard::KC_WEBFAVORITES = 137 OIS::Keyboard::KC_WEBREFRESH = 138 OIS::Keyboard::KC_WEBSTOP = 139 OIS::Keyboard::KC_WEBFORWARD = 140 OIS::Keyboard::KC_WEBBACK = 141 OIS::Keyboard::KC_MYCOMPUTER = 142 OIS::Keyboard::KC_MAIL = 143 OIS::Keyboard::KC_MEDIASELECT = 144 CODE: switch (ix) { case 0: RETVAL = OIS::KC_UNASSIGNED; break; case 1: RETVAL = OIS::KC_ESCAPE; break; case 2: RETVAL = OIS::KC_1; break; case 3: RETVAL = OIS::KC_2; break; case 4: RETVAL = OIS::KC_3; break; case 5: RETVAL = OIS::KC_4; break; case 6: RETVAL = OIS::KC_5; break; case 7: RETVAL = OIS::KC_6; break; case 8: RETVAL = OIS::KC_7; break; case 9: RETVAL = OIS::KC_8; break; case 10: RETVAL = OIS::KC_9; break; case 11: RETVAL = OIS::KC_0; break; case 12: RETVAL = OIS::KC_MINUS; break; case 13: RETVAL = OIS::KC_EQUALS; break; case 14: RETVAL = OIS::KC_BACK; break; case 15: RETVAL = OIS::KC_TAB; break; case 16: RETVAL = OIS::KC_Q; break; case 17: RETVAL = OIS::KC_W; break; case 18: RETVAL = OIS::KC_E; break; case 19: RETVAL = OIS::KC_R; break; case 20: RETVAL = OIS::KC_T; break; case 21: RETVAL = OIS::KC_Y; break; case 22: RETVAL = OIS::KC_U; break; case 23: RETVAL = OIS::KC_I; break; case 24: RETVAL = OIS::KC_O; break; case 25: RETVAL = OIS::KC_P; break; case 26: RETVAL = OIS::KC_LBRACKET; break; case 27: RETVAL = OIS::KC_RBRACKET; break; case 28: RETVAL = OIS::KC_RETURN; break; case 29: RETVAL = OIS::KC_LCONTROL; break; case 30: RETVAL = OIS::KC_A; break; case 31: RETVAL = OIS::KC_S; break; case 32: RETVAL = OIS::KC_D; break; case 33: RETVAL = OIS::KC_F; break; case 34: RETVAL = OIS::KC_G; break; case 35: RETVAL = OIS::KC_H; break; case 36: RETVAL = OIS::KC_J; break; case 37: RETVAL = OIS::KC_K; break; case 38: RETVAL = OIS::KC_L; break; case 39: RETVAL = OIS::KC_SEMICOLON; break; case 40: RETVAL = OIS::KC_APOSTROPHE; break; case 41: RETVAL = OIS::KC_GRAVE; break; case 42: RETVAL = OIS::KC_LSHIFT; break; case 43: RETVAL = OIS::KC_BACKSLASH; break; case 44: RETVAL = OIS::KC_Z; break; case 45: RETVAL = OIS::KC_X; break; case 46: RETVAL = OIS::KC_C; break; case 47: RETVAL = OIS::KC_V; break; case 48: RETVAL = OIS::KC_B; break; case 49: RETVAL = OIS::KC_N; break; case 50: RETVAL = OIS::KC_M; break; case 51: RETVAL = OIS::KC_COMMA; break; case 52: RETVAL = OIS::KC_PERIOD; break; case 53: RETVAL = OIS::KC_SLASH; break; case 54: RETVAL = OIS::KC_RSHIFT; break; case 55: RETVAL = OIS::KC_MULTIPLY; break; case 56: RETVAL = OIS::KC_LMENU; break; case 57: RETVAL = OIS::KC_SPACE; break; case 58: RETVAL = OIS::KC_CAPITAL; break; case 59: RETVAL = OIS::KC_F1; break; case 60: RETVAL = OIS::KC_F2; break; case 61: RETVAL = OIS::KC_F3; break; case 62: RETVAL = OIS::KC_F4; break; case 63: RETVAL = OIS::KC_F5; break; case 64: RETVAL = OIS::KC_F6; break; case 65: RETVAL = OIS::KC_F7; break; case 66: RETVAL = OIS::KC_F8; break; case 67: RETVAL = OIS::KC_F9; break; case 68: RETVAL = OIS::KC_F10; break; case 69: RETVAL = OIS::KC_NUMLOCK; break; case 70: RETVAL = OIS::KC_SCROLL; break; case 71: RETVAL = OIS::KC_NUMPAD7; break; case 72: RETVAL = OIS::KC_NUMPAD8; break; case 73: RETVAL = OIS::KC_NUMPAD9; break; case 74: RETVAL = OIS::KC_SUBTRACT; break; case 75: RETVAL = OIS::KC_NUMPAD4; break; case 76: RETVAL = OIS::KC_NUMPAD5; break; case 77: RETVAL = OIS::KC_NUMPAD6; break; case 78: RETVAL = OIS::KC_ADD; break; case 79: RETVAL = OIS::KC_NUMPAD1; break; case 80: RETVAL = OIS::KC_NUMPAD2; break; case 81: RETVAL = OIS::KC_NUMPAD3; break; case 82: RETVAL = OIS::KC_NUMPAD0; break; case 83: RETVAL = OIS::KC_DECIMAL; break; case 84: RETVAL = OIS::KC_OEM_102; break; case 85: RETVAL = OIS::KC_F11; break; case 86: RETVAL = OIS::KC_F12; break; case 87: RETVAL = OIS::KC_F13; break; case 88: RETVAL = OIS::KC_F14; break; case 89: RETVAL = OIS::KC_F15; break; case 90: RETVAL = OIS::KC_KANA; break; case 91: RETVAL = OIS::KC_ABNT_C1; break; case 92: RETVAL = OIS::KC_CONVERT; break; case 93: RETVAL = OIS::KC_NOCONVERT; break; case 94: RETVAL = OIS::KC_YEN; break; case 95: RETVAL = OIS::KC_ABNT_C2; break; case 96: RETVAL = OIS::KC_NUMPADEQUALS; break; case 97: RETVAL = OIS::KC_PREVTRACK; break; case 98: RETVAL = OIS::KC_AT; break; case 99: RETVAL = OIS::KC_COLON; break; case 100: RETVAL = OIS::KC_UNDERLINE; break; case 101: RETVAL = OIS::KC_KANJI; break; case 102: RETVAL = OIS::KC_STOP; break; case 103: RETVAL = OIS::KC_AX; break; case 104: RETVAL = OIS::KC_UNLABELED; break; case 105: RETVAL = OIS::KC_NEXTTRACK; break; case 106: RETVAL = OIS::KC_NUMPADENTER; break; case 107: RETVAL = OIS::KC_RCONTROL; break; case 108: RETVAL = OIS::KC_MUTE; break; case 109: RETVAL = OIS::KC_CALCULATOR; break; case 110: RETVAL = OIS::KC_PLAYPAUSE; break; case 111: RETVAL = OIS::KC_MEDIASTOP; break; case 112: RETVAL = OIS::KC_VOLUMEDOWN; break; case 113: RETVAL = OIS::KC_VOLUMEUP; break; case 114: RETVAL = OIS::KC_WEBHOME; break; case 115: RETVAL = OIS::KC_NUMPADCOMMA; break; case 116: RETVAL = OIS::KC_DIVIDE; break; case 117: RETVAL = OIS::KC_SYSRQ; break; case 118: RETVAL = OIS::KC_RMENU; break; case 119: RETVAL = OIS::KC_PAUSE; break; case 120: RETVAL = OIS::KC_HOME; break; case 121: RETVAL = OIS::KC_UP; break; case 122: RETVAL = OIS::KC_PGUP; break; case 123: RETVAL = OIS::KC_LEFT; break; case 124: RETVAL = OIS::KC_RIGHT; break; case 125: RETVAL = OIS::KC_END; break; case 126: RETVAL = OIS::KC_DOWN; break; case 127: RETVAL = OIS::KC_PGDOWN; break; case 128: RETVAL = OIS::KC_INSERT; break; case 129: RETVAL = OIS::KC_DELETE; break; case 130: RETVAL = OIS::KC_LWIN; break; case 131: RETVAL = OIS::KC_RWIN; break; case 132: RETVAL = OIS::KC_APPS; break; case 133: RETVAL = OIS::KC_POWER; break; case 134: RETVAL = OIS::KC_SLEEP; break; case 135: RETVAL = OIS::KC_WAKE; break; case 136: RETVAL = OIS::KC_WEBSEARCH; break; case 137: RETVAL = OIS::KC_WEBFAVORITES; break; case 138: RETVAL = OIS::KC_WEBREFRESH; break; case 139: RETVAL = OIS::KC_WEBSTOP; break; case 140: RETVAL = OIS::KC_WEBFORWARD; break; case 141: RETVAL = OIS::KC_WEBBACK; break; case 142: RETVAL = OIS::KC_MYCOMPUTER; break; case 143: RETVAL = OIS::KC_MAIL; break; case 144: RETVAL = OIS::KC_MEDIASELECT; break; } OUTPUT: RETVAL OIS-0.05/xs/Exception.xs0000644000175000017500000000307710665012465015254 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::Exception Exception * Exception::new(err, str, line, file) OIS_ERROR err char * str int line char * file void Exception::DESTROY() ## these are "public attributes", not methods OIS_ERROR Exception::eType() CODE: RETVAL = (*THIS).eType; OUTPUT: RETVAL int Exception::eLine() CODE: RETVAL = (*THIS).eLine; OUTPUT: RETVAL const char * Exception::eFile() CODE: RETVAL = (*THIS).eFile; OUTPUT: RETVAL const char * Exception::eText() CODE: RETVAL = (*THIS).eText; OUTPUT: RETVAL ## technically these are in OIS namespace, not OIS::Exception ## OIS_ERROR enum static int Exception::E_InputDisconnected() ALIAS: OIS::Exception::E_InputDeviceNonExistant = 1 OIS::Exception::E_InputDeviceNotSupported = 2 OIS::Exception::E_DeviceFull = 3 OIS::Exception::E_NotSupported = 4 OIS::Exception::E_NotImplemented = 5 OIS::Exception::E_Duplicate = 6 OIS::Exception::E_InvalidParam = 7 OIS::Exception::E_General = 8 CODE: switch (ix) { case 0: RETVAL = OIS::E_InputDisconnected; break; case 1: RETVAL = OIS::E_InputDeviceNonExistant; break; case 2: RETVAL = OIS::E_InputDeviceNotSupported; break; case 3: RETVAL = OIS::E_DeviceFull; break; case 4: RETVAL = OIS::E_NotSupported; break; case 5: RETVAL = OIS::E_NotImplemented; break; case 6: RETVAL = OIS::E_Duplicate; break; case 7: RETVAL = OIS::E_InvalidParam; break; case 8: RETVAL = OIS::E_General; break; } OUTPUT: RETVAL OIS-0.05/xs/InputManager.xs0000644000175000017500000000665611253007701015705 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::InputManager ## This class is completely wrapped ## Note: there are two different versions of this, handled in OIS/InputManager.pm ## static InputManager* OIS::InputManager::createInputSystem(std::size_t winHandle) ## static InputManager* OIS::InputManager::createInputSystem(ParamList ¶mList) static InputManager * InputManager::createInputSystemPtr(winHandle) size_t winHandle CODE: RETVAL = OIS::InputManager::createInputSystem(winHandle); OUTPUT: RETVAL static InputManager * InputManager::createInputSystemPL(key, value) string key string value CODE: OIS::ParamList pl; pl.insert(std::make_pair(key, value)); RETVAL = OIS::InputManager::createInputSystem(pl); OUTPUT: RETVAL static void InputManager::destroyInputSystem(manager) InputManager * manager ## Note: there is only one method in the C++ API: ## Object* OIS::InputManager::createInputObject(Type iType, bool bufferMode) ## However, the Object* is really a Joystick*, Keyboard*, or Mouse*, ## which would normally be static_cast (etc.) in C++; ## dunno how to do that with Perl, so I made three separate methods. JoyStick * InputManager::createInputObjectJoyStick(bufferMode) bool bufferMode CODE: try { RETVAL = static_cast(THIS->createInputObject(OISJoyStick, bufferMode)); } catch (const OIS::Exception &e) { // XXX: not sure if this actually works.... SV *errsv = get_sv("@", TRUE); SV *exception_object = sv_newmortal(); TMOIS_OUT(exception_object, &e, Exception); sv_setsv(errsv, exception_object); croak(Nullch); } OUTPUT: RETVAL Keyboard * InputManager::createInputObjectKeyboard(bufferMode) bool bufferMode CODE: try { RETVAL = static_cast(THIS->createInputObject(OISKeyboard, bufferMode)); } catch (const OIS::Exception &e) { // XXX: not sure if this actually works.... SV *errsv = get_sv("@", TRUE); SV *exception_object = sv_newmortal(); TMOIS_OUT(exception_object, &e, Exception); sv_setsv(errsv, exception_object); croak(Nullch); } OUTPUT: RETVAL Mouse * InputManager::createInputObjectMouse(bufferMode) bool bufferMode CODE: try { RETVAL = static_cast(THIS->createInputObject(OISMouse, bufferMode)); } catch (const OIS::Exception &e) { // XXX: not sure if this actually works.... SV *errsv = get_sv("@", TRUE); SV *exception_object = sv_newmortal(); TMOIS_OUT(exception_object, &e, Exception); sv_setsv(errsv, exception_object); croak(Nullch); } OUTPUT: RETVAL void InputManager::destroyInputObject(obj) Object * obj static unsigned int InputManager::getVersionNumber() ## for some reason, this is no longer a class method... string InputManager::getVersionName() CODE: RETVAL = THIS->getVersionNumber(); OUTPUT: RETVAL ## const std::string& OIS::InputManager::inputSystemName string InputManager::inputSystemName() ## these used to be around in 1.0... int InputManager::numJoySticks() CODE: RETVAL = THIS->getNumberOfDevices(OIS::OISJoyStick); OUTPUT: RETVAL int InputManager::numMice() CODE: RETVAL = THIS->getNumberOfDevices(OIS::OISMouse); OUTPUT: RETVAL int InputManager::numKeyboards() CODE: RETVAL = THIS->getNumberOfDevices(OIS::OISKeyboard); OUTPUT: RETVAL OIS-0.05/xs/MouseState.xs0000644000175000017500000000164410725074502015402 0ustar slanningslanningMODULE = OIS PACKAGE = OIS::MouseState int MouseState::buttonDown(button) int button C_ARGS: (OIS::MouseButtonID)button ## These are "public attributes", not methods. ## Not sure how useful these are, but there you go... int MouseState::width() CODE: RETVAL = THIS->width; OUTPUT: RETVAL int MouseState::height() CODE: RETVAL = THIS->height; OUTPUT: RETVAL ## setWidth and setHeight are special for Perl void MouseState::setWidth(width) int width CODE: THIS->width = width; void MouseState::setHeight(height) int height CODE: THIS->height = height; int MouseState::buttons() CODE: RETVAL = THIS->buttons; OUTPUT: RETVAL Axis * MouseState::X() CODE: RETVAL = &(THIS->X); OUTPUT: RETVAL Axis * MouseState::Y() CODE: RETVAL = &(THIS->Y); OUTPUT: RETVAL Axis * MouseState::Z() CODE: RETVAL = &(THIS->Z); OUTPUT: RETVAL OIS-0.05/PerlOISJoyStickListener.cpp0000644000175000017500000000710610665513717017462 0ustar slanningslanning#include "PerlOISJoyStickListener.h" // class implementing OIS::JoyStickListener interface, // but using Perl callbacks PerlOISJoyStickListener::PerlOISJoyStickListener() : mPerlObj((SV *)NULL) { } PerlOISJoyStickListener::~PerlOISJoyStickListener() { if (mPerlObj != (SV *)NULL && SvREFCNT(mPerlObj)) { SvREFCNT_dec(mPerlObj); } mCanMap.clear(); } bool PerlOISJoyStickListener::buttonPressed(const OIS::JoyStickEvent &evt, int button) { return callPerlCallback("buttonPressed", evt, button); } bool PerlOISJoyStickListener::buttonReleased(const OIS::JoyStickEvent &evt, int button) { return callPerlCallback("buttonReleased", evt, button); } bool PerlOISJoyStickListener::axisMoved(const OIS::JoyStickEvent &evt, int axis) { return callPerlCallback("axisMoved", evt, axis); } bool PerlOISJoyStickListener::sliderMoved(const OIS::JoyStickEvent &evt, int slider) { return callPerlCallback("sliderMoved", evt, slider); } bool PerlOISJoyStickListener::povMoved(const OIS::JoyStickEvent &evt, int pov) { return callPerlCallback("povMoved", evt, pov); } void PerlOISJoyStickListener::setPerlObject(SV *pobj) { if (pobj != (SV *)NULL && sv_isobject(pobj)) { // copy the SV * if (mPerlObj == (SV *)NULL) { // first time, create new SV * mPerlObj = newSVsv(pobj); } else { // just overwrite existing SV * SvSetSV(mPerlObj, pobj); } } else { croak("Argument wasn't an object, so MouseListener wasn't set.\n"); } setCans(); } void PerlOISJoyStickListener::setCans() { mCanMap["buttonPressed"] = perlCallbackCan("buttonPressed"); mCanMap["buttonReleased"] = perlCallbackCan("buttonReleased"); mCanMap["axisMoved"] = perlCallbackCan("axisMoved"); mCanMap["sliderMoved"] = perlCallbackCan("sliderMoved"); mCanMap["povMoved"] = perlCallbackCan("povMoved"); } // check whether the Perl object has a callback method implemented // (is there a perl API method or something easier than this?) bool PerlOISJoyStickListener::perlCallbackCan(string const &cbmeth) { int count; SV *methret; bool can; dSP; ENTER; SAVETMPS; // call `can' to see if they implemented the callback PUSHMARK(SP); XPUSHs(mPerlObj); XPUSHs(sv_2mortal(newSVpv(cbmeth.c_str(), 0))); PUTBACK; count = call_method("can", G_SCALAR); SPAGAIN; if (count != 1) { croak("can (%s) didn't return a single value?", cbmeth.c_str()); } methret = POPs; PUTBACK; can = SvTRUE(methret); FREETMPS; LEAVE; return can; } bool PerlOISJoyStickListener::callPerlCallback(string const &cbmeth, const OIS::JoyStickEvent &evt, int thingID) { int count; SV *methret; bool retval = true; // default to returning true if (! (mCanMap[cbmeth] == true)) { // method not implemented, just return true return retval; } if (mPerlObj != (SV *)NULL) { // see `perldoc perlcall` dSP; ENTER; SAVETMPS; SV *joyevt = sv_newmortal(); TMOIS_OUT(joyevt, &evt, JoyStickEvent); // put C++ object into Perl PUSHMARK(SP); XPUSHs(mPerlObj); XPUSHs(joyevt); XPUSHs(sv_2mortal(newSViv(thingID))); PUTBACK; count = call_method(cbmeth.c_str(), G_SCALAR); SPAGAIN; if (count != 1) { croak("Callbacks must return a single (boolean) value"); } methret = POPs; PUTBACK; retval = SvTRUE(methret) ? true : false; FREETMPS; LEAVE; } return retval; } OIS-0.05/Makefile.PL0000644000175000017500000000621211254006370014245 0ustar slanningslanninguse ExtUtils::MakeMaker; use strict; use warnings; my $MIN_OIS_VERSION = '1.2.0'; main(); exit 0; sub main { my $fixed_args = fixed_args('OIS'); my $varied_args = varied_args(); my $gpp_warn_args = gpp_warn_args(); WriteMakefile(%$fixed_args, %$varied_args, %$gpp_warn_args); } sub fixed_args { my ($pkg) = @_; return { 'NAME' => $pkg, 'VERSION_FROM' => "$pkg.pm", 'ABSTRACT_FROM' => "$pkg.pm", 'AUTHOR' => 'Scott Lanning ', 'CC' => $ENV{'CXX'} || 'g++', 'LD' => '$(CC)', 'OBJECT' => '$(O_FILES)', 'XSOPT' => '-C++', 'TYPEMAPS' => ['perlobject.map'], }; } sub gpp_warn_args { # If you're using gcc >= 4.2, you'll probably # get warnings like this during `make` : # OIS.c:1835: warning: deprecated conversion from string constant to 'char*' # The C code generated by `xsubpp` uses literal strings (string constants) # as args to functions expecting char*. This disables those warnings.... if (my_compiler() eq 'g++') { my $str = `g++ -dumpversion`; unless ($?) { chomp $str; my ($v, $s) = split /\./, $str; if (($v == 4 && $s >= 2) || $v > 4) { return {'CCFLAGS' => '-Wno-write-strings'}; } } } # there will be no warnings, or we'll just tolerate them return {}; } sub my_compiler { return $ENV{'CXX'} || 'g++'; } sub varied_args { # Make sure libs are known by pkg-config my @errors = (); push @errors, check_pkg_config('OIS', $MIN_OIS_VERSION); if (@errors) { die(map { "$_$/" } @errors); } # Get include dirs and defines my @cflags = (); push @cflags, pkg_config('OIS', 'cflags'); # Get lib dirs my @libs = (); push @libs, pkg_config('OIS', 'libs'); return { 'PREREQ_PM' => { 'Scalar::Util' => 1.18, # bugfix for looks_like_number 'Test::More' => 0, }, 'INC' => join(' ', @cflags, '-I.'), 'LIBS' => join(' ', @libs), }; } sub check_pkg_config { my ($pkg, $required_version) = @_; my $pc = 'pkg-config'; my @errors = (); # Check that pkg-config is installed my $pcver = `$pc --version`; if ($pcver eq '') { push @errors, "$pc not found"; } else { # Check that pkg-config knows about the package my $pkgexists = `$pc --exists $pkg`; if ($?) { push @errors, "Package $pkg not found by $pc"; } else { # Check that the package is the right version my $pkgver = `$pc --atleast-version='$required_version' $pkg`; if ($?) { push @errors, "Package $pkg is not the right version (at least $required_version)"; } } } return @errors; } sub pkg_config { my ($pkg, $option) = @_; my $pc = 'pkg-config'; my $str = `$pc --$option $pkg`; if ($?) { die "$pc --$option $pkg: $str\n"; } else { chomp $str; return $str; } } OIS-0.05/PerlOISMouseListener.cpp0000644000175000017500000000627010725106506017003 0ustar slanningslanning#include "PerlOISMouseListener.h" // class implementing OIS::MouseListener interface, // but using Perl callbacks PerlOISMouseListener::PerlOISMouseListener() : mPerlObj((SV *)NULL) { } PerlOISMouseListener::~PerlOISMouseListener() { if (mPerlObj != (SV *)NULL && SvREFCNT(mPerlObj)) { SvREFCNT_dec(mPerlObj); } mCanMap.clear(); } bool PerlOISMouseListener::mouseMoved(const OIS::MouseEvent &evt) { // no "int" arg for mouseMoved, so passing 0 return callPerlCallback("mouseMoved", evt, 0); } bool PerlOISMouseListener::mousePressed(const OIS::MouseEvent &evt, OIS::MouseButtonID id) { return callPerlCallback("mousePressed", evt, id); } bool PerlOISMouseListener::mouseReleased(const OIS::MouseEvent &evt, OIS::MouseButtonID id) { return callPerlCallback("mouseReleased", evt, id); } void PerlOISMouseListener::setPerlObject(SV *pobj) { if (pobj != (SV *)NULL && sv_isobject(pobj)) { // copy the SV * if (mPerlObj == (SV *)NULL) { // first time, create new SV * mPerlObj = newSVsv(pobj); } else { // just overwrite existing SV * SvSetSV(mPerlObj, pobj); } } else { croak("Argument wasn't an object, so MouseListener wasn't set.\n"); } setCans(); } void PerlOISMouseListener::setCans() { mCanMap["mouseMoved"] = perlCallbackCan("mouseMoved"); mCanMap["mousePressed"] = perlCallbackCan("mousePressed"); mCanMap["mouseReleased"] = perlCallbackCan("mouseReleased"); } // check whether the Perl object has a callback method implemented // (is there a perl API method or something easier than this?) bool PerlOISMouseListener::perlCallbackCan(string const &cbmeth) { int count; SV *methret; bool can; dSP; ENTER; SAVETMPS; // call `can' to see if they implemented the callback PUSHMARK(SP); XPUSHs(mPerlObj); XPUSHs(sv_2mortal(newSVpv(cbmeth.c_str(), 0))); PUTBACK; count = call_method("can", G_SCALAR); SPAGAIN; if (count != 1) { croak("can (%s) didn't return a single value?", cbmeth.c_str()); } methret = POPs; PUTBACK; can = SvTRUE(methret); FREETMPS; LEAVE; return can; } bool PerlOISMouseListener::callPerlCallback(string const &cbmeth, const OIS::MouseEvent &evt, int buttonID) { int count; SV *methret; bool retval = true; // default to returning true if (! (mCanMap[cbmeth] == true)) { // method not implemented, just return true return retval; } if (mPerlObj != (SV *)NULL) { // see `perldoc perlcall` dSP; ENTER; SAVETMPS; SV *mouseevt = sv_newmortal(); TMOIS_OUT(mouseevt, &evt, MouseEvent); // put C++ object into Perl PUSHMARK(SP); XPUSHs(mPerlObj); XPUSHs(mouseevt); XPUSHs(sv_2mortal(newSViv(buttonID))); PUTBACK; count = call_method(cbmeth.c_str(), G_SCALAR); SPAGAIN; if (count != 1) { croak("Callbacks must return a single (boolean) value"); } methret = POPs; PUTBACK; retval = SvTRUE(methret) ? true : false; FREETMPS; LEAVE; } return retval; } OIS-0.05/OIS.xs0000644000175000017500000000303511253007240013275 0ustar slanningslanning#include "perlOIS.h" #include // #include "PerlOISJoyStickListener.h" #include "PerlOISKeyListener.h" #include "PerlOISMouseListener.h" // These instances just sit around until needed by setEventCallback. // OIS only allows one listener each, so this should be okay I think. //PerlOISJoyStickListener poisJoyStickListener; PerlOISKeyListener poisKeyListener; PerlOISMouseListener poisMouseListener; using namespace std; using namespace OIS; MODULE = OIS PACKAGE = OIS PROTOTYPES: ENABLE ## Type enum static int OIS::OISUnknown() ALIAS: OIS::OISKeyboard = 1 OIS::OISMouse = 2 OIS::OISJoyStick = 3 OIS::OISTablet = 4 CODE: switch (ix) { case 0: RETVAL = OIS::OISUnknown; break; case 1: RETVAL = OIS::OISKeyboard; break; case 2: RETVAL = OIS::OISMouse; break; case 3: RETVAL = OIS::OISJoyStick; break; case 4: RETVAL = OIS::OISTablet; break; } OUTPUT: RETVAL ## ComponentType enum static int OIS::OIS_Unknown() ALIAS: OIS::OIS_Button = 1 OIS::OIS_Axis = 2 OIS::OIS_Slider = 3 OIS::OIS_POV = 4 OIS::OIS_Vector3 = 5 CODE: switch (ix) { case 0: RETVAL = OIS::OIS_Unknown; break; case 1: RETVAL = OIS::OIS_Button; break; case 2: RETVAL = OIS::OIS_Axis; break; case 3: RETVAL = OIS::OIS_Slider; break; case 4: RETVAL = OIS::OIS_POV; break; case 5: RETVAL = OIS::OIS_Vector3; break; } OUTPUT: RETVAL ## include all other .xs files INCLUDE: perl -e "print qq{INCLUDE: \$_\$/} for " | OIS-0.05/PerlOISMouseListener.h0000644000175000017500000000202010665512577016451 0ustar slanningslanning#ifndef _PERLOIS_MOUSELISTENER_H_ #define _PERLOIS_MOUSELISTENER_H_ #include "perlOIS.h" #include #include using namespace std; // this class implements OIS::MouseListener, // so it can be passed to Mouse->setEventCallback, // but it allows implementing the callbacks from Perl class PerlOISMouseListener : public OIS::MouseListener { public: PerlOISMouseListener(); ~PerlOISMouseListener(); // these are used in xs/Mouseboard.xs setEventCallback void setPerlObject(SV *pobj); // MouseListener interface bool mouseMoved(const OIS::MouseEvent &evt); bool mousePressed(const OIS::MouseEvent &evt, OIS::MouseButtonID id); bool mouseReleased(const OIS::MouseEvent &evt, OIS::MouseButtonID id); private: bool perlCallbackCan(string const &cbmeth); void setCans(); bool callPerlCallback(string const &cbmeth, const OIS::MouseEvent &evt, int id); SV * mPerlObj; typedef map CanMap; CanMap mCanMap; }; #endif /* define _PERLOIS_MOUSELISTENER_H_ */ OIS-0.05/README.txt0000644000175000017500000000456311254006254014001 0ustar slanningslanningPerl OIS ======== This is a Perl binding for OIS, Object-Oriented Input System, a crossplatform C++ input framework, found at http://sourceforge.net/projects/wgois . I made it so that Ogre (http://search.cpan.org/~slanning/Ogre/ ) can be useful, but there might be uses outside of Ogre. The wrapping isn't really complete, but I'm focusing on being able to use it with Ogre. (OIS::Component and OIS::ForceEffect, and their subclasses are basically the only parts not wrapped. Also changes between 1.0 and 1.2 aren't taken into account yet.) There is no documentation, which is no doubt frustrating. Then again, OIS itself isn't really very documented. :) There are examples in the Ogre module, and you can look at the (inadequate) tests under the t/ directory. DEPENDENCIES You should install the latest version of OIS. That's 1.2 as I'm writing this. If you run Ubuntu, see below for installation instructions. Makefile.PL uses pkg-config to get information about the libraries and header files needed to build against OIS, so you should be able to do this: pkg-config --libs OIS pkg-config --cflags OIS pkg-config --modversion OIS This latter should say at least 1.2.0. The C++ compiler used by default is `g++`, but you can specify a different C++ compiler by setting the CXX environmental variable. Anything more, and you'll have to hack at Makefile.PL. INSTALLATION To install this module, do the usual: perl Makefile.PL make make test make install You might have to edit Makefile.PL to get it to work for your system. If so, please let me know. INSTALLING OIS UNDER UBUNTU To install OIS in Ubuntu Jaunty, sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 6FED7057 sudo gedit /etc/apt/sources.list and add these lines: deb http://ppa.launchpad.net/andrewfenn/ogredev/ubuntu jaunty main deb-src http://ppa.launchpad.net/andrewfenn/ogredev/ubuntu jaunty main sudo apt-get install libois1 libois-dev `pkg-config --modversion OIS` should be 1.2.0 . COPYRIGHT AND LICENCE Please report any bugs/suggestions to Copyright 2007, 2009 Scott Lanning. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. OIS itself is under the "zlib/libpng" license. See the ReadMe.txt file in OIS's source distribution for more (and probably more accurate) information. OIS-0.05/MANIFEST0000644000175000017500000000171511254006577013440 0ustar slanningslanningMANIFEST This list of files README.txt Changes Makefile.PL typemap perlobject.map OIS.pm OIS.xs perlOIS.h PerlOISJoyStickListener.h PerlOISJoyStickListener.cpp PerlOISKeyListener.h PerlOISKeyListener.cpp PerlOISMouseListener.h PerlOISMouseListener.cpp xs/Axis.xs xs/EventArg.xs xs/Exception.xs xs/InputManager.xs xs/JoyStick.xs-disabled xs/JoyStickEvent.xs-disabled xs/JoyStickListener.xs-disabled xs/JoyStickState.xs-disabled xs/Keyboard.xs xs/KeyEvent.xs xs/KeyListener.xs xs/Mouse.xs xs/MouseEvent.xs xs/MouseListener.xs xs/MouseState.xs xs/Object.xs OIS/Axis.pm OIS/EventArg.pm OIS/Exception.pm OIS/InputManager.pm OIS/JoyStick.pm OIS/JoyStickEvent.pm OIS/JoyStickListener.pm OIS/JoyStickState.pm OIS/Keyboard.pm OIS/KeyEvent.pm OIS/KeyListener.pm OIS/Mouse.pm OIS/MouseEvent.pm OIS/MouseListener.pm OIS/MouseState.pm OIS/Object.pm t/000_use.t t/010_inputmanager.t t/090_exception.t META.yml Module meta-data (added by MakeMaker) OIS-0.05/t/0000755000175000017500000000000011254006577012546 5ustar slanningslanningOIS-0.05/t/090_exception.t0000644000175000017500000000204110665032202015303 0ustar slanningslanning#!/usr/bin/perl use strict; use warnings; use Scalar::Util qw(looks_like_number); use Test::More tests => 8; BEGIN { use_ok('OIS'); use_ok('OIS::Exception'); } # XXX: this is wrong - the constants are "exported" no matter what #use OIS::Exception qw(:OIS_ERROR); # XXX: I can't figure out why &E_General won't work here; # c.f. Ogre/examples/robot.pl where I use &ST_GENERIC; # I don't see what the difference is that's making it not work here. # Hmmm, it turns out that it's something to do with the tests... # It works fine outside of tests. my $type = OIS::Exception->E_General; my $line = 42; my $file = '090_exception.t'; my $text = 'a general error'; ok(looks_like_number($type), 'E_General is a number'); my $e = OIS::Exception->new($type, $text, $line, $file); isa_ok($e, 'OIS::Exception'); is($e->eType, $type, 'exception object has correct eType'); is($e->eLine, $line, 'exception object has correct eLine'); is($e->eFile, $file, 'exception object has correct eFile'); is($e->eText, $text, 'exception object has correct eText'); OIS-0.05/t/010_inputmanager.t0000644000175000017500000000132411253010105015762 0ustar slanningslanning#!/usr/bin/perl use strict; use warnings; use Test::More tests => 3; BEGIN { use_ok('OIS'); use_ok('OIS::InputManager'); } # pretty lame tests, but these methods are useless anyway like(OIS::InputManager->getVersionNumber(), qr/^\d+$/, 'check getVersionNumber'); ## the API changed here... #like(OIS::InputManager->getVersionName(), qr/^.+$/, 'check getVersionName'); # XXX: I don't know how to test createInputSystem and destroyInputSystem # without using Ogre. Consequently, I also don't know how to test the # object methods like numMice, etc., or createInputObject (note: there are # three methods in the Perl wrapping: createInputObjectMouse, # createInputObjectKeyboard, and createInputObjectJoyStick OIS-0.05/t/000_use.t0000644000175000017500000000014010664506054014100 0ustar slanningslanning#!/usr/bin/perl use strict; use warnings; use Test::More tests => 1; BEGIN { use_ok('OIS') } OIS-0.05/PerlOISJoyStickListener.h0000644000175000017500000000225510665512611017117 0ustar slanningslanning#ifndef _PERLOIS_JOYSTICKLISTENER_H_ #define _PERLOIS_JOYSTICKLISTENER_H_ #include "perlOIS.h" #include #include using namespace std; // this class implements OIS::JoyStickListener, // so it can be passed to JoyStick->setEventCallback, // but it allows implementing the callbacks from Perl class PerlOISJoyStickListener : public OIS::JoyStickListener { public: PerlOISJoyStickListener(); ~PerlOISJoyStickListener(); // these are used in xs/JoyStickboard.xs setEventCallback void setPerlObject(SV *pobj); // JoyStickListener interface bool buttonPressed(const OIS::JoyStickEvent &evt, int button); bool buttonReleased(const OIS::JoyStickEvent &evt, int button); bool axisMoved(const OIS::JoyStickEvent &evt, int axis); bool sliderMoved(const OIS::JoyStickEvent &evt, int slider); bool povMoved(const OIS::JoyStickEvent &evt, int pov); private: bool perlCallbackCan(string const &cbmeth); void setCans(); bool callPerlCallback(string const &cbmeth, const OIS::JoyStickEvent &evt, int id); SV * mPerlObj; typedef map CanMap; CanMap mCanMap; }; #endif /* define _PERLOIS_JOYSTICKLISTENER_H_ */ OIS-0.05/PerlOISKeyListener.cpp0000644000175000017500000000544710666560146016460 0ustar slanningslanning#include "PerlOISKeyListener.h" // class implementing OIS::KeyListener interface, // but using Perl callbacks PerlOISKeyListener::PerlOISKeyListener() : mPerlObj((SV *)NULL) { } PerlOISKeyListener::~PerlOISKeyListener() { if (mPerlObj != (SV *)NULL && SvREFCNT(mPerlObj)) { SvREFCNT_dec(mPerlObj); } mCanMap.clear(); } bool PerlOISKeyListener::keyPressed(const OIS::KeyEvent &evt) { return callPerlCallback("keyPressed", evt); } bool PerlOISKeyListener::keyReleased(const OIS::KeyEvent &evt) { return callPerlCallback("keyReleased", evt); } void PerlOISKeyListener::setPerlObject(SV *pobj) { if (pobj != (SV *)NULL && sv_isobject(pobj)) { // copy the SV * if (mPerlObj == (SV *)NULL) { // first time, create new SV * mPerlObj = newSVsv(pobj); } else { // just overwrite existing SV * SvSetSV(mPerlObj, pobj); } } else { croak("Argument wasn't an object, so KeyListener wasn't set.\n"); } setCans(); } void PerlOISKeyListener::setCans() { mCanMap["keyPressed"] = perlCallbackCan("keyPressed"); mCanMap["keyReleased"] = perlCallbackCan("keyReleased"); } // check whether the Perl object has a callback method implemented // (is there a perl API method or something easier than this?) bool PerlOISKeyListener::perlCallbackCan(string const &cbmeth) { int count; SV *methret; bool can; dSP; ENTER; SAVETMPS; // call `can' to see if they implemented the callback PUSHMARK(SP); XPUSHs(mPerlObj); XPUSHs(sv_2mortal(newSVpv(cbmeth.c_str(), 0))); PUTBACK; count = call_method("can", G_SCALAR); SPAGAIN; if (count != 1) { croak("can (%s) didn't return a single value?", cbmeth.c_str()); } methret = POPs; PUTBACK; can = SvTRUE(methret); FREETMPS; LEAVE; return can; } bool PerlOISKeyListener::callPerlCallback(string const &cbmeth, const OIS::KeyEvent &evt) { int count; SV *methret; bool retval = true; // default to returning true if (! (mCanMap[cbmeth] == true)) { // method not implemented, just return true return retval; } if (mPerlObj != (SV *)NULL) { // see `perldoc perlcall` dSP; ENTER; SAVETMPS; SV *keyevt = sv_newmortal(); TMOIS_OUT(keyevt, &evt, KeyEvent); // put C++ object into Perl PUSHMARK(SP); XPUSHs(mPerlObj); XPUSHs(keyevt); PUTBACK; count = call_method(cbmeth.c_str(), G_SCALAR); SPAGAIN; if (count != 1) { croak("Callbacks must return a single (boolean) value"); } methret = POPs; PUTBACK; retval = SvTRUE(methret) ? true : false; FREETMPS; LEAVE; } return retval; } OIS-0.05/OIS.pm0000644000175000017500000000245711252775262013305 0ustar slanningslanningpackage OIS; use 5.006; use strict; use warnings; # use all files under OIS/ - probably not a good idea use OIS::Axis; use OIS::EventArg; use OIS::Exception; use OIS::InputManager; use OIS::JoyStick; use OIS::JoyStickEvent; use OIS::JoyStickListener; use OIS::JoyStickState; use OIS::Keyboard; use OIS::KeyEvent; use OIS::KeyListener; use OIS::Mouse; use OIS::MouseEvent; use OIS::MouseListener; use OIS::MouseState; use OIS::Object; require Exporter; require DynaLoader; our @ISA = qw(Exporter DynaLoader); our $VERSION = '0.05'; sub dl_load_flags { $^O eq 'darwin' ? 0x00 : 0x01 } __PACKAGE__->bootstrap($VERSION); our %EXPORT_TAGS = ( 'Type' => [ qw( OISUnknown OISKeyboard OISMouse OISJoyStick OISTablet ) ], 'ComponentType' => [ qw( OIS_Unknown OIS_Button OIS_Axis OIS_Slider OIS_POV ) ], ); $EXPORT_TAGS{'all'} = [ map { @{ $EXPORT_TAGS{$_} } } keys %EXPORT_TAGS ]; our @EXPORT_OK = @{ $EXPORT_TAGS{'all'} }; our @EXPORT = (); 1; __END__ =head1 NAME OIS - Perl binding for the OIS C++ input framework =head1 SYNOPSIS use OIS; # ... =head1 DESCRIPTION For now, see README.txt. =head1 AUTHOR Scott Lanning Eslanning@cpan.orgE =cut OIS-0.05/META.yml0000664000175000017500000000103111254006577013551 0ustar slanningslanning--- #YAML:1.0 name: OIS version: 0.05 abstract: Perl binding for the OIS C++ input framework author: - Scott Lanning license: unknown distribution_type: module configure_requires: ExtUtils::MakeMaker: 0 requires: Scalar::Util: 1.18 Test::More: 0 no_index: directory: - t - inc generated_by: ExtUtils::MakeMaker version 6.48 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 OIS-0.05/OIS/0000755000175000017500000000000011254006577012735 5ustar slanningslanningOIS-0.05/OIS/EventArg.pm0000644000175000017500000000006710664552262015012 0ustar slanningslanningpackage OIS::EventArg; use strict; use warnings; 1; OIS-0.05/OIS/JoyStick.pm0000644000175000017500000000014510664551715015035 0ustar slanningslanningpackage OIS::JoyStick; use strict; use warnings; use OIS::Object; our @ISA = qw(OIS::Object); 1; OIS-0.05/OIS/Exception.pm0000644000175000017500000000105510664542615015234 0ustar slanningslanningpackage OIS::Exception; use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our %EXPORT_TAGS = ( 'OIS_ERROR' => [ qw( E_InputDisconnected E_InputDeviceNonExistant E_InputDeviceNotSupported E_DeviceFull E_NotSupported E_NotImplemented E_Duplicate E_InvalidParam E_General ) ], ); $EXPORT_TAGS{'all'} = [ map { @{ $EXPORT_TAGS{$_} } } keys %EXPORT_TAGS ]; our @EXPORT_OK = @{ $EXPORT_TAGS{'all'} }; our @EXPORT = (); 1; OIS-0.05/OIS/MouseListener.pm0000644000175000017500000000007410664552013016065 0ustar slanningslanningpackage OIS::MouseListener; use strict; use warnings; 1; OIS-0.05/OIS/MouseState.pm0000644000175000017500000000007110666544712015366 0ustar slanningslanningpackage OIS::MouseState; use strict; use warnings; 1; OIS-0.05/OIS/JoyStickState.pm0000644000175000017500000000007410664557352016042 0ustar slanningslanningpackage OIS::JoyStickState; use strict; use warnings; 1; OIS-0.05/OIS/JoyStickListener.pm0000644000175000017500000000007710664552042016541 0ustar slanningslanningpackage OIS::JoyStickListener; use strict; use warnings; 1; OIS-0.05/OIS/KeyEvent.pm0000644000175000017500000000015110664552526015026 0ustar slanningslanningpackage OIS::KeyEvent; use strict; use warnings; use OIS::EventArg; our @ISA = qw(OIS::EventArg); 1; OIS-0.05/OIS/Axis.pm0000644000175000017500000000006310666403335014175 0ustar slanningslanningpackage OIS::Axis; use strict; use warnings; 1; OIS-0.05/OIS/MouseEvent.pm0000644000175000017500000000015310664552547015373 0ustar slanningslanningpackage OIS::MouseEvent; use strict; use warnings; use OIS::EventArg; our @ISA = qw(OIS::EventArg); 1; OIS-0.05/OIS/KeyListener.pm0000644000175000017500000000007210664552025015526 0ustar slanningslanningpackage OIS::KeyListener; use strict; use warnings; 1; OIS-0.05/OIS/InputManager.pm0000644000175000017500000000150210664526255015667 0ustar slanningslanningpackage OIS::InputManager; use strict; use warnings; use Scalar::Util qw(looks_like_number); sub createInputSystem { my ($self, @args) = @_; # passed in 1 arg, a window handle (i.e. a number) if (@args == 1) { if (looks_like_number($args[0])) { return $self->createInputSystemPtr(int($args[0])); } else { require Carp; Carp::confess(__PACKAGE__ . '::createInputSystem: ', 'single arg must be a number (window handle)' . $/); } } # passed in 2 args, a ParamList (hash) elsif (@args == 2) { return $self->createInputSystemPL(@args); } else { require Carp; Carp::confess(__PACKAGE__ . '::createInputSystem: ', 'missing required 1 or 2 args' . $/); } } 1; OIS-0.05/OIS/JoyStickEvent.pm0000644000175000017500000000015610664552505016037 0ustar slanningslanningpackage OIS::JoyStickEvent; use strict; use warnings; use OIS::EventArg; our @ISA = qw(OIS::EventArg); 1; OIS-0.05/OIS/Mouse.pm0000644000175000017500000000100010666544621014355 0ustar slanningslanningpackage OIS::Mouse; use strict; use warnings; require Exporter; use OIS::Object; our @ISA = qw(OIS::Object Exporter); our %EXPORT_TAGS = ( 'MouseButtonID' => [ qw( MB_Left MB_Right MB_Middle MB_Button3 MB_Button4 MB_Button5 MB_Button6 MB_Button7 ), ], ); $EXPORT_TAGS{'all'} = [ map { @{ $EXPORT_TAGS{$_} } } keys %EXPORT_TAGS ]; our @EXPORT_OK = @{ $EXPORT_TAGS{'all'} }; our @EXPORT = (); 1; OIS-0.05/OIS/Keyboard.pm0000644000175000017500000000660410664771467015054 0ustar slanningslanningpackage OIS::Keyboard; use strict; use warnings; require Exporter; use OIS::Object; our @ISA = qw(OIS::Object Exporter); our %EXPORT_TAGS = ( # the OIS API is sometimes inconsistent... 'TextTranslationMode' => [ qw( Off Unicode Ascii ), ], 'Modifier' => [ qw( Shift Ctrl Alt ), ], 'KeyCode' => [ qw( KC_UNASSIGNED KC_ESCAPE KC_1 KC_2 KC_3 KC_4 KC_5 KC_6 KC_7 KC_8 KC_9 KC_0 KC_MINUS KC_EQUALS KC_BACK KC_TAB KC_Q KC_W KC_E KC_R KC_T KC_Y KC_U KC_I KC_O KC_P KC_LBRACKET KC_RBRACKET KC_RETURN KC_LCONTROL KC_A KC_S KC_D KC_F KC_G KC_H KC_J KC_K KC_L KC_SEMICOLON KC_APOSTROPHE KC_GRAVE KC_LSHIFT KC_BACKSLASH KC_Z KC_X KC_C KC_V KC_B KC_N KC_M KC_COMMA KC_PERIOD KC_SLASH KC_RSHIFT KC_MULTIPLY KC_LMENU KC_SPACE KC_CAPITAL KC_F1 KC_F2 KC_F3 KC_F4 KC_F5 KC_F6 KC_F7 KC_F8 KC_F9 KC_F10 KC_NUMLOCK KC_SCROLL KC_NUMPAD7 KC_NUMPAD8 KC_NUMPAD9 KC_SUBTRACT KC_NUMPAD4 KC_NUMPAD5 KC_NUMPAD6 KC_ADD KC_NUMPAD1 KC_NUMPAD2 KC_NUMPAD3 KC_NUMPAD0 KC_DECIMAL KC_OEM_102 KC_F11 KC_F12 KC_F13 KC_F14 KC_F15 KC_KANA KC_ABNT_C1 KC_CONVERT KC_NOCONVERT KC_YEN KC_ABNT_C2 KC_NUMPADEQUALS KC_PREVTRACK KC_AT KC_COLON KC_UNDERLINE KC_KANJI KC_STOP KC_AX KC_UNLABELED KC_NEXTTRACK KC_NUMPADENTER KC_RCONTROL KC_MUTE KC_CALCULATOR KC_PLAYPAUSE KC_MEDIASTOP KC_VOLUMEDOWN KC_VOLUMEUP KC_WEBHOME KC_NUMPADCOMMA KC_DIVIDE KC_SYSRQ KC_RMENU KC_PAUSE KC_HOME KC_UP KC_PGUP KC_LEFT KC_RIGHT KC_END KC_DOWN KC_PGDOWN KC_INSERT KC_DELETE KC_LWIN KC_RWIN KC_APPS KC_POWER KC_SLEEP KC_WAKE KC_WEBSEARCH KC_WEBFAVORITES KC_WEBREFRESH KC_WEBSTOP KC_WEBFORWARD KC_WEBBACK KC_MYCOMPUTER KC_MAIL KC_MEDIASELECT ), ], ); $EXPORT_TAGS{'all'} = [ map { @{ $EXPORT_TAGS{$_} } } keys %EXPORT_TAGS ]; our @EXPORT_OK = @{ $EXPORT_TAGS{'all'} }; our @EXPORT = (); 1; OIS-0.05/OIS/Object.pm0000644000175000017500000000006510664531234014477 0ustar slanningslanningpackage OIS::Object; use strict; use warnings; 1; OIS-0.05/perlOIS.h0000644000175000017500000000122410664663505013774 0ustar slanningslanning#ifndef _PERLOIS_H_ #define _PERLOIS_H_ #include // for C++ #ifdef __cplusplus extern "C" { #endif #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #ifdef __cplusplus } #endif // macros for typemap // xxx: let me know if you have a better way to do this... #define TMOIS_OUT(arg, var, pkg) sv_setref_pv(arg, "OIS::" #pkg, (void *) var); #define TMOIS_IN(arg, var, type, package, func, pkg) \ if (sv_isobject(arg) && sv_derived_from(arg, "OIS::" #pkg)) { \ var = (type) SvIV((SV *) SvRV(arg)); \ } else { \ warn(#package "::" #func "():" #var " is not an OIS::" #pkg " object"); \ XSRETURN_UNDEF; \ } #endif /* _PERLOIS_H_ */ OIS-0.05/perlobject.map0000644000175000017500000000507710664505616015146 0ustar slanningslanning# "perlobject.map" Dean Roehrich, version 19960302 # # TYPEMAPs # # HV * -> unblessed Perl HV object. # AV * -> unblessed Perl AV object. # # INPUT/OUTPUT maps # # O_* -> opaque blessed objects # T_* -> opaque blessed or unblessed objects # # O_OBJECT -> link an opaque C or C++ object to a blessed Perl object. # T_OBJECT -> link an opaque C or C++ object to an unblessed Perl object. # O_HvRV -> a blessed Perl HV object. # T_HvRV -> an unblessed Perl HV object. # O_AvRV -> a blessed Perl AV object. # T_AvRV -> an unblessed Perl AV object. TYPEMAP HV * T_HvRV AV * T_AvRV ###################################################################### OUTPUT # The Perl object is blessed into 'CLASS', which should be a # char* having the name of the package for the blessing. O_OBJECT sv_setref_pv( $arg, CLASS, (void*)$var ); T_OBJECT sv_setref_pv( $arg, Nullch, (void*)$var ); # Cannot use sv_setref_pv() because that will destroy # the HV-ness of the object. Remember that newRV() will increment # the refcount. O_HvRV $arg = sv_bless( newRV((SV*)$var), gv_stashpv(CLASS,1) ); T_HvRV $arg = newRV((SV*)$var); # Cannot use sv_setref_pv() because that will destroy # the AV-ness of the object. Remember that newRV() will increment # the refcount. O_AvRV $arg = sv_bless( newRV((SV*)$var), gv_stashpv(CLASS,1) ); T_AvRV $arg = newRV((SV*)$var); ###################################################################### INPUT O_OBJECT if( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) ) $var = ($type)SvIV((SV*)SvRV( $arg )); else{ warn( \"${Package}::$func_name() -- $var is not a blessed SV reference\" ); XSRETURN_UNDEF; } T_OBJECT if( SvROK($arg) ) $var = ($type)SvIV((SV*)SvRV( $arg )); else{ warn( \"${Package}::$func_name() -- $var is not an SV reference\" ); XSRETURN_UNDEF; } O_HvRV if( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVHV) ) $var = (HV*)SvRV( $arg ); else { warn( \"${Package}::$func_name() -- $var is not a blessed HV reference\" ); XSRETURN_UNDEF; } T_HvRV if( SvROK($arg) && (SvTYPE(SvRV($arg)) == SVt_PVHV) ) $var = (HV*)SvRV( $arg ); else { warn( \"${Package}::$func_name() -- $var is not an HV reference\" ); XSRETURN_UNDEF; } O_AvRV if( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVAV) ) $var = (AV*)SvRV( $arg ); else { warn( \"${Package}::$func_name() -- $var is not a blessed AV reference\" ); XSRETURN_UNDEF; } T_AvRV if( SvROK($arg) && (SvTYPE(SvRV($arg)) == SVt_PVAV) ) $var = (AV*)SvRV( $arg ); else { warn( \"${Package}::$func_name() -- $var is not an AV reference\" ); XSRETURN_UNDEF; } OIS-0.05/PerlOISKeyListener.h0000644000175000017500000000161510665512603016110 0ustar slanningslanning#ifndef _PERLOIS_KEYLISTENER_H_ #define _PERLOIS_KEYLISTENER_H_ #include "perlOIS.h" #include #include using namespace std; // this class implements OIS::KeyListener, // so it can be passed to Keyboard->setEventCallback, // but it allows implementing the callbacks from Perl class PerlOISKeyListener : public OIS::KeyListener { public: PerlOISKeyListener(); ~PerlOISKeyListener(); // these are used in xs/Keyboard.xs setEventCallback void setPerlObject(SV *pobj); // KeyListener interface bool keyPressed(const OIS::KeyEvent &evt); bool keyReleased(const OIS::KeyEvent &evt); private: bool perlCallbackCan(string const &cbmeth); void setCans(); bool callPerlCallback(string const &cbmeth, const OIS::KeyEvent &evt); SV * mPerlObj; typedef map CanMap; CanMap mCanMap; }; #endif /* define _PERLOIS_KEYLISTENER_H_ */ OIS-0.05/Changes0000644000175000017500000000101411254006445013564 0ustar slanningslanning0.05 2009-09-15 - updated to version 1.2.0 of OIS (needs more work...) 0.04 2007-12-04 - fixed MouseState (I was doing "new MouseState", which meant that any time you set width or height it wouldn't actually affect the MouseState of the Mouse object itself...) 0.03 2007-09-02 - KeyEvent, MouseEvent wrapped - MouseEvent no longer segfaults (I think) 0.02 2007-08-30 - fixed setEventCallback for Keyboard, Mouse, and JoyStick classes, along with the PerlOIS*Listener classes 0.01 2007-08-28 - first release