keytrans.cpp
上传用户:tigerk9
上传日期:2020-03-10
资源大小:237k
文件大小:7k
源码类别:

Telnet客户端

开发平台:

Visual C++

  1. ///////////////////////////////////////////////////////////////////////////////
  2. //Telnet Win32 : an ANSI telnet client.
  3. //Copyright (C) 1998-2000 Paul Brannan
  4. //Copyright (C) 1998 I.Ioannou
  5. //Copyright (C) 1997 Brad Johnson
  6. //
  7. //This program is free software; you can redistribute it and/or
  8. //modify it under the terms of the GNU General Public License
  9. //as published by the Free Software Foundation; either version 2
  10. //of the License, or (at your option) any later version.
  11. //
  12. //This program is distributed in the hope that it will be useful,
  13. //but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. //GNU General Public License for more details.
  16. //
  17. //You should have received a copy of the GNU General Public License
  18. //along with this program; if not, write to the Free Software
  19. //Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. //
  21. //I.Ioannou
  22. //roryt@hol.gr
  23. //
  24. ///////////////////////////////////////////////////////////////////////////
  25. ///////////////////////////////////////////////////////////////////
  26. //      Key translations - I.Ioannou (roryt@hol.gr)              //
  27. //          Athens - Greece    December 18, 1996 02:56am         //
  28. //          Reads a .cfg file and keeps the definitions          //
  29. //      modified for alternate keymap swiching                   //
  30. //          by Andrey V. Smilianets (smile@head.aval.kiev.ua)    //
  31. //          Kiev - Ukraine, December 1997.                       //
  32. //      modified to work with MSVC and the Standard Template     //
  33. //          library by Paul Brannan <pbranna@clemson.edu>,       //
  34. //          May 25, 1998                                         //
  35. //      updated June 7, 1998 by Paul Brannan to remove cout and  //
  36. //          cerr statements                                      //
  37. //      APP_KEY and APP2_Key added July 12, 1998 by Paul Brannan //
  38. ///////////////////////////////////////////////////////////////////
  39. //                class KeyTranslator                            //
  40. //  Load          : loads or replaces the keymap                 //
  41. //  TranslateKey  : returns a char * to the key def              //
  42. //  AddKeyDef     : Changes or adds the key translation          //
  43. //  DeleteKeyDef  : Deletes a key def from the list              //
  44. ///////////////////////////////////////////////////////////////////
  45. #include <windows.h>
  46. // changed to make work with VC++ (Paul Brannan 5/25/98)
  47. // FIX ME !!! Ioannou:  This must be __BORLANDC__ && VERSION < 5
  48. // but what is the directive for Borland version ????
  49. // FIXED Sept. 31, 2000 (Bernard Badger)
  50. //
  51. #if defined(__BORLANDC__) && (__BORLANDC < 0x0500)
  52. #include <mem.h>
  53. #else
  54. #include <memory.h>
  55. #endif
  56. #include "keytrans.h"
  57. #include "tnerror.h"
  58. /////////////////////////////////////////////////////////////
  59. //                class KeyTranslator                      //
  60. //  Load          : loads or replaces the keymap           //
  61. //  TranslateKey  : returns a sz to the key def            //
  62. //  AddKeyDef     : Changes or adds the key translation    //
  63. //  DeleteKeyDef  : Deletes a key def from the list        //
  64. /////////////////////////////////////////////////////////////
  65. KeyTranslator::KeyTranslator():
  66. mapArray(0,0,sizeof(KeyMap)),
  67. globals(0,0,sizeof(TKeyDef)) {
  68. ext_mode = 0; // Paul Brannan 8/28/98
  69. currentKeyMap = mainKeyMap = -1;
  70. };
  71. //AVS
  72. // perform keymap switching
  73. int KeyTranslator::switchMap(TKeyDef& tk) {
  74.     if ( mapArray.IsEmpty() ) {
  75. return currentKeyMap = -1;
  76.     };
  77.     int i = mapArray.Find(KeyMap(tk));
  78.     if ( i != INT_MAX ) {
  79. if (currentKeyMap == i)
  80.             currentKeyMap = mainKeyMap; // restore to default
  81. else currentKeyMap = i;
  82. return 1;
  83.     };
  84.     return 0;
  85. };
  86. // Let the calling function interpret the error code (Paul Brannan 12/17/98)
  87. int KeyTranslator::SwitchTo(int to) {
  88.     int max = mapArray.GetItemsInContainer();
  89.     if (max == 0) return -1;
  90.     if (to < 0 || to > (max-1)) return 0;
  91.     currentKeyMap = to;
  92.     return 1;
  93. };
  94. //AVS
  95. // rewrited to support multiple keymaps
  96. const char *KeyTranslator::TranslateKey(WORD wVirtualKeyCode,
  97.   DWORD dwControlKeyState)
  98. {
  99. if ( mapArray.IsEmpty() ) return NULL;
  100. TKeyDef ask(NULL, dwControlKeyState, wVirtualKeyCode);
  101. // if a keymap switch pressed
  102. if ( switchMap(ask) > 0 ) return "";
  103. int i = mapArray[currentKeyMap].map.Find(ask);
  104. if ( i != INT_MAX) return mapArray[currentKeyMap].map[i].GetszKey();
  105. // if not found in current keymap
  106. if ( currentKeyMap != mainKeyMap ) {
  107. i = mapArray[mainKeyMap].map.Find(ask);
  108. if ( i != INT_MAX)  return mapArray[mainKeyMap].map[i].GetszKey();
  109. };
  110. return NULL;
  111. };
  112. //AVS
  113. // rewrited to support multiple keymaps
  114. int KeyTranslator::AddKeyDef(WORD wVirtualKeyCode, DWORD dwControlKeyState,
  115.                              char*lpzKeyDef)
  116. {
  117. if ( ! mapArray[currentKeyMap].map.IsEmpty() ) {
  118. int i = mapArray[currentKeyMap].map.Find(TKeyDef(NULL, dwControlKeyState, wVirtualKeyCode));
  119. if ( i != INT_MAX) {
  120. mapArray[currentKeyMap].map[i] = lpzKeyDef;
  121. return 1;
  122. }
  123. };
  124. return mapArray[currentKeyMap].map.Add( TKeyDef(lpzKeyDef, dwControlKeyState, wVirtualKeyCode));
  125. }
  126. // Paul Brannan Feb. 22, 1999
  127. int KeyTranslator::AddKeyDef(WORD wVirtualKeyCode, DWORD dwControlKeyState,
  128.                              tn_ops the_op)
  129. {
  130. optype op;
  131. op.sendstr = 0;
  132. op.the_op = the_op;
  133. if ( ! mapArray[currentKeyMap].map.IsEmpty() ) {
  134. int i = mapArray[currentKeyMap].map.Find(TKeyDef(NULL, dwControlKeyState, wVirtualKeyCode));
  135. if ( i != INT_MAX) {
  136. mapArray[currentKeyMap].map[i] = op;
  137. return 1;
  138. }
  139. };
  140. return mapArray[currentKeyMap].map.Add( TKeyDef(op, dwControlKeyState, wVirtualKeyCode));
  141. }
  142. // AVS
  143. int KeyTranslator::LookOnGlobal(char* vkey) {
  144.     if ( ! globals.IsEmpty() ) {
  145. int max = globals.GetItemsInContainer();
  146. for ( int i = 0; i < max ; i++ )
  147. if ( stricmp(globals[i].GetszKey(), vkey) == 0 )
  148. return i;
  149.     };
  150.     return INT_MAX;
  151. };
  152. int KeyTranslator::AddGlobalDef(WORD wVirtualKeyCode, char*lpzKeyDef) {
  153. if ( ! globals.IsEmpty() ) {
  154. int max = globals.GetItemsInContainer();
  155. for ( int i = 0; i < max ; i++ ) {
  156. const char *s = globals[i].GetszKey();
  157. if ( stricmp(s, lpzKeyDef) == 0 ) {
  158. globals[i] = DWORD(wVirtualKeyCode);
  159. return 1;
  160. }
  161. }
  162. }
  163. return globals.Add( TKeyDef(lpzKeyDef, 0, wVirtualKeyCode));
  164. }
  165. //AVS
  166. // rewrited to support multiple keymaps
  167. int KeyTranslator::DeleteKeyDef(WORD wVirtualKeyCode, DWORD dwControlKeyState)
  168. {
  169. if ( mapArray.IsEmpty() || mapArray[currentKeyMap].map.IsEmpty() )
  170. return 0;
  171. int i = mapArray[currentKeyMap].map.Find(TKeyDef(NULL, dwControlKeyState, wVirtualKeyCode));
  172. if ( i != INT_MAX) {
  173. mapArray[currentKeyMap].map.Destroy(i);
  174. return 1;
  175. };
  176. return 0;
  177. };
  178. //AVS
  179. // rewritten to support multiple keymaps
  180. void KeyTranslator::DeleteAllDefs(void)
  181. {
  182. // This code wants to crash under the STL; Apparently the Destroy()
  183. // function actually deletes the entry, rather than simply releasing
  184. // memory.  I think flush() should do the same thing, at least the
  185. // way it is written with STL_BIDS (Paul Brannan 5/25/98).
  186. int max;
  187. max = mapArray.GetItemsInContainer();
  188. if ( ! mapArray.IsEmpty() ) {
  189. for ( int i = 0; i < max; i++ ) {
  190. if ( !mapArray[i].map.IsEmpty() ) {
  191. mapArray[i].map.Flush();
  192. };
  193. };
  194. };
  195. globals.Flush();
  196. mapArray.Flush();
  197. currentKeyMap = -1;
  198. mainKeyMap    = -1;
  199. };