I would like to start a series of articles of how you can lockdown your application user in your application. How can you achieve a kiosk mode application, where the user is only allowed to do what you define.

The first article is about the Windows Start and Done Icon in menu bar and about fullscreen. You may already know, how to hide the start and done icon permanently from a Windows Embedded Handheld (Windows Mobile 6.5.3) device: Link

But there is also a temporary way using the same approach. The trick is to change the registry keys, that make the OS believe you have hardware buttons for Start and Done, BEFORE you show your CSharp form.

Before Windows Embedded Handheld (WEH, or Windows Mobile 6.5.3), you are able to use SHFullScreen API calls. But this will not work with WEH. Neither the flags SHFS_HIDESIPBUTTON nor SHFS_HIDESTARTICON will work. The LockDown.cs class also includes code for that and you may test the functions with the Test-Application.

The class I am talking about is called LockDown. There is also a Test-Application (OEMTitleBarHandler, dont ask me about the name selection) to test all functions I will describe.

Left is Windows Mobile 6.1 and right image shows Windows Embedded Handheld 6.5.3! You can use the ShFullScreen menu on both, but it will only work with Mobile 6.1. But the test “Form without StartIcon” will bring up a form without Start button.

OK, let’s look what we can do to hide the Start icon for a new form:

Source code

private void mnuStartIconTestForm_Click(object sender, EventArgs e)
        {
            Lockdown.LockDown.SaveRegistryFullScreen();
            Lockdown.LockDown.SetRegistryFullScreen(true, false, false);
            LockDownTestForm frm = new LockDownTestForm();
            frm.ShowDialog();
            Lockdown.LockDown.RestoreRegistryFullScreen();
            frm.Dispose();
        }

The function SaveRegistryFullScreen() save the state of the registry values of TextmodeEnabled, HardwareStartKeyEnabled and HardwareDoneKeyEnabled below “HKLM\SOFTWARE\Microsoft\Shell\BubbleTiles”.

The function SetRegistryFullScreen(bool bStartButtonPresent, bool bDoneButtonPresent, bool bTextMode) sets the registry key according to the args. So, if  bStartButtonPresent is set to true, the registry value of HardwareStartKeyEnabled  is set to 1. With this setting, the next form or window is shown without Start button. Easy, isn’t it. The other args work similar.

RestoreRegistryFullScreen will restore the registry to the state saved with SaveRegistryFullScreen().

How can you remove all buttons that enable the user to quit or minimize a form? To show a compact framework form with or without Done or Minimize buttons, you just have to set the right properties of the form. But dont forget to give the user an option to get back from a form.

The ControlBox property switches the (X)/ (OK) button display. The clicking an (OK) button will close and exit a form or application:

Source code

private void mnuControlBox_Click(object sender, EventArgs e)
        {
            if (this.ControlBox)
            {
                //show the (X) button, hide OK button
                this.ControlBox = false;
                mnuControlBox.Checked = false;
            }
            else
            {
                //remove the (X) button in title, show the OK button
                this.ControlBox = true;
                mnuControlBox.Checked = true;
            }
        }

The MinimizeBox property of a compact framework form switches the (OK) button to a (X) button. Where (X) stands for minimize window.

Source code

private void mnuMinimizeBox_Click(object sender, EventArgs e)
        {
            if (this.MinimizeBox)
            {
                //hide minimize button (OK)
                this.MinimizeBox = false;
                mnuMinimizeBox.Checked = false;
            }
            else
            {
                //show minimize button (OK)
                this.MinimizeBox = true;
                mnuMinimizeBox.Checked = true;
            }
        }

The Test application has also menu options to test these properties as “Window Options”.

The menu option Maximize shows the testform maximized (oh, wonder), but that means only, that the taskbar at the top is hidden and the client area is larger. If you additionally set the menu to null, you will get a real full screen form:

You have to press the Escape key (hopefully you have one) to bring the menu back in the test application.

The class file LockDown offers some more functions, but these are left for another article.

The whole code with the test application is available here. You need a subversion client like TortoiseSVN or AnkhSVN to checkout the source code.

Download LockDown.cs: DOWNLOAD:LockDown.cs - (Hits: 3, size: 2.19 kB)

Bookmark It

First, I dont need any partnership and so I change my system to do GuestOnly connections with WMDC (Windows Mobile 7, 64Bit system).

OK, second annoyance is the awlays coming up WMDC or WMDC+Mobile Registration Wizard. These Popups can be avoided by changing the call to WMDC.exe to WMDCbase.exe. See also this post.

So, I can connect one of the several devices I have currently for development support (about 10-30) without annoying popups.

But then I found, that for each device and sometimes multiple times, Windows installs a new “Microsoft Windows Mobile Remote Adapter” in Device Manager. I found about 88 instances, where only ONE is needed. Before you can see the inactive adapters, you have to enable Show_Hidden_Devices. One way to show hidden devices is this []:

1. Click Start, point to All Programs, point to Accessories, and then click Command Prompt.
2. At a command prompt, type the following command , and then press ENTER:
   set devmgr_show_nonpresent_devices=1
3. Type the following command a command prompt, and then press ENTER:
   start devmgmt.msc
4. Troubleshoot the devices and drivers in Device Manager.

   NOTE: Click Show hidden devices on the View menu in Device Manager before you can see devices that are not connected to the computer.

5. When you finish troubleshooting, close Device Manager.
6. Type exit at the command prompt.

To remove the hidden, inactive Mobile Remote Instances, you can now right click on every instance, then click UnInstall and then [OK]. But for 88 instances, that is a bunch of clicking.

As programmer, I searched of a way to remove these instances programmatically. OK, I digged google and found DevCon, a tool to manage devices and instances from the command line. Unfortunately, I had to download a CD image of Windows WDK to get DevCon.exe. Then I found a site which described howto install DevCon only.

With the help of DevCon.exe, I produced a list of “Microsoft Windows Mobile Remote Adapter” instances, removed to not numbered one and then built a list of DevCon commands to remove the obsolete instances.

List all Windows Mobile Remote Adapters into a file:

devcon findall "USB\VID_067E&PID_1003&REV_0000" >wm_remote_adapters.txt

“USB\VID_067E&PID_1003&REV_0000″ is the identifier for Windows Mobile Remote Adapter (you can find this by right clicking the instance in device manager and select properties).

