How to enumerate files on a Windows CE based device from the Desktop
In this article I’d like to demonstrate how to enumerate files on a Windows CE based device from the desktop.
Listing the contents of a directly on a Windows CE from the desktop is something I found to be useful every now and then. It involves using the Remote API and ActiveSync / Windows Mobile Device Center
As usual this will involve a few P/Invokes:
[DllImport("rapi.dll", CharSet = CharSet.Unicode)]
static extern int CeRapiInit();
[DllImport("rapi.dll", CharSet = CharSet.Unicode)]
static extern int CeRapiUninit();
[DllImport("rapi.dll", CharSet = CharSet.Unicode)]
static extern IntPtr CeFindFirstFile(string lpFileName, ref CE_FIND_DATA lpFindFileData);
[DllImport("rapi.dll", CharSet = CharSet.Unicode)]
static extern bool CeFindNextFile(IntPtr hFindFile, ref CE_FIND_DATA lpFindFileData);
[DllImport("rapi.dll", CharSet = CharSet.Unicode)]
static extern bool CeFindClose(IntPtr hFindFile);
We also need the CE_FIND_DATA structure
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
struct CE_FIND_DATA
{
public int dwFileAttributes;
public FILETIME ftCreationTime;
public FILETIME ftLastAccessTime;
public FILETIME ftLastWriteTime;
public int nFileSizeHigh;
public int nFileSizeLow;
public int dwOID;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
public string cFileName;
};
[StructLayout(LayoutKind.Sequential)]
struct FILETIME
{
public int dwLowDateTime;
public int dwHighDateTime;
}
The CeRapiInit method has be always called before performing Remote API operations. Once done, the CeRapiUninit must be called. For listing the files in a directory, I use CeFindFirstFile, CeFindNextFile, and CeFindClose. How this works: If the file(s) exists CeFindFirstFile will return a valid handle that can be used for calling CeFindNextFile. After going through all the files CeFindNextFile will return false and a call to CeFindClose needs to be called.
public static string[] GetFiles(string remoteDirectory)
{
try
{
CeRapiInit();
var list = new List<string>();
var findData = new CE_FIND_DATA();
var hFindFile = CeFindFirstFile(remoteDirectory + "\\*", ref findData);
if (hFindFile != new IntPtr(-1))
{
try
{
do
{
if (findData.dwFileAttributes != (int)FileAttributes.Directory)
list.Add(findData.cFileName);
} while (CeFindNextFile(hFindFile, ref findData));
}
finally
{
CeFindClose(hFindFile);
}
}
return list.ToArray();
}
finally
{
CeRapiUninit();
}
}
I hope you found this useful.
How to draw a textured rounded rectangle in .NETCF
I’d like to demonstrate how to draw patterned rounded rectangles by P/Invoking the GDI function RoundRect using a patterned brush instead of a solid brush. Let’s create an extension method called FillRoundedTexturedRectangle to the Graphics class. With this method we can fill rectangles with an image. This image will be drawn as tiles to fill the rectangle bounds. This method can come in handy for drawing complex textures or patterns into a rectangle. With a little alpha blending and gradient fills, one can achieve a modern glass effect in the user interface
We create our brush with the CreatePatternBrush function instead of CreateSolidBrush as we did in my previous article on How to draw a rounded rectangle in .NETCF. We will mostly use P/Invoke for creating and releasing GDI objects.
const int PS_SOLID = 0;
const int PS_DASH = 1;
[DllImport("coredll.dll")]
static extern IntPtr CreatePen(int fnPenStyle, int nWidth, uint crColor);
[DllImport("coredll.dll")]
static extern int SetBrushOrgEx(IntPtr hdc, int nXOrg, int nYOrg, ref Point lppt);
[DllImport("coredll.dll")]
static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobject);
[DllImport("coredll.dll")]
static extern bool DeleteObject(IntPtr hObject);
[DllImport("coredll.dll")]
static extern IntPtr CreatePatternBrush(IntPtr hbmp);
[DllImport("coredll.dll")]
static extern bool RoundRect(
IntPtr hdc,
int nLeftRect,
int nTopRect,
int nRightRect,
int nBottomRect,
int nWidth,
int nHeight);
static uint GetColorRef(Color value)
{
return 0x00000000 | ((uint)value.B << 16) | ((uint)value.G << 8) | (uint)value.R;
}
Now we have our P/Invoke definitions in place we can neatly wrap all P/Invoke operations in a single function and let’s call that FillRoundedTexturedRectangle()
public static void FillRoundedTexturedRectangle(
this Graphics graphics,
Pen border,
Bitmap texture,
Rectangle rectangle,
Size ellipseSize)
{
var lppt = new Point();
var hdc = graphics.GetHdc();
var style = border.DashStyle == DashStyle.Solid ? PS_SOLID : PS_DASH;
var hpen = CreatePen(style, (int)border.Width, GetColorRef(border.Color));
var hbrush = CreatePatternBrush(texture.GetHbitmap());
try
{
SetBrushOrgEx(hdc, rectangle.Left, rectangle.Top, ref lppt);
SelectObject(hdc, hpen);
SelectObject(hdc, hbrush);
RoundRect(hdc,
rectangle.Left,
rectangle.Top,
rectangle.Right,
rectangle.Bottom,
ellipseSize.Width,
ellipseSize.Height);
}
finally
{
SetBrushOrgEx(hdc, lppt.Y, lppt.X, ref lppt);
DeleteObject(hpen);
DeleteObject(hbrush);
graphics.ReleaseHdc(hdc);
}
}
To use this extension method you need to create a Bitmap and a Pen. The pen will be used to draw the rounded border, and the Bitmap will be used as a fill (tiled). Here’s an example where “e” is an instance of PaintEventArgs
using (var pen = new Pen(SystemColors.Highlight, 5))
using (var texture = new Bitmap(@"\windows\msn.gif"))
e.Graphics.FillRoundedTexturedRectangle(pen,
texture,
ClientRectangle,
new Size(8, 8));
I hope you found this useful. If you’re interested in the full source code then you can grab it here
How to draw a rounded rectangle in .NETCF
In this short article I’d like to demonstrate how to draw rounded rectangles by P/Invoking the GDI function RoundRect. Let’s create an extension method called FillRoundedRectangle to the Graphics class.
In order to use the function we need to create a few GDI objects: a Pen to draw the border, and a Brush to fill the rectangle. We will mostly use P/Invoke for creating and releasing GDI objects
const int PS_SOLID = 0;
const int PS_DASH = 1;
[DllImport("coredll.dll")]
static extern IntPtr CreatePen(int fnPenStyle, int nWidth, uint crColor);
[DllImport("coredll.dll")]
static extern int SetBrushOrgEx(IntPtr hdc, int nXOrg, int nYOrg, ref Point lppt);
[DllImport("coredll.dll")]
static extern IntPtr CreateSolidBrush(uint color);
[DllImport("coredll.dll")]
static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobject);
[DllImport("coredll.dll")]
static extern bool DeleteObject(IntPtr hgdiobject);
[DllImport("coredll.dll")]
static extern bool RoundRect(
IntPtr hdc,
int nLeftRect,
int nTopRect,
int nRightRect,
int nBottomRect,
int nWidth,
int nHeight);
The CreateSolidBrush function in native code actually takes a COLORREF parameter, and the developer would normally use the RGB macro to create it. We need to translate that macro into a .NET function
static uint GetColorRef(Color value)
{
return 0x00000000 | ((uint)value.B << 16) | ((uint)value.G << 8) | (uint)value.R;
}
Now we have our P/Invoke definitions in place we can neatly wrap all P/Invoke operations in a single function and let’s call that FillRoundedRectangle()
public static void FillRoundedRectangle(
this Graphics graphics,
Pen border,
Color color,
Rectangle rectangle,
Size ellipseSize)
{
var lppt = new Point();
var hdc = graphics.GetHdc();
var style = border.DashStyle == DashStyle.Solid ? PS_SOLID : PS_DASH;
var hpen = CreatePen(style, (int)border.Width, GetColorRef(border.Color));
var hbrush = CreateSolidBrush(GetColorRef(color));
try
{
SetBrushOrgEx(hdc, rectangle.Left, rectangle.Top, ref lppt);
SelectObject(hdc, hpen);
SelectObject(hdc, hbrush);
RoundRect(hdc,
rectangle.Left,
rectangle.Top,
rectangle.Right,
rectangle.Bottom,
ellipseSize.Width,
ellipseSize.Height);
}
finally
{
SetBrushOrgEx(hdc, lppt.Y, lppt.X, ref lppt);
DeleteObject(hpen);
DeleteObject(hbrush);
graphics.ReleaseHdc(hdc);
}
}
Using this extension method should be straight forward, but here’s an example where “e” is an instance of PaintEventArgs:
using (var pen = new Pen(Color.Blue))
e.Graphics.FillRoundedRectangle(
pen,
Color.LightBlue,
new Rectangle(10, 10, 100, 100),
new Size(16, 16));
I hope you found this useful. If you’re interested in the full source code then you can grab it here