Christian Helle's Blog

SQL Compact Query Analyzer

2011-06-07T08:35:00.004+02:00

I’ve been working extensively on enterprise mobility projects lately. These applications integrate into large SAP based systems and when testing the system it can get very tedious to set up some temporary data from the backend. I’m also working with some not-so-technical testers that get intimidated by the Visual Studio or the SQL Server Management Studio. This led me to writing an open source project called SQL Compact Query Analyzer

Here’s some details I pulled directly off the CodePlex site

Project Description
SQL Server Compact Edition Database Query Analyzer

Features:
- Execute SQL Queries against a SQL Server Compact Edition database
- Table Data Editor to easily edit the contents of the database
- Supports SQLCE 3.0, 3.1, 3.5 and 4.0
- Execute multiple SQL queries (delimited by a semi colon ;)
- Display query result as XML
- Shrink and Compact Databases
- SDF file association with SQL Compact Query Analyzer for launching directly by opening the SDF in Windows Explorer
- Generate Schema and Data Scripts
- Display database and schema information
- Support for password protected databases

Coming Soon:
- Purge database content
- Create new database
- Create, edit, and drop tables
- Create, edit, and delete table references and indexes
- Support for SQL Server Compact Edition 2.0

Screenshots

- Displays database and schema information and executes multiple SQL queries directly

- Edit the table data directly

- Display the contents of IMAGE fields

- Performance numbers for queries

- Query errors

- Output result set as XML

Check it out! You might find it useful!

SQL Compact Code Generator

2011-03-10T23:17:00.004+01:00

More than a year ago, I published a project on CodePlex called SQL Compact Code Generator. Unfortunately, I never managed to find the time to do some work on it and the project was set on a very long hold. A year after I suddenly really needed such a tool and decided that I should put in some hours on the project.

I'm currently working on a large enterprise project where changes to the database schema is done rather frequently, to avoid the pain of updating my data layer after every change I decided to use my code generator.

Here's some details I pulled directly off the CodePlex site.

Project Description
Contains a stand alone GUI application and a Visual Studio Custom Tool for automatically generating a .NET data access layer code for objects in a SQL Server Compact Edition database.

Features:

Visual Studio 2008 and 2010 Custom Tool Support
Creates entity classes for each table in the database
Generates data access code that implements the Repository Pattern
Generates methods for Create, Read, Update and Delete operations
Generates SelectBy and DeleteBy methods for every column in every table
Generates a Purge method for every table to delete all records
Generates Count() method for retrieving the number of records in each table
Generates CreateDatabase() method for re-creating the database
Generates xml-doc code comments for entities and data access methods
Generates Entity Unit Tests
Generates Data Access Unit Tests
Generates .NET Compact and Full Framework compatible code
Support for SQL Compact Edition version 4.0
Multiple test framework code generation (MSTest, NUnit, xUnit)
Transaction support per DataRepository instance (Begin, Commit, Rollback)
Code generation options to enable/disable unit test code generation
Windows Phone 7 "Mango" support for generating a LINQ to SQL DataContext

Coming Soon:

Generate database maintenance code (clear database, shrink/compress database)
Support for multiple versions of SQL Server Compact Edition
VB.NET Code Support
Visual Studio Add-in

Screenshots:

NEW: Custom Tool for Windows Phone 7 "Mango"

Custom Tool

Generating Entity Classes

Generating Data Access methods that implement the Repository Pattern

Generating Entity Unit Tests

Generating Data Access Unit Tests to validate the integrity between the data layer and the actual database

Check it out! You might find it useful too...

How to display a Notification Bubble in Windows Mobile using .NETCF

2011-02-10T15:15:00.001+01:00

Yesterday, I found myself using an old piece of code that I wrote ages ago. It's something I've used every now and then for past few years. Since I myself find it useful, I might as well share it. All the code does is display a Notification Bubble in Windows Mobile. To do this you use the Notification class in the Microsoft.WindowsCE.Forms namespace. Even though the Notification class is very straight forward and easy to use, I created a helper class so that I only need to write one line of code for displaying a notification bubble: NotificationBubble.Show(2, "Caption", "Text");

/// <summary>

/// Used for displaying a notification bubble

/// </summary>

public static class NotificationBubble

    /// <summary>

    /// Displays a notification bubble

    /// </summary>

    /// <param name="duration">Duration in which the notification bubble is shown (in seconds)</param>

    /// <param name="caption">Caption</param>

    /// <param name="text">Body</param>

    public static void Show(int duration, string caption, string text)

        var bubble = new Notification

            InitialDuration = duration,

            Caption = caption,

            Text = text

};

        bubble.BalloonChanged += OnBalloonChanged;

        bubble.Visible = true;

    private static void OnBalloonChanged(object sender, BalloonChangedEventArgs e)

        if (!e.Visible)

            ((Notification)sender).Dispose();

Hope you found this helpful.

Working around Pivot SelectedIndex limitations in Windows Phone 7

2011-02-05T00:30:00.001+01:00

I've been working on an application with 2 pages, a main page and a content page. The content page contains a Pivot control with a few pivot items. The main page does nothing but navigate to the content page and suggest which pivot item to display. The only reason the main page exists is to display the information in the pivot item headers in a more graphical and elegant way.

For some reason I can't set the displayed pivot index to be the third item. I wanted to do this on the OnNavigatedTo event of the content page but whenever I attempt doing so an exception is thrown. Every other pivot item works fine, which I think is really weird.

To load the content page, I navigate to the page by passing some information of the pivot index I wish to be displayed. Something like this:

NavigationService.Navigate(new Uri("/ContentPage.xaml?index=" + index, UriKind.Relative));

If the value of index in the code above is set to 2 then I get an exception, any other valid value works fine. A value out of range (less than 0 or greater than 5) throws an out of range exception which is the behavior anyone would expect.

Here's the XAML definition of the content page

<phone:PhoneApplicationPage

    x:Class="WindowsPhonePivotApplication.ContentPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"

    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"

    xmlns:controls="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768"

    FontFamily="{StaticResource PhoneFontFamilyNormal}"

    FontSize="{StaticResource PhoneFontSizeNormal}"

    Foreground="{StaticResource PhoneForegroundBrush}"

    SupportedOrientations="Portrait"  Orientation="Portrait"

    shell:SystemTray.IsVisible="True">

  <Grid x:Name="LayoutRoot" Background="Transparent">

    <controls:Pivot Name="pivot" Title="CONTENT PAGE">

      <controls:PivotItem Header="first" />

      <controls:PivotItem Header="second" />

      <controls:PivotItem Header="third" />

      <controls:PivotItem Header="fourth" />

      <controls:PivotItem Header="fifth" />

      <controls:PivotItem Header="sixth" />

    </controls:Pivot>

  </Grid>

</phone:PhoneApplicationPage>

To work around this limitation, you can handle the Loaded event of the page and update the pivot selected index from there. Here's an example how to do it:

public partial class ContentPage : PhoneApplicationPage

    private int pivotIndex;

    public ContentPage()

        InitializeComponent();

        Loaded += delegate { pivot.SelectedIndex = pivotIndex; };

    protected override void OnNavigatedTo(NavigationEventArgs e)

        string value;

        if (NavigationContext.QueryString.TryGetValue("index", out value))

            pivotIndex = 0;

            int.TryParse(value, out pivotIndex);

I'm not sure if this limitation is by design or it's a bug in the control. Either way I managed to get it to work the way I wanted it to. Hopefully I'm not the only one who ran across this and that you found this information useful.

How to Darken an Image in WPF

2011-02-04T01:00:00.002+01:00

I'm really getting carried away with playing with image manipulation in WPF. Here's a short post on how to darken an image using the WriteableBitmap class.

The process is fairly simple, I manipulate each pixel by decrementing each RGB value with the provided level

unsafe static BitmapSource Darken(BitmapSource image, double level)

    const int PIXEL_SIZE = 4;

    int height = image.PixelHeight;

    int width = image.PixelWidth;

    var bitmap = new WriteableBitmap(image);

    bitmap.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

        var row = backBuffer + (y * bitmap.BackBufferStride);

        for (int x = 0; x < width; x++)

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = (byte)Math.Max(row[x * PIXEL_SIZE + i] - level, 0);

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap.Unlock();

    return bitmap;

Hope you found this useful.

How to Brighten an Image in WPF

2011-02-03T10:00:00.010+01:00

Now I'm just getting carried away with playing with image manipulation in WPF. Here's a short post on how to brighten an image using the WriteableBitmap class.

The process is fairly simple, I manipulate each pixel by incrementing each RGB value with the provided level

unsafe static BitmapSource Brighten(BitmapSource image, double level)

    const int PIXEL_SIZE = 4;

    int height = image.PixelHeight;

    int width = image.PixelWidth;

    var bitmap = new WriteableBitmap(image);

    bitmap.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

        var row = backBuffer + (y * bitmap.BackBufferStride);

        for (int x = 0; x < width; x++)

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = (byte)Math.Min(row[x * PIXEL_SIZE + i] + level, 255);

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap.Unlock();

    return bitmap;

Hope you found this useful

How to Alpha Blend 2 Images in WPF

2011-02-02T00:22:00.000+01:00

After having such fun trying to find optimal ways of manipulating images in WPF I decided to write another short post on image manipulation. This time I'd like to demonstrate how to alpha blend 2 images using the WriteableBitmap class.

I'm probably not the best one to explain how alpha blending is done but here's the idea in a nutshell. I get the RGB values of every pixel for the each image and write them to a new bitmap where I manipulate each color information by applying the following formula:

r = ((image1 pixel (red) * alpha level) + (image2 pixel (red) * inverse alpha level)) / 256
b = ((image1 pixel (blue) * alpha level) + (image2 pixel (blue) * inverse alpha level)) / 256
g = ((image1 pixel (green) * alpha level) + (image2 pixel (green) * inverse alpha level)) / 256

unsafe static WriteableBitmap AlphaBlend(BitmapSource image1, BitmapSource image2, int alphaLevel)

    const int PIXEL_SIZE = 4;

    int ialphaLevel = 256 - alphaLevel;

    int height = Math.Min(image1.PixelHeight, image2.PixelHeight);

    int width = Math.Min(image1.PixelWidth, image2.PixelWidth);

    var bitmap = new WriteableBitmap(width, height, image1.DpiX, image1.DpiY, PixelFormats.Bgr32, null);

    var bitmap1 = new WriteableBitmap(image1);

    var bitmap2 = new WriteableBitmap(image2);

    bitmap.Lock();

    bitmap1.Lock();

    bitmap2.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    var bitmap1Buffer = (byte*)bitmap1.BackBuffer.ToPointer();

    var bitmap2Buffer = (byte*)bitmap2.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

        var row = backBuffer + (y * bitmap.BackBufferStride);

        var img1Row = bitmap1Buffer + (y * bitmap1.BackBufferStride);

        var img2Row = bitmap2Buffer + (y * bitmap2.BackBufferStride);

        for (int x = 0; x < width; x++)

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = (byte)(((img1Row[x * PIXEL_SIZE + i] * alphaLevel) + (img2Row[x * PIXEL_SIZE + i] * ialphaLevel)) >> 8);

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap2.Unlock();

    bitmap1.Unlock();

    bitmap.Unlock();

    return bitmap;

