keyboard_be.cpp Source File

00001 /*
00002         $Id: keyboard_be.cpp,v 1.1 2001/03/06 15:09:20 mbn Exp $
00003 
00004         ------------------------------------------------------------------------
00005         ClanLib, the platform independent game SDK.
00006 
00007         This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
00008         version 2. See COPYING for details.
00009 
00010         For a total list of contributers see CREDITS.
00011 
00012         ------------------------------------------------------------------------
00013 */
00014 
00015 #include "Core/precomp.h"
00016 
00017 #include <Display/Input/Be/keyboard_be.h>
00018 #include <API/Display/Input/inputaxis.h>
00019 #include <API/Display/Input/inputbuffer.h>
00020 #include <Display/Input/Be/keyboard_be.h>
00021 #include <API/Display/Input/inputbutton.h>
00022 #include <Display/Input/Be/keyboard_be.h>
00023 #include <API/Display/Input/inputcursor.h>
00024 #include <API/Display/Input/inputhat.h>
00025 #include <Core/System/Be/app_beos.h>
00026 //#include <be/app/Message.h>
00027 
00028 /******************
00029   Keyboard
00030 ******************/
00031 
00032 CL_BeKeyboard::CL_BeKeyboard()
00033 {
00034         memset( &keymap, 0, sizeof(keymap) );
00035 
00036         buttons = new CL_InputButton_BeKeyboard*[CL_NUM_KEYS];
00037         for (int i=0; i<CL_NUM_KEYS; i++) buttons[i] = NULL;
00038 }
00039 
00040 CL_BeKeyboard::~CL_BeKeyboard()
00041 {
00042         for (int i=0; i<CL_NUM_KEYS; i++) delete buttons[i];
00043         delete[] buttons;
00044 }
00045 
00046 void CL_BeKeyboard::handle_modifiers(BMessage* msg)
00047 {
00048         int32 mods;
00049         msg->FindInt32("modifiers", &mods);
00050         
00051         keymap[CL_KEY_LSHIFT] = (mods & B_LEFT_SHIFT_KEY);
00052         keymap[CL_KEY_RSHIFT] = (mods & B_RIGHT_SHIFT_KEY);
00053         keymap[CL_KEY_LCTRL] = (mods & B_LEFT_CONTROL_KEY);
00054         keymap[CL_KEY_RCTRL] = (mods & B_RIGHT_CONTROL_KEY);
00055         keymap[CL_KEY_ALT] = (mods & B_LEFT_OPTION_KEY);
00056         keymap[CL_KEY_ALTGR] = (mods & B_RIGHT_OPTION_KEY);
00057 }
00058 
00059 void CL_BeKeyboard::handle_key(BMessage* msg, bool down)
00060 {
00061         int8 val;
00062         msg->FindInt8("byte", &val);
00063 
00064         switch (val)
00065         {
00066                 case B_ENTER:
00067 //                      if (down) buffer.add_key( CL_KEY_ENTER );
00068                         keymap[CL_KEY_ENTER] = down;
00069                         break;
00070                 case B_ESCAPE:
00071 //                      if (down) buffer.add_key( CL_KEY_ESCAPE );
00072                         keymap[CL_KEY_ESCAPE] = down;
00073                         break;
00074                 case B_BACKSPACE:
00075 //                      if (down) buffer.add_key( CL_KEY_BACKSPACE );
00076                         keymap[CL_KEY_BACKSPACE] = down;
00077                         break;
00078                 case B_SPACE:
00079 //                      if (down) buffer.add_key( CL_KEY_SPACE );
00080                         keymap[CL_KEY_SPACE] = down;
00081                         break;
00082                 case B_TAB:
00083 //                      if (down) buffer.add_key( CL_KEY_TAB );
00084                         keymap[CL_KEY_TAB] = down;
00085                         break;
00086                 case B_LEFT_ARROW:
00087 //                      if (down) buffer.add_key( CL_KEY_LEFT );
00088                         keymap[CL_KEY_LEFT] = down;
00089                         break;
00090                 case B_RIGHT_ARROW:
00091 //                      if (down) buffer.add_key( CL_KEY_RIGHT );
00092                         keymap[CL_KEY_RIGHT] = down;
00093                         break;
00094                 case B_UP_ARROW:
00095 //                      if (down) buffer.add_key( CL_KEY_UP );
00096                         keymap[CL_KEY_UP] = down;
00097                         break;
00098                 case B_DOWN_ARROW:
00099 //                      if (down) buffer.add_key( CL_KEY_DOWN );
00100                         keymap[CL_KEY_DOWN] = down;
00101                         break;
00102                 case B_INSERT:
00103 //                      if (down) buffer.add_key( CL_KEY_INSERT );
00104                         keymap[CL_KEY_INSERT] = down;
00105                         break;
00106                 case B_DELETE:
00107 //                      if (down) buffer.add_key( CL_KEY_DELETE );
00108                         keymap[CL_KEY_DELETE] = down;
00109                         break;
00110                 case B_HOME:
00111 //                      if (down) buffer.add_key( CL_KEY_HOME );
00112                         keymap[CL_KEY_HOME] = down;
00113                         break;
00114                 case B_END:
00115 //                      if (down) buffer.add_key( CL_KEY_END );
00116                         keymap[CL_KEY_END] = down;
00117                         break;
00118                 case B_PAGE_UP:
00119 //                      if (down) buffer.add_key( CL_KEY_PAGEUP );
00120                         keymap[CL_KEY_PAGEUP] = down;
00121                         break;
00122                 case B_PAGE_DOWN:
00123 //                      if (down) buffer.add_key( CL_KEY_PAGEDOWN );
00124                         keymap[CL_KEY_PAGEDOWN] = down;
00125                         break;
00126         }
00127         
00128         switch (msg->FindInt32("key"))
00129         {
00130                 case B_F1_KEY:
00131 //                      if (down) buffer.add_key( CL_KEY_F1 );
00132                         keymap[CL_KEY_F1] = down;
00133                         break;
00134                 case B_F2_KEY:
00135 //                      if (down) buffer.add_key( CL_KEY_F2 );
00136                         keymap[CL_KEY_F2] = down;
00137                         break;
00138                 case B_F3_KEY:
00139 //                      if (down) buffer.add_key( CL_KEY_F3 );
00140                         keymap[CL_KEY_F3] = down;
00141                         break;
00142                 case B_F4_KEY:
00143 //                      if (down) buffer.add_key( CL_KEY_F4 );
00144                         keymap[CL_KEY_F4] = down;
00145                         break;
00146                 case B_F5_KEY:
00147 //                      if (down) buffer.add_key( CL_KEY_F5 );
00148                         keymap[CL_KEY_F5] = down;
00149                         break;
00150                 case B_F6_KEY:
00151 //                      if (down) buffer.add_key( CL_KEY_F6 );
00152                         keymap[CL_KEY_F6] = down;
00153                         break;
00154                 case B_F7_KEY:
00155 //                      if (down) buffer.add_key( CL_KEY_F7 );
00156                         keymap[CL_KEY_F7] = down;
00157                         break;
00158                 case B_F8_KEY:
00159 //                      if (down) buffer.add_key( CL_KEY_F8 );
00160                         keymap[CL_KEY_F8] = down;
00161                         break;
00162                 case B_F9_KEY:
00163 //                      if (down) buffer.add_key( CL_KEY_F9 );
00164                         keymap[CL_KEY_F9] = down;
00165                         break;
00166                 case B_F10_KEY:
00167 //                      if (down) buffer.add_key( CL_KEY_F10 );
00168                         keymap[CL_KEY_F10] = down;
00169                         break;
00170                 case B_F11_KEY:
00171 //                      if (down) buffer.add_key( CL_KEY_F11 );
00172                         keymap[CL_KEY_F11] = down;
00173                         break;
00174                 case B_F12_KEY:
00175 //                      if (down) buffer.add_key( CL_KEY_F12 );
00176                         keymap[CL_KEY_F12] = down;
00177                         break;
00178         }
00179 
00180         switch (msg->FindInt32("raw_char"))
00181         {
00182                 case 'a':
00183 //                      if (down) buffer.add_key( CL_KEY_A );
00184                         keymap[CL_KEY_A] = down;
00185                         break;
00186                 case 'b':
00187 //                      if (down) buffer.add_key( CL_KEY_B );
00188                         keymap[CL_KEY_B] = down;
00189                         break;
00190                 case 'c':
00191 //                      if (down) buffer.add_key( CL_KEY_C );
00192                         keymap[CL_KEY_C] = down;
00193                         break;
00194                 case 'd':
00195 //                      if (down) buffer.add_key( CL_KEY_D );
00196                         keymap[CL_KEY_D] = down;
00197                         break;
00198                 case 'e':
00199 //                      if (down) buffer.add_key( CL_KEY_E );
00200                         keymap[CL_KEY_E] = down;
00201                         break;
00202                 case 'f':
00203 //                      if (down) buffer.add_key( CL_KEY_F );
00204                         keymap[CL_KEY_F] = down;
00205                         break;
00206                 case 'g':
00207 //                      if (down) buffer.add_key( CL_KEY_G );
00208                         keymap[CL_KEY_G] = down;
00209                         break;
00210                 case 'h':
00211 //                      if (down) buffer.add_key( CL_KEY_H );
00212                         keymap[CL_KEY_H] = down;
00213                         break;
00214                 case 'i':
00215 //                      if (down) buffer.add_key( CL_KEY_I );
00216                         keymap[CL_KEY_I] = down;
00217                         break;
00218                 case 'j':
00219 //                      if (down) buffer.add_key( CL_KEY_J );
00220                         keymap[CL_KEY_J] = down;
00221                         break;
00222                 case 'k':
00223 //                      if (down) buffer.add_key( CL_KEY_K );
00224                         keymap[CL_KEY_K] = down;
00225                         break;
00226                 case 'l':
00227 //                      if (down) buffer.add_key( CL_KEY_L );
00228                         keymap[CL_KEY_L] = down;
00229                         break;
00230                 case 'm':
00231 //                      if (down) buffer.add_key( CL_KEY_M );
00232                         keymap[CL_KEY_M] = down;
00233                         break;
00234                 case 'n':
00235 //                      if (down) buffer.add_key( CL_KEY_N );
00236                         keymap[CL_KEY_N] = down;
00237                         break;
00238                 case 'o':
00239 //                      if (down) buffer.add_key( CL_KEY_O );
00240                         keymap[CL_KEY_O] = down;
00241                         break;
00242                 case 'p':
00243 //                      if (down) buffer.add_key( CL_KEY_P );
00244                         keymap[CL_KEY_P] = down;
00245                         break;
00246                 case 'q':
00247 //                      if (down) buffer.add_key( CL_KEY_Q );
00248                         keymap[CL_KEY_Q] = down;
00249                         break;
00250                 case 'r':
00251 //                      if (down) buffer.add_key( CL_KEY_R );
00252                         keymap[CL_KEY_R] = down;
00253                         break;
00254                 case 's':
00255 //                      if (down) buffer.add_key( CL_KEY_S );
00256                         keymap[CL_KEY_S] = down;
00257                         break;
00258                 case 't':
00259 //                      if (down) buffer.add_key( CL_KEY_T );
00260                         keymap[CL_KEY_T] = down;
00261                         break;
00262                 case 'u':
00263 //                      if (down) buffer.add_key( CL_KEY_U );
00264                         keymap[CL_KEY_U] = down;
00265                         break;
00266                 case 'v':
00267 //                      if (down) buffer.add_key( CL_KEY_V );
00268                         keymap[CL_KEY_V] = down;
00269                         break;
00270                 case 'w':
00271 //                      if (down) buffer.add_key( CL_KEY_W );
00272                         keymap[CL_KEY_W] = down;
00273                         break;
00274                 case 'x':
00275 //                      if (down) buffer.add_key( CL_KEY_X );
00276                         keymap[CL_KEY_X] = down;
00277                         break;
00278                 case 'y':
00279 //                      if (down) buffer.add_key( CL_KEY_Y );
00280                         keymap[CL_KEY_Y] = down;
00281                         break;
00282                 case 'z':
00283 //                      if (down) buffer.add_key( CL_KEY_Z );
00284                         keymap[CL_KEY_Z] = down;
00285                         break;
00286         }
00287 }
00288 
00289 char *CL_BeKeyboard::get_name() const
00290 {
00291         return "Be Keyboard";
00292 }
00293 
00294 int CL_BeKeyboard::get_num_buttons() const
00295 {
00296         return CL_NUM_KEYS;
00297 }
00298 
00299 CL_InputButton *CL_BeKeyboard::get_button(int button_num)
00300 {
00301         if (buttons[button_num] != NULL) return buttons[button_num];
00302         
00303         buttons[button_num] = 
00304                 new CL_InputButton_BeKeyboard(button_num, keymap);
00305 
00306         return buttons[button_num];
00307 }
00308 
00309 int CL_BeKeyboard::get_num_axes() const
00310 {
00311         return 0;
00312 }
00313 
00314 CL_InputAxis *CL_BeKeyboard::get_axis(int /*axis_num*/)
00315 {
00316         return NULL;
00317 }
00318 
00319 int CL_BeKeyboard::get_num_hats() const
00320 {
00321         return 0;
00322 }
00323 
00324 CL_InputHat *CL_BeKeyboard::get_hat(int /*hat_num*/)
00325 {
00326         return NULL;
00327 }
00328 
00329 int CL_BeKeyboard::get_num_cursors() const
00330 {
00331         return 0;
00332 }
00333 
00334 CL_InputCursor *CL_BeKeyboard::get_cursor(int /*cursor_num*/)
00335 {
00336         return NULL;
00337 }
00338 
00339 
00340 /***************************
00341   CL_InputButton_BeKeyboard
00342 ***************************/
00343 
00344 CL_InputButton_BeKeyboard::CL_InputButton_BeKeyboard(
00345         int _key, bool *_keymap)
00346 {
00347         key = _key;
00348         keymap = _keymap;
00349 }
00350 
00351 bool CL_InputButton_BeKeyboard::is_pressed()
00352 {
00353         return keymap[key];
00354 }