USB\VID_067E&PID_1003\0040056A-0E9D-0801-0DE0-01130400682B  : Microsoft Windows Mobile Remote Adapter #59
USB\VID_067E&PID_1003\0040056A-0E9D-0801-1B10-010E04000801  : Microsoft Windows Mobile Remote Adapter #6
USB\VID_067E&PID_1003\0040056A-0E9D-0801-0B70-000E0400BA61  : Microsoft Windows Mobile Remote Adapter #24
USB\VID_067E&PID_1003\0040056A-0E9D-0801-1990-001104000E40  : Microsoft Windows Mobile Remote Adapter #77
USB\VID_067E&PID_1003\99461300-B56A-0801-DD17-0FBB99944738  : Microsoft Windows Mobile Remote Adapter #89
...

Then, in the list wm_remote_adapters.txt, I replaced all line starts etc and built this cmd list:

devcon.exe remove "@USB\VID_067E&PID_1003\0040056A-0E9D-0801-0590-010E0400A43B"
devcon.exe remove "@USB\VID_067E&PID_1003\99461300-B56A-0801-5AD3-B56444802FC3"
devcon.exe remove "@USB\VID_067E&PID_1003\99461300-B56A-0801-B87A-D1874E00C078"
devcon.exe remove "@USB\VID_067E&PID_1003\0040056A-0E9D-0801-1640-01100400B075"
...

Then I saved this cmd list as remove-adapters.cmd and started it from the command prompt. And, voila, all obsolete adapters are gone for now.

From time to time I have to rebuild the lists again to get rid of these many obsolete adapters.

Bookmark It

Fortunately, Henkie leaved a comment about a usefull alternative for WMDC. But as commented here, no visual control of the connection.

Now I started to think about a small tool to have a visual control of WMDC connected or not. I had to use RAPI either provided by MS or via OpenNetCF.Desktop.Communication. Although the OpenNETCF one works OK, I was not satisfied, as it was impossible to get a connection status without disconnect/connect. So I went back to WIN32 API and wrote this small tool based on DeviceInfo sample of Windows Mobile 6 SDK.

First I again messed up with notification icons in Windows 7 (64bit). But the icon may be removed or not, depending on Windows 7 decisions I dont know.

So the tool uses a simple window and an icon to let you know the connection status.

Just start the tool and the icon and edit window background will show, if device is connected or not. The application icon in the title bar as in the taskbar button will change from gray to color for a connected versa a disconnected device.

Visual Studio 2008 C/C++ Win32 code and exe: DOWNLOAD:WMDC-State2 Code and Exe - (Hits: 61, size: 122.55 kB)

Bookmark It

To disable all Connection Manager Dialogs set the following registry key:

[HKLM]Software\Microsoft\Shell\Rai\:MSREMNET\Disable
“All”=dword:1

to disable only certain dialogs or notification bubbles, use IDs like IDS_RAS_CARRIER_DROPPED:

[HKLM]Software\Microsoft\Shell\Rai\:MSREMNET\Disable
“0″=dword:1

to disable multiple dialogs, simply define additional IDs. For example to disable dialogs for IDS_RAS_DEVICE_NOT_READY and IDS_RAS_NO_ANSWER:

[HKLM]Software\Microsoft\Shell\Rai\:MSREMNET\Disable
“3″=dword:1
“5″=dword:1

Have fun

List of all IDS values: DOWNLOAD:IDS dialog values - (Hits: 27, size: 13.02 kB)

Bookmark It

this post describes a way to load class libraries (DLLs) dynamically on demand in your compact framework application.

What is it good for?

Hardware abstraction. Load only matching Libraries.

Organize your development for different devices. You will be able to only load the right hardware (device) dependent libraries. You are able to use a hardware abstraction layer.

Normally, you add a reference to an assembly during development in Visual Studio. Now, when the application starts on the device, it will try to load this assembly. If it contains hardware dependent code, like a barcode scanner library, the load of your application may fail.

Using the techniques described here, you can avoid this and direct your app to only load device matching libraries.

Plugin usage

You can write a Compact Framework application that will load and work with plugins. These reside in DLLs and can be added or removed on demand.

You can for example write an application launcher that will list the installed extensions. In example for a Transport and Logistic application you can have a truck loading and a truck unloading extension. If you have to update one of the plugins, you only need to replace the plugin DLL, the rest of the application (for example Login forms, Information screens, connection management) remains unchanged.

DLL loading in C/C++

Loading libs dynamically is well known in C/C++. You simply use LoadLibrary(dllName) and then you can get the addresses to known library functions and use these.

Static linking: Adding a reference in a compact framework (SmartDevice) application inside Visual Studio is like adding a header and lib file to a C/C++ application.

DLL loading in Compact Framework

You can also use the above in C#/VB.NET.

Source code

namespace ConsoleApplication1
{
  class Program
  {
    static IClass1 GetIClass1(string filename)
    {
      Assembly classLibrary1 = null;
      using (FileStream fs = File.Open(filename, FileMode.Open))
      {
        using (MemoryStream ms = new MemoryStream())
        {
          byte[] buffer = new byte[1024];
          int read = 0;
          while ((read = fs.Read(buffer, 0, 1024))>0)
            ms.Write(buffer, 0, read);
          classLibrary1 = Assembly.Load(ms.ToArray());
        }
      }
      foreach (Type type in classLibrary1.GetExportedTypes())
      {
        if (type.GetInterface("IClass1") != null)
          return Activator.CreateInstance(type) as IClass1;
      }
 
      throw new Exception("no class found that implements interface IClass1");
    }
 
    static void Main(string[] args)
    {
      IClass1 class1 = GetIClass1("ClassLibrary1.dll");
      class1.DoSomething();
    }
  }
}

