at KeyWedge I posted my code that connects to a serial port and then simulates keystrokes into your application.

Now, there were issues where the reconnect did not automatically take place after a Suspend/Resume and you had to invoke the main window and select File-Hide just to let KeyWedge reconnect. This happens on devices that provide the communication port all the time and dont close it during a suspend.

I have added some code to watch the Windows Mobile Power Message Queue for RESUM messages and then do an automatic reconnect. The other option would have been to send some data thru the port periodically to check if it is still working. But this may disturb the attached the device.

The main change is in PowerMsgQueue.cpp. It implements the msg queue to receive power broadcast messages like done in a MSDN example code. If a resume message is encountered, the code sends a WM_USER message to the main window, which will do a SuspendComm/ResumeComm cycle. Very easy.

In PowerMsgQueue.cpp we have code that recognizes the resume:

                case PBT_TRANSITION:
                    nclog(L"Power Notification Message: PBT_TRANSITION\n");
                    //Add2Log(L"Power Notification Message: PBT_TRANSITION\n",TRUE);
                    nclog(L"Flags: %lx\n", ppb->Flags);
                    nclog(L"Length: %d\n", ppb->Length);
                    wsprintf(szPBtype, L"trans.: ");
/*
Flags: 12010000
Length: 6
trans.: ON|PASSWORD|BACKLIGHTON|
*/
                    if(ppb->Flags & 0x12010000)
                    {
                        nclog(L"PwrMsgQueue: got 'ON|PASSWORD|BACKLIGHTON'...\n");
                        //send a message to main window
                        iPost = PostMessage(hwndMain, WM_USER_RESUMECOMM, 0, 0);
                        nclog(L"PostMessage WM_USER_RESUMECOMM returned %i\n", iPost);
                    }
                    break; 

                case PBT_RESUME:
                    nclog(L"Power Notification Message: PBT_RESUME\n");
                    //Add2Log(L"Power Notification Message: PBT_RESUME\n",TRUE);
                    wsprintf(szPBtype, L"resume: ");
                    //send a message to main window
                    iPost = PostMessage(hwndMain, WM_USER_RESUMECOMM, 0, 0);
                    nclog(L"PostMessage WM_USER_RESUMECOMM returned %i\n", iPost);
                    nclog(L"Power: PBT_RESUME\n");
                    break;

To not block the queue, I use PostMessage to inform the main window of the Resume. Here is the simple code block in WndProc of the main window:

        case WM_USER_RESUMECOMM: //will be called from bg thread after suspend/resume
            nclog(L"WndProc: received WM_USER_RESUMECOMM: restarting COMM\n");
            suspendCOMM();
            Sleep(100);
            resumeCOMM(); //suspend is called in MYMSG_TASKBARNOTIFY
            break;

The msgQueue thread is created in InitInstance of the main window:

    //create PowerResume watchdog thread
    hwndMain=hWnd;
    if(startMsgThread()==0)
        nclog(L"InitInstance: startMsgThread() OK\r\n");
    else
        nclog(L"InitInstance: startMsgThread() FAILED\r\n");

    //helps
    resumeCOMM();

    ShowWindow(hWnd, SW_HIDE);//nCmdShow);
    UpdateWindow(hWnd);

Have fun coding

Josef

VS2008 WM6 SDK Project: DOWNLOAD:KeyWedge 2 - (Hits: 34, size: 682.7 kB)

Bookmark It

recently the following was requested:

How can I start an application by just hitting some keys in sequence?

The answer: Just use a keyboard hook.

So I started to code this hook tool based on my KeyToggleBoot2 code. There was not too much to change. The new tool is called KeyToggleStart and it is configured by the registry:

            REGEDIT4

            [HKEY_LOCAL_MACHINE\Software\Intermec\KeyToggleStart]
            "ForbiddenKeys"=hex:\
                  72 73 00
            ;max 10 keys!
            "KeySeq"="123"
            "Timeout"=dword:00000003
            "LEDid"=dword:00000001
            "Exe"="\\Windows\\iexplore.exe"
            "Arg"=""

Reg keys meaning:

Forbiddenkeys is just an addon feature: key codes entered in this list will not be processed any more by your Windows Mobile device. For example, to disable the use of the F3(VK_TTALK) and F4 (VK_TEND) keys you have to enter a binary list of 0×72,0×73,0×00 (the zero is needed to terminate the list).

KeySeq list the char sequence you want to use to start an application. For example if this is the string “123″, everytime you enter 123 in sequence within the given time, the application defined will be started.

TimeOut is the time in seconds you have to enter the sequence. So do not use a long key sequence as “starteiexplorenow” and a short timeout (except you are a very fast type writer). The timeout is started with the first char matching and ends after the time or when you enter a non-matching char of the sequence.

With LEDid you can specify a LED index number. LED’s on Windows Mobile are controlled by an index number, each LED has one or more ID assigned to it. So, with LEDid you can control, which LED will lit, when the matching process is running. You can even find an ID to control a vibration motor, if your Windows Mobile device is equipped with one.

The Exe registry string value is used to specify which application will be started when the key sequence is matched.

If the application you want have to be started needs some arguments, you can enter these using the Arg registry value.

When you start the KeyToggleStart tool, you will not see any window except for a notification symbol on your Start/Home screen of the device.

If you tap this icon (redirection sign) you have the chance to end the hook tool.

The code itself is nothing special. Only the sequence matching code is a little bit special. As the chars in the sequence do not match keystrokes in a ont-to-one manner, I have to check the shift state of the keyboard and if the current char of the seqeunce is a char needing a shift. For example: the asterisk char (“*”) is a combination of the “8″ key plus the Shift key. So, if you have the “*” in the char sequence, the code has to check for the “8″ key and if the keyboard is in shift state:

// The command below tells the OS that this EXE has an export function so we can use the global hook without a DLL
__declspec(dllexport) LRESULT CALLBACK g_LLKeyboardHookCallback(
   int nCode,      // The hook code
   WPARAM wParam,  // The window message (WM_KEYUP, WM_KEYDOWN, etc.)
   LPARAM lParam   // A pointer to a struct with information about the pressed key
)
{
    /*    typedef struct {
        DWORD vkCode;
        DWORD scanCode;
        DWORD flags;
        DWORD time;
        ULONG_PTR dwExtraInfo;
    } KBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT;*/

    // Get out of hooks ASAP; no modal dialogs or CPU-intensive processes!
    // UI code really should be elsewhere, but this is just a test/prototype app
    // In my limited testing, HC_ACTION is the only value nCode is ever set to in CE
    static int iActOn = HC_ACTION;
    static bool isShifted=false;

#ifdef DEBUG
    static TCHAR str[MAX_PATH];
#endif

    PKBDLLHOOKSTRUCT pkbhData = (PKBDLLHOOKSTRUCT)lParam;
    //DWORD vKey;
    if (nCode == iActOn)
    {
        //only process unflagged keys
        if (pkbhData->flags != 0x00)
            return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam);
        //check vkCode against forbidden key list
        if(pForbiddenKeyList!=NULL)
        {
            BOOL bForbidden=false;
            int j=0;
            do{
                if(pForbiddenKeyList[j]==(BYTE)pkbhData->vkCode)
                {
                    bForbidden=true;
                    DEBUGMSG(1, (L"suppressing forbidden key: 0x%0x\n",pkbhData->vkCode));
                    continue;
                }
                j++;
            }while(!bForbidden && pForbiddenKeyList[j]!=0x00);
            if(bForbidden){
                return true;
            }
        }

        SHORT sShifted = GetAsyncKeyState(VK_SHIFT);
        if((sShifted & 0x800) == 0x800)
            isShifted = true;
        else
            isShifted = false;

        //check and toggle for Shft Key
        //do not process shift key
        if (pkbhData->vkCode == VK_SHIFT){
            DEBUGMSG(1, (L"Ignoring VK_SHIFT\n"));
            return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam);
        }

        //################################################################
        //check if the actual key is a match key including the shift state
        if ((byte)pkbhData->vkCode == (byte)szVKeySeq[iMatched]){
            DEBUGMSG(1 , (L"==== char match\n"));
            if (bCharShiftSeq[iMatched] == isShifted){
                DEBUGMSG(1 , (L"==== shift match\n"));
            }
            else{
                DEBUGMSG(1 , (L"==== shift not match\n"));
            }
        }

        if( wParam == WM_KEYUP ){
            DEBUGMSG(1, (L"---> szVKeySeq[iMatched] = 0x%02x\n", (byte)szVKeySeq[iMatched]));

            if ( ((byte)pkbhData->vkCode == (byte)szVKeySeq[iMatched]) && (isShifted == bCharShiftSeq[iMatched]) ) {

                //the first match?
                if(iMatched==0){
                    //start the timer and lit the LED
                    LedOn(LEDid,1);
                    tID=SetTimer(NULL, 0, matchTimeout, (TIMERPROC)Timer2Proc);
                }
                iMatched++;

                DEBUGMSG(1, (L"iMatched is now=%i\n", iMatched));
                //are all keys matched
                if (iMatched == iKeyCount){
                    //show modeless dialog
                    DEBUGMSG(1, (L"FULL MATCH, starting ...\n"));
                    PostMessage(g_hWnd, WM_SHOWMYDIALOG, 0, 0);
                    //reset match pos and stop timer
                    DEBUGMSG(1, (L"FULL MATCH: Reset matching\n"));
                    LedOn(LEDid,0);
                    iMatched=0; //reset match pos
                    KillTimer(NULL, tID);
                    //return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam);
                }
                //return -1; //do not forward key?
            }
            else
            {
                KillTimer(NULL, tID);
                LedOn(LEDid,0);
                iMatched=0; //reset match pos
                DEBUGMSG(1, (L"FULL MATCH missed. Reseting matching\n"));
            }
        } //if wParam == WM_KEY..
    }
    return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam);
}

