baseport/src/cedar/generic/base/syborg/keymap/keymap.cpp
changeset 2 d55eb581a87c
parent 1 2fb8b9db1c86
child 3 c2946f91d81f
equal deleted inserted replaced
1:2fb8b9db1c86 2:d55eb581a87c
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of the License "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: This is for a UK Keyboard
       
    15 *
       
    16 */
       
    17 
       
    18 #include <k32keys.h>
       
    19 
       
    20 //#define US_KEYBOARD
       
    21 
       
    22 // the "array" parameter must be a true array and not a pointer
       
    23 #define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))
       
    24 
       
    25 #define TABLE_ENTRY_ANOTHER_CTRL_DIGIT					\
       
    26 	{  													\
       
    27 		{												\
       
    28 		EModifierKeyUp|EModifierFunc,	                \
       
    29 		0												\
       
    30 		},												\
       
    31 		{												\
       
    32 		EKeyNull,										\
       
    33 		EAnyDigitGivenRadix								\
       
    34 		},												\
       
    35 		{												\
       
    36 		EStateCtrlDigits,								\
       
    37 		EAddOnCtrlDigit,								\
       
    38 		0												\
       
    39 		}												\
       
    40 	}
       
    41 
       
    42 // This table is searched for a match if a match has not been
       
    43 // found in the current state's table
       
    44 
       
    45 LOCAL_D const SFuncTableEntry defaultTable[]=
       
    46 	{
       
    47 		{ // prevent key up events generating keycodes
       
    48 			{
       
    49 			EModifierKeyUp,
       
    50 			EModifierKeyUp
       
    51 			},
       
    52 			{
       
    53 			EKeyNull,
       
    54 			EAnyKey
       
    55 			},
       
    56 			{
       
    57 			EStateUnchanged,
       
    58 			EDoNothing,
       
    59 			0
       
    60 			}
       
    61 		},
       
    62 		{ // prevent any modifer key from changing state
       
    63 			{
       
    64 			0,
       
    65 			0
       
    66 			},
       
    67 			{
       
    68 			EKeyNull,
       
    69 			EAnyModifierKey
       
    70 			},
       
    71 			{
       
    72 			EStateUnchanged,
       
    73 			EDoNothing,
       
    74 			0
       
    75 			}
       
    76 		},
       
    77 		{ // filter out any unprocessed codes???
       
    78 			{
       
    79 			0,
       
    80 			0
       
    81 			},
       
    82 			{
       
    83 			EKeyNull,
       
    84 			EAnyKey
       
    85 			},
       
    86 			{
       
    87 			EStateNormal,
       
    88 			EDoNothing,
       
    89 			0
       
    90 			}
       
    91 		}
       
    92 	};
       
    93 
       
    94 // The table indicating which keys change which modifiers;
       
    95 // the state field in this table is ignored
       
    96 LOCAL_D const SFuncTableEntry modifierTable[]=
       
    97 	{
       
    98         {
       
    99 			{
       
   100 			EModifierKeyUp,
       
   101 			0
       
   102 			},
       
   103 			{
       
   104 			EKeyCapsLock,
       
   105 			EMatchKey
       
   106 			},
       
   107 			{
       
   108 			EStateUnchanged,
       
   109 			EToggleModifier,
       
   110 			EModifierCapsLock
       
   111 			}
       
   112 		},
       
   113 		{
       
   114 			{
       
   115 			EModifierKeyUp,
       
   116 			0
       
   117 			},
       
   118 			{
       
   119 			EKeyNumLock,
       
   120 			EMatchKey
       
   121 			},
       
   122 			{
       
   123 			EStateUnchanged,
       
   124 			EToggleModifier,
       
   125 			EModifierNumLock
       
   126 			}
       
   127 		},
       
   128 		{
       
   129 			{
       
   130 			EModifierKeyUp,
       
   131 			0
       
   132 			},
       
   133 			{
       
   134 			EKeyScrollLock,
       
   135 			EMatchKey
       
   136 			},
       
   137 			{
       
   138 			EStateUnchanged,
       
   139 			EToggleModifier,
       
   140 			EModifierScrollLock
       
   141 			}
       
   142 		},
       
   143 		{
       
   144 			{
       
   145 			EModifierKeyUp,
       
   146 			0
       
   147 			},
       
   148 			{
       
   149 			EKeyLeftAlt,
       
   150 			EMatchKey
       
   151 			},
       
   152 			{
       
   153 			EStateUnchanged,
       
   154 			ETurnOnModifier,
       
   155 			EModifierAlt|EModifierLeftAlt
       
   156 			}
       
   157 		},
       
   158 		{
       
   159 			{
       
   160 			EModifierKeyUp,
       
   161 			EModifierKeyUp
       
   162 			},
       
   163 			{
       
   164 			EKeyLeftAlt,
       
   165 			EMatchKey
       
   166 			},
       
   167 			{
       
   168 			EStateUnchanged,
       
   169 			ETurnOffModifier,
       
   170 			EModifierLeftAlt
       
   171 			}
       
   172 		},
       
   173 		{
       
   174 			{
       
   175 			EModifierKeyUp,
       
   176 			0
       
   177 			},
       
   178 			{
       
   179 			EKeyLeftFunc,
       
   180 			EMatchKey
       
   181 			},
       
   182 			{
       
   183 			EStateUnchanged,
       
   184 			ETurnOnModifier,
       
   185 			EModifierFunc|EModifierLeftFunc
       
   186 			}
       
   187 		},
       
   188 		{
       
   189 			{
       
   190 			EModifierKeyUp,
       
   191 			EModifierKeyUp
       
   192 			},
       
   193 			{
       
   194 			EKeyLeftFunc,
       
   195 			EMatchKey
       
   196 			},
       
   197 			{
       
   198 			EStateUnchanged,
       
   199 			ETurnOffModifier,
       
   200 			EModifierLeftFunc
       
   201 			}
       
   202 		},
       
   203 		{
       
   204 			{
       
   205 			EModifierKeyUp,
       
   206 			0
       
   207 			},
       
   208 			{
       
   209 			EKeyLeftShift,
       
   210 			EMatchKey
       
   211 			},
       
   212 			{
       
   213 			EStateUnchanged,
       
   214 			ETurnOnModifier,
       
   215 			EModifierShift|EModifierLeftShift
       
   216 			}
       
   217 		},
       
   218 		{
       
   219 			{
       
   220 			EModifierKeyUp,
       
   221 			EModifierKeyUp
       
   222 			},
       
   223 			{
       
   224 			EKeyLeftShift,
       
   225 			EMatchKey
       
   226 			},
       
   227 			{
       
   228 			EStateUnchanged,
       
   229 			ETurnOffModifier,
       
   230 			EModifierLeftShift
       
   231 			}
       
   232 		},
       
   233 		{
       
   234 			{
       
   235 			EModifierKeyUp,
       
   236 			0
       
   237 			},
       
   238 			{
       
   239 			EKeyLeftCtrl,
       
   240 			EMatchKey
       
   241 			},
       
   242 			{
       
   243 			EStateUnchanged,
       
   244 			ETurnOnModifier,
       
   245 			EModifierCtrl|EModifierLeftCtrl
       
   246 			}
       
   247 		},
       
   248 		{
       
   249 			{
       
   250 			EModifierKeyUp,
       
   251 			EModifierKeyUp
       
   252 			},
       
   253 			{
       
   254 			EKeyLeftCtrl,
       
   255 			EMatchKey
       
   256 			},
       
   257 			{
       
   258 			EStateUnchanged,
       
   259 			ETurnOffModifier,
       
   260 			EModifierLeftCtrl
       
   261 			}
       
   262         },
       
   263 		{
       
   264 			{
       
   265 			EModifierKeyUp,
       
   266 			0
       
   267 			},
       
   268 			{
       
   269 			EKeyRightAlt,
       
   270 			EMatchKey
       
   271 			},
       
   272 			{
       
   273 			EStateUnchanged,
       
   274 			ETurnOnModifier,
       
   275 			EModifierAlt|EModifierRightAlt
       
   276 			}
       
   277 		},
       
   278 		{
       
   279 			{
       
   280 			EModifierKeyUp,
       
   281 			EModifierKeyUp
       
   282 			},
       
   283 			{
       
   284 			EKeyRightAlt,
       
   285 			EMatchKey
       
   286 			},
       
   287 			{
       
   288 			EStateUnchanged,
       
   289 			ETurnOffModifier,
       
   290 			EModifierRightAlt
       
   291 			}
       
   292 		},
       
   293 		{
       
   294 			{
       
   295 			EModifierKeyUp,
       
   296 			0
       
   297 			},
       
   298 			{
       
   299 			EKeyRightFunc,
       
   300 			EMatchKey
       
   301 			},
       
   302 			{
       
   303 			EStateUnchanged,
       
   304 			ETurnOnModifier,
       
   305 			EModifierFunc|EModifierRightFunc
       
   306 			}
       
   307 		},
       
   308 		{
       
   309 			{
       
   310 			EModifierKeyUp,
       
   311 			EModifierKeyUp
       
   312 			},
       
   313 			{
       
   314 			EKeyRightFunc,
       
   315 			EMatchKey
       
   316 			},
       
   317 			{
       
   318 			EStateUnchanged,
       
   319 			ETurnOffModifier,
       
   320 			EModifierRightFunc
       
   321 			}
       
   322 		},
       
   323 		{
       
   324 			{
       
   325 			EModifierKeyUp,
       
   326 			0
       
   327 			},
       
   328 			{
       
   329 			EKeyRightShift,
       
   330 			EMatchKey
       
   331 			},
       
   332 			{
       
   333 			EStateUnchanged,
       
   334 			ETurnOnModifier,
       
   335 			EModifierShift|EModifierRightShift
       
   336 			}
       
   337 		},
       
   338 		{
       
   339 			{
       
   340 			EModifierKeyUp,
       
   341 			EModifierKeyUp
       
   342 			},
       
   343 			{
       
   344 			EKeyRightShift,
       
   345 			EMatchKey
       
   346 			},
       
   347 			{
       
   348 			EStateUnchanged,
       
   349 			ETurnOffModifier,
       
   350 			EModifierRightShift
       
   351 			}
       
   352 		},
       
   353 		{
       
   354 			{
       
   355 			EModifierKeyUp,
       
   356 			0
       
   357 			},
       
   358 			{
       
   359 			EKeyRightCtrl,
       
   360 			EMatchKey
       
   361 			},
       
   362 			{
       
   363 			EStateUnchanged,
       
   364 			ETurnOnModifier,
       
   365 			EModifierCtrl|EModifierRightCtrl
       
   366 			}
       
   367 		},
       
   368 		{
       
   369 			{
       
   370 			EModifierKeyUp,
       
   371 			EModifierKeyUp
       
   372 			},
       
   373 			{
       
   374 			EKeyRightCtrl,
       
   375 			EMatchKey
       
   376 			},
       
   377 			{
       
   378 			EStateUnchanged,
       
   379 			ETurnOffModifier,
       
   380 			EModifierRightCtrl
       
   381 			}
       
   382 		}
       
   383 	};
       
   384 
       
   385 // table0 to table12 are the tables corresponding to states
       
   386 // 0 to 12 respectively
       
   387 
       
   388 //LOCAL_D const SFuncTableEntry table0[]=
       
   389 //	{
       
   390 //	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
   391 //	};
       
   392 
       
   393 LOCAL_D const SFuncTableEntry table1[]=
       
   394 	{
       
   395 		{
       
   396 			{
       
   397 			EModifierFunc|EModifierKeyUp,
       
   398 			0
       
   399 			},
       
   400 			{
       
   401 			'e',
       
   402 			EMatchKeyCaseInsens
       
   403 			},
       
   404 			{
       
   405 			EStateNormal,
       
   406 			EPassSpecialKeyThru,
       
   407 			ELatin1LcAe
       
   408 			}
       
   409 		},
       
   410 		{
       
   411 			{
       
   412 			EModifierFunc|EModifierKeyUp,
       
   413 			0
       
   414 			},
       
   415 			{
       
   416 			'c',
       
   417 			EMatchKeyCaseInsens
       
   418 			},
       
   419 			{
       
   420 			EStateNormal,
       
   421 			EPassSpecialKeyThru,
       
   422 			ELatin1LcCcedilla
       
   423 			}
       
   424 		},
       
   425 		{
       
   426 			{
       
   427 			EModifierFunc|EModifierKeyUp,
       
   428 			0
       
   429 			},
       
   430 			{
       
   431 			's',
       
   432 			EMatchKeyCaseInsens
       
   433 			},
       
   434 			{
       
   435 			EStateNormal,
       
   436 			EPassSpecialKeyThru,
       
   437 			ELatin1EsTset
       
   438 			}
       
   439 		},
       
   440 		{
       
   441 			{
       
   442 			EModifierFunc|EModifierKeyUp,
       
   443 			0
       
   444 			},
       
   445 			{
       
   446 			'o',
       
   447 			EMatchKeyCaseInsens
       
   448 			},
       
   449 			{
       
   450 			EStateNormal,
       
   451 			EPassSpecialKeyThru,
       
   452 			ELatin1LcOslash
       
   453 			}
       
   454 		},
       
   455 		{
       
   456 			{
       
   457 			EModifierFunc|EModifierKeyUp,
       
   458 			0
       
   459 			},
       
   460 			{
       
   461 			'd',
       
   462 			EMatchKeyCaseInsens
       
   463 			},
       
   464 			{
       
   465 			EStateNormal,
       
   466 			EPassSpecialKeyThru,
       
   467 			ELatin1LcThorn
       
   468 			}
       
   469 		},
       
   470 		{
       
   471 			{
       
   472 			EModifierFunc|EModifierKeyUp,
       
   473 			0
       
   474 			},
       
   475 			{
       
   476 			't',
       
   477 			EMatchKeyCaseInsens
       
   478 			},
       
   479 			{
       
   480 			EStateNormal,
       
   481 			EPassSpecialKeyThru,
       
   482 			ELatin1LcSoftTh
       
   483 			}
       
   484 		},
       
   485 		{
       
   486 			{
       
   487 			EModifierFunc|EModifierKeyUp,
       
   488 			0
       
   489 			},
       
   490 			{
       
   491 			'l',
       
   492 			EMatchKeyCaseInsens
       
   493 			},
       
   494 			{
       
   495 			EStateNormal,
       
   496 			EPassSpecialKeyThru,
       
   497 			ELatin1LeftChevron
       
   498 			}
       
   499 		},
       
   500 		{
       
   501 			{
       
   502 			EModifierFunc|EModifierKeyUp,
       
   503 			0
       
   504 			},
       
   505 			{
       
   506 			'r',
       
   507 			EMatchKeyCaseInsens
       
   508 			},
       
   509 			{
       
   510 			EStateNormal,
       
   511 			EPassSpecialKeyThru,
       
   512 			ELatin1RightChevron
       
   513 			}
       
   514 		},
       
   515 		{
       
   516 			{
       
   517 			EModifierFunc|EModifierKeyUp,
       
   518 			0
       
   519 			},
       
   520 			{
       
   521 			'x',
       
   522 			EMatchKeyCaseInsens
       
   523 			},
       
   524 			{
       
   525 			EStateNormal,
       
   526 			EPassSpecialKeyThru,
       
   527 			ELatin1InvExclam
       
   528 			}
       
   529 		},
       
   530 		{
       
   531 			{
       
   532 			EModifierFunc|EModifierKeyUp,
       
   533 			0
       
   534 			},
       
   535 			{
       
   536 			'q',
       
   537 			EMatchKeyCaseInsens
       
   538 			},
       
   539 			{
       
   540 			EStateNormal,
       
   541 			EPassSpecialKeyThru,
       
   542 			ELatin1InvQuest
       
   543 			}
       
   544 		},
       
   545 		{
       
   546 			{
       
   547 			EModifierFunc|EModifierKeyUp,
       
   548 			0
       
   549 			},
       
   550 			{
       
   551 			'a',
       
   552 			EMatchKeyCaseInsens
       
   553 			},
       
   554 			{
       
   555 			EStateNormal,
       
   556 			EPassSpecialKeyThru,
       
   557 			ELatin1LcAo
       
   558 			}
       
   559 		},
       
   560 		{
       
   561 			{
       
   562 			EModifierFunc|EModifierKeyUp,
       
   563 			0
       
   564 			},
       
   565 			{
       
   566 			'p',
       
   567 			EMatchKeyCaseInsens
       
   568 			},
       
   569 			{
       
   570 			EStateNormal,
       
   571 			EPassSpecialKeyThru,
       
   572 			ELatin1Pound
       
   573 			}
       
   574 		},
       
   575 	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
   576 	};
       
   577 
       
   578 LOCAL_D const SFuncTableEntry table2[]=
       
   579 	{
       
   580 		{
       
   581 			{
       
   582 			EModifierFunc|EModifierKeyUp,
       
   583 			0
       
   584 			},
       
   585 			{
       
   586 			'a',
       
   587 			EMatchKeyCaseInsens
       
   588 			},
       
   589 			{
       
   590 			EStateNormal,
       
   591 			EPassSpecialKeyThru,
       
   592 			ELatin1LcAumlaut
       
   593 			}
       
   594 		},
       
   595 		{
       
   596 			{
       
   597 			EModifierFunc|EModifierKeyUp,
       
   598 			0
       
   599 			},
       
   600 			{
       
   601 			'e',
       
   602 			EMatchKeyCaseInsens
       
   603 			},
       
   604 			{
       
   605 			EStateNormal,
       
   606 			EPassSpecialKeyThru,
       
   607 			ELatin1LcEumlaut
       
   608 			}
       
   609 		},
       
   610 		{
       
   611 			{
       
   612 			EModifierFunc|EModifierKeyUp,
       
   613 			0
       
   614 			},
       
   615 			{
       
   616 			'i',
       
   617 			EMatchKeyCaseInsens
       
   618 			},
       
   619 			{
       
   620 			EStateNormal,
       
   621 			EPassSpecialKeyThru,
       
   622 			ELatin1LcIumlaut
       
   623 			}
       
   624 		},
       
   625 		{
       
   626 			{
       
   627 			EModifierFunc|EModifierKeyUp,
       
   628 			0
       
   629 			},
       
   630 			{
       
   631 			'o',
       
   632 			EMatchKeyCaseInsens
       
   633 			},
       
   634 			{
       
   635 			EStateNormal,
       
   636 			EPassSpecialKeyThru,
       
   637 			ELatin1LcOumlaut
       
   638 			}
       
   639 		},
       
   640 		{
       
   641 			{
       
   642 			EModifierFunc|EModifierKeyUp,
       
   643 			0
       
   644 			},
       
   645 			{
       
   646 			'u',
       
   647 			EMatchKeyCaseInsens
       
   648 			},
       
   649 			{
       
   650 			EStateNormal,
       
   651 			EPassSpecialKeyThru,
       
   652 			ELatin1LcUumlaut
       
   653 			}
       
   654 		},
       
   655 		{
       
   656 			{
       
   657 			EModifierFunc|EModifierKeyUp,
       
   658 			0
       
   659 			},
       
   660 			{
       
   661 			'y',
       
   662 			EMatchKeyCaseInsens
       
   663 			},
       
   664 			{
       
   665 			EStateNormal,
       
   666 			EPassSpecialKeyThru,
       
   667 			ELatin1LcYumlaut
       
   668 			}
       
   669 		},
       
   670 		{
       
   671 			{
       
   672 			EModifierFunc|EModifierKeyUp,
       
   673 			0
       
   674 			},
       
   675 			{
       
   676 			' ',
       
   677 			EMatchKey
       
   678 			},
       
   679 			{
       
   680 			EStateNormal,
       
   681 			EPassSpecialKeyThru,
       
   682 			ELatin1SpaceUmlaut
       
   683 			}
       
   684 		},
       
   685 	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
   686 	};
       
   687 
       
   688 LOCAL_D const SFuncTableEntry table3[]=
       
   689 	{
       
   690 		{
       
   691 			{
       
   692 			EModifierFunc|EModifierKeyUp,
       
   693 			0
       
   694 			},
       
   695 			{
       
   696 			'a',
       
   697 			EMatchKeyCaseInsens
       
   698 			},
       
   699 			{
       
   700 			EStateNormal,
       
   701 			EPassSpecialKeyThru,
       
   702 			ELatin1LcAgrave
       
   703 			}
       
   704 		},
       
   705 		{
       
   706 			{
       
   707 			EModifierFunc|EModifierKeyUp,
       
   708 			0
       
   709 			},
       
   710 			{
       
   711 			'e',
       
   712 			EMatchKeyCaseInsens
       
   713 			},
       
   714 			{
       
   715 			EStateNormal,
       
   716 			EPassSpecialKeyThru,
       
   717 			ELatin1LcEgrave
       
   718 			}
       
   719 		},
       
   720 		{
       
   721 			{
       
   722 			EModifierFunc|EModifierKeyUp,
       
   723 			0
       
   724 			},
       
   725 			{
       
   726 			'i',
       
   727 			EMatchKeyCaseInsens
       
   728 			},
       
   729 			{
       
   730 			EStateNormal,
       
   731 			EPassSpecialKeyThru,
       
   732 			ELatin1LcIgrave
       
   733 			}
       
   734 		},
       
   735 		{
       
   736 			{
       
   737 			EModifierFunc|EModifierKeyUp,
       
   738 			0
       
   739 			},
       
   740 			{
       
   741 			'o',
       
   742 			EMatchKeyCaseInsens
       
   743 			},
       
   744 			{
       
   745 			EStateNormal,
       
   746 			EPassSpecialKeyThru,
       
   747 			ELatin1LcOgrave
       
   748 			}
       
   749 		},
       
   750 		{
       
   751 			{
       
   752 			EModifierFunc|EModifierKeyUp,
       
   753 			0
       
   754 			},
       
   755 			{
       
   756 			'u',
       
   757 			EMatchKeyCaseInsens
       
   758 			},
       
   759 			{
       
   760 			EStateNormal,
       
   761 			EPassSpecialKeyThru,
       
   762 			ELatin1LcUgrave
       
   763 			}
       
   764 		},
       
   765 		{
       
   766 			{
       
   767 			EModifierFunc|EModifierKeyUp,
       
   768 			0
       
   769 			},
       
   770 			{
       
   771 			' ',
       
   772 			EMatchKey
       
   773 			},
       
   774 			{
       
   775 			EStateNormal,
       
   776 			EPassSpecialKeyThru,
       
   777 			ELatin1SpaceGrave
       
   778 			}
       
   779 		},
       
   780 	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
   781 	};
       
   782 
       
   783 LOCAL_D const SFuncTableEntry table4[]=
       
   784 	{
       
   785 		{
       
   786 			{
       
   787 			EModifierFunc|EModifierKeyUp,
       
   788 			0
       
   789 			},
       
   790 			{
       
   791 			'a',
       
   792 			EMatchKeyCaseInsens
       
   793 			},
       
   794 			{
       
   795 			EStateNormal,
       
   796 			EPassSpecialKeyThru,
       
   797 			ELatin1LcAacute
       
   798 			}
       
   799 		},
       
   800 		{
       
   801 			{
       
   802 			EModifierFunc|EModifierKeyUp,
       
   803 			0
       
   804 			},
       
   805 			{
       
   806 			'e',
       
   807 			EMatchKeyCaseInsens
       
   808 			},
       
   809 			{
       
   810 			EStateNormal,
       
   811 			EPassSpecialKeyThru,
       
   812 			ELatin1LcEacute
       
   813 			}
       
   814 		},
       
   815 		{
       
   816 			{
       
   817 			EModifierFunc|EModifierKeyUp,
       
   818 			0
       
   819 			},
       
   820 			{
       
   821 			'i',
       
   822 			EMatchKeyCaseInsens
       
   823 			},
       
   824 			{
       
   825 			EStateNormal,
       
   826 			EPassSpecialKeyThru,
       
   827 			ELatin1LcIacute
       
   828 			}
       
   829 		},
       
   830 		{
       
   831 			{
       
   832 			EModifierFunc|EModifierKeyUp,
       
   833 			0
       
   834 			},
       
   835 			{
       
   836 			'o',
       
   837 			EMatchKeyCaseInsens
       
   838 			},
       
   839 			{
       
   840 			EStateNormal,
       
   841 			EPassSpecialKeyThru,
       
   842 			ELatin1LcOacute
       
   843 			}
       
   844 		},
       
   845 		{
       
   846 			{
       
   847 			EModifierFunc|EModifierKeyUp,
       
   848 			0
       
   849 			},
       
   850 			{
       
   851 			'u',
       
   852 			EMatchKeyCaseInsens
       
   853 			},
       
   854 			{
       
   855 			EStateNormal,
       
   856 			EPassSpecialKeyThru,
       
   857 			ELatin1LcUacute
       
   858 			}
       
   859 		},
       
   860 		{
       
   861 			{
       
   862 			EModifierFunc|EModifierKeyUp,
       
   863 			0
       
   864 			},
       
   865 			{
       
   866 			'y',
       
   867 			EMatchKeyCaseInsens
       
   868 			},
       
   869 			{
       
   870 			EStateNormal,
       
   871 			EPassSpecialKeyThru,
       
   872 			ELatin1LcYacute
       
   873 			}
       
   874 		},
       
   875 		{
       
   876 			{
       
   877 			EModifierFunc|EModifierKeyUp,
       
   878 			0
       
   879 			},
       
   880 			{
       
   881 			' ',
       
   882 			EMatchKey
       
   883 			},
       
   884 			{
       
   885 			EStateNormal,
       
   886 			EPassSpecialKeyThru,
       
   887 			ELatin1LcSpaceAcute
       
   888 			}
       
   889 		},
       
   890 	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
   891 	};
       
   892 
       
   893 LOCAL_D const SFuncTableEntry table5[]=
       
   894 	{
       
   895 		{
       
   896 			{
       
   897 			EModifierFunc|EModifierKeyUp,
       
   898 			0
       
   899 			},
       
   900 			{
       
   901 			'a',
       
   902 			EMatchKeyCaseInsens
       
   903 			},
       
   904 			{
       
   905 			EStateNormal,
       
   906 			EPassSpecialKeyThru,
       
   907 			ELatin1LcAtilde
       
   908 			}
       
   909 		},
       
   910 		{
       
   911 			{
       
   912 			EModifierFunc|EModifierKeyUp,
       
   913 			0
       
   914 			},
       
   915 			{
       
   916 			'n',
       
   917 			EMatchKeyCaseInsens
       
   918 			},
       
   919 			{
       
   920 			EStateNormal,
       
   921 			EPassSpecialKeyThru,
       
   922 			ELatin1LcNtilde
       
   923 			}
       
   924 		},
       
   925 		{
       
   926 			{
       
   927 			EModifierFunc|EModifierKeyUp,
       
   928 			0
       
   929 			},
       
   930 			{
       
   931 			'o',
       
   932 			EMatchKeyCaseInsens
       
   933 			},
       
   934 			{
       
   935 			EStateNormal,
       
   936 			EPassSpecialKeyThru,
       
   937 			ELatin1LcOtilde
       
   938 			}
       
   939 		},
       
   940 		{
       
   941 			{
       
   942 			EModifierFunc|EModifierKeyUp,
       
   943 			0
       
   944 			},
       
   945 			{
       
   946 			' ',
       
   947 			EMatchKey
       
   948 			},
       
   949 			{
       
   950 			EStateNormal,
       
   951 			EPassSpecialKeyThru,
       
   952 			ELatin1LcSpaceTilde
       
   953 			}
       
   954 		},
       
   955 	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
   956 	};
       
   957 
       
   958 LOCAL_D const SFuncTableEntry table6[]=
       
   959 	{
       
   960 		{
       
   961 			{
       
   962 			EModifierFunc|EModifierKeyUp,
       
   963 			0
       
   964 			},
       
   965 			{
       
   966 			'a',
       
   967 			EMatchKeyCaseInsens
       
   968 			},
       
   969 			{
       
   970 			EStateNormal,
       
   971 			EPassSpecialKeyThru,
       
   972 			ELatin1LcAcirc
       
   973 			}
       
   974 		},
       
   975 		{
       
   976 			{
       
   977 			EModifierFunc|EModifierKeyUp,
       
   978 			0
       
   979 			},
       
   980 			{
       
   981 			'e',
       
   982 			EMatchKeyCaseInsens
       
   983 			},
       
   984 			{
       
   985 			EStateNormal,
       
   986 			EPassSpecialKeyThru,
       
   987 			ELatin1LcEcirc
       
   988 			}
       
   989 		},
       
   990 		{
       
   991 			{
       
   992 			EModifierFunc|EModifierKeyUp,
       
   993 			0
       
   994 			},
       
   995 			{
       
   996 			'i',
       
   997 			EMatchKeyCaseInsens
       
   998 			},
       
   999 			{
       
  1000 			EStateNormal,
       
  1001 			EPassSpecialKeyThru,
       
  1002 			ELatin1LcIcirc
       
  1003 			}
       
  1004 		},
       
  1005 		{
       
  1006 			{
       
  1007 			EModifierFunc|EModifierKeyUp,
       
  1008 			0
       
  1009 			},
       
  1010 			{
       
  1011 			'o',
       
  1012 			EMatchKeyCaseInsens
       
  1013 			},
       
  1014 			{
       
  1015 			EStateNormal,
       
  1016 			EPassSpecialKeyThru,
       
  1017 			ELatin1LcOcirc
       
  1018 			}
       
  1019 		},
       
  1020 		{
       
  1021 			{
       
  1022 			EModifierFunc|EModifierKeyUp,
       
  1023 			0
       
  1024 			},
       
  1025 			{
       
  1026 			'u',
       
  1027 			EMatchKeyCaseInsens
       
  1028 			},
       
  1029 			{
       
  1030 			EStateNormal,
       
  1031 			EPassSpecialKeyThru,
       
  1032 			ELatin1LcUcirc
       
  1033 			}
       
  1034 		},
       
  1035 		{
       
  1036 			{
       
  1037 			EModifierFunc|EModifierKeyUp,
       
  1038 			0
       
  1039 			},
       
  1040 			{
       
  1041 			' ',
       
  1042 			EMatchKey
       
  1043 			},
       
  1044 			{
       
  1045 			EStateNormal,
       
  1046 			EPassSpecialKeyThru,
       
  1047 			ELatin1LcSpaceCirc
       
  1048 			}
       
  1049 		},
       
  1050 	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
  1051 	};
       
  1052 
       
  1053 //LOCAL_D const SFuncTableEntry table7[]=
       
  1054 //	{
       
  1055 //	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
  1056 //	};
       
  1057 
       
  1058 //LOCAL_D const SFuncTableEntry table8[]=
       
  1059 //	{
       
  1060 //	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
  1061 //	};
       
  1062 
       
  1063 //LOCAL_D const SFuncTableEntry table9[]=
       
  1064 //	{
       
  1065 //	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
  1066 //	};
       
  1067 
       
  1068 LOCAL_D const SFuncTableEntry table10[]=
       
  1069 	{
       
  1070 		{ // filter out up key strokes
       
  1071 			{
       
  1072 			EModifierKeyUp,
       
  1073 			EModifierKeyUp
       
  1074 			},
       
  1075 			{
       
  1076 			EKeyNull,
       
  1077 			EAnyKey
       
  1078 			},
       
  1079 			{
       
  1080 			EStateUnchanged,
       
  1081 			EDoNothing,
       
  1082 			0
       
  1083 			}
       
  1084 		},
       
  1085 		{ // check for ctrl-number presses
       
  1086 			{
       
  1087 			EModifierCtrl|EModifierFunc|EModifierKeyUp,
       
  1088 			EModifierCtrl
       
  1089 			},
       
  1090 			{
       
  1091 			EKeyNull,
       
  1092 			EAnyDecimalDigit
       
  1093 			},
       
  1094 			{
       
  1095 			EStateDerivedFromDigitEntered,
       
  1096 			EAddOnCtrlDigit,
       
  1097 			0
       
  1098 			}
       
  1099 		},
       
  1100 		{ // pass thru any keys which can't be state control keys
       
  1101 			{
       
  1102 			EModifierFunc,
       
  1103 			0,
       
  1104 			},
       
  1105 			{
       
  1106 			EKeyNull,
       
  1107 			EAnyKey
       
  1108 			},
       
  1109 			{
       
  1110 			EStateUnchanged,
       
  1111 			EPassKeyThru,
       
  1112 			0
       
  1113 			}
       
  1114 		},
       
  1115 		{ // pass thru any keys which can't be state control keys
       
  1116 			{
       
  1117 			EModifierCtrl,
       
  1118 			EModifierCtrl,
       
  1119 			},
       
  1120 			{
       
  1121 			EKeyNull,
       
  1122 			EAnyKey
       
  1123 			},
       
  1124 			{
       
  1125 			EStateUnchanged,
       
  1126 			EPassKeyThru,
       
  1127 			0
       
  1128 			}
       
  1129 		},
       
  1130 		{ // check for FN-q
       
  1131 			{
       
  1132 			EModifierCtrl|EModifierFunc|EModifierKeyUp,
       
  1133 			EModifierFunc
       
  1134 			},
       
  1135 			{
       
  1136 			'q',
       
  1137 			EMatchKeyCaseInsens
       
  1138 			},
       
  1139 			{
       
  1140 			1,
       
  1141 			EDoNothing,
       
  1142 			0
       
  1143 			}
       
  1144 		},
       
  1145 		{ // check for FN-z
       
  1146 			{
       
  1147 			EModifierCtrl|EModifierFunc|EModifierKeyUp,
       
  1148 			EModifierFunc
       
  1149 			},
       
  1150 			{
       
  1151 			'z',
       
  1152 			EMatchKeyCaseInsens
       
  1153 			},
       
  1154 			{
       
  1155 			2,
       
  1156 			EDoNothing,
       
  1157 			0
       
  1158 			}
       
  1159 		},
       
  1160 		{ // check for FN-x
       
  1161 			{
       
  1162 			EModifierCtrl|EModifierFunc|EModifierKeyUp,
       
  1163 			EModifierFunc
       
  1164 			},
       
  1165 			{
       
  1166 			'x',
       
  1167 			EMatchKeyCaseInsens
       
  1168 			},
       
  1169 			{
       
  1170 			3,
       
  1171 			EDoNothing,
       
  1172 			0
       
  1173 			}
       
  1174 		},
       
  1175 		{ // check for FN-c
       
  1176 			{
       
  1177 			EModifierCtrl|EModifierFunc|EModifierKeyUp,
       
  1178 			EModifierFunc
       
  1179 			},
       
  1180 			{
       
  1181 			'c',
       
  1182 			EMatchKeyCaseInsens
       
  1183 			},
       
  1184 			{
       
  1185 			4,
       
  1186 			EDoNothing,
       
  1187 			0
       
  1188 			}
       
  1189 		},
       
  1190 		{ // check for FN-v
       
  1191 			{
       
  1192 			EModifierCtrl|EModifierFunc|EModifierKeyUp,
       
  1193 			EModifierFunc
       
  1194 			},
       
  1195 			{
       
  1196 			'v',
       
  1197 			EMatchKeyCaseInsens
       
  1198 			},
       
  1199 			{
       
  1200 			5,
       
  1201 			EDoNothing,
       
  1202 			0
       
  1203 			}
       
  1204 		},
       
  1205 		{ // check for FN-b
       
  1206 			{
       
  1207 			EModifierCtrl|EModifierFunc|EModifierKeyUp,
       
  1208 			EModifierFunc
       
  1209 			},
       
  1210 			{
       
  1211 			'b',
       
  1212 			EMatchKeyCaseInsens
       
  1213 			},
       
  1214 			{
       
  1215 			6,
       
  1216 			EDoNothing,
       
  1217 			0
       
  1218 			}
       
  1219 		},
       
  1220 		{ // pass thru any non-processed keys
       
  1221 			{
       
  1222 			0,
       
  1223 			0
       
  1224 			},
       
  1225 			{
       
  1226 			EKeyNull,
       
  1227 			EAnyKey
       
  1228 			},
       
  1229 			{
       
  1230 			EStateUnchanged,
       
  1231 			EPassKeyThru,
       
  1232 			0
       
  1233 			}
       
  1234 		}
       
  1235 	};
       
  1236 
       
  1237 //LOCAL_D const SFuncTableEntry table11[]=
       
  1238 //	{
       
  1239 //	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
  1240 //	};
       
  1241 
       
  1242 LOCAL_D const SFuncTableEntry table12[]=
       
  1243 	{  
       
  1244 		{
       
  1245 			{
       
  1246 			EModifierKeyUp,
       
  1247 			EModifierKeyUp
       
  1248 			},
       
  1249 			{
       
  1250 			EKeyLeftCtrl,
       
  1251 			EMatchLeftOrRight
       
  1252 			},
       
  1253 			{
       
  1254 			EStateNormal,
       
  1255 			EPassCtrlDigitsThru,
       
  1256 			0
       
  1257 			}
       
  1258 		},
       
  1259 	TABLE_ENTRY_ANOTHER_CTRL_DIGIT
       
  1260 	};
       
  1261 
       
  1262 LOCAL_D const SFuncTable genFuncTables[]=
       
  1263 	{
       
  1264 		{
       
  1265 		0,
       
  1266 		NULL
       
  1267 		},
       
  1268 		{
       
  1269 		ARRAY_LENGTH(table1),
       
  1270 		&table1[0]
       
  1271 		},
       
  1272 		{
       
  1273 		ARRAY_LENGTH(table2),
       
  1274 		&table2[0]
       
  1275 		},
       
  1276 		{
       
  1277 		ARRAY_LENGTH(table3),
       
  1278 		&table3[0]
       
  1279 		},
       
  1280 		{
       
  1281 		ARRAY_LENGTH(table4),
       
  1282 		&table4[0]
       
  1283 		},
       
  1284 		{
       
  1285 		ARRAY_LENGTH(table5),
       
  1286 		&table5[0]
       
  1287 		},
       
  1288 		{
       
  1289 		ARRAY_LENGTH(table6),
       
  1290 		&table6[0]
       
  1291 		},
       
  1292 		{
       
  1293 		0,
       
  1294 		NULL
       
  1295 		},
       
  1296 		{
       
  1297 		0,
       
  1298 		NULL
       
  1299 		},
       
  1300 		{
       
  1301 		0,
       
  1302 		NULL
       
  1303 		},
       
  1304 		{
       
  1305 		ARRAY_LENGTH(table10),
       
  1306 		&table10[0]
       
  1307 		},
       
  1308 		{
       
  1309 		0,
       
  1310 		NULL
       
  1311 		},
       
  1312 		{
       
  1313 		ARRAY_LENGTH(table12),
       
  1314 		&table12[0]
       
  1315 		}
       
  1316 	};
       
  1317 
       
  1318 LOCAL_D const SFuncTables FuncTables=
       
  1319 	{
       
  1320 		{
       
  1321 		ARRAY_LENGTH(defaultTable),
       
  1322 		&defaultTable[0]
       
  1323 		},
       
  1324 		{
       
  1325 		ARRAY_LENGTH(modifierTable),
       
  1326 		&modifierTable[0]
       
  1327 		},
       
  1328 	ARRAY_LENGTH(genFuncTables),
       
  1329 	&genFuncTables[0]
       
  1330 	};
       
  1331 
       
  1332 LOCAL_D const SScanCodeBlock scanCodeBlock_unmodifiable[]=
       
  1333 	{
       
  1334 	{EStdKeyLeftShift, EStdKeyScrollLock}
       
  1335 	};
       
  1336 
       
  1337 LOCAL_D const TUint16 convKeyCodes_unmodifiable[]=
       
  1338 	{
       
  1339 	EKeyLeftShift,
       
  1340 	EKeyRightShift,
       
  1341 	EKeyLeftAlt,
       
  1342 	EKeyRightAlt,
       
  1343 	EKeyLeftCtrl,
       
  1344 	EKeyRightCtrl,
       
  1345 	EKeyLeftFunc,
       
  1346 	EKeyRightFunc,
       
  1347 	EKeyCapsLock,
       
  1348 	EKeyNumLock,
       
  1349 	EKeyScrollLock
       
  1350 	};
       
  1351 
       
  1352 // base: this table traps all of the keyboard's scanCodes except those in convKeyCodes_unmodifiable
       
  1353 LOCAL_D const SScanCodeBlock scanCodeBlock_base[]=
       
  1354 	{
       
  1355 	{EStdKeyNull, EStdKeyDownArrow},
       
  1356 	{'0', '9'},
       
  1357 	{'A', 'Z'},
       
  1358 	{EStdKeyF1, EStdKeyDictaphoneRecord},
       
  1359 	};
       
  1360 
       
  1361 LOCAL_D const TUint16 convKeyCodes_base[]=
       
  1362 	{
       
  1363 	EKeyNull,
       
  1364 	EKeyBackspace,
       
  1365 	EKeyTab,
       
  1366 	EKeyEnter,
       
  1367 	EKeyEscape,
       
  1368 	' ',
       
  1369 	EKeyPrintScreen,
       
  1370 	EKeyPause,
       
  1371 	EKeyHome,
       
  1372 	EKeyEnd,
       
  1373 	EKeyPageUp,
       
  1374 	EKeyPageDown,
       
  1375 	EKeyInsert,
       
  1376 	EKeyDelete,
       
  1377 	EKeyLeftArrow,
       
  1378 	EKeyRightArrow,
       
  1379 	EKeyUpArrow,
       
  1380 	EKeyDownArrow,
       
  1381 	'0',
       
  1382 	'1',
       
  1383 	'2',
       
  1384 	'3',
       
  1385 	'4',
       
  1386 	'5',
       
  1387 	'6',
       
  1388 	'7',
       
  1389 	'8',
       
  1390 	'9',
       
  1391 	'a',
       
  1392 	'b',
       
  1393 	'c',
       
  1394 	'd',
       
  1395 	'e',
       
  1396 	'f',
       
  1397 	'g',
       
  1398 	'h',
       
  1399 	'i',
       
  1400 	'j',
       
  1401 	'k',
       
  1402 	'l',
       
  1403 	'm',
       
  1404 	'n',
       
  1405 	'o',
       
  1406 	'p',
       
  1407 	'q',
       
  1408 	'r',
       
  1409 	's',
       
  1410 	't',
       
  1411 	'u',
       
  1412 	'v',
       
  1413 	'w',
       
  1414 	'x',
       
  1415 	'y',
       
  1416 	'z',
       
  1417 	EKeyF1,
       
  1418 	EKeyF2,
       
  1419 	EKeyF3,
       
  1420 	EKeyF4,
       
  1421 	EKeyF5,
       
  1422 	EKeyF6,
       
  1423 	EKeyF7,
       
  1424 	EKeyF8,
       
  1425 	EKeyF9,
       
  1426 	EKeyF10,
       
  1427 	EKeyF11,
       
  1428 	EKeyF12,
       
  1429 	EKeyF13,
       
  1430 	EKeyF14,
       
  1431 	EKeyF15,
       
  1432 	EKeyF16,
       
  1433 	EKeyF17,
       
  1434 	EKeyF18,
       
  1435 	EKeyF19,
       
  1436 	EKeyF20,
       
  1437 	EKeyF21,
       
  1438 	EKeyF22,
       
  1439 	EKeyF23,
       
  1440 	EKeyF24,
       
  1441 	'`',
       
  1442 	',',
       
  1443 	'.',
       
  1444 	'/',
       
  1445 	'\\',
       
  1446 	';',
       
  1447 	'\'',
       
  1448 #ifndef US_KEYBOARD
       
  1449 	'#',
       
  1450 #else
       
  1451 	'\\',
       
  1452 #endif
       
  1453 	'[',
       
  1454 	']',
       
  1455 	'-',
       
  1456 	'=',
       
  1457 	'/',
       
  1458 	'*',
       
  1459 	'-',
       
  1460 	'+',
       
  1461 	EKeyEnter,
       
  1462 	EKeyEnd,
       
  1463 	EKeyDownArrow,
       
  1464 	EKeyPageDown,
       
  1465 	EKeyLeftArrow,
       
  1466 	EKeyNull, // numeric keypad '5'
       
  1467 	EKeyRightArrow,
       
  1468 	EKeyHome,
       
  1469 	EKeyUpArrow,
       
  1470 	EKeyPageUp,
       
  1471 	EKeyInsert,
       
  1472 	EKeyDelete,
       
  1473     EKeyMenu,
       
  1474     EKeyBacklightOn,
       
  1475     EKeyBacklightOff,
       
  1476     EKeyBacklightToggle,
       
  1477     EKeyIncContrast,
       
  1478     EKeyDecContrast,
       
  1479     EKeySliderDown,
       
  1480     EKeySliderUp,
       
  1481     EKeyDictaphonePlay,
       
  1482     EKeyDictaphoneStop,
       
  1483     EKeyDictaphoneRecord,
       
  1484 	};
       
  1485 
       
  1486 // caps-lock: this table traps those scanCodes which are affected by caps-lock
       
  1487 LOCAL_D const SScanCodeBlock scanCodeBlock_capsLock[]=
       
  1488 	{
       
  1489 	{'A', 'Z'}
       
  1490 	};
       
  1491 
       
  1492 LOCAL_D const TUint16 convKeyCodes_capsLock[]=
       
  1493 	{
       
  1494 	'A',
       
  1495 	'B',
       
  1496 	'C',
       
  1497 	'D',
       
  1498 	'E',
       
  1499 	'F',
       
  1500 	'G',
       
  1501 	'H',
       
  1502 	'I',
       
  1503 	'J',
       
  1504 	'K',
       
  1505 	'L',
       
  1506 	'M',
       
  1507 	'N',
       
  1508 	'O',
       
  1509 	'P',
       
  1510 	'Q',
       
  1511 	'R',
       
  1512 	'S',
       
  1513 	'T',
       
  1514 	'U',
       
  1515 	'V',
       
  1516 	'W',
       
  1517 	'X',
       
  1518 	'Y',
       
  1519 	'Z'
       
  1520 	};
       
  1521 
       
  1522 // shift: this table traps those scanCodes which are affected
       
  1523 // by shift EXCEPT for those scanCodes affected by caps-lock
       
  1524 LOCAL_D const SScanCodeBlock scanCodeBlock_shift[]=
       
  1525 	{
       
  1526 	{'0', '9'},
       
  1527 	{EStdKeyXXX, EStdKeyEquals},
       
  1528 	};
       
  1529 
       
  1530 LOCAL_D const TUint16 convKeyCodes_shift[]=
       
  1531 	{
       
  1532 	')',
       
  1533 	'!',
       
  1534 	'"',
       
  1535 	ELatin1Pound,
       
  1536 	'$',
       
  1537 	'%',
       
  1538 	'^',
       
  1539 	'&',
       
  1540 	'*',
       
  1541 	'(',
       
  1542 	ELatin1LogicNot,
       
  1543 	'<',
       
  1544 	'>',
       
  1545 	'?',
       
  1546 	'|',
       
  1547 	':',
       
  1548 	'@',
       
  1549 	'~',
       
  1550 	'{',
       
  1551 	'}',
       
  1552 	'_',
       
  1553 	'+'
       
  1554 	};
       
  1555 
       
  1556 // numlock: this table traps those scanCodes which are affected by numlock
       
  1557 LOCAL_D const SScanCodeBlock scanCodeBlock_numLock[]=
       
  1558 	{
       
  1559 	{EStdKeyNkpForwardSlash, EStdKeyNkpFullStop}
       
  1560 	};
       
  1561 
       
  1562 LOCAL_D const TUint16 convKeyCodes_numLock[]=
       
  1563 	{
       
  1564 	'/',
       
  1565 	'*',
       
  1566 	'-',
       
  1567 	'+',
       
  1568 	EKeyEnter,
       
  1569 	'1',
       
  1570 	'2',
       
  1571 	'3',
       
  1572 	'4',
       
  1573 	'5',
       
  1574 	'6',
       
  1575 	'7',
       
  1576 	'8',
       
  1577 	'9',
       
  1578 	'0',
       
  1579 	'.'
       
  1580 	};
       
  1581 
       
  1582 // func: this table traps those scanCodes which are affected
       
  1583 // by func but not shift
       
  1584 LOCAL_D const SScanCodeBlock scanCodeBlock_func[]=
       
  1585 	{
       
  1586 	{'0', '9'},
       
  1587 	{'K', 'L'},
       
  1588 	{'U', 'U'},
       
  1589 	{'I', 'I'},
       
  1590 	{'O', 'P'},
       
  1591 	{EStdKeySingleQuote, EStdKeySingleQuote},
       
  1592 	{EStdKeyLeftArrow, EStdKeyDownArrow},
       
  1593 	{EStdKeyTab, EStdKeyTab},
       
  1594 	{EStdKeyEscape, EStdKeyEscape},
       
  1595 	{'M', 'M'},
       
  1596 	{EStdKeyComma, EStdKeyFullStop},
       
  1597 	{EStdKeySpace, EStdKeySpace},
       
  1598 	{EStdKeyMenu, EStdKeyMenu},
       
  1599 	};
       
  1600 
       
  1601 LOCAL_D const TUint16 convKeyCodes_func[]=
       
  1602 	{
       
  1603 	'}',
       
  1604 	'_',
       
  1605 	'#',
       
  1606 	'\\',
       
  1607 	'@',
       
  1608 	'<',
       
  1609 	'>',
       
  1610 	'[',
       
  1611 	']',
       
  1612 	'{',
       
  1613 	'~',
       
  1614 	';',
       
  1615 	'/',
       
  1616 	'*',
       
  1617 	'-',
       
  1618 	'+',
       
  1619 	':',
       
  1620 	EKeyHome,
       
  1621 	EKeyEnd,
       
  1622 	EKeyPageUp,
       
  1623 	EKeyPageDown,
       
  1624 	EKeyCapsLock,
       
  1625 	EKeyOff,
       
  1626 	EKeyDecContrast,
       
  1627 	EKeyHelp,
       
  1628 	EKeyIncContrast,
       
  1629 	EKeyBacklightToggle,
       
  1630 	EKeyDial,
       
  1631 	};
       
  1632 
       
  1633 // func: this table traps those scanCodes which are affected
       
  1634 // by func and shift - lower case entries
       
  1635 LOCAL_D const SScanCodeBlock scanCodeBlock_funcUnshifted[]=
       
  1636 	{
       
  1637 	{'E', 'E'},
       
  1638 	};
       
  1639 
       
  1640 LOCAL_D const TUint16 convKeyCodes_funcUnshifted[]=
       
  1641 	{
       
  1642 	ELatin1LcEacute,
       
  1643 	};
       
  1644 
       
  1645 // func: this table traps those scanCodes which are affected
       
  1646 // by func and shift - upper case entries
       
  1647 LOCAL_D const SScanCodeBlock scanCodeBlock_funcShifted[]=
       
  1648 	{
       
  1649 	{'E', 'E'},
       
  1650 	};
       
  1651 
       
  1652 LOCAL_D const TUint16 convKeyCodes_funcShifted[]=
       
  1653 	{
       
  1654 	ELatin1UcEacute,
       
  1655 	};
       
  1656 
       
  1657 // ctrl: this table traps those scanCodes which are affected by ctrl
       
  1658 LOCAL_D const SScanCodeBlock scanCodeBlock_ctrl[]=
       
  1659 	{
       
  1660 // The space key gets handled else where, otherwise it gets
       
  1661 // thrown away as a NULL key
       
  1662 //	{EStdKeySpace, EStdKeySpace},
       
  1663 
       
  1664 	{'A', 'Z'}
       
  1665 	};
       
  1666 
       
  1667 LOCAL_D const TUint16 convKeyCodes_ctrl[]=
       
  1668 	{
       
  1669 //	0,
       
  1670 	1,
       
  1671 	2,
       
  1672 	3,
       
  1673 	4,
       
  1674 	5,
       
  1675 	6,
       
  1676 	7,
       
  1677 	8,
       
  1678 	9,
       
  1679 	10,
       
  1680 	11,
       
  1681 	12,
       
  1682 	13,
       
  1683 	14,
       
  1684 	15,
       
  1685 	16,
       
  1686 	17,
       
  1687 	18,
       
  1688 	19,
       
  1689 	20,
       
  1690 	21,
       
  1691 	22,
       
  1692 	23,
       
  1693 	24,
       
  1694 	25,
       
  1695 	26
       
  1696 	};
       
  1697 
       
  1698 LOCAL_D const SConvSubTable
       
  1699 	convSubTable_unmodifiable=
       
  1700 		{
       
  1701 		&convKeyCodes_unmodifiable[0],
       
  1702 			{
       
  1703 			ARRAY_LENGTH(scanCodeBlock_unmodifiable),
       
  1704 			&scanCodeBlock_unmodifiable[0]
       
  1705 			}
       
  1706 		},
       
  1707     convSubTable_base=
       
  1708 		{
       
  1709 		&convKeyCodes_base[0],
       
  1710 			{
       
  1711 			ARRAY_LENGTH(scanCodeBlock_base),
       
  1712 			&scanCodeBlock_base[0]
       
  1713 			}
       
  1714 		},
       
  1715 	convSubTable_capsLock=
       
  1716 		{
       
  1717 		&convKeyCodes_capsLock[0],
       
  1718 			{
       
  1719 			ARRAY_LENGTH(scanCodeBlock_capsLock),
       
  1720 			&scanCodeBlock_capsLock[0]
       
  1721 			}
       
  1722 		},
       
  1723 	convSubTable_shift=
       
  1724 		{
       
  1725 		&convKeyCodes_shift[0],
       
  1726 			{
       
  1727 			ARRAY_LENGTH(scanCodeBlock_shift),
       
  1728 			&scanCodeBlock_shift[0]
       
  1729 			}
       
  1730 		},
       
  1731 	convSubTable_numLock=
       
  1732 		{
       
  1733 		&convKeyCodes_numLock[0],
       
  1734 			{
       
  1735 			ARRAY_LENGTH(scanCodeBlock_numLock),
       
  1736 			&scanCodeBlock_numLock[0]
       
  1737 			}
       
  1738         },
       
  1739 	convSubTable_func=
       
  1740 		{
       
  1741 		&convKeyCodes_func[0],
       
  1742 			{
       
  1743 			ARRAY_LENGTH(scanCodeBlock_func),
       
  1744 			&scanCodeBlock_func[0]
       
  1745 			}
       
  1746 		},
       
  1747 	convSubTable_funcUnshifted=
       
  1748 		{
       
  1749 		&convKeyCodes_funcUnshifted[0],
       
  1750 			{
       
  1751 			ARRAY_LENGTH(scanCodeBlock_funcUnshifted),
       
  1752 			&scanCodeBlock_funcUnshifted[0]
       
  1753 			}
       
  1754 		},
       
  1755 	convSubTable_funcShifted=
       
  1756 		{
       
  1757 		&convKeyCodes_funcShifted[0],
       
  1758 			{
       
  1759 			ARRAY_LENGTH(scanCodeBlock_funcShifted),
       
  1760 			&scanCodeBlock_funcShifted[0]
       
  1761 			}
       
  1762 		},
       
  1763 	convSubTable_ctrl=
       
  1764 		{
       
  1765 		&convKeyCodes_ctrl[0],
       
  1766 			{
       
  1767 			ARRAY_LENGTH(scanCodeBlock_ctrl),
       
  1768 			&scanCodeBlock_ctrl[0]
       
  1769 			}
       
  1770 		};
       
  1771 
       
  1772 // Some modifiers, e.g. shift, may required more than one table (other than "base")
       
  1773 // to be searched; therefore arrays of tables are required
       
  1774 LOCAL_D const SConvSubTable
       
  1775 	* const convSubTableArray_unmodifiable[]={&convSubTable_unmodifiable},
       
  1776 	* const convSubTableArray_base[]={&convSubTable_base},
       
  1777 	* const convSubTableArray_capsLock[]={&convSubTable_capsLock},
       
  1778 	* const convSubTableArray_shift[]={&convSubTable_capsLock, &convSubTable_shift},
       
  1779 	* const convSubTableArray_capsLockShift[]={&convSubTable_shift},
       
  1780 	* const convSubTableArray_numLock[]={&convSubTable_numLock},
       
  1781 	* const convSubTableArray_func[]={&convSubTable_func,&convSubTable_funcUnshifted},
       
  1782 	* const convSubTableArray_funcShift[]={&convSubTable_func,&convSubTable_funcShifted},
       
  1783 	* const convSubTableArray_ctrl[]={&convSubTable_ctrl};
       
  1784 
       
  1785 // The order of these nodes is VITAL, as the scanCode/modifiers are
       
  1786 // searched for a match in this order
       
  1787 LOCAL_D const SConvTableNode convTableNodes[]=
       
  1788 	{
       
  1789 		{
       
  1790 			{
       
  1791 			0,
       
  1792 			0
       
  1793 			},
       
  1794 		ARRAY_LENGTH(convSubTableArray_unmodifiable),
       
  1795 		&convSubTableArray_unmodifiable[0]
       
  1796 		},
       
  1797 		{
       
  1798 			{
       
  1799 			EModifierCtrl,
       
  1800 			EModifierCtrl
       
  1801 			},
       
  1802 		ARRAY_LENGTH(convSubTableArray_ctrl),
       
  1803 		&convSubTableArray_ctrl[0]
       
  1804 		},
       
  1805 		{
       
  1806 			{
       
  1807 			EModifierNumLock,
       
  1808 			EModifierNumLock
       
  1809 			},
       
  1810 		ARRAY_LENGTH(convSubTableArray_numLock),
       
  1811 		&convSubTableArray_numLock[0]
       
  1812 		},
       
  1813 		{
       
  1814 			{
       
  1815 			EModifierFunc|EModifierShift|EModifierCapsLock,
       
  1816 			EModifierFunc
       
  1817 			},
       
  1818 		ARRAY_LENGTH(convSubTableArray_func),
       
  1819 		&convSubTableArray_func[0]
       
  1820 		},
       
  1821 		{
       
  1822 			{
       
  1823 			EModifierFunc|EModifierShift|EModifierCapsLock,
       
  1824 			EModifierFunc|EModifierShift|EModifierCapsLock
       
  1825 			},
       
  1826 		ARRAY_LENGTH(convSubTableArray_func),
       
  1827 		&convSubTableArray_func[0]
       
  1828 		},
       
  1829 		{
       
  1830 			{
       
  1831 			EModifierFunc|EModifierShift|EModifierCapsLock,
       
  1832 			EModifierFunc|EModifierShift
       
  1833 			},
       
  1834 		ARRAY_LENGTH(convSubTableArray_funcShift),
       
  1835 		&convSubTableArray_funcShift[0]
       
  1836 		},
       
  1837 		{
       
  1838 			{
       
  1839 			EModifierFunc|EModifierShift|EModifierCapsLock,
       
  1840 			EModifierFunc|EModifierCapsLock
       
  1841 			},
       
  1842 		ARRAY_LENGTH(convSubTableArray_funcShift),
       
  1843 		&convSubTableArray_funcShift[0]
       
  1844 		},
       
  1845 		{
       
  1846 			{
       
  1847 			EModifierCapsLock|EModifierShift,
       
  1848 			EModifierCapsLock
       
  1849 			},
       
  1850 		ARRAY_LENGTH(convSubTableArray_capsLock),
       
  1851 		&convSubTableArray_capsLock[0]
       
  1852 		},
       
  1853 		{
       
  1854 			{
       
  1855 			EModifierShift|EModifierCapsLock,
       
  1856 			EModifierShift
       
  1857 			},
       
  1858 		ARRAY_LENGTH(convSubTableArray_shift),
       
  1859 		&convSubTableArray_shift[0]
       
  1860 		},
       
  1861 		{
       
  1862 			{
       
  1863 			EModifierCapsLock|EModifierShift,
       
  1864 			EModifierCapsLock|EModifierShift
       
  1865 			},
       
  1866 		ARRAY_LENGTH(convSubTableArray_capsLockShift),
       
  1867 		&convSubTableArray_capsLockShift[0]
       
  1868 		},
       
  1869 		{
       
  1870 			{
       
  1871 			0,
       
  1872 			0
       
  1873 			},
       
  1874 		ARRAY_LENGTH(convSubTableArray_base),
       
  1875 		&convSubTableArray_base[0]
       
  1876 		}
       
  1877 	};
       
  1878 
       
  1879 // The top-level exported data structure of all the conversion tables
       
  1880 LOCAL_D const SConvTable ConvTable=
       
  1881 	{
       
  1882 	ARRAY_LENGTH(convTableNodes),
       
  1883 	&convTableNodes[0]
       
  1884 	};
       
  1885 
       
  1886 // The list of scan-codes on the numeric keypad
       
  1887 LOCAL_D const SScanCodeBlock keypadScanCodeBlockArray[]=
       
  1888 	{
       
  1889 	{EStdKeyNumLock, EStdKeyNumLock},
       
  1890 	{EStdKeyNkpForwardSlash, EStdKeyNkpFullStop}
       
  1891 	};
       
  1892 
       
  1893 LOCAL_D const SScanCodeBlockList ConvTableKeypadScanCodes=
       
  1894 	{
       
  1895 	ARRAY_LENGTH(keypadScanCodeBlockArray),
       
  1896 	&keypadScanCodeBlockArray[0]
       
  1897 	};
       
  1898 
       
  1899 // The list of non-autorepeating key-codes
       
  1900 LOCAL_D const TUint16 nonAutorepKeyCodeArray[]=
       
  1901 	{
       
  1902 	EKeyEscape,
       
  1903 	EKeyPrintScreen,
       
  1904 	EKeyPause,
       
  1905 	EKeyInsert,
       
  1906 	EKeyLeftShift,
       
  1907 	EKeyRightShift,
       
  1908 	EKeyLeftAlt,
       
  1909 	EKeyRightAlt,
       
  1910 	EKeyLeftCtrl,
       
  1911 	EKeyRightCtrl,
       
  1912 	EKeyLeftFunc,
       
  1913 	EKeyRightFunc,
       
  1914 	EKeyCapsLock,
       
  1915 	EKeyNumLock,
       
  1916 	EKeyScrollLock,
       
  1917     EKeyMenu,
       
  1918     EKeyDictaphonePlay,
       
  1919     EKeyDictaphoneStop,
       
  1920     EKeyDictaphoneRecord
       
  1921 	};
       
  1922 
       
  1923 LOCAL_D const SKeyCodeList ConvTableNonAutorepKeyCodes=
       
  1924 	{
       
  1925 	ARRAY_LENGTH(nonAutorepKeyCodeArray),
       
  1926 	&nonAutorepKeyCodeArray[0]
       
  1927 	};
       
  1928 
       
  1929 EXPORT_C void KeyDataSettings(TRadix &aRadix,TCtrlDigitsTermination &aCtrlDigitsTermination,TInt &aDefaultCtrlDigitsMaxCount,
       
  1930 							  TInt &aMaximumCtrlDigitsMaxCount)
       
  1931 	{
       
  1932 	aRadix=EDecimal;
       
  1933 	aCtrlDigitsTermination=ETerminationByCtrlUp;
       
  1934 	aDefaultCtrlDigitsMaxCount=3;
       
  1935 	aMaximumCtrlDigitsMaxCount=10;
       
  1936 	}
       
  1937 
       
  1938 EXPORT_C void KeyDataFuncTable(SFuncTables &aFuncTables)
       
  1939 	{
       
  1940 	aFuncTables=FuncTables;
       
  1941 	}
       
  1942 
       
  1943 EXPORT_C void KeyDataConvTable(SConvTable &aConvTable, TUint &aConvTableFirstScanCode,TUint &aConvTableLastScanCode,
       
  1944 							 SScanCodeBlockList &aKeypadScanCode,SKeyCodeList &aNonAutorepKeyCodes)
       
  1945 	{
       
  1946 	aConvTable=ConvTable;
       
  1947 	aConvTableFirstScanCode=scanCodeBlock_base[0].firstScanCode;
       
  1948 	aConvTableLastScanCode=scanCodeBlock_base[ARRAY_LENGTH(scanCodeBlock_base)-1].lastScanCode;
       
  1949 	aKeypadScanCode=ConvTableKeypadScanCodes;
       
  1950 	aNonAutorepKeyCodes=ConvTableNonAutorepKeyCodes;
       
  1951 	}
       
  1952