[source: http://social.msdn.microsoft.com/forums/en-US/clr/thread/093c3606-e68e-46f4-98a1-f2396d3f88ca/], may not work without change in CF.

Using writing all the C/C++ LoadLibrary/GetProcAddress or the above for all your library functions  is very time consuming and error-prone.

There is another way using class interfaces and libraries for hardware dependent code described at MSDN: Barcode Scanners and the Compact Framework. The disadvantage of this solution is, that you have to add references to all different possible implementation assemblies: in the example, you have to add a ref to the Intermec barcode scanner implementation and to the symbol barcode scanner. Imagine if you have to manage this for 4 and more manufacturer and not only for barcode scanners but also for other OEM vendor features (WLAN, keyboard).

So, looking for a better solution, I found the Managed Extensibility Framework (MEF) and fortunately a Pocket MEF (the compact framework compatible variant). MEF was developed as a community project with technology previews at codeplex. It now is part of NET 4.0 framework.
Pocket MEF is also hosted a codeplex, it follows the main technology previews until CTP8.1. Although the full MEF has already reached version 2, the Pocket MEF is sufficiant to be very usefull.

Pocket MEF

I will describe how you can use PocketMEF to write an application that will automatically load the right hardware dependent DLLs. We will use PocketMEF to implement a Hardware Abstraction Layer (HAL). PocketMEF will load the right assemblies during runtime on demand using a file name pattern.

Use Interfaces

This step is also used in the article at http://msdn.microsoft.com/en-us/library/aa446489.aspx. Using interfaces or factory classes ensures, that your “plugins” or OEM modules have all the same interface.

Hardware abstraction: Implement the different OEM dependent class libs
Let PocketMEF load the right class libs

Plugin use: Implement different plugins using the same interface
Let PocketMEF load all matching plugins

The sample solution MEFdemo

I have done a sample application that shows both, hardware abstraction and plugin usage. The Visual Studio 2008 Windows Mobile 6 Prof. solution defines a main application, two different contracts (interfaces) and some extensions that fullfill the interfaces.

Unfortunately, the solution is more complex, as it shows both aspects. OK, here is a design schema:

You see, we have one IAppPlugin and one IBarcodeScanControl interface. Then there are two Forms that implement IAppPlugin and one of that uses an IBarcodeScanControl.

The IAppPlugin Interface

namespace MEFdemo1.AppContracts
{
    //describe a public appPlugin interface (contract)
    public interface IAppPlugin : IComponent
    {
        Bitmap appBitmap{ get; }
        System.Windows.Forms.DialogResult DialogResult { get; }
        string sAppText { get; }
        string sReturnData { get; }
    }
}

An IAppPlugin implementation

The simple AppPlugin1 Form implements this interface and exports it.

Source code
   
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
using System.ComponentModel;
using System.ComponentModel.Composition;
 
using MEFdemo1.AppContracts;
 
namespace AppPlugin1
{
    [PartCreationPolicy(CreationPolicy.NonShared)]
    [Export(typeof(IAppPlugin))]
    public partial class UserForm1 : Form, IAppPlugin
    {
...

The AppPlugin2 uses IBarcodeControl

This form imports the IBarcodeControl and exports IAppPlugin.

Source code
   
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.ComponentModel.Composition.Diagnostics;
 
using MEFdemo1.HAL.DeviceControlContracts;
using MEFdemo1.AppContracts;
 
namespace AppPlugin2
{
    [PartCreationPolicy(CreationPolicy.NonShared)]
    [Export(typeof(IAppPlugin))]
    public partial class BarcodeForm : Form, IAppPlugin
    {
    ...
    }
        //[Import(typeof(IBarcodeScanControl))]
        //if Import is used here, the catalog is unable to find the control!
        private IBarcodeScanControl conScan;
 
        DirectoryCatalog catalog2;
        CompositionContainer container2;
 
        public BarcodeForm()
        {
            InitializeComponent();
            try
            {
                string sPath="";
                if (isIntermec)
                    sPath = "MEFdemo1.HAL.Intermec.*Control*.dll";
                else
                    sPath = "MEFdemo1.HAL.ACME.*Control*.dll";
 
                //I was unable to use the different catalog and let it look in a subfolder
                //so the plugin names are used as a filter
                catalog2 = new DirectoryCatalog(".", sPath);
 
                foreach (string s in catalog2.LoadedFiles)
                    System.Diagnostics.Debug.WriteLine(s);
 
                container2 = new CompositionContainer(catalog2);
 
                container2.ComposeParts(this);
...

The usable BarcodeControl is loaded by using a different file pattern for the DirectoryCatalog. So only one BarcodeControl is loaded.

The MainForm

The main form scans the application dir for IAppPlugins and lists them using there bitmap property.

Source code
   
...
        //we will import all available plugins
        [ImportMany(typeof(IAppPlugin))]
        private int iPluginCount = 0;
 
        DirectoryCatalog catalog;
        CompositionContainer container;
...
        public MainForm()
        {
            InitializeComponent();
            try
            {
                catalog = new DirectoryCatalog(".", "MEFdemo1.Plugins.*.dll");
                container = new CompositionContainer(catalog);
                container.ComposeParts(this);
                drawPlugins();
            }
            catch (Exception ex)
            {
                MessageBox.Show("No Plugins loaded: " + ex.Message);
            }
        }

drawPlugins will draw the images inside MainForm using pictureboxes and applies a click handler for these.

Source code
   
        void MainForm_Click(object sender, EventArgs e)
        {
            string sApp = ((PictureBox)sender).Tag.ToString();
            System.Diagnostics.Debug.WriteLine(sApp);
            foreach (IAppPlugin iApp in plugins)
            {
                if (iApp.sAppText.Equals(sApp))
                {
                    ((System.Windows.Forms.Form)iApp).ShowDialog();
                    continue;
                }
            }
        }

Here is a screenshot of the composed parts:

When you click one of the pictureboxes, the plugins form is shown: either the BarcodeForm or the simple UserForm:

The programs dir reflects all the contracts and plugins:

intermec.datacollection.cf3.5.dll                            intermec barcode hardware wrapper
intermec.devicemanagement.smartsystem.itcssapi.dll           intermec software wrapper
MEFdemo1.exe                                                 the application
mefdemo1.appcontracts.dll                                    the AppPlugin contract
mefdemo1.devicecontrolcontracts.dll                          the BarcodePlugin contract
MEFdemo1.HAL.ACME.BarcodeControl2.dll                        one BarcodeControl (the generic implementation)
MEFdemo1.HAL.Intermec.BarcodeControl1.dll                    second BarcodeControl (intermec dependent)
MEFdemo1.Plugins.AppPlugin1.dll                              the UserForm application plugin
MEFdemo1.Plugins.AppPlugin2.dll                              the BarcodeForm application plugin
pocket.componentmodel.initialization.dll                     PocketMEF runtime
pocket.system.componentmodel.composition.dll                 PocketMEF runtime

If you remove one of the AppPlugin DLL files and then start MEFdemo, only the remaining Plugin is shown.

Although I implemented all plugins in there own class library projects, you can combine multiple plugins into one project and so will get less DLLs. The disadvantage is that you cant simply update only one these plugins, you have then to replace the whole lib.

Source code is hosted at code.google.com/p/pocketmef/source/

Bookmark It

on the wish of the one or other user I extended the RDP AutoLogin code and we now reached level 4.

The new code simply has only one extension, it supports the color depth selection. Also the color depth and other settings are visible on the dialog of Remote Desktop Mobile, the settings itself are done via the Default.rdp file. But you are right, RDP_AutoLogin also controls some of the dialog items directly.

Source code

...
Domain:s:
ColorDepthID:i:3
ScreenStyle:i:0
DesktopWidth:i:640
DesktopHeight:i:480
UserName:s:rdesktop
...
ServerName:s:192.168.128.5
SavePassword:i:1
...

The color depth setting supports two modes, 8 Bit with 256b colors (ColorDepthID:i:1) and 16 Bit with ~65000 colors (ColorDepthID:i:3).

Source code

REGEDIT4
 
[HKEY_LOCAL_MACHINE\Software\RDP_autologin]
"FitToScreen"="1"
"FullScreen"="1"
"Status"="connecting..."
"Save Password"="1"
"Domain"=""
"Password"="Intermec+2004"
"Username"="rdesktop"
"Computer"="192.168.0.130"
"DesktopWidth"=640
"DesktopHeight"=480
"startOnExit"="\\rdp_keepBusy.exe"
"execargs"="noRDPstart"
"UseMouseClick"="0"	//added with version 3 to switch between mouse and keyboard simulation
"ColorDepth"=1		//added with version 4 to enable switching between 8 and 16 Bit colors

The code changes are small. Some code addition to read the value from the registry and some to write the rdp file:

Source code

void readReg(){
...
        //ColorDepth new with version 4
        if(RegReadDword(L"ColorDepth", &dwTemp) == 0)
            dwColorDepth=dwTemp;
...
}
void writeRDP(){
...
			else if(wcsstr(rdpLines[c].line, L"ColorDepthID")!=NULL){
				wsprintf(szTemp, rdpLines[c].line, dwColorDepth);  //3=HighColor(16Bit) or 1=(8Bit) color
			}
...
}

Additionally I have added a new project to the solution to enable to set all the settings not only via the registry but using a GUI application. RDP_Autologin_Settings is born:

As you see, there is also a small file browser integrated. The default OpenFile dialog of Compact Framework does not allow you to browse all directories, but only “\My Documents”.

RDP AutoLogin Settings Editor (exe): DOWNLOAD:RDP AutoLogin Settings editor - (Hits: 80, size: 10.45 kB)
source (Visual Studio 2008 WM5 SDK project): DOWNLOAD:RDP AutoLogin Settings editor Source Code - (Hits: 52, size: 21.23 kB)

RDP_AutoLogin (exe): DOWNLOAD:RDP AutoLogin Executable - (Hits: 74, size: 6.78 kB)
source (Visual Studio 2008 WM5 SDK project): DOWNLOAD:RDP AutoLogin Source Code - (Hits: 52, size: 56.85 kB)

RDP_KeepBusy (exe): DOWNLOAD:RDP KeepBusy (executable) - (Hits: 62, size: 3.17 kB)
RDP_KeepBusy (vs2008 WM5 SDK project): DOWNLOAD:RDP KeepBusy Source Code - (Hits: 49, size: 12.92 kB)

Have fun

Josef

Bookmark It

Background process

We could have written a background process to run external tasks periodically. But the main disadvantage of timers and threads in background processes is that they do not run, if the device is in suspend mode.
To ensure that tasks will be launched also if the device is sleeping, we decided to use the windows mobile scheduler. There are functions inside the notification API to create notifications that will run an application at a specified time. This is what we call a schedule.

The scheduler (notification API)

After a timed schedule has been done by the scheduler, the schedule is removed from the notification database. If you like to have a periodic schedule, you have to ensure that a new schedule is created inside your code.

Pitfalls

During development we found many pitfalls in conjunction with the windows mobile scheduler. This is why I decided to write this post.

The tasks

Tasker2 is a console application without any GUI but it will write a log with all you need to know. Tasker2 supports up to ten tasks. A task is defined using the registry. Every task has an entry for start and stop times, the application to control, an interval for the schedule and a flag for control if a task is only to be run on external power:

REGEDIT4

[HKLM\Software\Tasker\Task1]
"active":DWORD=1
"exe":="\Windows\fexplore.exe"
"arg":="\My Documents"
"start":="1423"
"stop":="1523"
"interval":="2400"
"startOnAConly":DWORD=0;

active: if active is 0, tasker2 will not kill or start the process
exe: name of the process executable to start or kill
arg: arguments to be when launching the executable
start: when to start the executable the next time
stop: when to kill the process the next time
interval: when a start or kill has been executed, tasker2 will create a new schedule using this interval. If the interval is “0010″, the start process will be scheduled for every 10 minutes.
startOnAConly: if 1 and when a process has to be started, the process will only be started if the device is on external power

The scheduler

First, tasker2 is normally only launched one time manually and all future calls are made by the scheduler. Tasker2 will clear and schedule all planned tasks as defined in the registry if it is launched without arguments.

The scheduler is a task manager running all the time in windows mobile. If a timed schedule is reached, the scheduler will launch the specified application, see also here . This will also work if the device is in suspend mode (sleeps). The scheduler can also fire on special events like time or hardware changes (ON_RS232_CONNECT for example). See also my post here [http://www.hjgode.de/wp/2010/03/06/irunatevent/].

Theory of operation

Tasker2 uses command line arguments to control itself. The scheduler launches tasker2 with the specified arguments and tasker2 will then run or kill the defined task.

Delayed schedules (pitfall 1)

If your device supports a real power down, the scheduler will not awake the device and is not able to launch the defined schedules. When the device is later powered on, it will schedule all past schedules at once. This is what we call a ‘delayed schedule’ and a flooding of launches. Flooding in the mean of many schedules of tasker2 occurring at the same time for past tasks.
To avoid concurrent changes to the registry and scheduler entries, tasker2 uses a mutex to ensure only one instance is continuing execution. Subsequent instances will wait for existing instances before they do there work.

Source code

//##################### dont run if already running #############################
	nclog(L"Checking for Mutex (single instance allowed only)...\n");
 
	hMutex=CreateMutex(NULL, TRUE, MY_MUTEX);
	if(hMutex==NULL){
		//this should never happen
		nclog(L"Error in CreateMutex! GetLastError()=%i\n", GetLastError());
		nclog(L"-------- END -------\n");
		return -99;
	}
	DWORD dwLast = GetLastError();
	if(dwLast== ERROR_ALREADY_EXISTS){//mutex already exists, wait for mutex release
		nclog(L"\tAttached to existing mutex\n");
		nclog(L"................ Waiting for mutex release......\n");
		WaitForSingleObject( hMutex, INFINITE );
		nclog(L"++++++++++++++++ Mutex released. +++++++++++++++\n");
	}
	else{
		nclog(L"\tCreated new mutex\n");
	}
 
	//##################### dont run if already running #############################

On a delayed, flooding schedule ALL pending tasks are scheduled and possibly a Time_Changed string is sent to the pending tasks. This flooding will be serialized as tasker2 waits for existing tasker2 instances.

Time and time zone changes (pitfall 2)

When the time is changed on the device, the scheduler will inform all timed tasks. Tasker2 must then recalculate new schedules based on current local time. The scheduler launches the defined applications with the TIME_CHANGED string as argument.

Source code

else if(wcsicmp(argv[1], APP_RUN_AFTER_TIME_CHANGE)==0 || wcsicmp(argv[1], APP_RUN_AFTER_TZ_CHANGE)==0){
			nclog(L"got '%s' signaled\n", argv[1]);
				//better to reread the current time we work with, possibly we have been blocked
				g_tmCurrentStartTime=getLocalTime(&g_tmCurrentStartTime);
				//now again check if we have a valid date
				nclog(L"Checking for valid date/time...\n");
				if( ((g_tmCurrentStartTime.tm_year+1900)*100 + g_tmCurrentStartTime.tm_mon+1) < 201111){
					nclog(L"scheduling event notifications\n");
					//clear and renew all event notifications
					#ifndef TESTMODE
						RunAppAtTimeChangeEvents(szTaskerEXE);
					#endif
					nclog(L"Date/Time not valid!\n*********** END ************\n");
					return 0xBADCAB1E;
				}
				nclog(L"Date/Time after 11 2011. OK\n");
 
			//schedule all active tasks
			int iCount = scheduleAllTasks();
			nclog(L"Scheduled %i Tasks\n", iCount);
		}

Additionally we found that the time changes may also occur during program launch or as tasker2 instances wait for another tasker2 instance. So tasker2 uses only one (in real two) calls to get the current time. This is essential, as tasker2 uses the current time to re-schedule tasks. The current time is called at the beginning, before tasker2 waits for the mutex. This is the time tasker2 was launched. If there has been a time_changed schedule, tasker2 will use another call to the current time, as it may have changed between the launch and the further execution of the code – after the mutex is released and the current instance is allowed to run.

Delayed schedules II (pitfall 3)

As only one instance of tasker2 is executing, it may happen, that the current time and the task time do not match exactly. Although the scheduler may do its best to launch tasker2 at the right time, the execution may be delayed in regards of the time the task is to be scheduled and the current time. This is another delayed schedule compared to the above flooding of schedules after a power down/up cycle.
It may also happen that a lot of tasker2 instances are waiting for execution, you know that we can have up to ten tasks. This may also lead to ‘delayed’ code execution, but should be in a small time frame of some minutes only.
Therefor tasker2 supports a maximum allowed delay time to distinguish between allowed and flooding delayed calls.

Source code

//is this a delayed schedule?
		nclog(L"\tchecking for delayed schedule...\n");
		int iDeltaMinutes;
		__time64_t ttStart;
		__time64_t ttStop;
		__time64_t ttCurr;
		ttStop = _mktime64(&(_Tasks[iTask].stStopTime));
		ttStart = _mktime64(&(_Tasks[iTask].stStartTime));
		ttCurr = _mktime64(&g_tmCurrentStartTime);
 
		if(thisTaskType==stopTask){
			//difftime(timer1, timer0) returns the elapsed time in seconds, from timer0 to timer1
			iDeltaMinutes = difftime(ttCurr, ttStop)/60;// stDeltaMinutes(_Tasks[iTask].stStopTime, g_CurrentStartTime);
			nclog(L"stStopTime = '%s', ", getLongStrFromTM(_Tasks[iTask].stStopTime));
		}
		else{
			iDeltaMinutes = difftime(ttStart, ttCurr)/60;// stDeltaMinutes(_Tasks[iTask].stStartTime, g_CurrentStartTime);
			nclog(L"stStartTime = '%s', ", getLongStrFromTM(_Tasks[iTask].stStartTime));
		}

Adding a schedule

I am using central functions in code to add or remove schedules. Here is a sample of how a schedule is added:

Source code

...
#include "notify.h"
...
//--------------------------------------------------------------------
// Function name  : ScheduleRunApp
// Description    : add a schedule for exe with args at the time
// Argument       : LPCTSTR szExeName
// Argument       : LPCTSTR szArgs
// Argument       : struct tm tmTime
// Return type    : HRESULT, 0 for no error
//--------------------------------------------------------------------
HRESULT ScheduleRunApp(LPCTSTR szExeName, LPCTSTR szArgs, struct tm tmTime)
{
	HRESULT hr = S_OK;
	HANDLE hNotify = NULL;
 
	// set a CE_NOTIFICATION_TRIGGER
	CE_NOTIFICATION_TRIGGER notifTrigger;
	memset(&notifTrigger, 0, sizeof(CE_NOTIFICATION_TRIGGER));
	notifTrigger.dwSize = sizeof(CE_NOTIFICATION_TRIGGER);
 
	// calculate time
	SYSTEMTIME st = {0};
	//GetLocalTime(&st); //v.2.28
 
	st = convertTM2SYSTEMTIME(&st, &tmTime); //use provided new datetime
 
	wsprintf(str, L"Next run at: %02i.%02i.%02i %02i:%02i:%02i",
										st.wDay, st.wMonth , st.wYear,
										st.wHour , st.wMinute , st.wSecond );
	nclog(L"\tScheduleRunApp: %s\n", str);
 
	notifTrigger.dwType = CNT_TIME;
	notifTrigger.stStartTime = st;
 
	// timer: execute an exe at specified time
	notifTrigger.lpszApplication = (LPTSTR)szExeName;
	notifTrigger.lpszArguments = (LPTSTR)szArgs;
 
	hNotify = CeSetUserNotificationEx(0, &notifTrigger, NULL);
	// NULL because we do not care the action
	if (!hNotify) {
		hr = E_FAIL;
		nclog(L"\tScheduleRunApp: CeSetUserNotificationEx FAILED...\n");
	} else {
		// close the handle as we do not need to use it further
		CloseHandle(hNotify);
		nclog(L"\tScheduleRunApp: CeSetUserNotificationEx succeeded...\n");
	}
	return hr;
}

The main code

The main function is processStartStopCmd() beside createNextSchedule(). It does all the scheduling and time calculations.

Source code

/*	########################################################
		Process -s and -k comd line args
	########################################################
*/
//--------------------------------------------------------------------
// Function name  : processStartStopCmd
// Description    : calc new start/stop time, add schedules and start/kill application
// Argument       : TCHAR* argv[], the cmdLine array
// Return type    : int, 0 for no error
//--------------------------------------------------------------------
int processStartStopCmd(TCHAR* argv[]){
	int iReturn = 0;
 
	BOOL bIsDelayedSchedule = TRUE; //used to save a delayed schedule situation
 
	enum taskType{
		startTask = 1,
		stopTask = 2
	};
	taskType thisTaskType;
 
	if(wcsicmp(argv[1], L"-k")==0)	//kill taskX app
		thisTaskType=stopTask;
	else
		thisTaskType=startTask;
 
	int iTask = getTaskNumber(argv[2]);
	if(_Tasks[iTask].iActive==1){
		//create a new schedule cmd line for tasker
		TCHAR strTaskCmdLine[MAX_PATH];
 
		if(thisTaskType==stopTask)
			wsprintf(strTaskCmdLine, L"-k task%i", iTask+1); //the cmdLine for tasker.exe for this task
		else
			wsprintf(strTaskCmdLine, L"-s task%i", iTask+1); //the cmdLine for tasker.exe for this task	
 
		//clear all tasker schedules for taskX
		nclog(L"Clearing all schedules for Task%i with '%s'\n", iTask+1, strTaskCmdLine);
		notiClearRunApp(szTaskerEXE, strTaskCmdLine);
 
		struct tm tmNewTime = {0};
		short shHour	=	_Tasks[iTask].stDiffTime.tm_hour;
		short shMin		=	_Tasks[iTask].stDiffTime.tm_min;
		short shDays	=	0;
		if(shHour>=24){	//hour interval value is one day or more
			shDays = (short) (shHour / 24);
			shHour = (short) (shHour % 24);
		}				
 
		//is this a delayed schedule?
		nclog(L"\tchecking for delayed schedule...\n");
		int iDeltaMinutes;
		__time64_t ttStart;
		__time64_t ttStop;
		__time64_t ttCurr;
		ttStop = _mktime64(&(_Tasks[iTask].stStopTime));
		ttStart = _mktime64(&(_Tasks[iTask].stStartTime));
		ttCurr = _mktime64(&g_tmCurrentStartTime);
 
		if(thisTaskType==stopTask){
			//difftime(timer1, timer0) returns the elapsed time in seconds, from timer0 to timer1
			iDeltaMinutes = difftime(ttCurr, ttStop)/60;// stDeltaMinutes(_Tasks[iTask].stStopTime, g_CurrentStartTime);
			nclog(L"stStopTime = '%s', ", getLongStrFromTM(_Tasks[iTask].stStopTime));
		}
		else{
			iDeltaMinutes = difftime(ttStart, ttCurr)/60;// stDeltaMinutes(_Tasks[iTask].stStartTime, g_CurrentStartTime);
			nclog(L"stStartTime = '%s', ", getLongStrFromTM(_Tasks[iTask].stStartTime));
		}
 
		nclog(L"current time = '%s'\n", getLongStrFromTM(g_tmCurrentStartTime));
		nclog(L"interval is: %id%02ih%02im\n", shDays, shHour, shMin);
		nclog(L"\tdelta is %i minutes\n", iDeltaMinutes);
 
		//started BEFORE scheduled time, iDelta is negative
		if(iDeltaMinutes<0){
			if(thisTaskType==stopTask){
				//calculate new schedules or leave them as is?
				//tmNewTime=_Tasks[iTask].stStopTime;	//leave them as is
				tmNewTime=createNextSchedule(_Tasks[iTask].stStopTime, shDays,shHour,shMin); //calc new schedule
			}
			else{
				//tmNewTime=_Tasks[iTask].stStartTime;	//leave them as is
				tmNewTime=createNextSchedule(_Tasks[iTask].stStartTime, shDays,shHour,shMin); //calc new schedule
			}
#ifndef TESTMODE
			ScheduleRunApp(szTaskerEXE, strTaskCmdLine, tmNewTime);
#endif
			nclog(L"*** re-scheduled future task *** \n");
			return 0;
		}
 
		int iMaxDelay = getMaxDelay();
		nclog(L"\tmax allowed diff for delayed schedule recognition is plus %i\n", iMaxDelay);
 
		if( iDeltaMinutes > iMaxDelay ) //is the time diff greater than 1 minute
		{
			bIsDelayedSchedule = TRUE;
			nclog(L"*** delayed schedule *** recognized\n");
			//this is a delayed schedule
			DOUBLE dbTimeDiff = 0;
 
			//it may happen that the schedule is far in the future
			//we calc the next schedule on base of the current time by using the saved start/stop time
			//is just greater than the current time
			if(thisTaskType==stopTask)
				tmNewTime=_Tasks[iTask].stStopTime;
			else
				tmNewTime=_Tasks[iTask].stStartTime;
 
			tmNewTime = createNextSchedule(tmNewTime, shDays, shHour, shMin);
		}
		else{
			nclog(L"*** NO delayed schedule *** recognized\n");
			if(thisTaskType==stopTask){
				tmNewTime = createNextSchedule(_Tasks[iTask].stStopTime, shDays, shHour, shMin);
			}
			else{
				tmNewTime = createNextSchedule(_Tasks[iTask].stStartTime, shDays, shHour, shMin);
			}
			bIsDelayedSchedule=FALSE;
		}
 
		//create a new kill or start schedule with new time
		nclog(L"Creating new schedule for '%s' in Task%i\n", _Tasks[iTask].szExeName, iTask+1);
#ifndef TESTMODE
		ScheduleRunApp(szTaskerEXE, strTaskCmdLine, tmNewTime);
#endif
		//save new changed stop/start ime
		if(thisTaskType==stopTask)
			regSetStopTime(iTask, tmNewTime);
		else
			regSetStartTime(iTask, tmNewTime);
 
		if(!bIsDelayedSchedule){
			nclog(L"Not a delayed schedule\n");
			if(thisTaskType==startTask){
				if(_Tasks[iTask].bStartOnAConly){
					if(isACpowered()){
						nclog(L"Starting exe '%s' as on AC power\n", _Tasks[iTask].szExeName);
						runExe(_Tasks[iTask].szExeName, _Tasks[iTask].szArgs);
					}
					else{
						nclog(L"Skipping start of exe '%s' as not on AC power\n", _Tasks[iTask].szExeName);
					}
				}
				else{
					nclog(L"Starting exe '%s'\n", _Tasks[iTask].szExeName);
					runExe(_Tasks[iTask].szExeName, _Tasks[iTask].szArgs);
				}
			}
			else{ // a stop task
				//now kill the task's exe
				nclog(L"Killing exe '%s'\n", _Tasks[iTask].szExeName);
				DWORD iKillRes = killExe(_Tasks[iTask].szExeName);
				switch (iKillRes){
					case ERROR_NOT_FOUND:
						nclog(L"\texe not running\n");
						break;
					case 0:
						nclog(L"\texe killed\n");
						break;
					default:
						nclog(L"unable to kill exe. GetLastError=%08x\n", iKillRes);
						break;
				}
			}
		}
		else{
			nclog(L"Exec/Kill skipped as this is a delayed schedule\n");
		}
	}
	else
		nclog(L"\ttask %i is inactive (0x%02x)\n", iTask, _Tasks[iTask].iActive);
 
		return iReturn;
}

 Tasker2 control

Although you normally dont need to run tasker2 manually, I have added some command line arguments:

“-c”    instructs tasker2.exe to remove all tasker2 schedules of the scheduler database
“-r taskX”    deactivate processing of task with number X, sets the active flag to 0
“-a taskX”    activate processing of task number X, sets the active flag to 1
“-d”    dump a list of all active notifications of the windows mobile scheduler

Do not use -s taskX and -k taskX except for testing. The args ‘-s taskX’ and ‘-k taskX’ are only be used by the scheduler.

Log file

The log file will log all activities of tasker2 in the directory of tasker2.exe. It will grow until 1MB and then one log backup file is saved. So you may have two log files, one active and one backup of the previous log.

Source code

0xfacbcab2: ++++++++++++++++ Tasker v300 started +++++++++++++++++++
0xfacbcab2: Checking for Mutex (single instance allowed only)...
0xfacbcab2: 	Created new mutex
0xfacbcab2: ~~~ using actual localtime:
0xfacbcab2: 	 23.12.2011, 12:28
0xfacbcab2: CmdLine =
0xfacbcab2: Checking for valid date/time...
0xfacbcab2: Date/Time after 11 2011. OK
0xfacbcab2: Clearing Event Notifications...0xfacbcab2: OK
0xfacbcab2: ClearRunApp(): ...
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x3d00000f
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x33000025
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x3800002a
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x3b00001b
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x3800002e
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x3f00001e
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x37000016
0xfacbcab2: ClearRunApp(): CeClearUserNotification for handle: 0x3a000030
0xfacbcab2: ClearRunApp(): returns 8
0xfacbcab2: Cleared 8 Tasker schedules
0xfacbcab2: scheduleAllTasks: ClearAllSchedules for 8 tasks
0xfacbcab2: Clearing Event Notifications...0xfacbcab2: Clearing Event Notifications...0xfacbcab2: OK
0xfacbcab2: Adding Time_Change Event Notification...0xfacbcab2: OK
0xfacbcab2: Adding TZ_Change Event Notification...0xfacbcab2: OK
0xfacbcab2: Creating new Start Task schedule for '\Windows\notes.exe' in Task1
0xfacbcab2: 	calculating new schedule for '201112231300'...
0xfacbcab2: 	interval is: 0d01h00m
0xfacbcab2: 	schedule adjusted to '201112231300'
0xfacbcab2: 	ScheduleRunApp: Next run at: 23.12.2011 13:00:56
0xfacbcab2: 	ScheduleRunApp: CeSetUserNotificationEx succeeded...
0xfacbcab2: Creating new Kill Task schedule for '\Windows\notes.exe' in Task1
0xfacbcab2: 	calculating new schedule for '201112231300'...
0xfacbcab2: 	interval is: 0d01h00m
0xfacbcab2: 	schedule adjusted to '201112231300'
0xfacbcab2: 	ScheduleRunApp: Next run at: 23.12.2011 13:00:56
0xfacbcab2: 	ScheduleRunApp: CeSetUserNotificationEx succeeded...
...

The first entry in the log file is the current logging instance. As multiple instances may write randomly at the log, the instance number is needed to idetify which instance has written the current log line.

Changes

There are two variants of tasker2, one is using SYSTEMTIME and the other, new one uses time_t. I switched to time_t as it is more easy to do operations like add-one-day with time_t vars than with SYSTEMTIME.

The old variant (v234a) is available as a branch in the code repository: http://code.google.com/p/tasker2/source/browse/#svn%2Fbranch%2Fversion232%2FTasker

Tests

Fortunately I had great help by a tester of the software. Many thanks to Thomas B.

I built my only automatic test suite using batch files and a special build of tasker2.exe. If you uncomment the line //#define TESTMODE at the beginning of tasker2.cpp, the compiled app will be in test mode. That means it will not add or remove schedules to/from the windows mobile scheduler. There is another tool used in the test_run.bat that sets the date and time of the device remotely (ActiveSync or Windows Mobile Device Center connection).

The automatic test uses the great tools of itsutils and will set registry values, change date/time, launch tasker2, get the log and build a merged log with all essential data to check the function of tasker2:

http://code.google.com/p/tasker2/source/browse/#svn%2Ftrunk%2FTasker%2Ftest

Here is a snippet from the test_bat.bat:

Source code

@echo off
 
ECHO ############## START ###############
echo  MAKE SHURE THE RADIOS ARE OFF TO
echo  AVOID AUTOMATIC TIME SYNCS!
echo .
PAUSE Press any key to start
 
ECHO ############## START ############### >test_run.txt
 
echo Importing test reg keys...
echo Importing test reg keys... >>test_run.txt
pregutl @tasker2.reg >>test_run.txt
 
pdel \tasker2.exe.log.txt >NUL
pput -f ./tasker2.exe \tasker2.exe
 
ECHO TEST1...
ECHO 	set time manually to 01.01.2003 12:00
echo 	run tasker2.exe
ECHO ++++++++++++++ TEST1 ++++++++++++++++ >>test_run.txt
pregutl HKLM\Software\Tasker  >>test_run.txt
ECHO ------------------------------------- >>test_run.txt
ECHO set time manually to 01.01.2003 12:00 >>test_run.txt
ECHO ------------------------------------- >>test_run.txt
prun \SetDateTime.exe 200301011200
CALL :MYWAIT
prun \tasker2.exe
ECHO "############# Result:" >>test_run.txt
pregutl HKLM\Software\Tasker >>test_run.txt
ECHO *************** LOG  **************** >>test_run.txt
pget -f \tasker2.exe.log.txt
type tasker2.exe.log.txt >>test_run.txt
pdel \tasker2.exe.log.txt
ECHO ---------------TEST1  --------------- >>test_run.txt
ECHO .>>test_run.txt

Downloads

The full tasker2 source code is available at http://code.google.com/p/tasker2/source/browse

Tool to look at the scheduler database [NotificationList]: DOWNLOAD:NotificationList - A tool to list notifications (Hits: 45, size: 153.42 kB)

Bookmark It

I want to summarize the role of function keys in Windows Mobile, former Pocket PC, as I got several questions each week on how to use or enable Function keys in this or that application.

Here is a simple information about how function keys work in Windows Mobile.

As example you have a web application which shows F3 and F4 as shortcuts to previous/next page:

SAP ITS Mobile screen Intermec Browser

Without some prepare this screen will not react on function keys! As the screen shows Intermec Browser (IB) with a SAP ITS Mobile form, you are able to define settings in IB to be able to really use the Function Keys.

Windows Mobile uses Function Key values for its own purpose. The usage can be retrieved by looking at winuserm.h of a Windows Mobile SDK:

Source code

//winuserm.h
...
#define VK_TSOFT1   VK_F1               // Softkey 1
#define VK_TSOFT2   VK_F2               // Softkey 2
#define VK_TTALK    VK_F3               // Talk
#define VK_TEND     VK_F4               // End
...
#define VK_TRECORD      VK_F10          // Record
#define VK_TFLIP        VK_F17          // Flip
#define VK_TPOWER       VK_F18          // Power
#define VK_TVOLUMEUP    VK_F6           // Volume Up
#define VK_TVOLUMEDOWN  VK_F7           // Volume Down
...
#define VK_TSPEAKERPHONE_TOGGLE VK_F16
#define VK_END_ALL_DATA_CALLS   VK_F15
...
#define VK_TSTAR    VK_F8               // *
#define VK_TPOUND   VK_F9               // #
...
#define VK_SYMBOL   VK_F11              // Symbol (SYM) key
 
#define VK_REDKEY   VK_F19              // Sent by a keypad that has a special red function key
#define VK_ROCKER   VK_F20              // Arrow keys came from a Rocker
#define VK_DPAD     VK_F21              // Arrow keys came from a DPAD
#define VK_ACTION   VK_F23              // Sent with VK_RETURN when doing Action on PPC rockers
 
#define VK_VOICEDIAL  VK_F24            // Key used to kick off voice dial recognition
#define VK_KEYLOCK    VK_F22            // Key used to lock the device
#define VK_KEYUNLOCK  VK_F25             // Key used to unlock the key lock
 
// Chorded keys.  DONE is VK_RWIN + VK_F6 and MOJI is VK_RWIN + VK_F7
#define VK_DONE     VK_F6                 // <OK/Close> hotkey code
#define MOD_DONE    (MOD_WIN | MOD_KEYUP) // <OK/Close> hotkey modifiers
 
#define VK_MOJI     VK_F7                  // Key used to switch between FE language layouts
#define MOD_MOJI    (MOD_WIN | MOD_KEYUP)  //Modifiers so MOJI goes to the shell
...

You see that many FunctionKey values are assigned to OS specific functions like Phone, END, Volume Up/Down etc.

So, you can normally not use Function Keys in your application to provide shortcuts to function calls. This is also true for client applications like Terminal Emulators (TE) like NaurTechTE and Intermec TE (ITE), browser based applications like Internet Explorer Mobile or Intermec Kiosk Mode Browser (IB), thin clients like Java client apps (ie. SAP ITS Mobile) or Remote Desktop client apps (ie Remote Desktop Mobile, zaDesktop).

Some of the kiosk mode apps provide a way to enable you to use Function Keys (see example at top). They can do so, as they use API calls like UnregisterFunc1 or AllKeys(TRUE) or GXOpenInput (deprecated!). These APIs instruct Windows Mobile OS to NOT catch and use Function Keys but handle them like ‘normal’ keys.

If you are the coder of an application using CPP, CSharp (C#), VB.NET, CPP or JAVA, you can use the Microsoft API function AllKeys(TRUE) in your code and Windows Mobile will not tamper the function keys.

If you are not the coder you may use UnregisterFunc1 (see my post “Freedom for Function Keys“). But be warned, there are applications that even then will not process Function Keys or do not forward them. For example Internet Explorer Mobile (IEM) will NOT process Function Keys except for internal functions like help or full-screen. Another bad example is Remote Desktop Mobile (RDM). It does not support Function Keys, even if you un-register them before you launch RDM, Function Keys will NOT be processed or transmitted to the host application. An alternative to RDM with function key support is rdesktopCE.

When you use UnregisterFunc1, you can check the Function Keys using a tool like KeyTest3AK. It will show the keydown and keyup values of keys and shows what happens if you use AllKeys():

More posts about AllKeys

Update 1. march 2012:

Additional annoyance: Did youknow, that F11 will be signaled as
WM_KEYDOWN VK_PROCESSKEY
WM_KEYUP VK_F11
so you can only rely on the keyup message for this function key. The translation of WM_KEYDOWN VK_F11 is done by the OS and cant be disabled, AFAIK.

Bookmark It

Normalerweise muß ein Neu-Kunde seine Telefonnummer bei der Registrierung angeben. Dies wird durch dieses vqmod file geändert und der Kunde muß keine Telefonnumer angeben, wenn er sich registriert. Das vqmod file einfach in das Opencart vqmod/xml Verzeichnis kopieren. Wenn was nicht funktioniert, die Datei einfach wieder löschen.

vqmod_tel_not_required.xml

<?xml version="1.0" encoding="UTF-8"?>
<modification>
        <id>Do NOT require phone-number as required input</id>
        <version>1.0.0</version>
        <vqmver>1.0.9</vqmver>
        <author>hjgode</author>
		<!-- changes for opencart 1.5.1.3 -->
        <file name="catalog/view/theme/*/template/account/register.tpl">
                <operation>
                    <search position="replace">
                         <![CDATA[<td><span class="required">*</span> <?php echo $entry_telephone; ?></td>]]>
                    </search>
                    <add>
                          <![CDATA[<td><?php echo $entry_telephone; ?></td>]]>
                    </add>
                </operation>
        </file>
 
        <file name="catalog/controller/account/register.php">
                <operation>
                    <search position="replace">
                         <![CDATA[if ((utf8_strlen($this->request->post['telephone']) < 3) || (utf8_strlen($this->request->post['telephone']) > 32)) {]]>
                    </search>
                    <add>
                          <![CDATA[if ((utf8_strlen($this->request->post['telephone']) < 0) || (utf8_strlen($this->request->post['telephone']) > 32)) {]]>
                    </add>
                </operation>
        </file>
</modification>

Have Fun

Josef

Bookmark It