Enjoy the code

Download VS2008 Source code for Windows Mobile 6.5.3 SDK
DOWNLOAD:KeyToggleStart - (Hits: 90, size: 30.06 kB)

Download KeyToggleStart executable (Windows Mobile 6)
DOWNLOAD:KeyToggleStart WM6 Executable - (Hits: 78, size: 12.38 kB)

Bookmark It

• switch the keyboard plane (shiftkey)
• map as modifier key
• map as rotate key (one that produce abc depending on how often you press is)
• multikey that produces a sequence of key strokes
• event key, one that fires a named event pair (like the scan button does)
• a function key that executes a function inside a DLL

I also added classes to manage the used tables as for example MultiKeys, ShiftKeys, RotateKeys, ModifierKeys and so on.

As an example on how the the USB codes are layed out on a device. Unfortunately I only have mappings of this device and not for the others. Therefor you can only suggest the key to remap by the printing on the key.

There is no support in the Intermec tools to remap directKeys. For example the side buttons of a CN3 or CN4 or the PTT button of the CK3 are not managed via the usb keyboard driver, these are managed by a direct keyboard driver. ITCKEYBOARD enables you to remap this keys thru an API.

The ITCKEYBOARD namespace and the CUsbKeys and CDirectKeys classes are still in development and I started a google code project to invite you to collaborate. You are free to download and use the classes, the code is released under GPL v3 license. As this is a project in development, there is no warranty for anything.

The other reason I started to use googlecode was to get familar with a version control system. So forgive me, if I do or did something wrong with svn.

The classes are documented inline and an offline documentation is generated with Doxygen. On my windows developer PC I use AnkhSVN and on an Ubuntu PC (documentation only) I use the svn command line tool. On Windows you may also use TortoiseSVN, which integrates into the file explorer whereas AnkhSVN integrates into Visual Studio.

Both keyboard driver mappings are controlled thru the registry of the intermec device (see community.intermec.com for a doc called reprogramming the usb keypad). The ITCKEYBOARD namespace provides you managed, strongly typed access to these registry tables. For example the USB keyboard mappings are controlled by a sequence of 6 bytes for every key. These bytes define the key function and are concatenated in the registry into one binary registry value. The ITCKEYBOARD classes take this binary value and splits it into the single key sequences for easy managing.

Screenshots of a small Demo

The demo start and DirectKeys screen

DirectKey event management and USBKey demo form

In insight view with the dumpscreen