The method above will probably work best if the 2 images are of the same size. I hope you found this information useful.

How to convert an image to gray scale in WPF

2011-02-01T12:22:00.000+01:00

I've been playing with the Windows Presentation Foundation today and I had a task where I needed to convert an image to gray scale to do some image analysis on it. I've done this a bunch of times before using GDI methods or by accessing the BitmapData class in .NET. For this short post I'd like to demonstrate how to manipulate images using the WriteableBitmap class.

The easiest way to convert an image to gray scale is to set the RGB values of every pixel to the average of each pixels RBG values.
R = (R + B + G) / 3
G = (R + B + G) / 3
B = (R + B + G) / 3

Here's a code snippet for manipulating a BitmapSource object using the WriteableBitmap class into a gray scale image:

public unsafe static BitmapSource ToGrayScale(BitmapSource source)

    const int PIXEL_SIZE = 4;

    int width = source.PixelWidth;

    int height = source.PixelHeight;

    var bitmap = new WriteableBitmap(source);

    bitmap.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

        var row = backBuffer + (y * bitmap.BackBufferStride);

        for (int x = 0; x < width; x++)

            var grayScale = (byte)(((row[x * PIXEL_SIZE + 1]) + (row[x * PIXEL_SIZE + 2]) + (row[x * PIXEL_SIZE + 3])) / 3);

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = grayScale;

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap.Unlock();

    return bitmap;

Another way to to convert an image to gray scale is to set the RGB values of every pixel to the sum of 30% of the red value, 59% of the green value, and 11% of the blue value. Hope you find this useful.

Multi-platform Mobile Development - Sending SMS

2011-01-20T16:28:00.000+01:00

This is a task that pretty much every mobile device can do, or at least any mobile phone can do. In this short post on multi-platform mobile development I would like to demonstrate how to send an SMS or launch the SMS compose window in a mobile application.

I'm going to demonstrate how to use the messaging API's of the following platforms:

Android
Windows Phone 7
Windows Mobile 5.0 (and higher) using .NET Compact Framework
Windows Mobile using the Platform SDK (Native code)

Android

There are 2 ways of sending SMS from an Android application: Launching the Compose SMS window; Through the SmsManager API. I figured that since this article is supposed to demonstrate as many ways as possible for sending SMS that I create a helper class containing methods that I think would be useful or at least convenient to have.

Here's a SMS helper class for Android that I hope you would find useful.

package com.christianhelle.android.samples;

import android.app.Activity;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.Uri;
import android.telephony.SmsManager;
import android.widget.Toast;

/**
 * Helper class for sending SMS messages
 * 
 * @author Christian Resma Helle
 */
public class Sms {
    private final static String SENT_ACTION = "SENT";
    private final static String DELIVERED_ACTION = "DELIVERED";
    private Context context;
    private PendingIntent sentIntent;
    private PendingIntent deliveredIntent;

    /**
     * Creates an instance of the SMS class
     * 
     * @param context     Context that owns displayed notifications
     */
    public Sms(Context context) {
        this.context = context;
        registerForNotification();
    }

    private void registerForNotification() {
        sentIntent = PendingIntent.getBroadcast(context, 0, new Intent(SENT_ACTION), 0);
        deliveredIntent = PendingIntent.getBroadcast(context, 0, new Intent(DELIVERED_ACTION), 0);

        context.registerReceiver(messageSentReceiver, new IntentFilter(SENT_ACTION));
        context.registerReceiver(messageDeliveredReceiver, new IntentFilter(DELIVERED_ACTION));
    }
     
    protected void finalize() throws Throwable {
        context.unregisterReceiver(messageSentReceiver);
        context.unregisterReceiver(messageDeliveredReceiver);
    }

    /**
     * Opens the Compose SMS application with the recipient phone number displayed
     * 
     * @param phoneNumber     recipient phone number of the SMS
     */
    public void composeMessage(String phoneNumber) {
        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("sms:" + phoneNumber));
        context.startActivity(intent);
    }

    /**
     * Opens the Compose SMS application with the recipient phone number and message displayed
     * 
     * @param phoneNumber     recipient phone number of the SMS
     * @param text             message body
     */
    public void composeMessage(String phoneNumber, String text) {
        Intent intent = new Intent(Intent.ACTION_VIEW);
        intent.putExtra("sms_body", text);
        intent.putExtra("address", phoneNumber);
        intent.setType("vnd.android-dir/mms-sms");
        context.startActivity(intent);
    }

    /**
     * Opens the Compose SMS application with the multiple recipient phone numbers and the message displayed
     * 
     * @param phoneNumber     recipient phone numbers of the SMS
     * @param text             message body
     */
    public void composeMessage(String[] phoneNumbers, String text) {
        StringBuilder sb = new StringBuilder();
        for (String string : phoneNumbers) {
            sb.append(string);
            sb.append(";");
        }
        composeMessage(sb.toString(), text);
    }

    /**
     * Send an SMS to the specified number
     * 
     * @param phoneNumber     recipient phone number of the SMS
     * @param text             message body
     */
    public void sendMessage(String phoneNumber, String text) {
        sendMessage(phoneNumber, text, false);
    }

    /**
     * Send an SMS to the specified number and display a notification on the message status
     * if the notifyStatus parameter is set to <b>true</b>
     * 
     * @param phoneNumber     recipient phone number of the SMS
     * @param text             message body
     * @param notifyStatus     set to <b>true</b> to display a notification on the screen 
     *                         if the message was sent and delivered properly, otherwise <b>false</b>
     */
    public void sendMessage(String phoneNumber, String text, boolean notifyStatus) {
        SmsManager sms = SmsManager.getDefault();
        if (notifyStatus) {
            sms.sendTextMessage(phoneNumber, null, text, sentIntent, deliveredIntent);    
        } else {
            sms.sendTextMessage(phoneNumber, null, text, null, null);
        }    
    }

    /**
     * Send an SMS to multiple recipients and display
     * 
     * @param phoneNumber     recipient phone number of the SMS
     * @param text             message body
     */
    public void sendMessage(String[] phoneNumbers, String text) {
        sendMessage(phoneNumbers, text, false);
    }

    /**
     * Send an SMS to multiple recipients and display a notification 
     * on the message status if notifyStatus is set to <b>true</b>
     * 
     * @param phoneNumber     recipient phone number of the SMS
     * @param text             message body
     * @param notifyStatus     set to <b>true</b> to display a notification on the screen 
     *                         if the message was sent and delivered properly, otherwise <b>false</b>
     */
    public void sendMessage(String[] phoneNumbers, String text, boolean notifyStatus) {
        StringBuilder sb = new StringBuilder();
        for (String string : phoneNumbers) {
            sb.append(string);
            sb.append(";");
        }
        sendMessage(sb.toString(), text, notifyStatus);
    }

    private BroadcastReceiver messageSentReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            switch (getResultCode()) {
            case Activity.RESULT_OK:
                Toast.makeText(context, "SMS sent", Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
                Toast.makeText(context, "Generic failure", Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_NO_SERVICE:
                Toast.makeText(context, "No service", Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_NULL_PDU:
                Toast.makeText(context, "Null PDU", Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_RADIO_OFF:
                Toast.makeText(context, "Radio off", Toast.LENGTH_SHORT).show();
                break;
            }
        }
    };

    private BroadcastReceiver messageDeliveredReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            switch (getResultCode()) {
            case Activity.RESULT_OK:
                Toast.makeText(context, "Message delivered", Toast.LENGTH_SHORT).show();
                break;
            case Activity.RESULT_CANCELED:
                Toast.makeText(context, "Message not delivered", Toast.LENGTH_SHORT).show();
                break;
            }
        }
    };
}

Before your Android application can send SMS it needs the right permissions for it. Add the SEND_SMS permission your AndroidManifest.xml

<uses-permission android:name="android.permission.SEND_SMS"></uses-permission>

Here are some examples on how to use the SMS helper class defined above from within an Activity class:

Sms sms = new Sms(getApplicationContext());

// Send an SMS to the specified number
sms.sendMessage("+4512345678", "Multi-platform Mobile Development");

// Send an SMS to the specified number and display a notification on the message status
sms.sendMessage("+4512345678", "Multi-platform Mobile Development", true);

// Send an SMS to multiple recipients
sms.sendMessage(new String[] { "+4512345678", "+4598765432" }, "Multi-platform Mobile Development");        

// Send an SMS to multiple recipients and display a notification on the message status
sms.sendMessage(new String[] { "+4512345678", "+4598765432" }, "Multi-platform Mobile Development", true);

// Opens the Compose SMS application with the recipient phone number displayed
sms.composeMessage("+4512345678");

// Opens the Compose SMS application with the recipient phone number and message displayed
sms.composeMessage("+4512345678", "Multi-platform Mobile Development");

// Opens the Compose SMS application with the multiple recipient phone numbers and the message displayed
sms.composeMessage(new String[] { "+4512345678", "+4598765432" }, "Multi-platform Mobile Development");

Windows Phone 7

This platform unfortunately doesn't provide as vast a API collection compared to Android and Windows Mobile. To send an SMS in Windows Phone 7, you will have to use the SMS Compose page in the built-in messaging application. To launch this we call the Show() method in SmsComposeTask.

Here's how to use SmsComposeTask

SmsComposeTask launcher = new SmsComposeTask();

launcher.To = "+45 12 34 56 78";

launcher.Body = "Multi-platform Mobile Development";

launcher.Show();

Windows Mobile 5.0 (and higher) using .NET Compact Framework

Sending an SMS in this platform is just as easy as doing so in Windows Phone 7. Windows Mobile provides native API's for the Short Messaging System, these methods are exposed as C type methods in a DLL called sms.dll. Aside from the SMS API, the platform also offers another API called the Messaging API (CE MAPI) for sending SMS, MMS, and Emails. Microsoft has provided managed wrappers for these and many other API's to make the life of the managed code developer a lot easier.

To send an SMS in Windows Mobile 5.0 (and higher) we use the SmsMessage object. There are 2 ways of accomplishing this: Using the Send() method of the SmsMessage class; Sending the SMS using the Compose SMS application

Here's a snippet on how to send SMS using the Send() method

SmsMessage sms = new SmsMessage("+45 12 34 56 78", "Multi-platform Mobile Development");

sms.Send();

Here's a snippet on how to send SMS using the Compose SMS application

SmsMessage sms = new SmsMessage("+45 12 34 56 78", "Multi-platform Mobile Development");

MessagingApplication.DisplayComposeForm(sms);

The code above depends on 2 assemblies that must be referenced to the project:

Microsoft.WindowsMobile.dll
Microsoft.WindowsMobile.PocketOutlook.dll

It is also possible to P/Invoke the SMS API through sms.dll, but this requires a slightly more complicated solution. In the next section, I will demonstrate how use the SMS API in native code. This should give you an idea on how to use the SMS API if you would like to go try the P/Invoke approach.

Windows Mobile using the Platform SDK (Native code)

Probably not very relevant for most modern day managed code developers but just to demonstrate as many ways to send SMS in as many platforms as possible I'd like to show how to send SMS in native code using the Windows CE Short Message Service (SMS) API.

Here's a sample C++ helper class for sending SMS using the Platform SDK

