If you ever get in trouble with wrong encoding display of chars, give this article a try to know the backgrounds.

As you know, Windows CE and Windows Mobile  is always unicode except for serial and socket communication. But the truetype fonts available on Windows Mobile devices mostly support only common chars, there file size is about 600K. The file size of Arial Unicode MS is about 22MB.

regards

Bookmark It

Update 16. March 2011: Added dialog to connect to BT printer by BT Address on Intermec devices. New source and binary at code.google.com.

Update 21. March 2011: Splitted source code and providing three different flavours:
CommAppCFSerial does serial comm only.
CommAppCFbtSearch provides BT connect (Intermec Devices only) and BT discovery
CommAppCF itself is a unstable working release
see code.google.com/p/win-mobile-code … Executables are in bin subdirs.

You can enter and send texts to or send a whole file to the port. Additionally you are able to send ASCII codes by using \xAB syntax, where AB is the hex code of the byte you would like to send.

There is nothing special with the code except the hex decoding/encoding and the possibility to send a file.

Here is a short sample how the SendFile is implemented:

        private void sendFile(string filename)
        {
            try
            {
                updateTxtRcv("Starting sendFile(" + filename + ")");

                System.IO.StreamReader sr = new System.IO.StreamReader(filename);
                int r;
                int blockSize = 4096;
                char[] buf = new char[blockSize];
                //how many blocks to send?
                System.IO.FileInfo fi = new System.IO.FileInfo(filename);
                long lBlocks = (long)(fi.Length / blockSize);
                if (lBlocks == 0)
                    lBlocks = 1;
                updateTxtRcv("Need to send " + lBlocks.ToString() + " blocks...");
                long lBlockNr = 1;
                do
                {
                    updateTxtRcv("Sending block " + lBlockNr.ToString() + " ...");
                    r = sr.Read(buf, 0, blockSize); //r = number of bytes read
                    comport.Write(buf, 0, r);
                }
                while (r!=-1 && !sr.EndOfStream);
                sr.Close();
                updateTxtRcv("Finished sendFile(" + filename + ")");
            }
            catch (Exception x)
            {
                updateTxtRcv("sendFile exception:" + x.Message);
                System.Diagnostics.Debug.WriteLine(x.Message);
            }
        }

The application persists choosen settings in the registry. I had to implement classes to convert SerialPort Parity, Handshake, Stopbits etc settings between typed and integer values. Unfortunately the enums for these properties are not defined on base of integer. For example I had to code this class to enable save/restore of the Handshake property:

    public static class myHandshake
    {
        public static string[] handshakes = { "None", "XOnXOff", "RequestToSend", "RequestToSendXOnXOff" };
        public static Handshake ToHandshake(int i)
        {
            switch (i)
            {
                case 0: return Handshake.None;
                case 1: return Handshake.XOnXOff;
                case 2: return Handshake.RequestToSend;
                case 3: return Handshake.RequestToSendXOnXOff;
            }
            return Handshake.None;
        }
        public static Handshake ToHandshake(string text)
        {
            if (text.Equals("None", StringComparison.OrdinalIgnoreCase))
                return Handshake.None;
            if (text.Equals("XOnXOff", StringComparison.OrdinalIgnoreCase))
                return Handshake.XOnXOff;
            if (text.Equals("RequestToSend", StringComparison.OrdinalIgnoreCase))
                return Handshake.RequestToSend;
            if (text.Equals("RequestToSendXOnXOff", StringComparison.OrdinalIgnoreCase))
                return Handshake.RequestToSendXOnXOff;
            return Handshake.None;
        }
        public static int ToInt(Handshake hs)
        {
            switch (hs)
            {
                case Handshake.None: return 0;
                case Handshake.XOnXOff: return 1;
                case Handshake.RequestToSend: return 2;
                case Handshake.RequestToSendXOnXOff: return 3;
            }
            return 0;
        }
        public static string ToString(Handshake hs)
        {
            switch (hs)
            {
                case Handshake.None: return "None";
                case Handshake.XOnXOff: return "XOnXOff";
                case Handshake.RequestToSend: return "RequestToSend";
                case Handshake.RequestToSendXOnXOff: return "RequestToSendXOnXOff";
            }
            return "None";
        }
        public static string ToString(int i)
        {
            switch (i)
            {
                case 0: return "None";
                case 1: return "XOnXOff";
                case 2: return "RequestToSend";
                case 3: return "RequestToSendXOnXOff";
            }
            return "None";
        }
    }//class myHandshake

This would have been a lot easier if the Handshake enum was based on integer.

BTW using StopBits.None is not supported: “This value is not supported. Setting the System.IO.Ports.SerialPort.StopBits property to System.IO.Ports.StopBits.None raises an System.ArgumentOutOfRangeException.” (see StopBits enumeration).

Source code and binary located at code.google.com

Bookmark It

This article uses a technique known as subclassing as already used and decribed in my StartButtonHookWM65 article. For the CameraCapture dialog the code has been revised and you can now subclass any known window class and disable clicks within the Windows Mobile menu bar.

        private string _winClassName = "HHTaskbar";
        public string winClassName
        {
            get { return _winClassName; }
            set {
                if (this.oldWndProc == IntPtr.Zero) //only allow change before subclassing
                    _winClassName = value;
            }
        }
