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: 92, size: 30.06 kB)

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

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: 195, size: 5.19 kB)

Bookmark It

Updated on 10. feb 2010

I finished a toolset to free the function keys on windows mobile devices. That means a tool set that will give you back the function keys. Instead of F3 launching the phone app, you can free the F3 key and use it in your app.

The tool set consists of three files:

• FuncKeysCPL a control panel applet that will launch the second tool FuncKeys.
• FuncKeys will enable you to define the function keys to free up.
• FuncKeysUnReg, the tool that will apply your settings during startup of the device.

For some more information see the html help inside FuncKeys (use the [?] button).

The only disadvantage with the tool is that it cannot free VK_LWIN as GXOpenInput() or AllKeys() can do.

regards

Josef
DOWNLOAD:FuncKeys - Control the function of Function Keys on Windows Mobile devices (embedded Visual C++ 4.0 Source included) (Hits: 422, size: 721.86 KB)

Bookmark It

KeyToggle

Using function keys by pressing numbers. Written for ITC 700 color running windows mobile 2003.

Note: Updated KeyToggle.exe and download cab:
DOWNLOAD:KeyToggle - (Hits: 190, size: 14.95 KB)

There was a bug, so the sticky key still produced wm_keydown messages. Fixed version is v2.1.1.0.

With keytoggle you can define a ‘sticky’ key that will change the behaviour 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 or on today screen.

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
[HKEY_LOCAL_MACHINE\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 0×90 (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.

The central code inside KeyToggle

// 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;
	TCHAR str[MAX_PATH];
	PKBDLLHOOKSTRUCT pkbhData = (PKBDLLHOOKSTRUCT)lParam;
	DWORD vKey;
	if (nCode == iActOn)
	{
#ifdef DEBUG
			wsprintf(str, L"vkCode=\t0x%0x \n", pkbhData->vkCode);
			DEBUGMSG(true,(str));
			wsprintf(str, L"scanCode=\t0x%0x \n", pkbhData->scanCode);
			DEBUGMSG(true,(str));
			wsprintf(str, L"flags=\t0x%0x \n", pkbhData->flags);
			DEBUGMSG(true,(str));
			wsprintf(str, L"isStickyOn is=\t0x%0x \n", isStickyOn);
			DEBUGMSG(true,(str));
#endif
		//only process unflagged keys
		if (pkbhData->flags != 0x00)
			return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam);

		//only process these types
		if ((wParam == WM_KEYUP) || (wParam == WM_KEYDOWN) || (wParam == WM_CHAR))
		{
			//dont care about sticky key down. v2.1.1
			if  (
				(pkbhData->vkCode == vkSticky) &&
				(wParam == WM_KEYDOWN)
				)
			{
				return -1;
			}

			//if num active change numeric keys to function keys
			//if sticky key set isStickyOn to active and start a timer to reset num after 3 seconds
			if  (
				(pkbhData->vkCode == vkSticky) &&
				(isStickyOn==false) &&
				(wParam == WM_KEYUP)
				)
			{
				LedOn(LEDid,1);
				isStickyOn=true;
				//start a timer
				if (stickyTimeout!=0)
					tID=SetTimer(NULL, 0, stickyTimeout, (TIMERPROC)Timer2Proc);
				return -1;
			}
			//if isStickyOn and sticky key is again pressed, toggle isStickyOn to OFF
			if ((pkbhData->vkCode == vkSticky) && (isStickyOn==true) && (wParam == WM_KEYUP))
			{
				LedOn(LEDid,0);
				isStickyOn=false;
				//start a timer
				if (stickyTimeout!=0)
					KillTimer(NULL, tID);
				return -1;
			}

			if ((isStickyOn==true) && (pkbhData->vkCode >= 0x30) && (pkbhData->vkCode <= 0x39)) 			{ 				//number key pressed and isStickyOn is active 				//get the pressed key 				vKey=pkbhData->vkCode;
				switch (vKey)
				{
					case 0x30: //0->F10
						vKey=VK_F10;
						break;
					default:
						vKey+=0x3F;//1 is 0x31, convert to F1 is 0x70
						break;
				}

				//create a new key event
				if (wParam == WM_KEYDOWN)
					keybd_event((byte)vKey, 0, KEYEVENTF_SILENT, 0); //key_down
				if (wParam == WM_KEYUP)
					keybd_event((byte)vKey, 0, KEYEVENTF_KEYUP |  KEYEVENTF_SILENT, 0); //key_up
				wsprintf(str, L"old Key=0x%0x -> new vkCode=\t0x%0x \n", pkbhData->vkCode, vKey);
				DEBUGMSG(true,(str));
				if ((autoFallback==1) && (wParam == WM_KEYUP)) //if autofallback
				{
					LedOn(LEDid,0);
					isStickyOn=false;
					if (stickyTimeout!=0)
						KillTimer(NULL, tID);
				}
				return -1;
			}
		}
	}
	return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam);
}

Usage Sample Scenario

You have a ITC 700 Color device. This has a alphanumeric 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 keyboard remapper tool cpkbdmap.cab from the ITC site (keyboard remapping tool is part of ITC device Resource Kit) 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.

Source Code (eVC4, WM2003)

Bookmark It

Do you think windows mobile is the right choice for a commercial used handheld?

Having windows mobile OS on a barcode scanner data retrieval system has a lots of disadvantages. There may be unwanted popups and it is hard to lock the user in the application. Windows CE is shrinked down, but no one will miss outlook and other PIM of windows mobile on a data retrieval system.

When I am talking about industrial/commercial used handhelds, I am talking about such devices.

Windows Mobile offers a rich set of functions, but from a support and developing view, it is harder to lock down the user in the application they have to use to enter data. There is an strange function key mapping and every time a popup may appear, where the user can get out of the main app back to the OS.

Windows CE is much easier to support and it is easier to lock down the user. It also has a smaller footprint and the application has more memory: no outlook and other mostly unused apps in the background. For browser type applications, the browser is more compatible to desktop browser than the Mobile Internet Explorer.

What do you think?

Some companies for ruggedized handhelds offer both OS types for there devices, some not.

Please vote at right sidebar.

Bookmark It