#include "stdafx.h"

#include "sms.h"

#include <string>

class SmsMessage

private:

    std::wstring recipient;

    std::wstring message;

public:

    SmsMessage(const wchar_t* phoneNumber, const wchar_t* text)

        recipient = phoneNumber;

        message = text;

    void Send()

        SMS_HANDLE smshHandle;

        HRESULT hr = SmsOpen(SMS_MSGTYPE_TEXT, SMS_MODE_SEND, &smshHandle, NULL);

        if (hr != S_OK)

            return;

        SMS_ADDRESS smsaDestination;

        memset (&smsaDestination, 0, sizeof (smsaDestination));

        smsaDestination.smsatAddressType = SMSAT_INTERNATIONAL;

        lstrcpy(smsaDestination.ptsAddress, recipient.c_str());

        TEXT_PROVIDER_SPECIFIC_DATA tpsd;

        tpsd.dwMessageOptions = PS_MESSAGE_OPTION_NONE;

        tpsd.psMessageClass = PS_MESSAGE_CLASS1;

        tpsd.psReplaceOption = PSRO_NONE;

        SMS_MESSAGE_ID smsmidMessageID = 0;

        hr = SmsSendMessage(smshHandle,

                            NULL,

                            &smsaDestination,

                            NULL,

                            (PBYTE) message.c_str(),

                            (message.length() + 1) * sizeof(wchar_t),

                            (PBYTE) &tpsd,

                            sizeof(TEXT_PROVIDER_SPECIFIC_DATA),

                            SMSDE_OPTIMAL,

                            SMS_OPTION_DELIVERY_NONE,

                            &smsmidMessageID);

        SmsClose (smshHandle);

};

The code above requires the that the project is linked with sms.lib, otherwise you won't be able to build.

Here's a snippet of how to use the SMS helper class defined above:

SmsMessage *sms = new SmsMessage(L"+14250010001", L"Multi-platform Mobile Development");

sms->Send();

delete sms;

For those who don't know what +14250010001 is, this is the phone number of the Windows Mobile emulator. For testing SMS functionality on the emulator, you can use this phone number.

That's it for now. I hope you found this article interesting.

Multi-platform Mobile Development - Creating a List Based UI

2011-01-19T16:05:00.002+01:00

Here's the first installment on my series on multi-platform mobile development articles. A common practice on displaying information to a mobile device user is a list. A list is one of the best ways to display a group of information allowing the user to easily select which specific details he/she wishes to display.

A good example of decent list implementations is the Inbox on pretty much all mobile devices. Most Inbox list implementations display sender, title, date, size, and a preview of the message body. A good list is not only bound to textual information but also visual. Most Inbox implementation displays the information using bold fonts if the message is unread

In this article I would like to demonstrate how to implement customized list based UI's on the following platforms:

Windows Phone 7
Windows Mobile using .NET Compact Framework
Android

Let's get started...

Windows Phone 7

This is definitely the easiest platform to target, in fact this is by far the easiest platform I've ever worked with. Development times on this platform are a lot shorter than any other platform I've worked with. I've been working with Windows CE based phones for the last 7 or so and I definitely think that this is the best Windows CE based OS ever. There unfortunately a few down sides like lack of a native code API and limited platform integration, but considering the performance and development ease, it is for most cases worth it. The best part with designing UI's for Windows Phone 7 is that I don't have to care about the design very much, I just ask my designer / graphic artist to shine up my XAML file and I can concentrate on the code.

A Visual Studio 2010 project template is actually provided by default for creating a list based UI makes things easier. This project template is called a Windows Phone Databound Applicaton, the description goes "A project for creating Windows Phone applications using List and Navigation controls". This project creates 2 pages, one for displaying the list, and the other for displaying details of this list.

The code examples for Windows Phone 7 uses the Model-View-ViewModel. This pattern is heavily used and I guess one can say an accepted standard in developing Windows Phone 7 applications. I'm not gonna go deep into the pattern in this article, so I assume that you do a bit of home work on MVVM.

To display a list Windows Phone 7 we use the ListBox control in XAML. This will represent the View.

<ListBox ItemsSource="{Binding Items}">

  <ListBox.ItemTemplate>

    <DataTemplate>

      <StackPanel>

        <TextBlock Text="{Binding LineOne}" TextWrapping="Wrap"/>

        <TextBlock Text="{Binding LineTwo}" TextWrapping="Wrap"/>

      </StackPanel>

    </DataTemplate>

  </ListBox.ItemTemplate>

</ListBox>

Our ViewModel is implemented in code. A ViewModel class should implement the INotifyPropertyChanged interface for the View to be able to respond to changes in the ViewModel.

public class ViewModelBase : INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged;

    protected void NotifyPropertyChanged(String propertyName)

        PropertyChangedEventHandler handler = PropertyChanged;

        if (null != handler)

            handler(this, new PropertyChangedEventArgs(propertyName));

public class ItemViewModel : ViewModelBase

    private string _lineOne;

    public string LineOne

        get { return _lineOne; }

set

            if (value != _lineOne)

                _lineOne = value;

                NotifyPropertyChanged("LineOne");

    private string _lineTwo;

    public string LineTwo

        get { return _lineTwo; }

set

            if (value != _lineTwo)

                _lineTwo = value;

                NotifyPropertyChanged("LineTwo");

public class MainViewModel : ViewModelBase

    private MainModel model;

    public MainViewModel()

        model = new MainModel();

        Items = model.GetData();

    public ObservableCollection<ItemViewModel> Items { get; private set; }

The ViewModel code above contains an instance of the Model. The Model in this naive example just returns a populated collection of ItemViewModel.

public class MainModel

    public ObservableCollection<ItemViewModel> GetData()

        return new ObservableCollection<ItemViewModel>

            new ItemViewModel() { LineOne = "runtime one", LineTwo = "Maecenas praesent accumsan bibendum" },

            new ItemViewModel() { LineOne = "runtime two", LineTwo = "Dictumst eleifend facilisi faucibus" },

            new ItemViewModel() { LineOne = "runtime three", LineTwo = "Habitant inceptos interdum lobortis" },

            new ItemViewModel() { LineOne = "runtime four", LineTwo = "Nascetur pharetra placerat pulvinar" }

};

Here's how the application looks like:

Windows Mobile

This is actually a pretty decent platform and offers a huge selection of low level API's for platform integration. The OS also offers full multi tasking and the ability to create applications that run behind scenes. The down side of course to all that fun stuff is that you have to do a lot of things the hard way. Implementing a decent list based UI in this platforms can be done in 2 ways: Using the Windows CE custom drawing service; Creating an Owner Drawn List Control. Both require writing a few hundred lines of code.

For this example we create an Owner Drawn List. For those who are not familiar what that means, we draw the entire control from scratch, manually. We create a class that inherits from System.Windows.Forms.Control (the base class of all UI components) and override the drawing, resizing, and input methods. It's a bit tedious, but most of the code in owner drawn controls can be re-used as base classes for other owner drawn controls.

Let's start off with creating an owner drawn list base class.

abstract class OwnerDrawnListBase<T> : Control

    int selectedIndex;

    int visibleItemsPortrait;

    int visibleItemsLandscape;

    VScrollBar scrollBar;

    protected OwnerDrawnListBase()

        : this(7, 4)

    protected OwnerDrawnListBase(int visibleItemsPortrait, int visibleItemsLandscape)

        this.visibleItemsPortrait = visibleItemsPortrait;

        this.visibleItemsLandscape = visibleItemsLandscape;

        Items = new List<T>();

        scrollBar = new VScrollBar { Parent = this, Visible = false, SmallChange = 1 };

        scrollBar.ValueChanged += (sender, e) => Invalidate();

    public List<T> Items { get; private set; }

    public int SelectedIndex

        get { return selectedIndex; }

set

            selectedIndex = value;

            if (SelectedIndexChanged != null)

                SelectedIndexChanged(this, EventArgs.Empty);

            Invalidate();

    public event EventHandler SelectedIndexChanged;

    protected virtual void OnSelectedIndexChanged(EventArgs e)

        if (SelectedIndexChanged != null)

            SelectedIndexChanged(this, e);

    public T SelectedItem

get

            if (selectedIndex >= 0 && selectedIndex < Items.Count)

                return Items[selectedIndex];

            else

                return null;

    protected Bitmap OffScreen { get; private set; }

    protected int VisibleItems

get

            if (Screen.PrimaryScreen.Bounds.Height > Screen.PrimaryScreen.Bounds.Width)

                return visibleItemsPortrait;

            else

                return visibleItemsLandscape;

    protected int ItemHeight

        get { return Height / VisibleItems; }

    protected int ScrollPosition

        get { return scrollBar.Value; }

    protected bool ScrollBarVisible

        get { return scrollBar.Visible; }

    protected int ScrollBarWidth

        get { return scrollBar.Width; }

    protected int DrawCount

get

            if (ScrollPosition + scrollBar.LargeChange > scrollBar.Maximum)

                return scrollBar.Maximum - ScrollPosition + 1;

            else

                return scrollBar.LargeChange;

    #region Overrides

    protected override void OnResize(EventArgs e)

        scrollBar.Bounds = new Rectangle(

            ClientSize.Width - scrollBar.Width,

0,

            scrollBar.Width,

            ClientSize.Height);

        Dispose(OffScreen);

        if (Items.Count > VisibleItems)

            scrollBar.Visible = true;

            scrollBar.LargeChange = VisibleItems;

            OffScreen = new Bitmap(ClientSize.Width - scrollBar.Width, ClientSize.Height);

        else

            scrollBar.Visible = false;

            scrollBar.LargeChange = Items.Count;

            OffScreen = new Bitmap(ClientSize.Width, ClientSize.Height);

        DrawBorder();

        scrollBar.Maximum = Items.Count - 1;

    private void DrawBorder()

        using (var gfx = Graphics.FromImage(OffScreen))

        using (var pen = new Pen(SystemColors.ControlText))

            gfx.DrawRectangle(pen, new Rectangle(0, 0, OffScreen.Width - 1, OffScreen.Height - 1));

    protected override void OnMouseDown(MouseEventArgs e)

        // Update the selected index based on where the user clicks

        SelectedIndex = scrollBar.Value + (e.Y / ItemHeight);

        if (SelectedIndex > Items.Count - 1)

            SelectedIndex = -1;

        if (!Focused)

            Focus();

        base.OnMouseUp(e);

    protected override void OnPaintBackground(PaintEventArgs e)

        // To avoid flickering, do all drawing in OnPaint

    protected override void Dispose(bool disposing)

        if (disposing)

            Dispose(OffScreen);

        base.Dispose(disposing);

    #endregion

    protected static void Dispose(IDisposable obj)

        if (obj != null)

            obj.Dispose();

            obj = null;

The class above implements the basic functionality of an owner drawn list. It hands resizing the off screen bitmap that serves as a double buffer, handles the scroll bar visibility, and handles updating the selected index. One can implement responding to keyboard input or gestures from here as well.

Next we create a class where we define how the control is drawn. This class inherits from our owner drawn list base class.

class CustomListViewItem

    public string LineOne { get; set; }

    public string LineTwo { get; set; }