...
        /// <summary>
        /// SubClassing: Install the wndproc hook
        /// </summary>
        /// <returns></returns>
        private bool hookWindow()
        {
            //find the window to hook
            IntPtr hWndHooked = FindWindow(_winClassName, IntPtr.Zero);
            if (hWndHooked == IntPtr.Zero)
                return false;
            //enable the taskbar, not realy necessary
            EnableWindow(hWndHooked, true);
            //already installed?
            if (oldWndProc == IntPtr.Zero)
            {
                //find the menu_worker window
                IntPtr hwndMenu_Worker = FindWindow("menu_worker", IntPtr.Zero);
                if (hwndMenu_Worker != IntPtr.Zero)
                {
                    //get the child window which has the buttons on it
                    IntPtr hwndToolbar = GetWindow(hwndMenu_Worker, GetWindow_Cmd.GW_CHILD);
                    if (hwndToolbar != IntPtr.Zero)
                    {
                        _mHwnd = hwndToolbar;       //store to remember
                        SubclassHWnd(hwndToolbar);  //subclass the wndproc
                    }
                }
            }
            return true;
        }

As the call to CameraCaptureDialog will block and you can not subclass it before it is launched, I use a timer that will subclass the dialog assuming it will show after the call to .ShowDialog().

        private System.Windows.Forms.Timer timer;
        hwndutils subClassUtils;
        private void ShowCamera()
        {
            CameraCaptureDialog cdlg = new CameraCaptureDialog();
            cdlg.DefaultFileName="picture.jpg";
            cdlg.InitialDirectory = "\\My Documents";
            cdlg.Mode = CameraCaptureMode.Still;
            cdlg.Owner = this.pictureBox1;
            cdlg.StillQuality = CameraCaptureStillQuality.High;
            cdlg.Title = "Take a picture and Select";
            cdlg.Resolution = new Size(240, 320);
            cdlg.VideoTypes = CameraCaptureVideoTypes.All;

            //subclass main window with delay
            subClassUtils = new hwndutils();
            timer = new Timer();
            timer.Interval = 1000;
            timer.Tick += new EventHandler(timer_Tick);
            timer.Enabled = true;

            DialogResult dRes = cdlg.ShowDialog();
...
        void timer_Tick(object sender, EventArgs e)
        {
            subClassUtils.winClassName = "Camera View";
            subClassUtils.CloseButtonDisabled = true;
            System.Threading.Thread.Sleep(500);
            if(subClassUtils.CloseButtonDisabled)
                timer.Enabled = false;

        }

In the line “subClassUtils.CloseButtonDisabled = true;” the subclassing (or the hook) will be activated and clicks on (OK) will not be accepted.

Code subclassing.cs download: DOWNLOAD:subclassing.cs - subclassing code for C# compact framework (Hits: 156, size: 2.4 kB)

Bookmark It

The issue is simple to explain:
1) The WinMo device has a local time and date within DST
2) You use SetSystemTime to set a new system time and date outside the DST frame
3) The local time changes but DST is still applied!

In concrete example:

GetTimeZoneInformation:
 DaylightSaving-Time:

Bias -60  Daylight-Name: W  Daylight-Bias: -60 Standard-Name: W  Standard-Bias: 0
Standard-Date: 00/10/05 03:00:00, Daylight-Date: 00/03/05 02:00:00

1. Set time inside DST +++++++++++
+++++++++++ TstSetTime ++++++++++++
SetSystemTime:  2010/09/21 10:32:00
GetLocalTime:   2010/09/21 12:32:00
GetSystemTime:  2010/09/21 10:32:00

------------ TstSetTime ------------
2. Set time outside DST ----------
+++++++++++ TstSetTime ++++++++++++
SetSystemTime:  2010/10/31 01:50:00
GetLocalTime:   2010/10/31 03:50:00
GetSystemTime:  2010/10/31 01:50:00

As you can see, local time is 2 hours of, although the data/time is outside DST. You can also see, that the device is in GMT+1 time zone.

Ah, you say this is a known issue. OK, lets do it the microsoft way and Sleep() and set system time again:

3. SLEEP...
4. Set time outside DST 2nd CALL ----------
+++++++++++ TstSetTime ++++++++++++
SetSystemTime:  2010/10/31 01:50:00
GetLocalTime:   2010/10/31 02:50:00
GetSystemTime:  2010/10/31 01:50:00

You are right, now the local time is correct.

Ok, not clear but a workaround. Now go on and set time back into DST:

------------ TstSetTime ------------
5. Set time back inside DST +++++++++++
+++++++++++ TstSetTime ++++++++++++
SetSystemTime:  2010/09/21 10:32:00
GetLocalTime:   2010/09/21 11:32:00
GetSystemTime:  2010/09/21 10:32:00

Again a fault. This time DST is not applied although the date is within DST frame.

Doing the same in Compact Framework is more worst and you will only get valid results with disabled DST.

The best workaround is to disable DST BEFORE you change the system time and then restore DST after changing the system time.

.Net code snippets:

        private DateTime startDateTime = DateTime.Parse("2010/9/24 11:42:00");

        [DllImport("coredll.dll", SetLastError = true)]
        static extern Int32 GetLastError();

        [DllImport("coredll.dll", SetLastError = true)]
        static extern bool SetSystemTime(ref SYSTEMTIME time);
        [DllImport("coredll.dll", SetLastError = true)]
        static extern void GetSystemTime(out SYSTEMTIME lpSystemTime);

        [DllImport("coredll.dll")]
        static extern bool SetTimeZoneInformation([In] ref TIME_ZONE_INFORMATION lpTimeZoneInformation);
        [DllImport("coredll.dll", CharSet = CharSet.Auto)]
        private static extern int GetTimeZoneInformation(out TIME_ZONE_INFORMATION lpTimeZoneInformation);

        private const int TIME_ZONE_ID_UNKNOWN = 0;
        private const int TIME_ZONE_ID_STANDARD = 1;
        private const int TIME_ZONE_ID_DAYLIGHT = 2;

        [StructLayoutAttribute(LayoutKind.Sequential)]
        public struct SYSTEMTIME
        {
            public short wYear;
            public short wMonth;
            public short wDayOfWeek;
            public short wDay;
            public short wHour;
            public short wMinute;
            public short wSecond;
            public short wMilliseconds;
        }
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct TIME_ZONE_INFORMATION
        {
            public int bias;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
            public string standardName;
            public SYSTEMTIME standardDate;
            public int standardBias;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
            public string daylightName;
            public SYSTEMTIME daylightDate;
            public int daylightBias;
        }
