Page 1
The main reason for wrapping Windows
controls in .Net is the fact that a lot of useful Windows
controls are not available in .Net CF, for example, a DateTimePicker,
a "hybrid" combo box (combo box with string editing), and
owner-draw list box and others. Some useful controls (for
example, owner-draw list boxes) may be easily implemented
in pure .Net, but unfortunately they will be not very much
reliable and too slow for serious applications.
In this article I'd like to explain
how to wrap a standard Windows control. This is somehow
a "one-direction" wrapping. Another article
will be devoted to how to handle messages and callbacks
from the created controls. In most cases you don't need
any callbacks from the control and "one-direction" wrapping
will be enough for you.
For example, it will be shown how to
wrap the DateTimePicker control which doesn't exist in .Net
Compact Framework. All other controls may be implemented
similarly. The language that we use is C#. The main idea
for the wrapping of a standard Windows control is to create
an instance of the control window via CreateWindowEx API
function (this will give us the handle of the created window)
and then to use the messages or other API functions to assign
the created object all the required properties.
A.
The first thing we should learn to do is wrap Windows API
function. The syntax is very easy:
namespace WinAPI
{
public class WinAPI {
[DllImport ("coredll.dll")]
public static extern IntPtr CreateWindowEx(
uint dwExStyle, string lpClassName, string lpWindowName,
uint dwStyle, int x, int y, int width, int height, IntPtr
hWndParent,
int hMenu, IntPtr hInstance, string lpParam);
[DllImport("coredll.dll",EntryPoint="SendMessage")]
public static extern int SendMessageStr(
IntPtr hWnd,
int message,
int data,
string s);
[DllImport("coredll.dll",EntryPoint="SendMessage")]
public static extern int SendMessageSystemTime(
IntPtr hWnd,
int message,
int data,
SystemTime d);
}
}
where SystemTime class is declared in
the same WinAPI namespace as follows:
public class SystemTime
{
public ushort Year;
public ushort Month;
public ushort DayOfWeek;
public ushort Day;
public ushort Hour;
public ushort Minute;
public ushort Second;
public ushort MilliSecond;
}
Of course, all standard Windows constants
(WS_XXXX, WM_XXXX and others) is useful to declare as C#
constants inside WinAPI class:
public class WinAPI
{
...
public const int DTM_SETFORMAT = 0x1032;
public const int DTM_GETSYSTEMTIME = 0x1001;
public const int DTM_SETSYSTEMTIME = 0x1002;
public const int WS_CHILD = 0x40000000;
public const int WS_VISIBLE = 0x10000000;
public const int WS_BORDER = 0x800000;
public const int DTS_TIMEFORMAT = 0x0009;
public const int GWL_STYLE = -16;
public const int WM_USER = 0x0400;
...
}
Later we will add to WinAPI class all
necessary Windows API functions: InitCommonControlsEx and
others. The rule for parameter types conversion is intuitive
and is shown in the following table:
| Native type
|
.Net CF type
|
| int |
int |
| DWORD |
uint |
| LPCTSTR |
string |
| LPTSTR |
char[] |
| HANDLE, HWND, HMENU, HICON, etc...
|
IntPtr |
Here is a useful function for handling
the parameters of type LPTSTR:
public static
string CharsToString(char[] c)
{
int nLength = 0;
while (nLength < c.Length &&
c[nLength] != '\0')
nLength++;
return new string(c, 0, nLength);
}
You create a large enough char[] buffer,
pass it to the imported function and then translate the
result into a normal .Net string.
B.
The hWndParent parameter to be passed to CreateWindowEx
function is a HWND window handle of a .Net window that will
become a parent for our new created DateTimePicker control.
C. We declare a .Net C#
class for our DateTimePicker control:
public class DateTimePicker {}
We will not wrap DateTimePicker into
a normal .Net control (a descendant of System.Windows.Forms.Control
class) but instead we declare a set of static functions
that provide all required operations on the control i.e.
the creation, the time format specification, the get/set
time/date operations. Therefore the DateTimePicker class
declaration stands for a namespace. If you want you can
easily create a normal .Net control over ours but I don't
see any reasons for doing this.
The creation function is like
this:
public class DateTimePicker
{
...
public const int DTP_HEIGHT = 22;
public static IntPtr DTP_Create(Formats.DateTimeSpec
nDTSpec, IntPtr hWndParent, int nX, int nY)
{
string strFormat = "";
int nWidth = 0;
switch (nDTSpec)
{
case Formats.DateTimeSpec.DTS_DATE:
nWidth = 90;
strFormat = "MM'/'dd'/'yyyy";
break;
case Formats.DateTimeSpec.DTS_TIME:
nWidth = 90;
strFormat = "hh':'mm':'ss";
break;
case Formats.DateTimeSpec.DTS_DATETIME:
nWidth = 150;
strFormat = "hh':'mm':'ss MM'/'dd'/'yyyy";
break;
}
uint nStyle = 0;
if (nDTSpec == Formats.DateTimeSpec.DTS_TIME)
nStyle |= WinAPI.WinAPI.DTS_TIMEFORMAT;
byte[] ics = {8, 0, 0, 0, 0, 1, 0, 0};
WinAPI.WinAPI.InitCommonControlsEx(ics);
IntPtr hWnd = WinAPI.WinAPI.CreateWindowEx(0,
"SysDateTimePick32", "",
WinAPI.WinAPI.WS_VISIBLE | WinAPI.WinAPI.WS_BORDER | WinAPI.WinAPI.WS_CHILD
| nStyle,
nX, nY,
nWidth, DTP_HEIGHT, hWndParent,
0, 0, null);
if (hWnd != IntPtr.Zero)
WinAPI.WinAPI.SendMessageStr(hWnd, WinAPI.WinAPI.DTM_SETFORMAT,
0, strFormat);
return hWnd;
}
...
}
D.
The C# code for creating the DateTimePicker control as a
child of the form form1 is as follows:
IntPtr hWndForm = WinAPI.WinAPI.GetHWnd(form1);
IntPtr hDTPicker = DateTimePicker.DTP_Create(Formats.DateTimeSpec.DTS_DATETIME,
hWndForm, 20, 10);
This will create the control and
insert it into given form and gives us its window handle
which can be used for getting and setting the control's
properties. For example, this function gets current date/time
value in the DateTimePicker editor:
public class DateTimePicker
{
...
public static WinAPI.SystemTime DTP_GetSystemTime(IntPtr
hWnd)
{
WinAPI.SystemTime st = new WinAPI.SystemTime();
WinAPI.WinAPI.SendMessageSystemTime(hWnd,
WinAPI.WinAPI.DTM_GETSYSTEMTIME, 0, st);
return st;
}
...
}
The usage of this method is as follows:
WinAPI.SystemTime st = DateTimePicker.DTP_GetSystemTime(hDTPicker);
Done!