class CustomListView : OwnerDrawnListBase<CustomListViewItem>

    const int topleft = 3;

    StringFormat noWrap;

    Pen pen;

    SolidBrush backgroundBrush;

    SolidBrush selectedBrush;

    SolidBrush selectedTextBrush;

    SolidBrush textBrush;

    Font headerFont;

    public override Font Font

        get { return base.Font; }

set

            base.Font = value;

            Dispose(headerFont);

            headerFont = new Font(value.Name, value.Size, FontStyle.Bold);

    public CustomListView()

        pen = new Pen(ForeColor);

        textBrush = new SolidBrush(ForeColor);

        backgroundBrush = new SolidBrush(BackColor);

        selectedTextBrush = new SolidBrush(SystemColors.HighlightText);

        selectedBrush = new SolidBrush(SystemColors.Highlight);

        noWrap = new StringFormat(StringFormatFlags.NoWrap);

        headerFont = new Font(base.Font.Name, base.Font.Size, FontStyle.Bold);

    protected override void OnPaint(PaintEventArgs e)

        using (var gfx = Graphics.FromImage(OffScreen))

            gfx.FillRectangle(backgroundBrush, 1, 1, Width - 2, Height - 2);

            int top = 1;

            bool lastItem = false;

            bool itemSelected = false; ;

            for (var i = ScrollPosition; i < ScrollPosition + DrawCount; i++)

                if (top > 1)

                    lastItem = Height - 1 < top;

                // Fill the rectangle if the item is selected

                itemSelected = i == SelectedIndex;

                if (itemSelected)

                    if (!lastItem)

                        gfx.FillRectangle(

                            selectedBrush,

1,

                            (i == ScrollPosition) ? top : top + 1,

                            ClientSize.Width - (ScrollBarVisible ? ScrollBarWidth : 2),

                            (i == ScrollPosition) ? ItemHeight : ItemHeight - 1);

                    else

                        gfx.FillRectangle(

                            selectedBrush,

1,

                            top + 1,

                            ClientSize.Width - (ScrollBarVisible ? ScrollBarWidth : 1),

                            ItemHeight);

                // Draw seperator lines after each item unless the item is the last item in the list

                if (!lastItem)

                    gfx.DrawLine(

                        pen,

1,

                        top + ItemHeight,

                        ClientSize.Width - (ScrollBarVisible ? ScrollBarWidth : 2),

                        top + ItemHeight);

                // Get the dimensions for creating the drawing areas

                var item = Items[i];

                var size = gfx.MeasureString(item.LineOne, Font);

                var rectheight = ItemHeight - (int)size.Height - 6;

                var rectwidth = ClientSize.Width - (ScrollBarVisible ? ScrollBarWidth : 5);

                // Draw line one with an offset of 3 pixels from the top of the rectangle

                // using a bold font (no text wrapping)

                gfx.DrawString(

                    item.LineOne,

                    headerFont,

                    (i == SelectedIndex) ? selectedTextBrush : textBrush,

                    new RectangleF(topleft, top + 3, rectwidth, rectheight),

                    noWrap);

                // Draw line two with an offset of 3 pixels from the bottom of line one

                // (no text wrapping)

                gfx.DrawString(

                    item.LineTwo,

                    Font,

                    (i == SelectedIndex) ? selectedTextBrush : textBrush,

                    new RectangleF(topleft, top + size.Height + 6, rectwidth, rectheight),

                    noWrap);

                // Set the top for the next item

                top += ItemHeight;

            e.Graphics.DrawImage(OffScreen, 0, 0);

    protected override void Dispose(bool disposing)

        if (disposing)

            Dispose(headerFont);

            Dispose(backgroundBrush);

            Dispose(textBrush);

            Dispose(selectedTextBrush);

            Dispose(selectedBrush);

            Dispose(pen);

        base.Dispose(disposing);

Once that is in place you can just drag it in from the toolbox or dynamically add it to the Form in runtime.

var lv = new CustomListView();

lv.Dock = DockStyle.Fill;

Controls.Add(lv);

lv.Items.AddRange(new List<CustomListViewItem>

    new CustomListViewItem { LineOne = "runtime one", LineTwo = "Maecenas praesent accumsan bibendum" },

    new CustomListViewItem { LineOne = "runtime two", LineTwo = "Dictumst eleifend facilisi faucibus" },

    new CustomListViewItem { LineOne = "runtime three", LineTwo="Habitant inceptos interdum lobortis" },

    new CustomListViewItem { LineOne = "runtime four", LineTwo="Nascetur pharetra placerat pulvinar" },

    new CustomListViewItem { LineOne = "runtime five", LineTwo = "Maecenas praesent accumsan bibendum" },

    new CustomListViewItem { LineOne = "runtime six", LineTwo = "Dictumst eleifend facilisi faucibus" },

    new CustomListViewItem { LineOne = "runtime seven", LineTwo="Habitant inceptos interdum lobortis" },

    new CustomListViewItem { LineOne = "runtime eight", LineTwo="Nascetur pharetra placerat pulvinar" }

});

Here's how the custom list view looks like in a Windows Mobile 6.5.3 emulator

You can grab the source for Windows Mobile application above here.

Android

Creating decent list based UI's is also pretty easy. The designer experience is unfortunately not as elegant as what Windows Phone 7 has to offer, but shares the same idea. The user interface layout of Android applications are described in XML files and are parsed during runtime. In some occasions it seems easier to create the UI layout in runtime through code instead of struggling with the UI designer. This is probably because of my lack of patience with the tool or because of my lack of experience using it. Either way, I think it could have been done in a much smarter way.

To create a list based UI in Android we can create a class that extends from the ListActivity class. The ListActivity base class contains a List control set to fill the parent, it comes in handy if you want a UI with nothing but a list control. In android development, you usually setup the UI and do other initialization methods in the onCreate() method, our example will do the same. We set the data source of our list control by calling setListAdapter().

To have a more flexible and customizable we use the ArrayAdapter for presenting our data source to the screen. To optimize performance, we use an object called convertView that ArrayAdapter exposes, we can store a single instance of a class containing UI text components and just update the text for that instance. This is done by overriding the ArrayAdapter getView method.

Here's the code for implementing the ListActivity and ArrayAdapter

import java.util.ArrayList;
import java.util.List;

import android.app.Activity;
import android.app.ListActivity;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;

public class MainActivity extends ListActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setListAdapter(new ListItemActivity(this, R.layout.list_item, createList()));
    }

    private List<ListItem> createList() {
        List<ListItem> list = new ArrayList<ListItem>();
        list.add(new ListItem("runtime one", "Maecenas praesent accumsan bibendum"));
        list.add(new ListItem("runtime two", "Dictumst eleifend facilisi faucibus"));
        list.add(new ListItem("runtime three", "Habitant inceptos interdum lobortis"));
        list.add(new ListItem("runtime four", "Nascetur pharetra placerat pulvinar"));
        return list;
    }

    class ListItem {
        public String lineOne;
        public String lineTwo;

        public ListItem(String lineOne, String lineTwo) {
            this.lineOne = lineOne;
            this.lineTwo = lineTwo;
        }
    }

    class ListItemActivity extends ArrayAdapter<ListItem> {
        private Activity context;
        private List<ListItem> items;

        public ListItemActivity(Activity context, int textViewResourceId, List<ListItem> items) {
            super(context, textViewResourceId, items);
            this.context = context;
            this.items = items;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder;
            if (convertView == null) {
                LayoutInflater inflater = context.getLayoutInflater();
                convertView = inflater.inflate(R.layout.list_item, parent, false);
                holder = new ViewHolder();
                holder.lineOne = (TextView) convertView.findViewById(R.id.lineOne);
                holder.lineTwo = (TextView) convertView.findViewById(R.id.lineTwo);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();
            }

            ListItem item = items.get(position);
            holder.lineOne.setText(item.lineOne);
            holder.lineTwo.setText(item.lineTwo);
            return convertView;
        }
    }

    static class ViewHolder {
        TextView lineOne;
        TextView lineTwo;
    }
}

Here's how the XML layout file is for the list item (list_item.xml)

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout

  xmlns:android="http://schemas.android.com/apk/res/android"

  android:layout_width="fill_parent"

  android:layout_height="fill_parent"

  android:orientation="vertical">

  <TextView

    android:id="@+id/lineOne"

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:paddingTop="12dp"

    android:paddingLeft="12dp"

    android:textSize="18sp"

    android:textStyle="bold"

/>

  <TextView

    android:id="@+id/lineTwo"

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:paddingLeft="12dp"

    android:paddingBottom="12dp"

/>

</LinearLayout>

Here's how the applications looks like on an Android 2.3 emulator

You can grab the source for Android application above here.

So this basically all I have for now. I plan to go into detail by breaking down each part of the code samples I provided for all 3 platforms, or perhaps add another platform as well. I hope you found this useful.

Multi-platform Mobile Development

2011-01-10T14:37:00.000+01:00

I've been away from the blog sphere for a few months due to contracts I had to complete. I can't and won't complain about that since its these piles of work that get the bills payed. The types of jobs I've been getting lately have been changing, I've seen customers requesting for 3 different platform implementations of mobile applications. So these past few months I've been working on Android, Windows Mobile, Windows Phone 7, and as of last week iPhone. I find these challenges to be really fun even though the initial start up with a new platform doesn't always go that fast. Once you get a hang of it you learn to appreciate the architectural difference of each platform.

There are always a bunch of obstacles, some things are easier done in some platforms and some things are just more straight forward and runs faster in some platforms. The Microsoft platform's have extremely good development environments where productivity is kept at a constant high. I feel very at home in the Microsoft space since I've been doing mobile development since the days of Windows CE 3.0. Developing applications for Windows Phone 7 is very easy as long as one sticks to the development guidelines (provided by Microsoft) from the start.

What I came to really appreciate lately was Android development. I think this platform is very well designed and thought through. Getting started wasn't so hard and since Java is rather similar to C# I didn't have any trouble switching languages. The performance of Android applications is to my surprise superior to Windows Phone 7 and highly optimized Windows Mobile .NETCF applications and the API's provided for Android are elegant and well documented.

I haven't really gotten too far with iPhone development and I can't say much about that for now. But I am very pleased with the iPhone itself. Until the release of Windows Phone 7 devices I carried an iPhone around. It's extremely easy to use and it provided the very first software input panel that actually impressed me and that I really found useful.

I usually don't post my random thoughts on my blog. So what does all this mean? Well this post is meant to be the start of a long series of articles on multi-platform mobile development. The purpose of this series is to explain and demonstrate how to implement mobile applications on different platforms; to discuss architectural considerations for multi-platform design; demonstrate how to share common assets between the different platforms; to explore the best design patterns applicable to each platform, etc etc.

How to enable Internet Tethering on a Samsung Omnia 7

2010-11-11T12:34:00.000+01:00

I recently received a Samsung Omnia 7 and I think it's a pretty awesome phone. But, Windows Phone 7 in general lags behind with a few things, one of these things is a built in internet tethering feature (like in the iPhone for example). Since I'm going away for a few days I don't intend on going around with a 3G modem (my laptop doesn't have a built in 3G modem), neither am I to keen on switching back to my iPhone. So I searched for a solution and stumbled upon a hack to enable launch the Omnia 7 Diagnostic Menu and the Micro USB Test.