...
        private bool disableDST(TIME_ZONE_INFORMATION tzi){
            //set wMonth in standardDate to zero
            SYSTEMTIME stStd;
            stStd=tzi.standardDate;
            stStd.wMonth=0;
            //set wMonth in daylightDate to zero
            SYSTEMTIME stDST;
            stDST=tzi.daylightDate;
            stDST.wMonth=0;

            tzi.daylightDate=stDST;
            tzi.standardDate=stStd;
            bool bRes = SetTimeZoneInformation(ref tzi);
            if (bRes)
                addText("*** Disabling DST OK***");
            else
                addText("*** Disabling DST failed***");
            return bRes;
        }

Possibly a good information for all that do TimeSync with a server.

Bookmark It

The final solution uses a MessageWindow inside a control based class with a worker thread. As the control and the MessageWindow is part of the GUI thread, there is no need to use Invokes.

Inside the thread I use SendMessage to transfer background thread informations to the control, which then fires an event you can subscribe in the GUI thread.

The test app attached shows three threads running independently and all update the GUI frequently without blocking the GUI.

Here is my try to visualize my idea and solution

Normally you have to use such a construction:

// this variable will hold some text set by the worker thread
public string Message = "";

// Create a worker thread and then add items to the ListBox from the
// UI thread
public void DoThreading()
{
    // Create the worker thread and start it
    ThreadStart starter = new ThreadStart(this.UpdateListBox);
    Thread t = new Thread(starter);
    t.Start();

    // Loop 4 times, adding a message to the ListBox each time
    for(int i = 0; i < 4; i++);
    {
        this.listBox1.Items.Add("Message from UI thread");
        this.listBox1.Update();
        // Process any queued events on the UI thread
        Application.DoEvents();
        // Suspend processing for 1 second
        Thread.Sleep(1000);
    }
    this.listBox1.Items.Add("Last message from UI thread");
    this.listBox1.Update();
}

public void UpdateListBox()
{
    for(int j = 0; j < 5; j++)
    {
        // Set the message to be added to the ListBox from the worker
        // thread
        this.Message = "Worker thread loop count = " + j.ToString();
        // Invoke the WorkerUpdate method in the ListBox’s thread
        // context
        this.listBox1.Invoke(new EventHandler(WorkerUpdate));
        Thread.Sleep(700);
    }
}
// The delegate that’s called from the worker thread
// to update the ListBox
public void WorkerUpdate(object sender, EventArgs e)
{
    this.listBox1.Items.Add(this.Message);
    this.listBox1.Update();
}

As you can see from the code you need to inform the worker thread about the delegate to use for GUI updates. An GUI update from the worker thread is done with the help of UpdateListBox() and that invokes WorkerUpdate and that function finally updates the GUI. So four places are tight together with function names and definitions.

There are also other  ways to do it. For example with declaring a delegate first and then Invoke from background thread (see here):

delegate void setText(string sText);
...
private void ThreadProcSafe()
		{
			this.SetText("This text was set safely.");
		}
...
		private void SetText(string text)
		{
			// InvokeRequired required compares the thread ID of the
			// calling thread to the thread ID of the creating thread.
			// If these threads are different, it returns true.
			if (this.textBox1.InvokeRequired)
			{
				SetTextCallback d = new SetTextCallback(SetText);
				this.Invoke(d, new object[] { text });
			}
			else
			{
				this.textBox1.Text = text;
			}
		}

But this solution also needs your background thread to know the delegate name (SetText(string s)).

I also used this patterns  often, but finally I thought, I need an easy to use class that is independent from the main gui thread code and easy to re-use.