Sample usage

            //create a new, empty usbkey
            CUSBkeys.usbKeyStruct _theKey = new CUSBkeys.usbKeyStruct();
            _theKey.bHID = 0x07;
            _theKey.bFlagHigh = CUsbKeyTypes.usbFlagsHigh.NoFlag;// UsbKeyFlags3.NoFlag;
            _theKey.bFlagMid = CUsbKeyTypes.usbFlagsMid.NoRepeat;// UsbKeyFlags2.NoRepeat;
            _theKey.bFlagLow = CUsbKeyTypes.usbFlagsLow.RotateKeyIndex;// UsbKeyFlags3.RotateKeyIndex;

            //initialize a new usbkey object
            CUSBkeys _cusb = new CUSBkeys();

            //ShiftPlane 1 ####################################################
            //CAPS lock on "1"
            // 'ModKey2' = 00,02,08,58 //caps lock
            _theKey.bFlagHigh = CUsbKeyTypes.usbFlagsHigh.NoFlag;// UsbKeyFlags3.NoFlag;
            _theKey.bFlagMid = CUsbKeyTypes.usbFlagsMid.NoRepeat;// UsbKeyFlags2.NoRepeat;
            _theKey.bFlagLow = CUsbKeyTypes.usbFlagsLow.ModifierIndex;// UsbKeyFlags3.ModifierIndex;
            _theKey.bIntScan = 0x02; //ModKey index at 2 is caps lock
            _theKey.bScanKey =  (CUsbKeyTypes.HWkeys)0x1E;
            if (_cusb.setKey(2, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(2, _theKey);

            //space on "0"
            _theKey.bFlagHigh = CUsbKeyTypes.usbFlagsHigh.NoFlag;// UsbKeyFlags3.NoFlag;
            _theKey.bFlagMid = CUsbKeyTypes.usbFlagsMid.VKEY;// UsbKeyFlags2.VKEY;
            _theKey.bFlagLow = CUsbKeyTypes.usbFlagsLow.NormalKey;// UsbKeyFlags3.NormalKey;
            _theKey.bIntScan = 0x20;
            _theKey.bScanKey = (CUsbKeyTypes.HWkeys)0x27;
            if (_cusb.setKey(2, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(2, _theKey);

            //remap (OK) to "@" (Shifted-Space)
            _theKey.bFlagHigh = CUsbKeyTypes.usbFlagsHigh.NoFlag;// UsbKeyFlags3.NoFlag;
            _theKey.bFlagMid = CUsbKeyTypes.usbFlagsMid.VKEY | CUsbKeyTypes.usbFlagsMid.Shifted;// UsbKeyFlags2.Shifted;
            _theKey.bFlagLow = CUsbKeyTypes.usbFlagsLow.NormalKey;// UsbKeyFlags3.NormalKey;
            _theKey.bIntScan = 0x32;
            _theKey.bScanKey = CUsbKeyTypes.HWkeys.Right_GUI;
            if (_cusb.setKey(2, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(2, _theKey);

            //ShiftPlane 1 ####################################################
            //VKLWIN='Left GUI' on "0", 07,27,00,01,00,1F (07,E3,00,01,00,1F)
            //remap "0" on shift plane 1 to VK_LWIN (windows key)
            _theKey.bFlagHigh = CUsbKeyTypes.usbFlagsHigh.NoFlag;// UsbKeyFlags3.NoFlag;
            _theKey.bFlagMid = CUsbKeyTypes.usbFlagsMid.Extended;// UsbKeyFlags2.Extended;
            _theKey.bFlagLow = CUsbKeyTypes.usbFlagsLow.NormalKey;// UsbKeyFlags3.NormalKey;
            _theKey.bIntScan = 0x1F;
            _theKey.bScanKey = (CUsbKeyTypes.HWkeys)0x27;
            if (_cusb.setKey(1, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(1, _theKey);

            //change the top row of keys to F1 to F4
            _theKey.bHID = 0x07;
            _theKey.bScanKey = CUsbKeyTypes.HWkeys.Left_GUI;
            _theKey.bFlagHigh = CUsbKeyTypes.usbFlagsHigh.NoFlag;// UsbKeyFlags3.NoFlag;
            _theKey.bFlagMid = CUsbKeyTypes.usbFlagsMid.VKEY;// UsbKeyFlags2.VKEY;
            _theKey.bFlagLow = CUsbKeyTypes.usbFlagsLow.NormalKey;// UsbKeyFlags3.NormalKey;
            _theKey.bIntScan = 0x70; //F1
            if (_cusb.setKey(0, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(0, _theKey);

            _theKey.bScanKey = CUsbKeyTypes.HWkeys.F1;
            _theKey.bIntScan = (byte)VKEY.VK_PRIOR;//PageUp // 0x71; //F2
            if (_cusb.setKey(0, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(0, _theKey);

            _theKey.bScanKey = CUsbKeyTypes.HWkeys.F2;
            _theKey.bIntScan = (byte)VKEY.VK_NEXT;//PgDwn 0x72; //F3
            if (_cusb.setKey(0, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(0, _theKey);

            _theKey.bScanKey = CUsbKeyTypes.HWkeys.Right_GUI;
            _theKey.bIntScan = 0x73; //F3
            if (_cusb.setKey(0, _theKey.bScanKey, _theKey) != 0)
                _cusb.addKey(0, _theKey);

            _cusb.writeKeyTables(); //save the changes

            // DIRECT Keys stuff
            //remap PTT to @
            CDirectKeys _directKeys = new CDirectKeys(); //create a new directkey object
            _directKeys.setKey(0x02, VKEY.VK_SPACE, CDirectKeys.directKeyType.kTypeShiftdVirtualKey);
            _directKeys.saveKeyTable(); //save the changes
            _directKeys = null;

Source Code (Visual Studio 2005, Windows Mobile 6 Prof. SDK). (Work in progress)
http://code.google.com/p/itc-keyboard/

Bookmark It

3.0        added code for read/write reg for CharTable and KeyTable
 REGEDIT4

 [HKEY_LOCAL_MACHINE\Software\Intermec\KeyToggleChar]
 "KeyTable"=hex:\
 30,31,32,33,34,35,36,37,38,39
 "CharTable"=hex:\
 C6,00,E6,00,D8,00,F8,00,C5,00,E5,00,C2,00,E2,00,C4,00,E4,00
 "LEDid"=dword:00000001
 "autoFallback"=dword:00000000
 "Timeout"=dword:00000003
 "StickyKey"=dword:00000074

 KeyTable     holds a list of 10 keys which will be 'remapped'
 CharTable    holds  list of UniChar codes to use as replacement
 LEDid        defines the ID of the LED to use for showing sticky state
 autoFallback defines, if the sticky state is reset after a mapped key is pressed.
              Use 0, if you dont want the sticky state to fallback after keypress
 TimeOut      defines a timout after which sticky state will be reset

To get the UTF-8 word entries for Unicode chars, see for example here: http://www.unicode.org/charts/charindex.html

The default mapping used here is defined as follows and maps the keys 0-9 to:

0x00c6, 0x00e6, 0x00d8, 0x00f8, 0x00C5, 0x00e5, 0x00c2, 0x00e2, 0x00c4, 0x00e4
 AE        ae     O/       o/      A°      a°      A^      a^      Ä       ä

The main problem I had was finding a function to get the window handle of the current input active window. Finally I found GetForegroundKeyboardTarget() (after some days of searching).

void sendKey(UINT vKey){
 TCHAR* lpText;
 lpText = new TCHAR[MAX_PATH];
 TCHAR strClass[MAX_PATH];
 int iRes;

 // hWndActive = GetFocusEx(); // a trick that does not deliver the focusses window
 hWndActive = GetForegroundKeyboardTarget();

 GetWindowText(hWndActive, lpText, MAX_PATH-1);
 iRes = GetClassName(hWndActive, strClass, MAX_PATH);
 DEBUGMSG(1, (L"### GetFocusEx() window, handle=0x%x, text='%s', class='%s'\n", hWndActive, lpText, strClass));

 if(hWndActive == NULL)
 return; //no window found

 WPARAM wParam = getCharForKey(vKey); // charTable[vKey-0x30];// 0x00c6; //AE
 LPARAM lParam = 1; //flags: repeat=1

/*
 wm_keydown, wParam=0, lParam=1
 wm_char, wParam=char code, lParam=1
 wm_keyup, wParam=0, lParam=c0000001;
*/

 LRESULT lRes=0;
 lRes = SendMessage(hWndActive, WM_KEYDOWN, 0, 1);
 DEBUGMSG(1, (L"SendMessage1 for 'WM_KEYDOWN' returned 0x%0x\n", lRes));
 lRes = SendMessage(hWndActive, WM_CHAR, wParam, 1);
 DEBUGMSG(1, (L"SendMessage2 for '0x%04x' returned 0x%0x\n", wParam, lRes));
 lRes = SendMessage(hWndActive, WM_KEYUP, 0, 0xc0000001);
 DEBUGMSG(1, (L"SendMessage3 for 'WM_KEYUP' returned 0x%0x\n", lRes));

 return;
}

I leaved my different finding in code (commented out), so you can see, what functions I have tried.

Bookmark It

Extend your keyboard to get function keys by pressing numbers.

With keytoggle you can define a ‘sticky’ key that will change the beahviour of the number keys. As long as the sticky key is ‘active’, number keys from 1 to 0 will produce the function keys F1 to F10. If sticky key is active, the left LED will light in green.

To start keytoggle just tap it or let it start by a link in StartUp. If keytoggle is loaded, you can see a small yellow arrow sign in the taskbar.

If you tap this symbol, you are asked, if you want to unload the app. If the registry does not have values defined for keytoggle, it will use default values. If you try to launch keytoggle a second time you will get a message box. Only one instance of keytoggle can run at a time.

Using the registry you can define the behaviour of the sticky key. In example, you can have the sticky key remain active until it is pressed again, let it ‘go off’ or ‘fallback’ after a period of time or let it fallback after a number key has been pressed. If the sticky key is pressed again, it will always fallback.

REGEDIT4
[HKEYLOCALMACHINE\SOFTWARE\Intermec\KeyToggle]
“Timeout”=dword:00000000
“autoFallback”=dword:00000001
“StickyKey”=dword:00000090

The values:

  StickyKey:
  default "144", decimal (VK_NUMLOCK)
  the VK_ value of the sticky key. Here you define, what you will have as the sticky key. VK_ values are defined as in winuser.h. In example the VK_ value for the NumLock key is 0x90 (144 decimal, see VK_NUMLOCK). The sticky key will be consumed by keytoggle and is not visible to the system any more. That means, that you should choose key value that you do not need in any app you use.

  Timeout:
  default "3", three seconds
  number of seconds the sticky key will remain active. If 0, the sticky key will not fallback automatically by time

  autoFallback:
  default "0"
  if 0 the sticky key will not fallback after pressing a number key. If 1 the sticky key will fallback after a number key is pressed

Launch arguments

  Keytoggle only supports one argument: "-writereg". This will create the registry keys used by keytoggle and fill them with the default values.

Usage Sample Scenario

You have a ITC Color device with a numeric keyboard but no function keys. You need the function keys to be able to use a web application within iBrowse. With keytoggle you can now for example use the Gold key as sticky key. You have to download the device reource kit to get a keyboard remapper tool from the ITC site and assign the Gold key to NUMLOCK.

With this remapping and keytoggle running you will to get a function keystroke simulated if you press the Gold key and then a number key.

Download installer: DOWNLOAD:KeyToggle Installer CAB - (Hits: 194, size: 5.19 kB)

Bookmark It

You can use this to catch the funny OS asigned keys like F1, F2, F3, F4, F6 and F7 (Softkey 1 and 2, Phone, End, Volume Up, Volume Down); and last but not least catch the Win Key press.

The hooking class:

using System;
using System.Runtime.InteropServices;
/*
In order to use this class in your program, just declare the varialble and hook up into HookEvent:
HookKeys hook = new HookKeys();
hook.HookEvent += new HookKeys.HookEventHandler(HookEvent);
hook.Start();
*/
public class HookKeys
{
#region delegates
    public delegate int HookProc(int code, IntPtr wParam, IntPtr lParam);
    public delegate void HookEventHandler(HookEventArgs e, KeyBoardInfo keyBoardInfo);
    public HookEventHandler HookEvent;
#endregion
#region fields
    private HookProc hookDeleg;
    private static int hHook = 0;
#endregion

    public HookKeys()
    {
    }
    ~HookKeys(){
        if(hHook!=0)
            this.Stop();
    }
    #region public methods
    ///
    /// Starts the hook
    ///
    public void Start()
    {
        if (hHook != 0)
        {
            //Unhook the previouse one
            this.Stop();
        }
        hookDeleg = new HookProc(HookProcedure);
        hHook = SetWindowsHookEx(WH_KEYBOARD_LL, hookDeleg, GetModuleHandle(null), 0);
        if (hHook == 0)
        {
            throw new SystemException("Failed acquiring of the hook.");
        }
        AllKeys(true);
    }
    ///
    /// Stops the hook
    ///
    public void Stop()
    {
        UnhookWindowsHookEx(hHook);
        AllKeys(false);
    }
    #endregion
    #region protected and private methods
    protected virtual void OnHookEvent(HookEventArgs hookArgs, KeyBoardInfo keyBoardInfo)
    {
        if (HookEvent != null)
        {
            HookEvent(hookArgs, keyBoardInfo);
        }
    }

    private int HookProcedure(int code, IntPtr wParam, IntPtr lParam)
    {
       KBDLLHOOKSTRUCT hookStruct =  (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
       if (code < 0)
            return CallNextHookEx(hookDeleg, code, wParam, lParam);
       // Let clients determine what to do
       HookEventArgs e = new HookEventArgs();
       e.Code = code;
       e.wParam = wParam;
       e.lParam = lParam;
       KeyBoardInfo keyInfo = new KeyBoardInfo();
       keyInfo.vkCode = hookStruct.vkCode;
       keyInfo.scanCode = hookStruct.scanCode;
       OnHookEvent(e, keyInfo);
       // Yield to the next hook in the chain
       return CallNextHookEx(hookDeleg, code, wParam, lParam);
   }
   #endregion
   #region P/Invoke declarations

   [DllImport("coredll.dll")]
   private static extern int AllKeys(bool bEnable);

   [DllImport("coredll.dll")]
   private static extern int SetWindowsHookEx(int type, HookProc hookProc, IntPtr hInstance, int m);
   [DllImport("coredll.dll")]
   private static extern IntPtr GetModuleHandle(string mod);
   [DllImport("coredll.dll")]
   private static extern int CallNextHookEx(
           HookProc hhk,
           int nCode,
           IntPtr wParam,
           IntPtr lParam
           );
   [DllImport("coredll.dll")]
   private static extern int GetCurrentThreadId();
   [DllImport("coredll.dll", SetLastError = true)]
   private static extern int UnhookWindowsHookEx(int idHook);
   private struct KBDLLHOOKSTRUCT
   {
       public int vkCode;
       public int scanCode;
       public int flags;
       public int time;
       public IntPtr dwExtraInfo;
   }
   const int WH_KEYBOARD_LL = 20;
   #endregion
}
#region event arguments

    public class HookEventArgs : EventArgs
    {
        public int Code;    // Hook code
        public IntPtr wParam;   // WPARAM argument
        public IntPtr lParam;   // LPARAM argument
    }
    public class KeyBoardInfo
    {
        public int vkCode;
        public int scanCode;
        public int flags;
        public int time;
    }
#endregion

Here is the download of the Visual Studio 2005 Windows Mobile 6 SDK targeting source code:

Bookmark It

The ITC devices use a USB keyboard driver. You can remap keys of the keypad using the keby remapper tool from the Device Resource Kit. Unfortunately not all possible assignments are available with this remapper tool, so I wrote a tool that gives you full control. Be careful when using.

Usage

no args no work

usbkey restore 0

restore keytable shiftplane numbered 0

i.e. a CK3 numPad has 3 shiftplanes (0 to 2), with this command you can restore the original layout of a shiftplane.

usbkey dump

this will dump the actual shiftplanes into a file: \usbkey.txt

usbkey setNOOP 0 “Left gui”

this will set the NOOP flag for the matching PS/2 key “Left Gui”, which is the windows key. This disables the Windows key. PS2 keynames here are not case sensitive.

usbkey setNOOP 0 "1"

this will disable (NOOP = No Operation) of the 1 key in plane 0.

usbkey resetNOOP 0 "Left GUI"

this will restore (unset) the NOOP flag for key “Left GUI” in plane 0.

usbkey setPS2key 0 "1" "2"

setPS2key iPlane szOldKey szNewKey
will change key assigned to ’1′ to produce a ’2′

you can use the usb hex code of a key to specify the OldKey. You have to prefix the hex code by SCX (not case sensitive). In example:

usbkey setPS2key 1 scx0x1E F1

will set the key with usb scancode 0x1e in plane 1 to produce a F1

Since version 1.1, usbkey supports remapping of keys to point to ModifiersKeys:

To map F3 to the Caps modifier key, use this:

usbkey setKey2Mod 0 "F3" "Caps"

To map F4 to the Alt modifier key, use this:

usbkey setKey2Mod 0 "F4" "Alt"

The output of dump has been extended to show ModifiersKeys and Keys, that are not mapped to a PS2 key now are listed with there pointer. In example:

iUSBkey[30] hex: 0x0C,0xE9,0x00,0x02,0x01,0x01	CodePage:0x0C, ScanCode:0xE9, 'SHIFTKEY INDEX->1'

says: key with USB scancode 0xE9 is mapped as ShiftKey (dont see this as Shifted Key, ‘ShiftKey’ is used here as indicator for keys that change the shift plane).

General

Quotes are only needed around arguments containing spaces.
SCX syntax to specify key to change using USB code in hex can be used for setNoop, ResetNoop, SetKey2Mod and setPS2key. To get a list of available USB scan codes use the dump command argument: ‘usbkey dump’. The second byte is the USB scanCode to use.

In example:

    iUSBkey[8] hex: 0x07,0x22,0x00,0x00,0x00,0x2E    ... 'keyName='5'
                           ^
                           This is the entry for USB scancode: 0x22
                           The PS2 code created here is 0x2E,

                           which will produce '5'

If you specify one of the implicit VKEY values (F13 to F24) as newKey, you must specify the correct spelled name. Example: ‘setPS2key 0 scX0x1e F13′ – the F13 will be looked up in aPS2 table which says, this is a VKEY and then the tool will look in the VKEY table and look for ‘VK_F13′ to get the scancode.

Remarks

USBkey uses a table to search against a given keyname string. This search is using the number of characters specified and is not case sensitive actually. This means, if you specify only “Left” as keyname, the tool will use the first found ‘left’ from a table, this may result in finding the entry for ‘Left Arrow’ or ‘Left GUI’ or anything else that I have in my keyname table starting with ‘left’. Here is the actual keyname table (PS2).

//UNASSIGNED replaced by 0xffff
//RESERVED   replaced by 0xAAAA
//NONE       replaced by 0xFFFE
//UNDEFINED  replaced by 0xFFFD
//vkey = 0xFFFA
//extended is 0xE0__

//"Key Name"	, HID Usage Page	, HID Usage ID	, PS/2 Set
usbPageUsageID usbPageUsageIDs[] = {
    {L"System Power", 0x01, 0x81, 0xE037},
    {L"System Sleep", 0x01, 0x82, 0xE03F},
    {L"System Wake", 0x01, 0x83, 0xE05E},
    {L"No Event", 0x07, 0x00, 0xFFFE},
    {L"Overrun Error", 0x07, 0x01, 0x00},
    {L"POST Fail", 0x07, 0x02, 0xFC},
    {L"Error Undefined", 0x07, 0x03, 0xFFFF},
    {L"a A", 0x07, 0x04, 0x1C},
    {L"b B", 0x07, 0x05, 0x32},
    {L"c C", 0x07, 0x06, 0x21},
    {L"d D", 0x07, 0x07, 0x23},
    {L"e E", 0x07, 0x08, 0x24},
    {L"f F", 0x07, 0x09, 0x2B},
    {L"g G", 0x07, 0x0A, 0x34},
    {L"h H", 0x07, 0x0B, 0x33},
    {L"i I", 0x07, 0x0C, 0x43},
    {L"j J", 0x07, 0x0D, 0x3B},
    {L"k K", 0x07, 0x0E, 0x42},
    {L"l L", 0x07, 0x0F, 0x4B},
    {L"m M", 0x07, 0x10, 0x3A},
    {L"n N", 0x07, 0x11, 0x31},
    {L"o O", 0x07, 0x12, 0x44},
    {L"p P", 0x07, 0x13, 0x4D},
    {L"q Q", 0x07, 0x14, 0x15},
    {L"r R", 0x07, 0x15, 0x2D},
    {L"s S", 0x07, 0x16, 0x1B},
    {L"t T", 0x07, 0x17, 0x2C},
    {L"u U", 0x07, 0x18, 0x3C},
    {L"v V", 0x07, 0x19, 0x2A},
    {L"w W", 0x07, 0x1A, 0x1D},
    {L"x X", 0x07, 0x1B, 0x22},
    {L"y Y", 0x07, 0x1C, 0x35},
    {L"z Z", 0x07, 0x1D, 0x1A},
    {L"1 !", 0x07, 0x1E, 0x16},
    {L"2 @", 0x07, 0x1F, 0x1E},
    {L"3 #", 0x07, 0x20, 0x26},
    {L"4 $", 0x07, 0x21, 0x25},
    {L"5 %%", 0x07, 0x22, 0x2E},
    {L"6 ^", 0x07, 0x23, 0x36},
    {L"7 &", 0x07, 0x24, 0x3D},
    {L"8 *", 0x07, 0x25, 0x3E},
    {L"9 (", 0x07, 0x26, 0x46},
    {L"0 )", 0x07, 0x27, 0x45},
    {L"Return", 0x07, 0x28, 0x5A},
    {L"Escape", 0x07, 0x29, 0x76},
    {L"Backspace", 0x07, 0x2A, 0x66},
    {L"Tab", 0x07, 0x2B, 0x0D},
    {L"Space", 0x07, 0x2C, 0x29},
    {L"-_", 0x07, 0x2D, 0x4E},
    {L"= +", 0x07, 0x2E, 0x55},
    {L"[ {L", 0x07, 0x2F, 0x54},
    {L"] }", 0x07, 0x30, 0x5B},
    {L"\\ |", 0x07, 0x31, 0x5D},
    {L"Europe 1", 0x07, 0x32, 0x5D},
    {L"; :", 0x07, 0x33, 0x4C},
    {L"‘ \"", 0x07, 0x34, 0x52},
    {L"` ~", 0x07, 0x35, 0x0E},
    {L", <", 0x07, 0x36, 0x41},
    {L". >", 0x07, 0x37, 0x49},
    {L"/ ?", 0x07, 0x38, 0x4A},
    {L"Caps Lock", 0x07, 0x39, 0x58},
    {L"F1", 0x07, 0x3A, 0x05},
    {L"F2", 0x07, 0x3B, 0x06},
    {L"F3", 0x07, 0x3C, 0x04},
    {L"F4", 0x07, 0x3D, 0x0C},
    {L"F5", 0x07, 0x3E, 0x03},
    {L"F6", 0x07, 0x3F, 0x0B},
    {L"F7", 0x07, 0x40, 0x83},
    {L"F8", 0x07, 0x41, 0x0A},
    {L"F9", 0x07, 0x42, 0x01},
    {L"F10", 0x07, 0x43, 0x09},
    {L"F11", 0x07, 0x44, 0x78},
    {L"F12", 0x07, 0x45, 0x07},
    {L"Print Screen", 0x07, 0x46, 0xE07C},
    {L"Scroll Lock", 0x07, 0x47, 0x7E},
    {L"Break", 0x07, 0x48, 0xE07E},
    {L"Pause", 0x07, 0x48, 0xfffD},
    {L"Insert", 0x07, 0x49, 0xE070},
    {L"Home", 0x07, 0x4A, 0xE06C},
    {L"Page Up", 0x07, 0x4B, 0xE07D},
    {L"Delete", 0x07, 0x4C, 0xE071},
    {L"End", 0x07, 0x4D, 0xE069},
    {L"Page Down", 0x07, 0x4E, 0xE07A},
    {L"Right Arrow", 0x07, 0x4F, 0xE074},
    {L"Left Arrow", 0x07, 0x50, 0xE06B},
    {L"Down Arrow", 0x07, 0x51, 0xE072},
    {L"Up Arrow", 0x07, 0x52, 0xE075},
    {L"Num Lock", 0x07, 0x53, 0x77},
    {L"Keypad /", 0x07, 0x54, 0xE04A},
    {L"Keypad *", 0x07, 0x55, 0xE07C},
    {L"Keypad -", 0x07, 0x56, 0xE07B},
    {L"Keypad +", 0x07, 0x57, 0x79},
    {L"Keypad Enter", 0x07, 0x58, 0xE05A},
    {L"Keypad 1", 0x07, 0x59, 0x69},
    {L"Keypad 2", 0x07, 0x5A, 0x72},
    {L"Keypad 3", 0x07, 0x5B, 0x7A},
    {L"Keypad 4", 0x07, 0x5C, 0x79},
    {L"Keypad 5", 0x07, 0x5D, 0x73},
    {L"Keypad 6", 0x07, 0x5E, 0x74},
    {L"Keypad 7", 0x07, 0x5F, 0x6C},
    {L"Keypad 8", 0x07, 0x60, 0x75},
    {L"Keypad 9", 0x07, 0x61, 0x7D},
    {L"Keypad 0", 0x07, 0x62, 0x70},
    {L"Keypad .", 0x07, 0x63, 0x71},
    {L"Europe 2", 0x07, 0x64, 0x61},
    {L"App", 0x07, 0x65, 0xE02F},
    {L"Keyboard Power", 0x07, 0x66, 0xE037},
    {L"Keypad =", 0x07, 0x67, 0x0F},
    {L"F13", 0x07, 0x68, 0xFFFA},
    {L"F14", 0x07, 0x69, 0xFFFA},
    {L"F15", 0x07, 0x6A, 0xFFFA},
    {L"F16", 0x07, 0x6B, 0xFFFA},
    {L"F17", 0x07, 0x6C, 0xFFFA},
    {L"F18", 0x07, 0x6D, 0xFFFA},
    {L"F19", 0x07, 0x6E, 0xFFFA},
    {L"F20", 0x07, 0x6F, 0xFFFA},
    {L"F21", 0x07, 0x70, 0xFFFA},
    {L"F22", 0x07, 0x71, 0xFFFA},
    {L"F23", 0x07, 0x72, 0xFFFA},
    {L"F24", 0x07, 0x73, 0xFFFA},
    {L"Keyboard Execute", 0x07, 0x74, 0xFFFF},
    {L"Keyboard Help", 0x07, 0x75, 0xFFFF},
    {L"Keyboard Menu", 0x07, 0x76, 0xFFFF},
    {L"Keyboard Select", 0x07, 0x77, 0xFFFF},
    {L"Keyboard Stop", 0x07, 0x78, 0xFFFF},
    {L"Keyboard Again", 0x07, 0x79, 0xFFFF},
    {L"Keyboard Undo", 0x07, 0x7A, 0xFFFF},
    {L"Keyboard Cut", 0x07, 0x7B, 0xFFFF},
    {L"Keyboard Copy", 0x07, 0x7C, 0xFFFF},
    {L"Keyboard Paste", 0x07, 0x7D, 0xFFFF},
    {L"Keyboard Find", 0x07, 0x7E, 0xFFFF},
    {L"Keyboard Mute", 0x07, 0x7F, 0xFFFF},
    {L"Keyboard Volume Up", 0x07, 0x80, 0xFFFF},
    {L"Keyboard Volume Down", 0x07, 0x81, 0xFFFF},
    {L"Keyboard Locking Caps Lock", 0x07, 0x82, 0xFFFF},
    {L"Keyboard Locking Num Lock", 0x07, 0x83, 0xFFFF},
    {L"Keyboard Locking Scroll Lock", 0x07, 0x84, 0xFFFF},
    {L"Keypad ,", 0x07, 0x85, 0xFFFF},
    {L"Keyboard Equal Sign", 0x07, 0x86, 0xFFFF},
    {L"Keyboard Int’l 1", 0x07, 0x87, 0xFFFF},
    {L"Keyboard Int’l 2", 0x07, 0x88, 0xFFFF},
    {L"Keyboard Int’l 3", 0x07, 0x89, 0xFFFF},
    {L"Keyboard Int’l 4", 0x07, 0x8A, 0xFFFF},
    {L"Keyboard Int’l 5", 0x07, 0x8B, 0xFFFF},
    {L"Keyboard Int’l 6", 0x07, 0x8C, 0xFFFF},
    {L"Keyboard Int’l 7", 0x07, 0x8D, 0xFFFF},
    {L"Keyboard Int’l 8", 0x07, 0x8E, 0xFFFF},
    {L"Keyboard Int’l 9", 0x07, 0x8F, 0xFFFF},
    {L"Keyboard Lang 1", 0x07, 0x90, 0xFFFF},
    {L"Keyboard Lang 2", 0x07, 0x91, 0xFFFF},
    {L"Keyboard Lang 3", 0x07, 0x92, 0xFFFF},
    {L"Keyboard Lang 4", 0x07, 0x93, 0xFFFF},
    {L"Keyboard Lang 5", 0x07, 0x94, 0xFFFF},
    {L"Keyboard Lang 6", 0x07, 0x95, 0xFFFF},
    {L"Keyboard Lang 7", 0x07, 0x96, 0xFFFF},
    {L"Keyboard Lang 8", 0x07, 0x97, 0xFFFF},
    {L"Keyboard Lang 9", 0x07, 0x98, 0xFFFF},
    {L"Keyboard Alternate Erase", 0x07, 0x99, 0xFFFF},
    {L"Keyboard SysReq/Attention", 0x07, 0x9A, 0xFFFF},
    {L"Keyboard Cancel", 0x07, 0x9B, 0xFFFF},
    {L"Keyboard Clear", 0x07, 0x9C, 0xFFFF},
    {L"Keyboard Prior", 0x07, 0x9D, 0xFFFF},
    {L"Keyboard Return", 0x07, 0x9E, 0xFFFF},
    {L"Keyboard Separator", 0x07, 0x9F, 0xFFFF},
    {L"Keyboard Out", 0x07, 0xA0, 0xFFFF},
    {L"Keyboard Oper", 0x07, 0xA1, 0xFFFF},
    {L"Keyboard Clear/Again", 0x07, 0xA2, 0xFFFF},
    {L"Keyboard CrSel/Props", 0x07, 0xA3, 0xFFFF},
    {L"Keyboard ExSel", 0x07, 0xA4, 0xFFFF},
    {L"RESERVED", 0x07, 0xA5, 0xAAAA},
    //
    {L"RESERVED", 0x07, 0xDF, 0xAAAA},
    {L"Left Control", 0x07, 0xE0, 0x14},
    {L"Left Shift", 0x07, 0xE1, 0x12},
    {L"Left Alt", 0x07, 0xE2, 0x11},
    {L"Left GUI", 0x07, 0xE3, 0xE01F},
    {L"Right Control", 0x07, 0xE4, 0xE014},
    {L"Right Shift", 0x07, 0xE5, 0x59},
    {L"Right Alt", 0x07, 0xE6, 0xE011},
    {L"Right GUI", 0x07, 0xE7, 0xE027},
    {L"RESERVED", 0x07, 0xE8, 0xAAAA},
	{L"RESERVED", 0x07, 0xFFFF, 0xAAAA},
	{NULL, 0x00, 0x00, 0x00} //last marker
};

Sample Dump

Here is a sample of the USB HID scan codes of a ITC device.

Warning

the 62h, 61h, 05h, 71h and 52h keys at the top are NOT part of the USB keypad, they are direct keys (see my post about DirectKeyUI):

Unfortunately, I dont have these mappings for all devices and keypads and so you have to evaluate the dump files, to find the right scan codes.

Here is a sample of usbkey.txt of a CN3 with numeric phone style keypad:

######## dump of plane 0 ###########
iUSBkey[0] hex: 0x07,0x00,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x00, KeyName:'No Event'
iUSBkey[1] hex: 0x07,0x01,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x01, KeyName:'Overrun Error'
iUSBkey[2] hex: 0x07,0x02,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x02, KeyName:'POST Fail'
iUSBkey[3] hex: 0x07,0x03,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x03, KeyName:'Error Undefined'
iUSBkey[4] hex: 0x07,0x1E,0x00,0x00,0x00,0x16	CodePage:0x07, ScanCode:0x1E, KeyName:'1 !'
iUSBkey[5] hex: 0x07,0x1F,0x00,0x00,0x00,0x1E	CodePage:0x07, ScanCode:0x1F, KeyName:'2 @'
iUSBkey[6] hex: 0x07,0x20,0x00,0x00,0x00,0x26	CodePage:0x07, ScanCode:0x20, KeyName:'3 #'
iUSBkey[7] hex: 0x07,0x21,0x00,0x00,0x00,0x25	CodePage:0x07, ScanCode:0x21, KeyName:'4 $'
iUSBkey[8] hex: 0x07,0x22,0x00,0x00,0x00,0x2E	CodePage:0x07, ScanCode:0x22, KeyName:'5 %%'
iUSBkey[9] hex: 0x07,0x23,0x00,0x00,0x00,0x36	CodePage:0x07, ScanCode:0x23, KeyName:'6 ^'
iUSBkey[10] hex: 0x07,0x24,0x00,0x00,0x00,0x3D	CodePage:0x07, ScanCode:0x24, KeyName:'7 &'
iUSBkey[11] hex: 0x07,0x25,0x00,0x00,0x00,0x3E	CodePage:0x07, ScanCode:0x25, KeyName:'8 *'
iUSBkey[12] hex: 0x07,0x26,0x00,0x00,0x00,0x46	CodePage:0x07, ScanCode:0x26, KeyName:'9 ('
iUSBkey[13] hex: 0x07,0x27,0x00,0x00,0x00,0x45	CodePage:0x07, ScanCode:0x27, KeyName:'0 )'
iUSBkey[14] hex: 0x07,0x28,0x00,0x00,0x00,0x5A	CodePage:0x07, ScanCode:0x28, KeyName:'Return'
iUSBkey[15] hex: 0x07,0x29,0x00,0x00,0x00,0x76	CodePage:0x07, ScanCode:0x29, KeyName:'Escape'
iUSBkey[16] hex: 0x07,0x2A,0x00,0x00,0x00,0x66	CodePage:0x07, ScanCode:0x2A, KeyName:'Backspace'
iUSBkey[17] hex: 0x07,0x2B,0x00,0x00,0x00,0x0D	CodePage:0x07, ScanCode:0x2B, KeyName:'Tab'
iUSBkey[18] hex: 0x07,0x37,0x00,0x00,0x00,0x49	CodePage:0x07, ScanCode:0x37, KeyName:'. >'
iUSBkey[19] hex: 0x07,0x41,0x00,0x20,0x00,0x3E	CodePage:0x07, ScanCode:0x41, KeyName:'F8'
iUSBkey[20] hex: 0x07,0x42,0x00,0x20,0x00,0x26	CodePage:0x07, ScanCode:0x42, KeyName:'F9'
iUSBkey[21] hex: 0x07,0x51,0x00,0x01,0x00,0x72	CodePage:0x07, ScanCode:0x51, KeyName:'Down Arrow'
iUSBkey[22] hex: 0x07,0x52,0x00,0x01,0x00,0x75	CodePage:0x07, ScanCode:0x52, KeyName:'Up Arrow'
iUSBkey[23] hex: 0x07,0xE3,0x00,0x01,0x00,0x1F	CodePage:0x07, ScanCode:0xE3, KeyName:'Left GUI'
iUSBkey[24] hex: 0x07,0x3A,0x00,0x00,0x00,0x05	CodePage:0x07, ScanCode:0x3A, KeyName:'F1'
iUSBkey[25] hex: 0x07,0x3B,0x00,0x00,0x00,0x06	CodePage:0x07, ScanCode:0x3B, KeyName:'F2'
iUSBkey[26] hex: 0x07,0x3C,0x00,0x00,0x00,0x04	CodePage:0x07, ScanCode:0x3C, KeyName:'F3'
iUSBkey[27] hex: 0x07,0x3D,0x00,0x00,0x00,0x0C	CodePage:0x07, ScanCode:0x3D, KeyName:'F4'
iUSBkey[28] hex: 0x07,0x8B,0x00,0x02,0x01,0x02	CodePage:0x07, ScanCode:0x8B, KeyName:'Keyboard Int’l 5'
iUSBkey[29] hex: 0x07,0x90,0x00,0x02,0x02,0x01	CodePage:0x07, ScanCode:0x90, KeyName:'Keyboard Lang 1'
iUSBkey[30] hex: 0x0C,0xE9,0x00,0x02,0x01,0x01	CodePage:0x0C, ScanCode:0xE9, KeyName:'undefined'
--------------------------------------
######## dump of plane 1 ###########
iUSBkey[0] hex: 0x07,0x00,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x00, KeyName:'No Event'
iUSBkey[1] hex: 0x07,0x01,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x01, KeyName:'Overrun Error'
iUSBkey[2] hex: 0x07,0x02,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x02, KeyName:'POST Fail'
iUSBkey[3] hex: 0x07,0x03,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x03, KeyName:'Error Undefined'
iUSBkey[4] hex: 0x07,0x1E,0x00,0x00,0x00,0x05	CodePage:0x07, ScanCode:0x1E, KeyName:'1 !'
iUSBkey[5] hex: 0x07,0x1F,0x00,0x00,0x00,0x1E	CodePage:0x07, ScanCode:0x1F, KeyName:'2 @'
iUSBkey[6] hex: 0x07,0x20,0x00,0x00,0x00,0x06	CodePage:0x07, ScanCode:0x20, KeyName:'3 #'
iUSBkey[7] hex: 0x07,0x21,0x00,0x00,0x00,0x25	CodePage:0x07, ScanCode:0x21, KeyName:'4 $'
iUSBkey[8] hex: 0x07,0x22,0x00,0x00,0x00,0x2E	CodePage:0x07, ScanCode:0x22, KeyName:'5 %%'
iUSBkey[9] hex: 0x07,0x23,0x00,0x00,0x00,0x36	CodePage:0x07, ScanCode:0x23, KeyName:'6 ^'
iUSBkey[10] hex: 0x07,0x24,0x00,0x00,0x00,0x3D	CodePage:0x07, ScanCode:0x24, KeyName:'7 &'
iUSBkey[11] hex: 0x07,0x25,0x00,0x00,0x00,0x3E	CodePage:0x07, ScanCode:0x25, KeyName:'8 *'
iUSBkey[12] hex: 0x07,0x26,0x00,0x00,0x00,0x46	CodePage:0x07, ScanCode:0x26, KeyName:'9 ('
iUSBkey[13] hex: 0x07,0x27,0x00,0x00,0x00,0x45	CodePage:0x07, ScanCode:0x27, KeyName:'0 )'
iUSBkey[14] hex: 0x07,0x28,0x00,0x00,0x00,0x5A	CodePage:0x07, ScanCode:0x28, KeyName:'Return'
iUSBkey[15] hex: 0x07,0x29,0x00,0x02,0x04,0x02	CodePage:0x07, ScanCode:0x29, KeyName:'Escape'
iUSBkey[16] hex: 0x07,0x2A,0x00,0x00,0x00,0x66	CodePage:0x07, ScanCode:0x2A, KeyName:'Backspace'
iUSBkey[17] hex: 0x07,0x2B,0x00,0x00,0x04,0x03	CodePage:0x07, ScanCode:0x2B, KeyName:'Tab'
iUSBkey[18] hex: 0x07,0x37,0x00,0x02,0x02,0x03	CodePage:0x07, ScanCode:0x37, KeyName:'. >'
iUSBkey[19] hex: 0x07,0x41,0x00,0x00,0x00,0x4E	CodePage:0x07, ScanCode:0x41, KeyName:'F8'
iUSBkey[20] hex: 0x07,0x42,0x00,0x20,0x00,0x55	CodePage:0x07, ScanCode:0x42, KeyName:'F9'
iUSBkey[21] hex: 0x07,0x51,0x00,0x01,0x00,0x74	CodePage:0x07, ScanCode:0x51, KeyName:'Down Arrow'
iUSBkey[22] hex: 0x07,0x52,0x00,0x01,0x00,0x6B	CodePage:0x07, ScanCode:0x52, KeyName:'Up Arrow'
iUSBkey[23] hex: 0x07,0xE3,0x00,0x10,0x00,0x1F	CodePage:0x07, ScanCode:0xE3, KeyName:'Left GUI'
iUSBkey[24] hex: 0x07,0x3C,0x00,0x00,0x00,0x04	CodePage:0x07, ScanCode:0x3C, KeyName:'F3'
iUSBkey[25] hex: 0x07,0x3D,0x00,0x00,0x00,0x0C	CodePage:0x07, ScanCode:0x3D, KeyName:'F4'
iUSBkey[26] hex: 0x07,0x8B,0x00,0x02,0x01,0x02	CodePage:0x07, ScanCode:0x8B, KeyName:'Keyboard Int’l 5'
iUSBkey[27] hex: 0x07,0x90,0x00,0x02,0x02,0x01	CodePage:0x07, ScanCode:0x90, KeyName:'Keyboard Lang 1'
iUSBkey[28] hex: 0x0C,0xE9,0x00,0x02,0x01,0x01	CodePage:0x0C, ScanCode:0xE9, KeyName:'undefined'
--------------------------------------
######## dump of plane 2 ###########
iUSBkey[0] hex: 0x07,0x00,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x00, KeyName:'No Event'
iUSBkey[1] hex: 0x07,0x01,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x01, KeyName:'Overrun Error'
iUSBkey[2] hex: 0x07,0x02,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x02, KeyName:'POST Fail'
iUSBkey[3] hex: 0x07,0x03,0x00,0x00,0x00,0x00	CodePage:0x07, ScanCode:0x03, KeyName:'Error Undefined'
iUSBkey[4] hex: 0x07,0x1E,0x00,0x00,0x08,0x04	CodePage:0x07, ScanCode:0x1E, KeyName:'1 !'
iUSBkey[5] hex: 0x07,0x1F,0x00,0x02,0x40,0x01	CodePage:0x07, ScanCode:0x1F, KeyName:'2 @'
iUSBkey[6] hex: 0x07,0x20,0x00,0x02,0x40,0x02	CodePage:0x07, ScanCode:0x20, KeyName:'3 #'
iUSBkey[7] hex: 0x07,0x21,0x00,0x02,0x40,0x03	CodePage:0x07, ScanCode:0x21, KeyName:'4 $'
iUSBkey[8] hex: 0x07,0x22,0x00,0x02,0x40,0x04	CodePage:0x07, ScanCode:0x22, KeyName:'5 %%'
iUSBkey[9] hex: 0x07,0x23,0x00,0x02,0x40,0x05	CodePage:0x07, ScanCode:0x23, KeyName:'6 ^'
iUSBkey[10] hex: 0x07,0x24,0x00,0x02,0x40,0x06	CodePage:0x07, ScanCode:0x24, KeyName:'7 &'
iUSBkey[11] hex: 0x07,0x25,0x00,0x02,0x40,0x07	CodePage:0x07, ScanCode:0x25, KeyName:'8 *'
iUSBkey[12] hex: 0x07,0x26,0x00,0x02,0x40,0x08	CodePage:0x07, ScanCode:0x26, KeyName:'9 ('
iUSBkey[13] hex: 0x07,0x27,0x00,0x00,0x00,0x29	CodePage:0x07, ScanCode:0x27, KeyName:'0 )'
iUSBkey[14] hex: 0x07,0x28,0x00,0x00,0x00,0x5A	CodePage:0x07, ScanCode:0x28, KeyName:'Return'
iUSBkey[15] hex: 0x07,0x29,0x00,0x00,0x00,0x76	CodePage:0x07, ScanCode:0x29, KeyName:'Escape'
iUSBkey[16] hex: 0x07,0x2A,0x00,0x00,0x00,0x66	CodePage:0x07, ScanCode:0x2A, KeyName:'Backspace'
iUSBkey[17] hex: 0x07,0x2B,0x00,0x00,0x00,0x0D	CodePage:0x07, ScanCode:0x2B, KeyName:'Tab'
iUSBkey[18] hex: 0x07,0x37,0x00,0x00,0x00,0x49	CodePage:0x07, ScanCode:0x37, KeyName:'. >'
iUSBkey[19] hex: 0x07,0x41,0x00,0x20,0x00,0x3E	CodePage:0x07, ScanCode:0x41, KeyName:'F8'
iUSBkey[20] hex: 0x07,0x42,0x00,0x20,0x00,0x26	CodePage:0x07, ScanCode:0x42, KeyName:'F9'
iUSBkey[21] hex: 0x07,0x51,0x00,0x01,0x00,0x74	CodePage:0x07, ScanCode:0x51, KeyName:'Down Arrow'
iUSBkey[22] hex: 0x07,0x52,0x00,0x01,0x00,0x6B	CodePage:0x07, ScanCode:0x52, KeyName:'Up Arrow'
iUSBkey[23] hex: 0x07,0xE3,0x00,0x10,0x00,0x1F	CodePage:0x07, ScanCode:0xE3, KeyName:'Left GUI'
iUSBkey[24] hex: 0x07,0x3C,0x00,0x00,0x00,0x04	CodePage:0x07, ScanCode:0x3C, KeyName:'F3'
iUSBkey[25] hex: 0x07,0x3D,0x00,0x00,0x00,0x0C	CodePage:0x07, ScanCode:0x3D, KeyName:'F4'
iUSBkey[26] hex: 0x07,0x8B,0x00,0x02,0x01,0x02	CodePage:0x07, ScanCode:0x8B, KeyName:'Keyboard Int’l 5'
iUSBkey[27] hex: 0x07,0x90,0x00,0x02,0x02,0x01	CodePage:0x07, ScanCode:0x90, KeyName:'Keyboard Lang 1'
iUSBkey[28] hex: 0x0C,0xE9,0x00,0x02,0x01,0x01	CodePage:0x0C, ScanCode:0xE9, KeyName:'undefined'
--------------------------------------

See also readme.txt and sample dump included in attached file

Bookmark It

as this is asked from time to tim, here is a sample and a class in C# (VS2005) that enables you to switch the green and orange keyboard shift plane of the keyboards on ITC CN3, CN3e and possibly other ruggedized ITC handheld devices.

You can control the keyboard shift state and you can subscribe to an event to get information about changes in the keyboard shift panel state. With the latter, you can create an application that is always aware of the active keyboard shift plane.

On the left image you see, that no shift plane is active. In the mid image, the Orange button was pressed. If you had pressed the orange key on the keypad, the Lock mode would be Locked. On the right image the green button was pressed.

As soon as a state change is detected (polling frequency is 200ms), the focus is moved to the right TextBox and the background color of the upper TextBox changes.

The code is written in C# and uses the native WIn32 APIs KernelIOControl, DeviceIOControl and CreateFile. You can either ask the current state of the shift plane and set it directly using the provided static class, or you can use the dynamic class object. The dynamic class fires an event, if the keypad shift panle status changes.

Bookmark It

iHook3

This application provides the user with key shortcuts to applications. All keystrokes or hot keys are transparent, this means, they are not lost and will reach the application just running in foreground. iHook2 can be started by placing a link to the exe in \Windows\Startup, by a batch file or some other AutoStart feature of the device OS.

iHook3 Version 1.3

This versions uses the registry to read the assigned keys and applications. Additionally the app is now safe and will only load once. The only argument supported is “-writereg” to write a default registry (see below).

Sample registry:

[HKEY_LOCAL_MACHINE\SOFTWARE\Intermec\iHook2]
"arg4"="iRun2.exe"
"exe4"="\\windows\\iKill2.exe"
"key4"=hex:\
      1b
"arg3"=""
"exe3"="explorer.exe"
"key3"=hex:\
      71
"arg2"=""
"exe2"="\\windows\\iSIP2.exe"
"key2"=hex:\
      74
"arg1"="-toggle"
"exe1"="\\windows\\LockTaskBar.exe"
"key1"=hex:\
      73
"arg0"=""
"exe0"="\\windows\\iRotateCN2.exe"
"key0"=hex:\
      72

New in version iHook3 (version 2.0)
recognizes CK60
adds Notification icon in taskbar

New in iHook3 (version 3.1)
recognizes CN3
supports consuming/forwarding switch for hot-keys. Use “ForwardKey” registry binary value 0 to disable forwarding hot-keys, 1 to enable forwarding hotkeys.
This new option is usefull if you have a phone device and hook the number keys. In this case disable forwarding with 0, otherwise the phone app will come in front for the number keys.

REGEDIT4
[HKEY_LOCAL_MACHINE\Software\Intermec\iHook3]
"arg0"=""
"exe0"="\\Windows\\iRotate.exe"
"key0"=hex:\
      26
"ForwardKey"=hex:\
      00

The main functionality is in here:
#pragma data_seg(".HOOKDATA")									//	Shared data (memory) among all instances.
	HHOOK g_hInstalledLLKBDhook = NULL;						// Handle to low-level keyboard hook
	//HWND hWnd	= NULL;											// If in a DLL, handle to app window receiving WM_USER+n message
#pragma data_seg()

#pragma comment(linker, "/SECTION:.HOOKDATA,RWS")		//linker directive

// The command below tells the OS that this EXE has an export function so we can use the global hook without a DLL
__declspec(dllexport) LRESULT CALLBACK g_LLKeyboardHookCallback(
   int nCode,      // The hook code
   WPARAM wParam,  // The window message (WM_KEYUP, WM_KEYDOWN, etc.)
   LPARAM lParam   // A pointer to a struct with information about the pressed key
)
{
	/*	typedef struct {
	    DWORD vkCode;
	    DWORD scanCode;
	    DWORD flags;
	    DWORD time;
	    ULONG_PTR dwExtraInfo;
	} KBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT;*/

	// Get out of hooks ASAP; no modal dialogs or CPU-intensive processes!
	// UI code really should be elsewhere, but this is just a test/prototype app
	// In my limited testing, HC_ACTION is the only value nCode is ever set to in CE
	static int iActOn = HC_ACTION;
	PROCESS_INFORMATION pi;
	int i;
	bool processed_key=false;
	if (nCode == iActOn)
	{
		PKBDLLHOOKSTRUCT pkbhData = (PKBDLLHOOKSTRUCT)lParam;
		if ( (wParam == WM_KEYUP) && (processed_key==false) )
		{
			for (i=0; i<=lastKey; i++)
			{
				if (pkbhData->vkCode == kMap[i].keyCode)
				{

Below is the download of the source code as done with embedded visual c 4.
DOWNLOAD:iHook3 Embedded Visual C++ 4 source code -  (Hits: 340, size: 90.75 KB)

Bookmark It