Here's what you need to do

Open the phone application
Dial # # 634 # and press Call
This will launch the diagnostic menu
Enter * # 7284 #
If the code above is entered properly then the Micro USB Test app launches
Select Modem, Tethered Call
You are prompted to restart the device
Connect your Omnia 7 to your computer via USB

In my attempt I was prompted to install the Samsung USB Driver and Windows 7 provided me with a link. Try it out :)

Chris' Puzzle Game on the Windows Phone 7 Marketplace

2010-11-05T10:39:00.000+01:00

I got my first application published on the Marketplace. The process was surprisingly fast, took overnight to get it certified and another day before it appeared on the Marketplace. I have a video demo of the game here and I demonstrate how parts of the game was built in an article called Writing a Puzzle Game for Windows Phone 7 using XNA. Try the game out, I'd love to get some feedback. It's a game made over a weekend and the main purpose was to experience the publishing process. If you have some comments, suggestions, or questions on the game then please send them to me and I'll see what I can do.

How to launch the Marketplace in the Windows Phone 7 Emulator

2010-11-02T13:10:00.000+01:00

You probably noticed by now that the default Windows Phone 7 emulator only contains Internet Explorer and the Settings. I stumbled upon a tip from Daniel Vaughan about Launchers and Choosers today and I learned about a task that can start up the Marketplace Hub. Unfortunately you will have to create an application that calls into the Launcher API to accomplish this.

Here's what you need to do:

1) Create a new Silverlight Windows Phone Application
2) In your MainPage.cs and add a using directive to the Microsoft.Phone.Tasks namespace.
3) Add the following in the constructor of MainPage.cs after calling the InitializeComponent() method:

var task = new MarketplaceHubTask();
task.ContentType = MarketplaceContentType.Applications;
task.Show();

4) Launch the application and you should be good to go.

Here's how the Marketplace looks like on the emulator:

Click here to see a list of supported launchers and choosers for Windows Phone 7. You can read more about Launchers and Choosers here.

How to use the keyboard in the Windows Phone 7 Emulator

2010-10-26T12:36:00.013+02:00

The one thing that irritated me the most about the Windows Phone 7 emulator the first time I used it was that the host computer keyboard is not directly mapped to the emulator. This means you by default have to use the software input panel that is built in Windows Phone 7.

I immediately looked for a solution and found some MSDN documentation on the keyboard mappings for the emulator.

To enable the keyboard in the emulator - press the PAGE UP key or PAUSE/BREAK key.

To disable the keyboard in the emulator - press the PAGE DOWN key PAUSE/BREAK key.

If you want to learn more then I suggest you check out this article called Keyboard Mapping for Windows Phone Emulator

Windows Phone 7 Unlocked Emulator

2010-10-25T10:37:00.014+02:00

If are not pleased with the emulator that shipped with the Windows Phone 7 developer tools then here's a quick way to replace the trimmed down emulator with the full version

1) Create a back up of your current emulator image file, to avoid re-installing the developer tools if in case anything goes wrong. This file will be under [PROGRAM FILES (x86)]\Microsoft SDKs\Windows Phone\v7.0\Emulator\Images\ and is called WM70C1.en-US.bin

2) Find and download an unlocked image in your search engine of choice, search for WM70C1.en-US.unlocked :)

3) Once downloaded, Copy the unlocked emulator image to [PROGRAM FILES (x86)]\Microsoft SDKs\Windows Phone\v7.0\Emulation\Images\

4) Rename the unlocked emulator image to WM70C1.en-US.bin

5) Run the emulator :)

If all goes well you should be able to run the unlocked emulator and it should look like this:

I would advise to make sure that you can deploy and debug applications with Visual Studio. If not then you probably found an older version of the unlocked emulator image and you should try to search again for a newer version.

Chris' Puzzle Game for Windows Phone 7

2010-10-22T09:00:00.012+02:00

I finally managed to find the time to complete my puzzle game for Windows Phone 7. This will be my first attempt to publish anything on the marketplace. Let's see how it goes!

If you're interested in how I made the game then I'll be more than willing to share. I might be able to post code directly as this is soon be available commercially, but I can always give some tips and share knowledge. I wrote a step by step article on how to Create a Puzzle Game for Windows Phone 7 using XNA. The puzzle game logic is described in this article and I pretty use the same logic.

Motorola Dual Bluetooth Stack Support

2010-10-21T23:44:00.005+02:00

Apparently most Motorola devices support 2 Bluetooth Stacks: Microsoft and StoneStreet. To switch which stack to use you would have to make some changes in the registry and restart the device.

[HKEY_LOCAL_MACHINE\SOFTWARE\SymbolBluetooth]

"SSStack"=DWORD:1

0 = Microsoft Stack
1 = StoneStreet One Stack

The StoneStreet One Stack is supported in all devices except the ES400 and MC65. For the Microsoft stack, any device running Windows Mobile 6.1, Windows Mobile 6.5.x and Windows CE 6.0

Motorola recommendeds using the Microsoft stack for new development and I strongly agree with Motorola on this!

Widcomm Bluetooth Pairing Prompt

2010-10-20T12:58:00.017+02:00

Not so long ago I had a project that involved Bluetooth communication from a windows mobile device to some custom designed hardware. Everything went smoothly with only a few bumps during the scope of the project. When we had the applications on the field, certain users where running on devices that used the Widcomm Bluetooth Stack and that gave us a few headaches. For one, our system doesn't use any security features in bluetooth hence it doesn't not require pairing. Our security architecture is service based and checks for certain keys being passed back and forth to an online service. Very standard stuff. The problem we had with the devices running on a Widcomm Bluetooth stack was that the user was always prompted to pair even though the device did not require pairing. The application was not designed to handle user input aside from logging in/out and some diagnostic features. The application was designed to just run quietly in the background with the device tucked in the users pocket.

Since quite a few devices use the Widcomm Bluetooth Stack I needed a quick fix/hack to avoid the user having to pick up the device and click "Yes" on the security prompt to communicate with the device. The fix had to be as simple as possible and had to run without disrupting the user. My not so clean solution was to create a small application that does nothing but check if the Widcomm security pairing prompt app was running and if so send a keystroke event to simulate the user clicking on "Yes".

The Widcomm security prompt app main window uses the class name Broadcom_BTWizard with the window name Bluetooth. I check if this window exists and send the F1 keyboard event to simulate clicking on the left hardware button on the device

Here's a code snippet in C#

[DllImport("coredll.dll")]

static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

[DllImport("coredll")]

static extern void keybd_event(byte bVk, byte bScan, int dwFlags, int dwExtraInfo);

const int KEYEVENTF_KEYUP = 0x02;

const int KEYEVENTF_KEYDOWN = 0x00;

static bool running = true;

static void CloseBroadcomWindowWorker()

    while (running)

        var hwnd = FindWindow("Broadcom_BTWizard", "Bluetooth");

        if (hwnd != IntPtr.Zero)

            keybd_event((byte)Keys.F1, 0, KEYEVENTF_KEYDOWN, 0);

            keybd_event((byte)Keys.F1, 0, KEYEVENTF_KEYUP, 0);

        Thread.Sleep(5000);

This is of course not the best solution but if you have a similar problem then this might save you some time if your only requirement is to get it to work as soon as possible. Otherwise, I would suggest avoiding the Widcomm Bluetooth Stack and just go for devices that use the Microsoft Bluetooth Stack

Windows Phone 7 Game State Management using XNA

2010-10-15T15:45:00.010+02:00

Not so long ago I wrote a Puzzle game for Windows Phone 7 using XNA. The game was really simple and had no menu or state management. Luckily, I recently stumbled upon a sample on MSDN that describes the basics of implementing game state management using XNA.

To try things out a bit more I modified my existing puzzle game and included the sample game state management code. The results are pretty amazing!

Here's how my Puzzle Game for Windows Phone 7 looks like now:

If you're getting into writing games for Windows Phone 7 using XNA then you should really check out the Game State Management sample here:
http://create.msdn.com/en-US/education/catalog/sample/game_state_management

I described in detail how I built my puzzle game application in an article called Writing a Puzzle Game for Windows Phone 7 using XNA. Try checking it out, I hope you find it interesting

Microsoft Advertising SDK for Windows Phone 7

2010-10-11T15:17:00.027+02:00

I recently stumbled upon the Microsoft Advertising SDK for Windows Phone 7. At the client side, it provides a control called AdControl that retrieves banner information based on the specified ApplicationId and AdUnitId. In order to use the Microsoft Advertising’s ad delivery system, you first need to create a Microsoft pubCenter account.

Here's some information extracted from the help file included in the SDK:
The Microsoft Advertising SDK for Windows Phone 7 provides an AdControl that you can use to publish advertisements in Windows Phone 7 applications. The Microsoft Advertising AdControl communicates with Microsoft servers that deliver ads. When these servers return ads to the AdControl, the AdControl will render the ads within your Windows Phone 7 application.

In order to use the Microsoft Advertising’s ad delivery system, you first need to create a Microsoft pubCenter account. Microsoft pubCenter is an advertising publisher management system that enables you to create ad placements and collect advertising revenue. Once you create an account, you will register your mobile applications by using Microsoft pubCenter. When a Windows Phone 7 application is registered with Microsoft pubCenter it will receive a unique mobile application identifier (ApplicationId).

When a mobile application displays a window, the application can define a space within the window for the presentation of advertisements. Each ad placement that is presented is called an ad unit. You will define and create mobile ad units by using Microsoft pubCenter, and each mobile ad unit will be assigned a unique ad unit identifier (AdUnitId).

The ApplicationId and the AdUnitId are required for your Windows Phone 7 application to request ads from Microsoft Advertising’s ad delivery system. The ApplicationId and the AdUnitId identify the ad unit that is delivered to a Windows Phone 7 application and the publisher that will receive credit for displaying the ad unit.

It takes only a few easy steps to register with Microsoft pubCenter, create ad units, manage revenues, and integrate the Microsoft Advertising Mobile AdControl for Windows Phone 7 into your application.

Sounds fairly simple but not everything can be perfect in a first release. The first problem I found was that the pubCenter Registration and Payment will only be available for publishers from the United States. So to be eligable for payments one must for example have a valid US address and a valid Tax Information Number (TIN) if the publisher is a business entity. As I'm not based in the US, I haven't tried this yet. But based on what I've read in the documentation, using the AdControl in a Windows Phone 7 application seems fairly easy.

Here are some C# and XAML snippets:

The following C# code instantiates a new AdControl and sets mandatory targeting parameters.

AdControl ctrl = new AdControl();

ctrl.ApplicationId = "testapplication";

ctrl.AdUnitId = "testadunit";

this.ContentGrid.Children.Add(ctrl);

The following C# code instantiates a new AdControl with manual ad rotation.

string applicationId = "testapplication";

string adUnitId = "testadunit";

bool isAutoRotation = false;

AdControl ctrl = new AdControl(applicationId, adUnitId, AdModel.Contextual, isAutoRotation);

ctrl.Width = 480;

ctrl.Height = 80;

this.ContentGrid.Children.Add(ctrl);

The following XAML instantiates a new AdControl with mandatory targeting parameters.