With my bgThread classes (yes there are three predefined ones), you can simply use this construction:

    public partial class ThreadTest2 : Form
    {
        private bgThread _bgThread;
...
        //start and link the thread
        private void btn_bgThreadTest_Click(object sender, EventArgs e)
        {
            _bgThread = new bgThread("192.168.128.5");
            _bgThread.bgThreadEvent += new bgThread.bgThreadEventHandler(_bgThread_bgThreadEvent);
        }

        void _bgThread_bgThreadEvent(object sender, bgThread.BgThreadEventArgs bte)
        {
            listBox1.Items.Insert(0, "bgThread: " + bte.iStatus.ToString();
        }
...
        //in your exit function you MUST dispose existing threads
            if (_bgThread != null)
                _bgThread.Dispose();
            Application.Exit();
...

As you can see, you have only a bgThread object and after creating a new instance just add the eventhandler. From the eventhandler you can directly update the GUI. You don’t have to define  a delegate.

All three bgThread classes work fine. They differ in the amount and type of data you have to transfer from the background thread to the GUI and so the BgThreadEventArgs differ in there definition.

The first class, bgThread1 class, only uses the IntPtr’s usable with SendMessage to transfer data. So you can transfer a maximum of two integers or so. That is enough for the most usage scenarios, where you only need to know status codes from the background thread. The attached bgThread1 class only impements one DWORD (or int).

The second class, bgThread class, uses a global lock and can transfer the data you desire. You have to redefine only the bgThreadEventArgs class to include the data types you would like to transfer. This class uses PostMessage and NOT SendMessage. It may happen, that the data and the message will get out of sync as PostMessage works asynchron.

The third class, bgThread2 class, uses WM_COPYDATA to transfer strutured data from the background thread. It is more complicated to use and extend than bgThread1 but uses SendMessage and no lock objects. Your data is delivered with SendMessage and so there will be no problem with data and message syncronization.

All classes define a class based on Component.

    public class bgThread : Component
    {
        public delegate void bgThreadEventHandler(object sender, BgThreadEventArgs bte);
        public event bgThreadEventHandler bgThreadEvent;
...
        internal BgThreadEventArgs _BGeventArgs;
        private Thread myThread;
...
        internal class bgThreadWndProc : MessageWindow
        {
            public bgThreadWndProc(bgThread Parent)
            {
                this._bgThread = Parent;
                hwndControl = Hwnd;
            }
            protected override void WndProc(ref Message m)
            {
                int iMsg = m.Msg;
                System.Diagnostics.Debug.WriteLine("WndProc called...");
                switch (iMsg)
                {
                    case msgID:
                        {
                            this._bgThread.NotifyData(m.WParam);
                            break;
                        }
                    default:
                        {
                            base.WndProc(ref m);
                            break;
                        }
                }
            }
        }//MsgWnd

Within the bgThread class there is a nested class based on MessageWindow.

The bgThread class constructor:

        public bgThread()
        {
            bgWnd = new bgThreadWndProc(this);
            myThread = new Thread(myThreadStart);
            bRunThread = true;
            myThread.Start();
        }

The thread proc itself. It may contain more or less blocking functions  calls.

       private void myThreadStart()
        {
            try
            {
                do
                {
                    //The blocking function...
                    //sample: call ping and return number of pings answered
                    int iReply = myPing.Ping(System.Net.IPAddress.Parse(_sIP));
                    //create a msg and send it to the messagewindow, the messagewindow will then inform the event subscribers
                    //we only need the number of ping replies (0 or 1) for the ping
                    Microsoft.WindowsCE.Forms.Message msg = Message.Create(bgWnd.Hwnd, msgID, new IntPtr(iReply), IntPtr.Zero);
                    MessageWindow.SendMessage(ref msg); //async Message send
                    Thread.Sleep(1000); //if you have fast 'blocking' functions you should sleep
                } while (bRunThread);
            }
            catch (ThreadAbortException)
            {
                System.Diagnostics.Debug.WriteLine("Thread will abort");
                bRunThread = false;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine("Exception in ThreadStart: " + ex.Message);
            }
            System.Diagnostics.Debug.WriteLine("ThreadProc ended");
        }

The code that fires the event is not called from the thread. Instead it is called from the MessageWindow. The thread itself sends its ‘data’ via SendMessage to the bgThread ‘Component’ (which is part of the GUI!):

        private void NotifyData(IntPtr i1)
        {
            BgThreadEventArgs _bgThreadEventArgs;
            //is there any subscriber
            if (this.bgThreadEvent == null)
            {
                return;
            }
            try
            {
                int i = i1.ToInt32();
                _bgThreadEventArgs = new BgThreadEventArgs(i);
                this.bgThreadEvent(this, _bgThreadEventArgs);
            }
            catch (MissingMethodException)
            {
            }
        }

The above code snippets are taken from bgThread1 class, the one that only ‘transfers’ an integer to the GUI.

Possible extensions

• extend bgThread to Stop (pause) a bgThread
• extend bgThread and let it invoke a eventhandler that does the blocking stuff. Similar to the BackgroundWorker class available in internet. So you can define your background function inside the main code.

delegate void SetTextCallback(string text);

Bookmark It

A class that enables you to

• lock/unlock the taskbar
• hide/show the taskbar and resize form to occupy the whole screen
• hide the menu bar but show/hide SIP
• disables OS to capture Function keys like F6/F7 for Volume Up/Down etc and makes these keys available to be used in your app. Also the use of the WinKey does not open the Start Menu

(You are right, you dont see ‘fullscreen’ in the screen shot, BUT the taskbar is locked!)

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace myApp{
    class fullScreen
    {
        #region DllImports
        ///
        /// FindWindow will find a window by specifying the WndClass or the Caption
        ///
        ///

        ///

        /// an intPtr to the found window or null, if not found
        [DllImport("coredll.dll")]
        extern private static IntPtr FindWindowW(string lpClassName, string lpWindowName);

        ///
        /// we need this to get the size of the screen
        ///
        ///

        ///
        [DllImport("coredll.dll")]
        extern private static int GetSystemMetrics(int nIndex);
        ///
        /// the used nIndex values for screen width and height
        ///
        private const int SM_CXSCREEN = 0;
        private const int SM_CYSCREEN = 1;

        ///
        /// query a window for his state
        ///
        ///

        /// true if window is visible
        [DllImport("coredll.dll")]
        static extern bool IsWindowVisible(IntPtr hWnd);

        #endregion
        ///
        /// function to modify the window state of a window
        ///
        /// handle to the window
        /// the required window state
        ///
        [DllImport("coredll.dll")]
        static extern bool ShowWindow(IntPtr hWnd, uint nCmdShow);

        #region WStyles
        /// Enumeration of the different ways of showing a window using
        /// ShowWindow
        private enum WindowShowStyle : uint
        {
            /// Hides the window and activates another window.
            /// See SW_HIDE
            Hide = 0,
            /// Activates and displays a window. If the window is minimized
            /// or maximized, the system restores it to its original size and
            /// position. An application should specify this flag when displaying
            /// the window for the first time.
            /// See SW_SHOWNORMAL
            ShowNormal = 1,
            /// Activates the window and displays it as a minimized window.
            /// See SW_SHOWMINIMIZED
            ShowMinimized = 2,
            /// Activates the window and displays it as a maximized window.
            /// See SW_SHOWMAXIMIZED
            ShowMaximized = 3,
            /// Maximizes the specified window.
            /// See SW_MAXIMIZE
            Maximize = 3,
            /// Displays a window in its most recent size and position.
            /// This value is similar to "ShowNormal", except the window is not
            /// actived.
            /// See SW_SHOWNOACTIVATE
            ShowNormalNoActivate = 4,
            /// Activates the window and displays it in its current size
            /// and position.
            /// See SW_SHOW
            Show = 5,
            /// Minimizes the specified window and activates the next
            /// top-level window in the Z order.
            /// See SW_MINIMIZE
            Minimize = 6,
            /// Displays the window as a minimized window. This value is
            /// similar to "ShowMinimized", except the window is not activated.
            /// See SW_SHOWMINNOACTIVE
            ShowMinNoActivate = 7,
            /// Displays the window in its current size and position. This
            /// value is similar to "Show", except the window is not activated.
            /// See SW_SHOWNA
            ShowNoActivate = 8,
            /// Activates and displays the window. If the window is
            /// minimized or maximized, the system restores it to its original size
            /// and position. An application should specify this flag when restoring
            /// a minimized window.
            /// See SW_RESTORE
            Restore = 9,
            /// Sets the show state based on the SW_ value specified in the
            /// STARTUPINFO structure passed to the CreateProcess function by the
            /// program that started the application.
            /// See SW_SHOWDEFAULT
            ShowDefault = 10,
            /// Windows 2000/XP: Minimizes a window, even if the thread
            /// that owns the window is hung. This flag should only be used when
            /// minimizing windows from a different thread.
            /// See SW_FORCEMINIMIZE
            ForceMinimized = 11
        }
        #endregion
#region private vars
        private int m_width = 240;
        private int m_height = 320;
        private bool m_SIP_shown = false;
#endregion
        ///
        /// class instantiation
        /// store the screen size
        ///
        public fullScreen()
        {
            m_width = GetSystemMetrics(SM_CXSCREEN);
            m_height = GetSystemMetrics(SM_CYSCREEN);
            //Find SipWndClass
            IntPtr hWndSipWndClass = IntPtr.Zero;
            hWndSipWndClass = FindWindowW("SipWndClass", null);
            if (hWndSipWndClass != IntPtr.Zero)
            {
                m_SIP_shown = IsWindowVisible(hWndSipWndClass);
            }
            GXopen();
        }
        ///
        /// this will open the GX API and all keystrokes, even the softkeys as Vol_Up, Win etc will not be handled by the OS
        /// the gx.dll is only available on Windows Mobile OS, not on WinCE OS devices
        /// The GX class has been ousourced and will only be loaded in gx.dll exists
        /// otherwise you will get missing DLL exceptions
        ///
        private void GXopen(){
            if (System.IO.File.Exists(@"\Windows\gx.dll"))
            {
                GX_WM gxwm = new GX_WM();
                gxwm.GXopen();
            }
        }

        ///
        /// deinit GX API and let wiondows handle the 'softkeys'
        ///
        private void GXclose()
        {
            if (System.IO.File.Exists(@"\Windows\gx.dll"))
            {
                GX_WM gxwm = new GX_WM();
                gxwm.GXopen();
            }
        }
        ///
        /// public vars to get the screen size
        ///
        public int width
        {
            get
            {
                return m_width;
            }
        }
        public int height
        {
            get
            {
                return m_height;
            }
        }
        ///
        /// will enlarge the form to cover the full screen
        /// the taskbar will be hidden
        /// the SIP will be hidden
        ///
        /// the form to make fullscreen
        public void makeFullScreen(System.Windows.Forms.Form f)
        {
            f.Width = m_width;
            f.Height = m_height;
            f.Top = 0; f.Left = 0; // move the form to upper left
            hideTaskBar(true); //hide the taskbar
            showSIP(false); //hide the SIP window, regardless of it is shown or not
        }

        ///
        /// restore previous screen settings
        ///
        public void Unload()
        {
            hideTaskBar(false);
            if (m_SIP_shown)
                showSIP(true);
        }

        ///
        /// Hide or show the SIP
        ///
        ///

        public void showSIP(bool bShow)
        {
            //Find SipWndClass
            IntPtr hWndSipWndClass = IntPtr.Zero;
            hWndSipWndClass = FindWindowW("SipWndClass", null);
            if (hWndSipWndClass != IntPtr.Zero)
            {
                if (bShow)
                    ShowWindow(hWndSipWndClass, (uint)WindowShowStyle.ShowNormal);
                else
                    ShowWindow(hWndSipWndClass, (uint)WindowShowStyle.Minimize);
            }
        }

        ///
        /// Hide or show the TaskBar
        ///
        ///

        ///
        private int hideTaskBar(bool mode)
        {
            IntPtr hWndTaskBar = IntPtr.Zero;
            if (mode)
            {
                hWndTaskBar = FindWindowW("HHTaskBar", null);
                if (hWndTaskBar != IntPtr.Zero)
                    ShowWindow(hWndTaskBar, (uint)WindowShowStyle.Hide);
            }
            else
            {
                hWndTaskBar = FindWindowW("HHTaskBar", null);
                if (hWndTaskBar != IntPtr.Zero)
                    ShowWindow(hWndTaskBar, (uint)WindowShowStyle.ShowNormal);
            }
            return 0;
        }

    }
}

The GX_WM class:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices; 

namespace myApp
{
	class GX_WM {
		//nice mangled names
		//?GXCloseInput@@YAHXZ or use "#3"
		[DllImport("gx.dll", EntryPoint="?GXCloseInput@@YAHXZ")]
		extern private static Int16 GXOpenInput();
		//?GXOpenInput@@YAHXZ or use "#9"
		[DllImport("gx.dll", EntryPoint="?GXOpenInput@@YAHXZ")]
		extern private static Int16 GXCloseInput(); 

		public void GXopen(){
			GXOpenInput();
			System.Diagnostics.Debug.WriteLine("GXOpenInput()");
		}
		public void GXclose() {
			GXCloseInput();
			System.Diagnostics.Debug.WriteLine("GXCloseInput()");
		}
	}
}

To use the classes in your code, declare a new fullScreen object at a central point of your app. For example in Program.cs:

        public static fullScreen fse;

The declaration is static to enable you to use this object in all forms of your app. Then before your Run statement place the initialisation of the fullScreen object. At the end of your app, it is a good way to unload the object, so it may restore the taskbar and SIP status.

static class Program
    {
        ///
        /// The main entry point for the application.
        ///
        public static fullScreen fse;
        [MTAThread]
        static void Main()
        {
            try
            {
                fse = new fullScreen();
                Application.Run(new MyAppForm());
            }
            catch (Exception ex)
            {
                MessageBox.Show("Sorry: " + ex.Message);
            }
            fse.Unload();
        }
    }

Now in every form you have, place the line:

Program.fse.makeFullScreen(this);

in the _Load event or – as I do – in the form constructor after the line “InitializeComponent();”

public myAppForm() {
    if (!InitApp())
        AppShutdown();
    InitializeComponent();
    Program.fse.makeFullScreen(this);
}

If you need to show the SIP, use

Program.fse.showSIP(true); 

If you want to have a real fullscreen app without a title bar, dont forget to set the borderstyle of your form to None. You can also change the makeFullScreen function and do this for the form given in the argument.

Any comments or enhancements?

Have fun

PS: Key catching works fine in C# with the fullscreen class (either using GXOpenInput() or AllKeys()), see attached c# sample.

Bookmark It

If you need to print, show, generate or analyse DataMatrix Barcodes on a Windows Mobile device, you can now use this class library. I have ported the code to be compatible with Compact Framework 2.0 and Visual Studio 2005.

The original full .NET framework source code is located at SourceForge.

Here is first a screenshot of the test application running on a Windows Mobile device using the DataMatrixNetCF class:

The full .NET framework has much more functions or the classes provide more optional arguments than Compact Framework (CF) does. So there some code to be changed to work with CF. BTW: you can run the code on a desktop PC to, as the Full Framework is upwards compatible to CF.

I had to change some constructs which are used initialize a structure directly with some values. Here is one example for DmtxDecode.cs:

Original:

            DmtxPixelLoc pEmpty = new DmtxPixelLoc() { X = 0, Y = 0 };

Visual Studio 2005 / Compact Framework 2:

            DmtxPixelLoc pEmpty = new DmtxPixelLoc();
            pEmpty.X = 0; pEmpty.Y = 0;

Similar changes have to be applied to a lot of code lines:
Original:

    follow.Loc = new DmtxPixelLoc() { X = followBeg.Loc.X + DmtxConstants.DmtxPatternX[patternIdx], Y = followBeg.Loc.Y + DmtxConstants.DmtxPatternY[patternIdx] };

Visual Studio 2005 / Compact Framework 2:

    follow.Loc = new DmtxPixelLoc(followBeg.Loc.X + DmtxConstants.DmtxPatternX[patternIdx], followBeg.Loc.Y + DmtxConstants.DmtxPatternY[patternIdx]);

To get this working, the structure defined in DmtxPixelLoc.cs had to get a constructor code:

        public DmtxPixelLoc(int x, int y)
        {
            _x = x;
            _y = y;
        }

As the compiler complained about this ugly contruct, I rewrote this:

    prevPrevValue = (byte)((prevIndex > channel.FirstCodeWord / 12) ? channel.EncodedWords[prevIndex - 1] : 0);

to this

    if (prevIndex > channel.FirstCodeWord / 12)
       prevPrevValue = channel.EncodedWords[prevIndex - 1];
    else
       prevPrevValue = 0;

I dont like this short forms of If/else.

Finally it took some time to convert this code of the file DmtxImageEncoder.cs to CF:

        internal static Bitmap CopyDataToBitmap(byte[] data, int width, int height)
        {
            data = InsertPaddingBytes(data, width, height, 24);
            int stride = 4 * ((width * 24 + 31) / 32);
            GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
            //Here create the Bitmap to the know height, width and format
            Bitmap bmp = new Bitmap(width, height, stride, PixelFormat.Format24bppRgb, dataHandle.AddrOfPinnedObject());
            return bmp;
        }

In compact framework this works:

        internal static Bitmap CopyDataToBitmap(byte[] data, int width, int height)
        {
            data = InsertPaddingBytes(data, width, height, 24);
            int stride = 4 * ((width * 24 + 31) / 32);
            GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);

            // Create a new bitmap.
            Bitmap msBMP = new Bitmap(width,height,PixelFormat.Format24bppRgb);

            // Lock the bitmap's bits.
            Rectangle rect = new Rectangle(0, 0, msBMP.Width, msBMP.Height);
            System.Drawing.Imaging.BitmapData bmpData =
                msBMP.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite,
                PixelFormat.Format24bppRgb);

            // Get the address of the first line.
            IntPtr ptr = bmpData.Scan0;

            int bytes  = bmpData.Stride * msBMP.Height;
            // Copy the RGB values back to the bitmap
            System.Runtime.InteropServices.Marshal.Copy(data, 0, ptr, bytes);

            // Unlock the bits.
            msBMP.UnlockBits(bmpData);
            return msBMP; // return bmp;
        }

Here you can download the source code of the class library and a test application. The code is written in Visual Studio 2005 with Windows Mobile 5 SDK as target: DOWNLOAD:DataMatrixNetCF: Class Library and TestApp, binary and source - (Hits: 631, size: 308.35 KB)

If you need some PDF library for Windows Mobile, see my port of iTextSharp. The sourceforge DataMatrixNet code uses iTextSharp too.

Update 28.  april 2010:

There was a question at CodeProject about ECC200 compatibilty and a barcode test application called bcTester, that does not accept the barcodes generated with this sample app.

So I took a deeper look at the library and found, that my default datamatrixnet options dont fit what bcTester likes. So I changed the code of the sample application and it now offers a Settings dialog:

The main changes are the default options:

            options.ModuleSize = 4;
            options.MarginSize = 4;
            options.BackColor = Color.White;
            options.ForeColor = Color.Black;
            options.SizeIdx = DmtxSymbolSize.DmtxSymbol32x32;// DmtxSymbol96x96;
            options.Scheme = DmtxScheme.DmtxSchemeAscii;// DmtxSchemeAutoBest;

Another nice new feature (I think) is that you can use \xHH (HH=hex byte value) to encode control characters. Here is the string parser, that translates the mixed string to byte[]:

        public static byte[] FromHexedString(string val){
            //replace \xHH with char of before using getbytes
            int iPos = val.IndexOf("\\x");
            while(iPos>=0){
                string s = val.Substring(iPos, 4);
                byte b = byte.Parse(val.Substring(iPos+2,2), NumberStyles.HexNumber);
                //string c = Convert.ToString(b,16);
                char ch = (char)b;
                //test
                //byte[] bTest = Encoding.ASCII.GetBytes(ch.ToString());
                //System.Diagnostics.Debug.WriteLine(string.Format("Encoded {0:x} as '{1}'", bTest,ch));
                string o = val.Substring(0, iPos) + ch + val.Substring(iPos + 4);
                val = o;
                iPos = val.IndexOf("\\x");
            }
            byte[] valAsByteArray = Encoding.ASCII.GetBytes(val);
            return valAsByteArray;
        }

I extended my lib HexEncoding.cs to be able to do so. After all, bcTester accepts the barcode:

Download new version: DOWNLOAD:DatamatrixNetCF Version 2 - Bug fixed (Hits: 127, size: 148.29 KB)

Bookmark It

Unfortunately the webservice does not offer WSDL and so you have to write your own wrapper class. I wrote a small class that does the HttpWebRequest and decodes the xml reponse for easy use in your application.

When you query the webservice you have to use the following form:

http://ws.geonames.org/timezone?lat=47.01&lng=10.2

The answer will then be:

         <geonames>
            <timezone>
                <countryCode>AT</countryCode>
                <countryName>Austria</countryName>
                <lat>47.01</lat>
                <lng>10.2</lng>
                <timezoneId>Europe/Vienna</timezoneId>
                <dstOffset>2.0</dstOffset>
                <gmtOffset>1.0</gmtOffset>
                <rawOffset>1.0</rawOffset>
                <time>2010-03-02 12:14</time>
            </timezone>
        </geonames>

The sample application will use this answer and shows the result:

The attached Visual Studio 2005 SmartDevice Windows Mobile 5 project has two classes: GeonamesTZ is a blocking class and geonamesTZ is a non-blocking class.

A blocking code is never good and so I implemented the class with an event. To use the class include a using statement for the geonames namespace and then initialize a new geonamesTZ object. Then add an event handler for the object’s event delegate. Finally add a event handler function that will get the timezone data.

using geonames;
    public partial class Form1 : Form
    {
        geonamesTZ myGeoTZ;
        geonamesTZfields tzFields;

        public Form1()
        {
            InitializeComponent();
            myGeoTZ = new geonamesTZ();
            myGeoTZ.geonamesEventHandler += new geonamesEvent(myGeoTZ_geonamesEvent);
        }

        void myGeoTZ_geonamesEvent(object sender, geonamesEventArgs e)
        {
            //Cursor.Current = Cursors.Default;
            //MessageBox.Show(e.m_myEventArgumentdata.strCountryName);
            tzFields = e.m_myEventArgumentdata;
            updateUI(tzFields);
        }

To get the timezone information you have to call the class function

            myGeoTZ.startRequest(txtLat.Text, txtLng.Text); //the answer should come...

and after some time the function myGeoTZ_geonamesEvent is called with the received data. Using the event driven approach will give the possibility to write an app that reads GPS data and updates timezone information in the background. Maybe this is usefull for Windows Mobile phones that often ’fly’ between continents. The timezone can then be updated in background.

As updating the UI from a different thread may fail, the updateUI function is implemented like this:

        // see http://blog.opennetcf.com/ctacke/2008/12/03/ControlInvokeWithoutExplicitDelegates.aspx
        public void updateUI(geonames.geonamesTZfields myTZinfos)
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new EventHandler(delegate(object o, EventArgs a)
                {
                    txtDSToffset.Text = myTZinfos.dstOffset.ToString();
                    txtGMToffset.Text = myTZinfos.gmtOffset.ToString();
                    txtTimzoneID.Text = myTZinfos.strTimezoneID;
                    txtTime.Text = myTZinfos.tzTime.ToString();
                    txtTZcountryCode.Text = myTZinfos.strCountryCode;
                    lblStatus.Text = myTZinfos.strLastError;
                }));
            }
            else
            {
                txtDSToffset.Text = myTZinfos.dstOffset.ToString();
                txtGMToffset.Text = myTZinfos.gmtOffset.ToString();
                txtTimzoneID.Text = myTZinfos.strTimezoneID;
                txtTime.Text = myTZinfos.tzTime.ToString();
                txtTZcountryCode.Text = myTZinfos.strCountryCode;
                lblStatus.Text = myTZinfos.strLastError;
            }
        }

