llkeyboard.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:11k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llkeyboard.cpp
  3.  * @brief Handler for assignable key bindings
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #include "linden_common.h"
  33. #include "indra_constants.h"
  34. #include "llkeyboard.h"
  35. #include "llwindowcallbacks.h"
  36. //
  37. // Globals
  38. //
  39. LLKeyboard *gKeyboard = NULL;
  40. //static
  41. std::map<KEY,std::string> LLKeyboard::sKeysToNames;
  42. std::map<std::string,KEY> LLKeyboard::sNamesToKeys;
  43. LLKeyStringTranslatorFunc* LLKeyboard::mStringTranslator = NULL; // Used for l10n + PC/Mac/Linux accelerator labeling
  44. //
  45. // Class Implementation
  46. //
  47. LLKeyboard::LLKeyboard() : mCallbacks(NULL), mNumpadDistinct(ND_NUMLOCK_OFF)
  48. {
  49. S32 i;
  50. // Constructor for LLTimer inits each timer. We want them to
  51. // be constructed without being initialized, so we shut them down here.
  52. for (i = 0; i < KEY_COUNT; i++)
  53. {
  54. mKeyLevelFrameCount[i] = 0;
  55. mKeyLevel[i] = FALSE;
  56. mKeyUp[i]    = FALSE;
  57. mKeyDown[i]  = FALSE;
  58. mKeyRepeated[i] = FALSE;
  59. }
  60. mInsertMode = LL_KIM_INSERT;
  61. mCurTranslatedKey = KEY_NONE;
  62. mCurScanKey = KEY_NONE;
  63. addKeyName(' ', "Space" );
  64. addKeyName(KEY_RETURN, "Enter" );
  65. addKeyName(KEY_LEFT, "Left" );
  66. addKeyName(KEY_RIGHT, "Right" );
  67. addKeyName(KEY_UP, "Up" );
  68. addKeyName(KEY_DOWN, "Down" );
  69. addKeyName(KEY_ESCAPE, "Esc" );
  70. addKeyName(KEY_HOME, "Home" );
  71. addKeyName(KEY_END, "End" );
  72. addKeyName(KEY_PAGE_UP, "PgUp" );
  73. addKeyName(KEY_PAGE_DOWN, "PgDn" );
  74. addKeyName(KEY_F1, "F1" );
  75. addKeyName(KEY_F2, "F2" );
  76. addKeyName(KEY_F3, "F3" );
  77. addKeyName(KEY_F4, "F4" );
  78. addKeyName(KEY_F5, "F5" );
  79. addKeyName(KEY_F6, "F6" );
  80. addKeyName(KEY_F7, "F7" );
  81. addKeyName(KEY_F8, "F8" );
  82. addKeyName(KEY_F9, "F9" );
  83. addKeyName(KEY_F10, "F10" );
  84. addKeyName(KEY_F11, "F11" );
  85. addKeyName(KEY_F12, "F12" );
  86. addKeyName(KEY_TAB, "Tab" );
  87. addKeyName(KEY_ADD, "Add" );
  88. addKeyName(KEY_SUBTRACT, "Subtract" );
  89. addKeyName(KEY_MULTIPLY, "Multiply" );
  90. addKeyName(KEY_DIVIDE, "Divide" );
  91. addKeyName(KEY_PAD_DIVIDE, "PAD_DIVIDE" );
  92. addKeyName(KEY_PAD_LEFT, "PAD_LEFT" );
  93. addKeyName(KEY_PAD_RIGHT, "PAD_RIGHT" );
  94. addKeyName(KEY_PAD_DOWN, "PAD_DOWN" );
  95. addKeyName(KEY_PAD_UP, "PAD_UP" );
  96. addKeyName(KEY_PAD_HOME, "PAD_HOME" );
  97. addKeyName(KEY_PAD_END, "PAD_END" );
  98. addKeyName(KEY_PAD_PGUP, "PAD_PGUP" );
  99. addKeyName(KEY_PAD_PGDN, "PAD_PGDN" );
  100. addKeyName(KEY_PAD_CENTER, "PAD_CENTER" );
  101. addKeyName(KEY_PAD_INS, "PAD_INS" );
  102. addKeyName(KEY_PAD_DEL, "PAD_DEL" );
  103. addKeyName(KEY_PAD_RETURN, "PAD_Enter" );
  104. addKeyName(KEY_BUTTON0, "PAD_BUTTON0" );
  105. addKeyName(KEY_BUTTON1, "PAD_BUTTON1" );
  106. addKeyName(KEY_BUTTON2, "PAD_BUTTON2" );
  107. addKeyName(KEY_BUTTON3, "PAD_BUTTON3" );
  108. addKeyName(KEY_BUTTON4, "PAD_BUTTON4" );
  109. addKeyName(KEY_BUTTON5, "PAD_BUTTON5" );
  110. addKeyName(KEY_BUTTON6, "PAD_BUTTON6" );
  111. addKeyName(KEY_BUTTON7, "PAD_BUTTON7" );
  112. addKeyName(KEY_BUTTON8, "PAD_BUTTON8" );
  113. addKeyName(KEY_BUTTON9, "PAD_BUTTON9" );
  114. addKeyName(KEY_BUTTON10, "PAD_BUTTON10" );
  115. addKeyName(KEY_BUTTON11, "PAD_BUTTON11" );
  116. addKeyName(KEY_BUTTON12, "PAD_BUTTON12" );
  117. addKeyName(KEY_BUTTON13, "PAD_BUTTON13" );
  118. addKeyName(KEY_BUTTON14, "PAD_BUTTON14" );
  119. addKeyName(KEY_BUTTON15, "PAD_BUTTON15" );
  120. addKeyName(KEY_BACKSPACE, "Backsp" );
  121. addKeyName(KEY_DELETE, "Del" );
  122. addKeyName(KEY_SHIFT, "Shift" );
  123. addKeyName(KEY_CONTROL, "Ctrl" );
  124. addKeyName(KEY_ALT, "Alt" );
  125. addKeyName(KEY_HYPHEN, "-" );
  126. addKeyName(KEY_EQUALS, "=" );
  127. addKeyName(KEY_INSERT, "Ins" );
  128. addKeyName(KEY_CAPSLOCK, "CapsLock" );
  129. }
  130. LLKeyboard::~LLKeyboard()
  131. {
  132. // nothing
  133. }
  134. void LLKeyboard::addKeyName(KEY key, const std::string& name)
  135. {
  136. sKeysToNames[key] = name;
  137. std::string nameuc = name;
  138. LLStringUtil::toUpper(nameuc);
  139. sNamesToKeys[nameuc] = key;
  140. }
  141. // BUG this has to be called when an OS dialog is shown, otherwise modifier key state
  142. // is wrong because the keyup event is never received by the main window. JC
  143. void LLKeyboard::resetKeys()
  144. {
  145. S32 i;
  146. for (i = 0; i < KEY_COUNT; i++)
  147. {
  148. if( mKeyLevel[i] )
  149. {
  150. mKeyLevel[i] = FALSE;
  151. }
  152. }
  153. for (i = 0; i < KEY_COUNT; i++)
  154. {
  155. mKeyUp[i] = FALSE;
  156. }
  157. for (i = 0; i < KEY_COUNT; i++)
  158. {
  159. mKeyDown[i] = FALSE;
  160. }
  161. for (i = 0; i < KEY_COUNT; i++)
  162. {
  163. mKeyRepeated[i] = FALSE;
  164. }
  165. }
  166. BOOL LLKeyboard::translateKey(const U16 os_key, KEY *out_key)
  167. {
  168. std::map<U16, KEY>::iterator iter;
  169. // Only translate keys in the map, ignore all other keys for now
  170. iter = mTranslateKeyMap.find(os_key);
  171. if (iter == mTranslateKeyMap.end())
  172. {
  173. //llwarns << "Unknown virtual key " << os_key << llendl;
  174. *out_key = 0;
  175. return FALSE;
  176. }
  177. else
  178. {
  179. *out_key = iter->second;
  180. return TRUE;
  181. }
  182. }
  183. U16 LLKeyboard::inverseTranslateKey(const KEY translated_key)
  184. {
  185. std::map<KEY, U16>::iterator iter;
  186. iter = mInvTranslateKeyMap.find(translated_key);
  187. if (iter == mInvTranslateKeyMap.end())
  188. {
  189. return 0;
  190. }
  191. else
  192. {
  193. return iter->second;
  194. }
  195. }
  196. BOOL LLKeyboard::handleTranslatedKeyDown(KEY translated_key, U32 translated_mask)
  197. {
  198. BOOL handled = FALSE;
  199. BOOL repeated = FALSE;
  200. // is this the first time the key went down?
  201. // if so, generate "character" message
  202. if( !mKeyLevel[translated_key] )
  203. {
  204. mKeyLevel[translated_key] = TRUE;
  205. mKeyLevelTimer[translated_key].reset();
  206. mKeyLevelFrameCount[translated_key] = 0;
  207. mKeyRepeated[translated_key] = FALSE;
  208. }
  209. else
  210. {
  211. // Level is already down, assume it's repeated.
  212. repeated = TRUE;
  213. mKeyRepeated[translated_key] = TRUE;
  214. }
  215. mKeyDown[translated_key] = TRUE;
  216. mCurTranslatedKey = (KEY)translated_key;
  217. handled = mCallbacks->handleTranslatedKeyDown(translated_key, translated_mask, repeated);
  218. return handled;
  219. }
  220. BOOL LLKeyboard::handleTranslatedKeyUp(KEY translated_key, U32 translated_mask)
  221. {
  222. BOOL handled = FALSE;
  223. if( mKeyLevel[translated_key] )
  224. {
  225. mKeyLevel[translated_key] = FALSE;
  226. // Only generate key up events if the key is thought to
  227. // be down.  This allows you to call resetKeys() in the
  228. // middle of a frame and ignore subsequent KEY_UP
  229. // messages in the same frame.  This was causing the
  230. // sequence W<return> in chat to move agents forward. JC
  231. mKeyUp[translated_key] = TRUE;
  232. handled = mCallbacks->handleTranslatedKeyUp(translated_key, translated_mask);
  233. }
  234. lldebugst(LLERR_USER_INPUT) << "keyup -" << translated_key << "-" << llendl;
  235. return handled;
  236. }
  237. void LLKeyboard::toggleInsertMode()
  238. {
  239. if (LL_KIM_INSERT == mInsertMode)
  240. {
  241. mInsertMode = LL_KIM_OVERWRITE;
  242. }
  243. else
  244. {
  245. mInsertMode = LL_KIM_INSERT;
  246. }
  247. }
  248. // Returns time in seconds since key was pressed.
  249. F32 LLKeyboard::getKeyElapsedTime(KEY key)
  250. {
  251. return mKeyLevelTimer[key].getElapsedTimeF32();
  252. }
  253. // Returns time in frames since key was pressed.
  254. S32 LLKeyboard::getKeyElapsedFrameCount(KEY key)
  255. {
  256. return mKeyLevelFrameCount[key];
  257. }
  258. // static
  259. BOOL LLKeyboard::keyFromString(const std::string& str, KEY *key)
  260. {
  261. std::string instring(str);
  262. size_t length = instring.size();
  263. if (length < 1)
  264. {
  265. return FALSE;
  266. }
  267. if (length == 1)
  268. {
  269. char ch = toupper(instring[0]);
  270. if (('0' <= ch && ch <= '9') ||
  271. ('A' <= ch && ch <= 'Z') ||
  272. ('!' <= ch && ch <= '/') || // !"#$%&'()*+,-./
  273. (':' <= ch && ch <= '@') || // :;<=>?@
  274. ('[' <= ch && ch <= '`') || // []^_`
  275. ('{' <= ch && ch <= '~'))   // {|}~
  276. {
  277. *key = ch;
  278. return TRUE;
  279. }
  280. }
  281. LLStringUtil::toUpper(instring);
  282. KEY res = get_if_there(sNamesToKeys, instring, (KEY)0);
  283. if (res != 0)
  284. {
  285. *key = res;
  286. return TRUE;
  287. }
  288. llwarns << "keyFromString failed: " << str << llendl;
  289. return FALSE;
  290. }
  291. // static
  292. std::string LLKeyboard::stringFromKey(KEY key)
  293. {
  294. std::string res = get_if_there(sKeysToNames, key, std::string());
  295. if (res.empty())
  296. {
  297. char buffer[2]; /* Flawfinder: ignore */
  298. buffer[0] = key;
  299. buffer[1] = '';
  300. res = std::string(buffer);
  301. }
  302. return res;
  303. }
  304. //static
  305. std::string LLKeyboard::stringFromAccelerator( MASK accel_mask, KEY key )
  306. {
  307. std::string res;
  308. // break early if this is a silly thing to do.
  309. if( KEY_NONE == key )
  310. {
  311. return res;
  312. }
  313. LLKeyStringTranslatorFunc *trans = gKeyboard->mStringTranslator;
  314. if( trans == NULL )
  315. {
  316. llerrs << "No mKeyStringTranslator" << llendl;
  317. return res;
  318. }
  319. // Append any masks
  320. #ifdef LL_DARWIN
  321. // Standard Mac names for modifier keys in menu equivalents
  322. // We could use the symbol characters, but they only exist in certain fonts.
  323. if( accel_mask & MASK_CONTROL )
  324. {
  325. if ( accel_mask & MASK_MAC_CONTROL )
  326. {
  327. res.append( trans("accel-mac-control") );
  328. }
  329. else
  330. {
  331. res.append( trans("accel-mac-command") ); // Symbol would be "xE2x8Cx98"
  332. }
  333. }
  334. if( accel_mask & MASK_ALT )
  335. res.append( trans("accel-mac-option") ); // Symbol would be "xE2x8CxA5"
  336. if( accel_mask & MASK_SHIFT )
  337. res.append( trans("accel-mac-shift") ); // Symbol would be "xE2x8CxA7"
  338. #else
  339. if( accel_mask & MASK_CONTROL )
  340. res.append( trans("accel-win-control") );
  341. if( accel_mask & MASK_ALT )
  342. res.append( trans("accel-win-alt") );
  343. if( accel_mask & MASK_SHIFT )
  344. res.append( trans("accel-win-shift") );
  345. #endif
  346. std::string key_string = LLKeyboard::stringFromKey(key);
  347. if ((accel_mask & MASK_NORMALKEYS) &&
  348. (key_string[0] == '-' || key_string[0] == '=' || key_string[0] == '+'))
  349. {
  350. res.append( " " );
  351. }
  352. std::string keystr = stringFromKey( key );
  353. res.append( keystr );
  354. return res;
  355. }
  356. //static
  357. BOOL LLKeyboard::maskFromString(const std::string& str, MASK *mask)
  358. {
  359. std::string instring(str);
  360. if (instring == "NONE")
  361. {
  362. *mask = MASK_NONE;
  363. return TRUE;
  364. }
  365. else if (instring == "SHIFT")
  366. {
  367. *mask = MASK_SHIFT;
  368. return TRUE;
  369. }
  370. else if (instring == "CTL")
  371. {
  372. *mask = MASK_CONTROL;
  373. return TRUE;
  374. }
  375. else if (instring == "ALT")
  376. {
  377. *mask = MASK_ALT;
  378. return TRUE;
  379. }
  380. else if (instring == "CTL_SHIFT")
  381. {
  382. *mask = MASK_CONTROL | MASK_SHIFT;
  383. return TRUE;
  384. }
  385. else if (instring == "ALT_SHIFT")
  386. {
  387. *mask = MASK_ALT | MASK_SHIFT;
  388. return TRUE;
  389. }
  390. else if (instring == "CTL_ALT")
  391. {
  392. *mask = MASK_CONTROL | MASK_ALT;
  393. return TRUE;
  394. }
  395. else if (instring == "CTL_ALT_SHIFT")
  396. {
  397. *mask = MASK_CONTROL | MASK_ALT | MASK_SHIFT;
  398. return TRUE;
  399. }
  400. else 
  401. {
  402. return FALSE;
  403. }
  404. }
  405. //static
  406. void LLKeyboard::setStringTranslatorFunc( LLKeyStringTranslatorFunc *trans_func )
  407. {
  408. mStringTranslator = trans_func;
  409. }