<Grid xmlns:adctl="clr-namespace:Microsoft.Advertising.Mobile.UI;assembly=Microsoft.Advertising.Mobile.UI" Grid.Row="1">

   <adctl:AdControl Height="80" Width="480" AdUnitId="Test" ApplicationId="Test" AdModel="Contextual" />

</Grid>

I'm looking forward for these tools to be available in Europe so I can try them out.

How to retrieve a list of installed applications using .NETCF

2010-10-06T14:29:00.016+02:00

In this short post I'd like to demonstrate how to retrieve a list of installed applications on a Windows Mobile device using OMA Client Provisioning. First you need to add a reference to the Microsoft.WindowsMobile.Configuration assembly. To retrieve the list we need to process a specific configuration (UnInstall Configuration Service Provider) using the ConfigurationManager.ProcessConfiguration method. The configuration is described in an XML and the response to this will also be described in XML

To query the device we process this configuration:

<wap-provisioningdoc>

  <characteristic-query type="UnInstall"/>

</wap-provisioningdoc>

The query above will only return installed application that can be uninstalled. The device would then respond with something like this:

<wap-provisioningdoc>

  <characteristic type="UnInstall">

    <characteristic type="Microsoft Application#2">

      <parm name="uninstall" value="0"/>

    </characteristic>

    <characteristic type="Microsoft Application#1">

      <parm name="uninstall" value="0"/>

    </characteristic>

    <characteristic type="Demo Home Screen">

      <parm name="uninstall" value="0"/>

    </characteristic>

  </characteristic>

</wap-provisioningdoc>

And here's how to accomplish this task using .NETCF and C#

var doc = new XmlDocument();

doc.LoadXml(@"<wap-provisioningdoc><characteristic-query type=""UnInstall""/></wap-provisioningdoc>");

doc = ConfigurationManager.ProcessConfiguration(doc, true);

var nodes = doc.SelectNodes("wap-provisioningdoc/characteristic[@type='UnInstall']/characteristic/@type");

foreach (var node in nodes.Cast<XmlNode>())

    Trace.WriteLine(node.InnerText);

I hope you found this useful.

Writing a Puzzle Game for Windows Phone 7 using XNA

2010-09-15T10:38:00.147+02:00

This article is a step by step guide on how to write a puzzle game for Windows Phone 7 using XNA. Before we get started you will need the Windows Phone 7 Developer Tools. Please note that I'm not really a game developer and I might not be doing the best practices. The intention of this article is just to demonstrate how easy it is to write a game using XNA even if one has little to no experience in game development.

I've been playing around with XNA these past few nights and decided to write a few casual games. The first prototype I have is a port of my old Puzzle Game. The game is still really incomplete, like there is no menu or state management which means you can't shut it down properly and stuff. But I thought I'd share some thoughts on my experience with it and at the same time share some code.

The structure of the game is fairly simple. I have 2 collections: one contains an image, another contains an index to the each of the elements of the first collection and its the area where to display the image on the screen. The collection that contains the indexes is my scrambled puzzle. Each time a piece is moved, I update the order of my scrambled list afterwards I check if all the items in my scrambled list are correctly sorted in an ascending fashion. If all the items are sorted properly then it means that the puzzle was solved.

Enough said and let's get started. The first step is to of course fire up Visual Studio and create a new XNA Game Studio 4.0 - Windows Phone Game project. Let's call the project PuzzleGame

Now that we have a project we can start adding some content or game assets. For this simple project, we will use 3 different game assets: the puzzle image, and 2 Sprite Font for drawing the elapsed playing time and to draw text to congratulate the player once they complete the puzzle. To add content, right click on the PuzzleGameContent project, then click on Add.

For the puzzle image, we can pick up one of the sample pictures included in Windows 7 (e.g. \Users\Public\Pictures\Sample Pictures)

After adding the puzzle image we should change the Asset Name property to PuzzleImage. This can be done through the Properties Window (Right click on the added image in the Solution Explorer and click Properties)

To add Sprite Fonts, right click on the content project, click Add - New Item, then select Sprite Font. Let's add 2 sprite fonts and call them GameTime and Congratulations

Let's change the Asset Name of the Sprite Fonts we just added to GameTimeFont and CongratulationsFont

The SpriteFont content is actually just an XML file. The GameTime font's default description should be good enough but let's change the Congratulations font description to use a larger size. Open Congratulations.spritefont from the solution explorer and change the Size to 48, and change the Style to Bold

Now that we have our game assets in place we can start coding. A lot of initial code is generated when creating a new XNA Game Studio project. To start things clean let's rename default Game1 class to PuzzleGame and delete all the contents leaving the PuzzleGame class empty.

Before we start implementing our PuzzleGame class we'll need to create a class which will represent a piece of the puzzle, let's call this PuzzlePiece

class PuzzlePiece

    public int Index { get; set; }

    public Vector2 Bounds { get; set; }

    public override int GetHashCode()

        return Index.GetHashCode();

    public override bool Equals(object obj)

        var piece = obj as PuzzlePiece;

        if (piece != null)

            return Index.Equals(piece.Index);

        return base.Equals(obj);

We'll also need an enumeration that describes the state of the game. This state describes what to draw on the screen. Let's call this enum DrawMode. There are 2 simple states of the game:

1. Puzzle - Draws the puzzle game
2. Congratulations - Draws a "Congratulations" text once the player solves the puzzle

enum DrawMode

    Puzzle,

    Congratulations

Now we can start implementing our PuzzleGame class. The first step is to define our global variables and the constructor method

GraphicsDeviceManager graphics;

SpriteBatch spriteBatch;

Texture2D previewTexture;

Vector2 previewVector, emptyPiece, totalGameTimeVector, congratulationsVector;

SpriteFont gameTimerFont,congratulationsFont;

Dictionary<int, Texture2D> puzzlePieces;

Dictionary<int, PuzzlePiece> scrambledPieces;

DrawMode Mode;

int height, width;

double elapsedTime, playingTime;

Queue<Keys> pendingCommands;

const int PIECE_COUNT = 4 * 4;

bool solved;

static bool animating;

public PuzzleGame()

    graphics = new GraphicsDeviceManager(this);

    Content.RootDirectory = "Content";

Next step is to implement the Initialize() method. This method allows the game to perform any initialization it needs before it starts to run. With a simple game such as this one could debate where to put the initialization code, I could easily see myself having my initialize code in the constructor method. To make this example as XNA'ish let's initialize our non-content variables in the Initialize() method.

/// <summary>

/// Allows the game to perform any initialization it needs to before starting to run.

/// This is where it can query for any required services and load any non-graphic

/// related content.  Calling base.Initialize will enumerate through any components

/// and initialize them as well.

/// </summary>

protected override void Initialize()

    pendingCommands = new Queue<Keys>();

    Mode = DrawMode.Puzzle;

    previewVector = new Vector2(0, 0);

    totalGameTimeVector = new Vector2(10, 10);

    base.Initialize();

Next we implement the LoadContent() and UnloadContent()

/// <summary>

/// LoadContent will be called once per game and is the place to load

/// all of your content.

/// </summary>

protected override void LoadContent()

    spriteBatch = new SpriteBatch(GraphicsDevice);

    previewTexture = Content.Load<Texture2D>("PuzzleImage");

    gameTimerFont = Content.Load<SpriteFont>("GameTimeFont");

    congratulationsFont = Content.Load<SpriteFont>("CongratulationsFont");

    var size = congratulationsFont.MeasureString("Congrautulations!");

    congratulationsVector = new Vector2(

        (GraphicsDevice.Viewport.Width - size.X) / 2,

        (GraphicsDevice.Viewport.Height - size.Y) / 2);

    Divide();

    Scramble();

/// <summary>

/// UnloadContent will be called once per game and is the place to unload

/// all content.

/// </summary>

protected override void UnloadContent()

    previewTexture.Dispose();

    foreach (var item in puzzlePieces)

        item.Value.Dispose();

    spriteBatch.Dispose();

You probably noticed that LoadContent calls methods called Divide() and Scramble().

The Divide() method splits the puzzle image into tiny pieces represented by the PuzzlePiece class. The full puzzle image is stored in a Texture2D object called previewTexture, to split this into pieces I copy the color information of the puzzle image within a specified bounds into an array of type Color and then I set this color information in a new instance of Texture2D.

private void Divide()

    int idx = 0;

    int cells = Convert.ToInt32(Math.Sqrt(PIECE_COUNT));

    height = GraphicsDevice.Viewport.Height / cells;

    width = GraphicsDevice.Viewport.Width / cells;

    puzzlePieces = new Dictionary<int, Texture2D>();

    for (int y = 0; y < GraphicsDevice.Viewport.Height; y += height)

        for (int x = 0; x < GraphicsDevice.Viewport.Width; x += width)

            var rectangle = new Rectangle(x, y, width, height);

            var data = new Color[width * height];

            previewTexture.GetData<Color>(0, rectangle, data, 0, data.Length);

            var piece = new Texture2D(GraphicsDevice, width, height);

            piece.SetData(data);

            puzzlePieces.Add(idx++, piece);

The Scramble() method does exactly what the method name describes, it scrambles the puzzle. The field called scrambledPieces is a key/value pair collection that uses the index of the puzzlePieces collection as the key and the bounds of this image to be drawn on the screen as the value. The bounds of the image is stored in a Vector2 object.

private void Scramble()

    int idx = 0;

    var random = new Random();

    int capacity = puzzlePieces.Count - 1;

    scrambledPieces = new Dictionary<int, PuzzlePiece>(puzzlePieces.Count);

    for (int y = 0; y < GraphicsDevice.Viewport.Height; y += height)

        for (int x = 0; x < GraphicsDevice.Viewport.Width; x += width)

            if (idx < capacity)

                var piece = new PuzzlePiece();

                while (true)

                    piece.Index = random.Next(0, capacity);

                    if (!scrambledPieces.ContainsValue(piece))

                        break;

                piece.Bounds = new Vector2(x, y);

                scrambledPieces.Add(idx++, piece);

            else

                emptyPiece = new Vector2(x, y);

    scrambledPieces.Add(idx, new PuzzlePiece { Index = -1 });

All we need now is to implement the Game Loop.

The Update() method will contain the game logic. The game logic will be used for updating the game surface, collision detection, accepting and handling user input, background music, sounds effects, etc. In our game we use it for accepting and handling user input. We accept the user input through polling the Mouse state by calling the static method Mouse.GetState(). We handle the user input by doing a hit test to get which puzzle piece was clicked and moving this piece. Only one piece can be moved at a time and this piece can only move up, down, left, or right. For those who are not familiar with what a hit test is, here's my attempt to define it: A hit test is a way of detecting if 2 objects are touching or intersecting with each other. In our case, we use hit testing to figure out which puzzle piece was clicked by checking all the pieces of the puzzle if the mouse position is inside its bounds. Moving a puzzle piece is implemented as a very basic animation that runs on a separate thread. User input is not handled while the puzzle pieces are being moved around. The update method also updates the game playing time which we later on draw on the screen.

/// <summary>

/// Allows the game to run logic such as updating the world,

/// checking for collisions, gathering input, and playing audio.

/// </summary>

/// <param name="gameTime">Provides a snapshot of timing values.</param>