That was much easier than doing invokes on every txt field separately.

The raw xml response is parsed by another class called xml_helper. This class makes it easy to extract single values from the raw xml response. Here is one example:

namespace xml_helper{
    public static class xml_helper
    {
        public static string getStrSetting(StringBuilder sb, String sField)
        {
            string sVal = sb.ToString();
            string sFieldString = "<" + sField + ">";
            int iIdx = sVal.IndexOf(sFieldString);
            string sResult = "";
            if (iIdx >= 0)
            {
                string fieldStr = sVal.Substring(iIdx);
                string ssidStr = fieldStr.Remove(0, sFieldString.Length);
                iIdx = ssidStr.IndexOf("</");
                sResult = ssidStr.Substring(0, iIdx);
            }
            return sResult;
        }

These simple functions can be easily used on a xml file with single element data. Just call, for example getStrSettings with the xml string and the setting you would like to get.

Download Visual Studio 2005 SmartDevice Windows Mobile 5 project: DOWNLOAD:TimeZone by GPS demo application - (Hits: 244, size: 52.09 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

Recently I needed a tool to combine several pictures into one file. First I thought about creating a memory bitmap and then BitBlit the source files into this single bitmap. Then I found an entry about iText and iTextSharp. This is a JAVA and .NET class library to create pdf files. As it seems very easy to use I decided to take a closer look. I found one message, where Marco states he has done a port for .NET compact framework and provided a patch to the sourceforge iTextSharp team. Unfortunately the iTextSharp team seems to ignore this port. So I started with iTextSharp and the patch to get iTextSharp running on Compact Framework.

The patch was done against version 4.0.1 of iTextSharp but there were still some rejects and some additional work to do. The main problem was the use of GetInstance where always the general WebRequest.Create(url); and then GetResponseStream() was used. A first workaround is to load the bitmap first and then provide this to doc.Add:

#if !TEST
 Bitmap myBitmap = new Bitmap(sFilename);
 if (sFilename.ToLower().EndsWith("jpg"))
 img = iTextSharp.text.Image.GetInstance(myBitmap, System.Drawing.Imaging.ImageFormat.Jpeg);
 else if (sFilename.ToLower().EndsWith("gif"))
 img = iTextSharp.text.Image.GetInstance(myBitmap, System.Drawing.Imaging.ImageFormat.Gif);
 else if (sFilename.ToLower().EndsWith("bmp"))
 img = iTextSharp.text.Image.GetInstance(myBitmap, System.Drawing.Imaging.ImageFormat.Bmp);
 else if (sFilename.ToLower().EndsWith("png"))
 img = iTextSharp.text.Image.GetInstance(myBitmap, System.Drawing.Imaging.ImageFormat.Png);
 else
 throw new NotSupportedException("Unsupported image format");
#else
 img = iTextSharp.text.Image.GetInstance(sFilename);
#endif
 doc.Add(img);

The GetResponseStream() returns a stream or filestream within full framework. But with Comapct Framework you will always get ‘NotSupportedException’ for local files. The CF does not support local files within GetResponseStream. The URI for a local file is ‘file://…’ and an easy replacement for getting a filestream was to use ‘new FileStream(url.LocalPath, FileMode.Open);’. I did insert a #ifdef in all source files with GetResponseStream() as I have no real need to build image instances from network files:

//NETCF does not know fileWebRequest (file://...)
#if !NETCF
 WebRequest w = WebRequest.Create(url);
 istr = w.GetResponse().GetResponseStream();
#else
 istr = new FileStream(url.LocalPath, FileMode.Open);
#endif

There are also some more #if !NETCF inside the source files for everything that differs between full and compact framework.

The attached zip archive has all files you need to compile and use iTextSharp on your windows mobile. The Visual Studio 2005 solution includes a simple demo application that allows you to add some image files and create a PDF with the filenames and images inside. I inserted a new page for every image. The solution is written against the target “Windows Mobile 6 Prof”. So you need Windows Mobile 6 SDK installed.

The left screen shows the demo application and the right one the created pdf inside Adobe Reader Mobile.

The incomplete patch source

A tiny tutorial for iTextSharp usage

The new full source: DOWNLOAD:iTextSharpCF-4.0.1_CF - Sample source code using the modified iTextSharp library (also included) (Hits: 684, size: 3.23 MB)

Bookmark It