protected override void Update(GameTime gameTime)

    var mouseState = Mouse.GetState();

    if (mouseState.LeftButton == ButtonState.Pressed)

        if (animating)

            base.Update(gameTime);

            return;

        var clickedRectangle = new Rectangle(mouseState.X, mouseState.Y, width, height);

        var pieceRect = new Rectangle(0, 0, width, height);

        for (int i = 0; i < scrambledPieces.Count; i++)

            pieceRect.X = (int)scrambledPieces[i].Bounds.X;

            pieceRect.Y = (int)scrambledPieces[i].Bounds.Y;

            if (!pieceRect.Intersects(clickedRectangle))

                continue;

            if (mouseState.X >= emptyPiece.X &&

                mouseState.X <= emptyPiece.X + width &&

                mouseState.Y >= emptyPiece.Y &&

                mouseState.Y <= emptyPiece.Y + height)

                continue;

            Keys command = Keys.None;

            if (pieceRect.X >= emptyPiece.X && pieceRect.X <= emptyPiece.X)

                if (pieceRect.Y - height == emptyPiece.Y)

                    command = Keys.Up;

                else if (pieceRect.Y + height == emptyPiece.Y)

                    command = Keys.Down;

            else if (pieceRect.Y >= emptyPiece.Y && pieceRect.Y <= emptyPiece.Y)

                if (pieceRect.X - width == emptyPiece.X)

                    command = Keys.Left;

                else if (pieceRect.X + width == emptyPiece.X)

                    command = Keys.Right;

            if (command != Keys.None && !pendingCommands.Contains(command))

                pendingCommands.Enqueue(command);

                Debug.WriteLine("Clicked: " + i);

            break;

    else

        elapsedTime += gameTime.ElapsedGameTime.TotalMilliseconds;

    if (elapsedTime >= 10)

        if (pendingCommands.Count > 0)

            MovePiece(pendingCommands.Dequeue());

        elapsedTime = 0;

    if (!solved)

        playingTime += gameTime.ElapsedGameTime.TotalMilliseconds;

    base.Update(gameTime);

The MovePiece() method does a hit test to find which piece to move. Once the correct piece is found the Animate() method is called.

private void MovePiece(Keys command)

    for (int i = 0; i < scrambledPieces.Count; i++)

        switch (command)

            case Keys.Up:

                if (scrambledPieces[i].Bounds.X == emptyPiece.X && scrambledPieces[i].Bounds.Y - height == emptyPiece.Y)

                    Animate(command, i);

                    return;

                break;

            case Keys.Down:

                if (scrambledPieces[i].Bounds.X == emptyPiece.X && scrambledPieces[i].Bounds.Y + height == emptyPiece.Y)

                    Animate(command, i);

                    return;

                break;

            case Keys.Left:

                if (scrambledPieces[i].Bounds.Y == emptyPiece.Y && scrambledPieces[i].Bounds.X - width == emptyPiece.X)

                    Animate(command, i);

                    return;

                break;

            case Keys.Right:

                if (scrambledPieces[i].Bounds.Y == emptyPiece.Y && scrambledPieces[i].Bounds.X + width == emptyPiece.X)

                    Animate(command, i);

                    return;

                break;

The Animate() method starts a thread in the ThreadPool which will move the puzzle piece by 2 pixels at a time until the piece is placed in the empty area. The empty area information is stored in the emptyPiece object. Once the piece is in the empty area the scrambled index of the piece is updated together with its new bounds. Finally a check if the puzzle was solved by the move is done.

private void Animate(Keys direction, int i)

    animating = true;

    ThreadPool.QueueUserWorkItem((state) =>

try

            const int INCREMENT = 2;

            var newEmptyPiece = scrambledPieces[i].Bounds;

            while (scrambledPieces[i].Bounds != emptyPiece)

                switch (direction)

                    case Keys.Up:

                        scrambledPieces[i].Bounds = new Vector2(emptyPiece.X, scrambledPieces[i].Bounds.Y - INCREMENT);

                        break;

                    case Keys.Down:

                        scrambledPieces[i].Bounds = new Vector2(emptyPiece.X, scrambledPieces[i].Bounds.Y + INCREMENT);

                        break;

                    case Keys.Left:

                        scrambledPieces[i].Bounds = new Vector2(scrambledPieces[i].Bounds.X - INCREMENT, emptyPiece.Y);

                        break;

                    case Keys.Right:

                        scrambledPieces[i].Bounds = new Vector2(scrambledPieces[i].Bounds.X + INCREMENT, emptyPiece.Y);

                        break;

                Thread.Sleep(1);

            emptyPiece = newEmptyPiece;

        finally

            UpdateScrambledIndex(direction, i);

            CheckForCompletion();

            animating = false;

});

private void UpdateScrambledIndex(Keys command, int index)

    int newIndex = -1;

    int INCREMENT = Convert.ToInt32(Math.Sqrt(PIECE_COUNT));

    switch (command)

        case Keys.Up:

            newIndex = index - INCREMENT;

            if (newIndex < 0) newIndex = 0;

            break;

        case Keys.Down:

            newIndex = index + INCREMENT;

            if (newIndex > scrambledPieces.Count - 1) newIndex = scrambledPieces.Count - 1;

            break;

        case Keys.Left:

            newIndex = index - 1;

            if (newIndex < 0) newIndex = 0;

            break;

        case Keys.Right:

            newIndex = index + 1;

            if (newIndex > scrambledPieces.Count - 1) newIndex = scrambledPieces.Count - 1;

            break;

    var temp = scrambledPieces[newIndex];

    scrambledPieces[newIndex] = scrambledPieces[index];

    scrambledPieces[index] = temp;

private void CheckForCompletion()

    for (int i = 0; i < scrambledPieces.Count - 1; i++)

        if (scrambledPieces[i].Index != i)

            return;

    solved = true;

    Mode = DrawMode.Congratulations;

Last but not the least we implement the Draw() method. This is where we render the screen. We always start by clearing the screen and afterwards adding sprites to our SpriteBatch. In our game we only have 2 ways of rendering the screen: rendering the puzzle game in play; and rendering if the puzzle was solved.

To render the puzzle game I add a sprite that draws the game playing time on the top left corner then I add a sprite for each piece of the puzzle by iterating through my scrambledPieces collection..

To render the screen when the puzzle is solved I draw 2 sprites. One is the playing time and the other is "Congratulations"

/// <summary>

/// This is called when the game should draw itself.

/// </summary>

/// <param name="gameTime">Provides a snapshot of timing values.</param>

protected override void Draw(GameTime gameTime)

    GraphicsDevice.Clear(Color.Black);

    spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);

    switch (Mode)

        case DrawMode.Puzzle:

            spriteBatch.DrawString(gameTimerFont, new TimeSpan(0, 0, 0, 0, (int)playingTime).ToString(), totalGameTimeVector, Color.White);

            for (int i = 0; i < scrambledPieces.Count; i++)

                if (scrambledPieces[i].Index == -1) continue;

                var piece = puzzlePieces[scrambledPieces[i].Index];

                spriteBatch.Draw(piece, scrambledPieces[i].Bounds, Color.White);

            break;

        case DrawMode.Congratulations:

            spriteBatch.DrawString(gameTimerFont, new TimeSpan(0, 0, 0, 0, (int)playingTime).ToString(), totalGameTimeVector, Color.White);

            spriteBatch.DrawString(congratulationsFont, "Congratulations!", congratulationsVector, Color.White);

            break;

    spriteBatch.End();

    base.Draw(gameTime);

I hope you found this article useful and educational. You can grab the source code here

Copying files from the Desktop to the Device using .NET

2010-08-23T12:18:00.014+02:00

Someone asked me recently how to copy files from the desktop to the device after reading my old article called How to copy files from the Device to the Desktop using .NET. Well here's how to do it:

First, we'll need our P/Invokes to rapi.dll

[DllImport("rapi.dll")]

static extern int CeRapiInit();

[DllImport("rapi.dll")]

static extern int CeRapiUninit();

[DllImport("rapi.dll", CharSet = CharSet.Unicode)]

static extern IntPtr CeCreateFile(

  string lpFileName,

  uint dwDesiredAccess,

  int dwShareMode,

  int lpSecurityAttributes,

  int dwCreationDisposition,

  int dwFlagsAndAttributes,

  int hTemplateFile);

[DllImport("rapi.dll", CharSet = CharSet.Unicode)]

internal static extern int CeWriteFile(

    IntPtr hFile,

    byte[] lpBuffer,

    int nNumberOfbytesToWrite,

    ref int lpNumberOfbytesWritten,

    int lpOverlapped);

[DllImport("rapi.dll", CharSet = CharSet.Unicode)]

internal static extern int CeSetFileTime(

    IntPtr hFile,

    ref long lpCreationTime,

    ref long lpLastAccessTime,

    ref long lpLastWriteTime);

const int BUFFER_SIZE = 1024 * 5; // 5k transfer buffer

const int CREATE_ALWAYS = 2;

const int ERROR_SUCCESS = 0;

const int FILE_ATTRIBUTE_NORMAL = 0x80;

const uint GENERIC_WRITE = 0x40000000;

const int INVALID_HANDLE_VALUE = -1;

Now let's wrap all those in a method called CopyToDevice(string localFile, string remoteFile). The localFile is the file located on the desktop and the remoteFile is the destination filename on the device.

void CopyToDevice(string localFile, string remoteFile)

    var rapi = CeRapiInit() == ERROR_SUCCESS;

    if (!rapi)

        return;

try

        var filePtr = CeCreateFile(remoteFile, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);

        if (filePtr == new IntPtr(INVALID_HANDLE_VALUE))

            return;

        using (var localFileStream = new FileStream(localFile, FileMode.Open, FileAccess.Read))

            var byteswritten = 0;

            var position = 0;

            var buffer = new byte[BUFFER_SIZE];

            var bytesread = localFileStream.Read(buffer, position, BUFFER_SIZE);

            while (bytesread > 0)

                position += bytesread;

                if (CeWriteFile(filePtr, buffer, bytesread, ref byteswritten, 0) == ERROR_SUCCESS)

                    return;

try

                    bytesread = localFileStream.Read(buffer, 0, BUFFER_SIZE);

                catch

                    bytesread = 0;

    finally

        CeRapiUninit();

To use the code above you will have to know the full path of the file on the desktop.
I hope you found this useful.

Enumerating Bluetooth Devices from .NETCF

2010-07-29T07:47:00.011+02:00

I recently had a project where I needed to send data to Bluetooth devices. The client applications where to run in several platforms, currently only J2ME (Nokia phones) and Windows Mobile phones. Windows Mobile actually offers a pretty decent Bluetooth stack but not all devices use this. One of the devices I needed to use used the Widcomm stack. Luckily, there is an open source project called 32feet.NET which came in very handy for providing a layer over the 2 different stacks I use. The 32feet.NET library was also incredibly easy and fun to use.

In this article I'd like to demonstrate how to enumerate Bluetooth devices using .NETCF and the 32feet.NET library. The following code will work on both Microsoft and Widcomm Bluetooth stacks:

using System.Diagnostics;

using InTheHand.Net.Sockets;

namespace BluetoothSample

    static class Program

        private static void Main()

            BluetoothDeviceInfo[] devices;

            using (BluetoothClient sdp = new BluetoothClient())

                devices = sdp.DiscoverDevices();

            foreach (BluetoothDeviceInfo deviceInfo in devices)

                Debug.WriteLine(string.Format("{0} ({1})",deviceInfo.DeviceName, deviceInfo.DeviceAddress));

An interesting thing I had to consider for this project was the CPU architecture or endianness of the device I'm running on and the device I'm sending data to. I needed to reverse the byte order of the numeric data I sent and received.

Cropping an Image in .NETCF

2010-07-26T15:35:00.005+02:00

I've seen some people ask how to crop an image in .NET Compact Framework in the community. Although the operation is pretty simple, I'll share a code snippet anyway.

public static Image Crop(Image image, Rectangle bounds)

    Image newImage = new Bitmap(bounds.Width, bounds.Height);

    using (Graphics g = Graphics.FromImage(newImage))

        g.DrawImage(image,

                    new Rectangle(0, 0, newImage.Width, newImage.Height),

                    bounds,

                    GraphicsUnit.Pixel);

    return newImage;

What the code above does is to create a new image and draw part of the source image specified in the bounds to the new image.

.NET Compact Framework 3.5 Data Driven Applications

2010-07-12T23:16:00.003+02:00

I recently discovered a new book called .NET Compact Framework 3.5 Data Driven Applications. I've so far only read a few chapters but it seems like a promising book providing a lot of examples.

Here's a downloadable free chapter :
http://www.packtpub.com/data-driven-applications-with-.net-compact-framework-3-5/book?utm_source=christian-helle.blogspot.com&utm_medium=bookrev&utm_content=blog&utm_campaign=mdb_003787

I plan to write a detailed review of the book once I'm done reading it

Themed Image Button in .NETCF

2010-05-17T14:49:00.034+02:00

In this article I'd like to demonstrate how to create a themed image button control. I'll be using the same techniques in my previous article, How to draw a textured rounded rectangle and Semi-Transparent Controls in .NETCF.

First, we need to define our theme. We get the start and end gradient colors from alpha blending the SystemColors.Highlight color and Color.White

class Theme

    public static Color AlphaBlend(Color value1, Color value2, int alpha)

        int ialpha = 256 - alpha;

        return Color.FromArgb((value1.R * alpha) + (value2.R * ialpha) >> 8,

                              (value1.G * alpha) + (value2.G * ialpha) >> 8,

                              (value1.B * alpha) + (value2.B * ialpha) >> 8);

    public static Color GradientLight

get

            var color = AlphaBlend(SystemColors.Highlight, Color.White, 100);

            return AlphaBlend(Color.White, color, 50); ;

    public static Color GradientDark

get

            var color = AlphaBlend(SystemColors.Highlight, Color.Black, 256);

            return AlphaBlend(Color.White, color, 50); ;

We'll be using the GradientFill method as well in this example. For this we need to define 2 structures, TRIVERTEX and GRADIENT_RECT

struct TRIVERTEX

    private int x;

    private int y;

    private ushort Red;

    private ushort Green;

    private ushort Blue;

    private ushort Alpha;

    public TRIVERTEX(int x, int y, Color color)

        : this(x, y, color.R, color.G, color.B, color.A)

    public TRIVERTEX(

        int x, int y,

        ushort red, ushort green, ushort blue,

        ushort alpha)

        this.x = x;

        this.y = y;

        Red = (ushort)(red << 8);

        Green = (ushort)(green << 8);

        Blue = (ushort)(blue << 8);

        Alpha = (ushort)(alpha << 8);

struct GRADIENT_RECT

    private uint UpperLeft;

    private uint LowerRight;

    public GRADIENT_RECT(uint ul, uint lr)

        UpperLeft = ul;

        LowerRight = lr;

Using the 2 structures above we can now define our P/Invoke for GradientFill

[DllImport("coredll.dll")]

static extern bool GradientFill(

    IntPtr hdc,

    TRIVERTEX[] pVertex,

    int dwNumVertex,

    GRADIENT_RECT[] pMesh,

    int dwNumMesh,

    int dwMode);

Let's wrap the P/Invoke call to GradientFill in a nice method

const int GRADIENT_FILL_RECT_V = 0x00000001;

public static void GradientFill(

    this Graphics graphics,

    Rectangle rect,

    Color startColor,

    Color endColor)

    var tva = new TRIVERTEX[2];

    tva[0] = new TRIVERTEX(rect.X, rect.Y, startColor);

    tva[1] = new TRIVERTEX(rect.Right, rect.Bottom, endColor);

    var gra = new GRADIENT_RECT[] { new GRADIENT_RECT(0, 1) };

    var hdc = graphics.GetHdc();

    GradientFill(hdc, tva, tva.Length, gra, gra.Length, GRADIENT_FILL_RECT_V);

    graphics.ReleaseHdc(hdc);

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 IntPtr CreatePatternBrush(IntPtr HBITMAP);

[DllImport("coredll.dll")]

static extern bool RoundRect(

    IntPtr hdc,

    int nLeftRect,

    int nTopRect,

    int nRightRect,

    int nBottomRect,

    int nWidth,

    int nHeight);

We'll draw a textured rounded rectangle with a gradient fill that uses the current theme's Highlight color as the base color.

public static void DrawThemedGradientRectangle(

    this Graphics graphics,

    Pen border,

    Rectangle area,

    Size ellipseSize)

    using (var texture = new Bitmap(area.Right, area.Bottom))

        using (var g = Graphics.FromImage(texture))

            GradientFill(g, area, Theme.GradientLight, Theme.GradientDark);

        FillRoundedTexturedRectangle(graphics, border, texture, area, ellipseSize);

static IntPtr CreateGdiPen(Pen pen)

    var style = pen.DashStyle == DashStyle.Solid ? PS_SOLID : PS_DASH;

    return CreatePen(style, (int)pen.Width, GetColorRef(pen.Color));

public static void FillRoundedTexturedRectangle(

    this Graphics graphics,

    Pen border,

    Bitmap texture,

    Rectangle rect,

    Size ellipseSize)

    Point old = new Point();

    var hdc = graphics.GetHdc();

    var hpen = CreateGdiPen(border);

    var hbitmap = texture.GetHbitmap();

    var hbrush = CreatePatternBrush(hbitmap);

    SetBrushOrgEx(hdc, rect.Left, rect.Top, ref old);

    SelectObject(hdc, hpen);

    SelectObject(hdc, hbrush);

    RoundRect(hdc, rect.Left, rect.Top, rect.Right, rect.Bottom, ellipseSize.Width, ellipseSize.Height);

    SetBrushOrgEx(hdc, old.Y, old.X, ref old);

    DeleteObject(hpen);

    DeleteObject(hbrush);

    graphics.ReleaseHdc(hdc);

Let's wrap all the code above as extension methods to the Graphics class and use them in our owner drawn button control. A button control is one of the easiest owner drawn controls to create. Let's keep it as simple as possible and only have 2 states for our button: pressed and not pressed.

class ThemedImageButton : Control

    bool pushed = false;

    private Bitmap image;

    private Bitmap offScreen;

    public Bitmap Image

        get { return image; }

set

            image = value;

            Invalidate();

    protected override void OnResize(EventArgs e)

        base.OnResize(e);

        if (offScreen != null)

            offScreen.Dispose();

            offScreen = null;

        offScreen = new Bitmap(ClientSize.Width, ClientSize.Height);

    protected override void OnPaint(PaintEventArgs e)

        if (offScreen == null)

            offScreen = new Bitmap(ClientSize.Width, ClientSize.Height);

        using (var attributes = new ImageAttributes())

        using (var g = Graphics.FromImage(offScreen))

            if (pushed)

                using (var pen = new Pen(SystemColors.Highlight))

                    g.DrawThemedGradientRectangle(pen, ClientRectangle, new Size(4, 4));

            else

                g.Clear(Parent.BackColor);

            var textSize = g.MeasureString(Text, Font);

            var textArea = new RectangleF(

                (ClientSize.Width - textSize.Width) / 2,

                (ClientSize.Height - textSize.Height),

                textSize.Width,

                textSize.Height);

            if (Image != null)

                var imageArea = new Rectangle(

                    (ClientSize.Width - Image.Width) / 2,

                    (ClientSize.Height - Image.Height) / 2,

                    Image.Width,

                    Image.Height);

                var key = Image.GetPixel(0, 0);

                attributes.SetColorKey(key, key);

                g.DrawImage(

                    Image,

                    imageArea,

                    0, 0, Image.Width, Image.Height,

                    GraphicsUnit.Pixel,

                    attributes);

            using (var brush = new SolidBrush(ForeColor))

                g.DrawString(Text, Font, brush, textArea);

            if (pushed)

                var key = offScreen.GetPixel(0, 0);

                attributes.SetColorKey(key, key);

            else

                attributes.ClearColorKey();

            e.Graphics.DrawImage(

                offScreen,

                ClientRectangle,

                0, 0, offScreen.Width, offScreen.Height,

                GraphicsUnit.Pixel,

                attributes);

    protected override void OnPaintBackground(PaintEventArgs e)

    protected override void OnMouseDown(MouseEventArgs e)

        base.OnMouseDown(e);

        pushed = true;

        Invalidate();

    protected override void OnMouseUp(MouseEventArgs e)

        base.OnMouseUp(e);

        pushed = false;

        Invalidate();

    protected override void OnParentChanged(EventArgs e)

        base.OnParentChanged(e);

        Invalidate();

    protected override void OnTextChanged(EventArgs e)

        base.OnTextChanged(e);

        Invalidate();

I hope you found this useful. If you're interested in the full source code then you can grab it here

How to enumerate files on a Windows CE based device from the Desktop

2010-04-29T13:02:00.032+02:00

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

2010-01-27T07:41:00.039+01:00

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

2010-01-25T22:29:00.035+01:00

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

Pocket News - Newsgroup reader for Windows Mobile

2010-01-24T22:06:00.003+01:00

A few of you who know me probably have seen me from the Mobility community, MSDN Forums or the Newsgroups. I love helping out in the Newsgroups, I had so much fun doing so that I needed an application where I can do so while I'm on the go. Being the nerd that I am, my first reaction to this was that I needed to write a mobile newsgroup reader. I actually did before ever checking that a few of them already existed! Oh well, it was fun to write. I used the application a lot, especially while waiting in the airport, or for the train, or wherever that time feels like it stopped.

I decided to share this application to the public and publish it on CodePlex. If you're interested in the source code or if you want to contribute to the project then check it out at http://pocketnews.codeplex.com.

Unfortunately the application misses some basic features that any messaging application should have like a drafts folder. Maybe some day I can pull myself together to finish it up, or maybe some one out there who loves the Newsgroups just as much as I do would want to contribute some time and code :)

SQLCE Code Generator

2010-01-24T21:59:00.004+01:00

Some time ago, I started a hobby project for generating data access layer code for SQL Compact Edition databases. I managed to get as far as creating a custom tool and generating a code behind data access layer file (currently only in C#) for every table in the database.

I'm having a bit of a hard time finding the time to work on the project so I published it on CodePlex. If you're interested in the source code or if you want to contribute to the project then check it out at http://sqlcecodegen.codeplex.com/