Coding4Fun : web

use Less to reduce CSS clutter!

Coding4Fun — Fri, 11 Dec 2009 18:16:00 GMT

Reading a post by Phil Haack, I learned about a neat technology called LESS that helps reduce the amount of CSS and duplicated code you have to create. It was originally a Ruby Gem but now has a .Net port called .Less which can be found at www.dotlesscss.com.

It lets you do some amazing things like global changes and even operations!

Variable:

@brand_color: #4D926F;
 
#header {
  color: @brand_color;
}
 
h2 {
  color: @brand_color;
}

Operation:

@the-border: 1px;
@base-color: #111;
 
#header {
  color: @base-color * 3;
  border-left: @the-border;
  border-right: @the-border * 2;
}
 
#footer { 
  color: (@base-color + #111) * 1.5; 
}

bugs on your screen?

Coding4Fun — Mon, 07 Dec 2009 18:13:00 GMT

Adam Kinney created a fun example squishing bugs to show off Silverlight 4.0’s webcam support. He created simple motion detection using a diff calculation on multiple threads to figure out where his finger was to smooth the bugs! Here is a video showing off the project.

If you want to check out the source code for BugCamSmash, Adam has that along with a few other helpful hints at his blog post.

In addition, Adam is posting articles on how he created the application as well.

Jquery faster

Coding4Fun — Wed, 23 Sep 2009 21:36:03 GMT

The ASP.Net team has just announced a new free service for the public to use. If you have a website that uses jquery or the ASP.Net Ajax libraries, you can leverage our content delivery network (CDN) servers.

To implement this, on your website you just need to replace your current jquery script link with this link:

<script 
   src="http://ajax.microsoft.com/ajax/jquery/jquery-1.3.2.min.js" 
   type="text/javascript">
</script>

You can get a full listing of the JavaScript libraries (and associated URLs) we already have loaded in our CDN cache here: www.asp.net/ajax/cdn

[via ScottGu]

Silverlight 3 File Transfer Application

Coding4Fun — Fri, 04 Sep 2009 09:43:00 GMT

Author: Giovanni Montrone
Difficulty: Intermediate
Time Required: 5-10 hours
Cost: Free
Software: Visual Web Developer Express SP1 (or Visual Studio 2008 SP1), Silverlight 3 SDK, Silverlight 3 Tools for VS, Silverlight Toolkit
Hardware: None
Use it Now: Run the Application
Source Download: CodePlex

Introduction

Every once in a while I will run into a situation where I need to send a file to someone, but struggle to find an easy way of doing it. Instant messenger programs usually work until you run into a situation where someone just cannot send or receive a file from chat client whether it’s due to firewalls, differing client versions, or multi-IM incompatibilities. Other times, I will try to send the file via email just to find out that the person’s email server blocks specific extensions. This quick application will allow two users to quickly and easily connect to a Silverlight 3 client and send each other files.

Overview

In this application, a user will connect to the Silverlight application and choose to either host or join a session. If a user decides to host a session, he or she will be given a random eight character session key, and he or she will be in a waiting status until another user connects. When a user wishes to connect to the host, he or she can supply the host’s session key which will establish a connection between the two users. Once connected, the users will be able to send files to one another, and will also be able to chat with each other via simple text messages.

Polling Duplex

Sending a file from one client application to another requires a common central point in order to properly route the message from one user to another. Since it is easy to host a Silverlight application in an ASP.NET page, we will use an ASP.NET back end to manage all communications between all connected users. In order to do this, we must be able to host a service that is able to accept incoming messages from the Silverlight client, and perform a push back out to the intended recipient. This is accomplished by using the WCF Polling Duplex (System.ServiceModel.PollingDuplex.dll) channel. Silverlight 3 allows us to directly add a service reference to a service of this type, and handles all of the complexities for us. I began by using the DuplexService.cs file from a sample application from MIX09 when Silverlight 3 beta was released. The code starts us out with a couple of base abstract classes, and interfaces that we must inherit from in order to create our own service.

FileSendService

The two main things we need to do in order to create our own service is to define custom message types that will be used for communication, and override the base DuplexService class to properly handle these messages. We will create our custom message types by using DuplexMessage (defined in DuplexService.cs) as our base class. Our message classes must be defined with the [DataContract] attribute, and the the member variables must be public and contain the [DataMember] attribute. This will allow our Silverlight client project to share these definitions using a service reference. Additionally, the Duplex message class must have the [KnownType] attribute for each descendant message created.

[KnownType(typeof(HostSessionMessage))]
[KnownType(typeof(JoinSessionMessage))]
[KnownType(typeof(FileBeginUploadMessage))]
[KnownType(typeof(FileTransferBytesMessage))]
public class DuplexMessage { }

[DataContract]
public class HostSessionMessage : DuplexMessage
{
    [DataMember]
    public string Username;
}

[DataContract]
public class JoinSessionMessage : DuplexMessage
{
    [DataMember]
    public string Username;
    [DataMember]
    public string SessionKey;
}

[DataContract]
public class FileBeginUploadMessage : DuplexMessage
{
    [DataMember]
    public string FileName;
    [DataMember]
    public long TotalBytes;
}

[DataContract]
public class FileTransferBytesMessage : DuplexMessage
{
    [DataMember]
    public long StartByte;
    [DataMember]
    public long PacketSize;
    [DataMember]
    public byte[] Bytes;
    [DataMember]
    public bool EndFile;
}

<DataContract(Namespace := "http://samples.microsoft.com/silverlight2/duplex"), 
KnownType(GetType(HostSessionMessage)), KnownType(GetType(JoinSessionMessage)), KnownType(GetType(FileBeginUploadMessage)), KnownType(GetType(FileTransferBytesMessage))> _
Public Class DuplexMessage
End Class

<DataContract()> _
Public Class HostSessionMessage
    Inherits DuplexMessage
    <DataMember()> Public Username As String
End Class

<DataContract()> _
Public Class JoinSessionMessage
    Inherits DuplexMessage
    <DataMember()> Public Username As String
    <DataMember()> Public SessionKey As String
End Class

<DataContract()> _
Public Class FileTransferBytesMessage
    Inherits DuplexMessage
    <DataMember()> Public StartByte As Long
    <DataMember()> Public PacketSize As Long
    <DataMember()> Public Bytes() As Byte
    <DataMember()> Public EndFile As Boolean
End Class

<DataContract()> _
Public Class FileBeginUploadMessage
    Inherits DuplexMessage
    <DataMember()> Public FileName As String
    <DataMember()> Public TotalBytes As Long
End Class

The next step is to create our FileSendService class which descends from the DuplexService class as described above. We override the OnMessage method so that we can do custom processing based on the type of message sent as shown below.

[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class FileSendService : DuplexService
{
    private List<SessionConnectionInfo> sessionConnections = new List<SessionConnectionInfo>();

    {...}

    protected override void OnMessage(string sessionId, DuplexMessage data)
    {
        if (data is HostSessionMessage)
            CreateHostSession(data as HostSessionMessage);
        else if (data is JoinSessionMessage)
            JoinSession(data as JoinSessionMessage);
        else if (data is FileBeginUploadMessage)
            StartSendFile(data as FileBeginUploadMessage);
        else
            SendMessage(data);
    }
    
}


        else if (data is JoinSessionMessage)
            JoinSession(data as JoinSessionMessage);
        else if (data is FileBeginUploadMessage)
            StartSendFile(data as FileBeginUploadMessage);
        else
            SendMessage(data);
    }
    
}


    }
    
}

Public Class FileSenderServiceFactory
    Inherits DuplexServiceFactory(Of FileSendService)
End Class

<AspNetCompatibilityRequirements(RequirementsMode := AspNetCompatibilityRequirementsMode.Allowed)> _
Public Class FileSendService
    Inherits DuplexService
    Private sessionConnections As New List(Of SessionConnectionInfo)()

    ...

    Protected Overrides Sub OnMessage(ByVal sessionId As String, ByVal data As DuplexMessage)
        If TypeOf data Is HostSessionMessage Then
            CreateHostSession(TryCast(data, HostSessionMessage))
        ElseIf TypeOf data Is JoinSessionMessage Then
            JoinSession(TryCast(data, JoinSessionMessage))
        ElseIf TypeOf data Is FileBeginUploadMessage Then
            StartSendFile(TryCast(data, FileBeginUploadMessage))
        Else
            SendMessage(data)
        End If
    End Sub

End Class

Since we are going to have to keep track of each host and user connected to that host, we will create a class, SessionConnectionInfo, to manage the relevant data. When a user decides to host a session, our OnMessage method will receive a HostSessionMessage which will scan our List<SessionConnectionInfo> to see if there is another host with the same username. If not found, a new SessionConnectionInfo object is created along with a randomly generated session key. When a user attempts to join a session, the OnMessage method will receive a JoinSessionMessage containing a session key and the name of the user joining the session. The service will search for a SessionConnectionInfo object containing that session key, and if found, establishes a connection between the two users.

public class SessionConnectionInfo
{
    public string HostUserName { get; set; }
    public string ConnectedUsername { get; private set; }
    public string SessionKey { get; set; }

    public string ConnectedUserInternalSession { get; private set; }
    public string HostInternalSession { get; set; }

    public bool UserConnected
    {
        get { return ConnectedUserInternalSession != string.Empty; }
    }

    public SessionConnectionInfo()
    {
        ConnectedUserInternalSession = string.Empty;
        ConnectedUsername = string.Empty;
    }

    ....
}

Public Class SessionConnectionInfo
    Private privateHostUserName As String
    Public Property HostUserName() As String
        Get
            Return privateHostUserName
        End Get
        Set(ByVal value As String)
            privateHostUserName = value
        End Set
    End Property
    Private privateConnectedUsername As String
    Public Property ConnectedUsername() As String
        Get
            Return privateConnectedUsername
        End Get
        Private Set(ByVal value As String)
            privateConnectedUsername = value
        End Set
    End Property
    Private privateSessionKey As String
    Public Property SessionKey() As String
        Get
            Return privateSessionKey
        End Get
        Set(ByVal value As String)
            privateSessionKey = value
        End Set
    End Property

    Private privateConnectedUserInternalSession As String
    Public Property ConnectedUserInternalSession() As String
        Get
            Return privateConnectedUserInternalSession
        End Get
        Private Set(ByVal value As String)
            privateConnectedUserInternalSession = value
        End Set
    End Property
    Private privateHostInternalSession As String
    Public Property HostInternalSession() As String
        Get
            Return privateHostInternalSession
        End Get
        Set(ByVal value As String)
            privateHostInternalSession = value
        End Set
    End Property

    Public ReadOnly Property UserConnected() As Boolean
        Get
            Return ConnectedUserInternalSession <> String.Empty
        End Get
    End Property

    Public Sub New()
        ConnectedUserInternalSession = String.Empty
        ConnectedUsername = String.Empty
    End Sub


End Class

Client Side

Now that we have the basic server side complete, we can add a service reference, and create the necessary service reference. Our service is hosted within ASP.NET via a simple xml file (see FileSendService.svc), which allows our Silverlight project to see it.

Be sure to mark the checkbox “Always generate message contracts”. Note that your web portion of the project must be compiled before you will be able to “Discover” the service.

We will now have access to the DuplexServiceClient class which will allow us to send and receive messages to the server. We instantiate the service as shown below. In order to do this, you must manually add a reference to System.ServiceModel.PollingDuplex assembly.

private DuplexServiceClient fileDuplexService;

private CustomBinding binding = new CustomBinding(
    new PollingDuplexBindingElement(),
    new BinaryMessageEncodingBindingElement(),
    new HttpTransportBindingElement());

public MainPage()
{
    InitializeComponent();
    fileDuplexService = new DuplexServiceClient(binding, new EndpointAddress("http://localhost:9797/FileSendService.svc"));
    ...
}

Private fileDuplexService As DuplexServiceClient

Private binding As New CustomBinding(New PollingDuplexBindingElement(), New BinaryMessageEncodingBindingElement(), New HttpTransportBindingElement())
    
Public Sub New()
    InitializeComponent()
    fileDuplexService = New DuplexServiceClient(binding, New EndpointAddress("http://localhost:9797/FileSendService.svc"))
End Sub

Note that at the time of this writing, adding the service reference does not properly create the ServiceReferences.ClientConfig file. This is the reason the above is done using code.

Now that our service is setup, we need to set it up to handle sending and receiving of messages. In order to send a message, we must first create a DupexMessage (or a descendant), and use the SendToServiceAsync method. This requires a SendToService object which will contain the message, and an optional userState object which we can use to tag the request. In this case, we will pass an enum value which represents the status of our upload. In the example below, when the user clicks on the send file button, after choosing the file, we open our file, and send a FileBeginUpload message which contains the file name and its size. Note that the server is set to deny any file that is greater than 20 million bytes.

private void btnSendFile_Click(object sender, RoutedEventArgs e)
 {
     OpenFileDialog openFileDialog = new OpenFileDialog();
     openFileDialog.Multiselect = false;
     openFileDialog.ShowDialog();
     if (openFileDialog.File != null)
     {
         fileToSend = openFileDialog.File.OpenRead();

         FileBeginUploadMessage fsm = new FileBeginUploadMessage();
         fsm.FileName = openFileDialog.File.Name;
         fsm.TotalBytes = openFileDialog.File.Length;
         fileDuplexService.SendToServiceAsync(new SendToService(fsm), FileSendState.FileStart);
         ....
     }
 }

Private Sub btnSendFile_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    Dim openFileDialog As New OpenFileDialog()
    openFileDialog.Multiselect = False
    openFileDialog.ShowDialog()
    If openFileDialog.File IsNot Nothing Then
        fileToSend = openFileDialog.File.OpenRead()
        Dim fsm As New FileBeginUploadMessage()
        fsm.FileName = openFileDialog.File.Name
        fsm.TotalBytes = openFileDialog.File.Length
        totalBytesSent = 0
        fileDuplexService.SendToServiceAsync(New SendToService(fsm), FileSendState.FileStart)
        ....
    End If
End Sub

The service object fires two main events that need to be handled: SendToServiceCompleted and SendToClientReceived. SendToServiceCompleted is the event which is fired after the server acknowledges that it has received and processed a message that the client has sent. Once the server receives and processes the FileBeginUploadMessage, the event handler below will receive the results. In this case, if there isn’t an error, and the value of userState is FileSendState.FileStart, the method will send a FileTransferBytesMessage which will send the bytes from the file.

private void FileDuplexServiceSendToServiceCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
{
    if (e.Error == null)
    {
        {...}
        if ((FileSendState)e.UserState == FileSendState.FileEnd)
        {
            fileToSend.Close();
            fileProgress.Value = 100;
            return;
        }
        if ((FileSendState)e.UserState == FileSendState.FileStart || (FileSendState)e.UserState == FileSendState.FileContinue)
        {

            ...
            FileTransferBytesMessage fileMessage = new FileTransferBytesMessage();
            fileMessage.StartByte = totalBytesSent;
            fileMessage.EndFile = false;
            fileMessage.PacketSize = CHUNK;

            ...

            byte[] bytes = new byte[numBytesToRead];
            fileToSend.Read(bytes, 0, numBytesToRead);
            totalBytesSent += numBytesToRead;
            fileMessage.Bytes = bytes;

            if (fileMessage.EndFile)
                fileDuplexService.SendToServiceAsync(new SendToService(fileMessage), FileSendState.FileEnd);
            else
                fileDuplexService.SendToServiceAsync(new SendToService(fileMessage), FileSendState.FileContinue);
        }
    }
}

Private Sub FileDuplexServiceSendToServiceCompleted(ByVal sender As Object, ByVal e As System.ComponentModel.AsyncCompletedEventArgs)
    If e.Error Is Nothing Then
        If e.UserState Is Nothing Then
            Return
        End If
        If CType(e.UserState, FileSendState) = FileSendState.FileEnd Then
            fileToSend.Close()
            fileProgress.Value = 100
            Return
        End If
        If CType(e.UserState, FileSendState) = FileSendState.FileStart OrElse CType(e.UserState, FileSendState) = FileSendState.FileContinue Then
            ...
            Dim fileMessage As New FileTransferBytesMessage()
            fileMessage.StartByte = totalBytesSent
            fileMessage.EndFile = False
            fileMessage.PacketSize = CHUNK
            ...
            Dim bytes(numBytesToRead - 1) As Byte
            fileToSend.Read(bytes, 0, numBytesToRead)
            totalBytesSent += numBytesToRead
            fileMessage.Bytes = bytes

            If fileMessage.EndFile Then
                fileDuplexService.SendToServiceAsync(New SendToService(fileMessage), FileSendState.FileEnd)
            Else
                fileDuplexService.SendToServiceAsync(New SendToService(fileMessage), FileSendState.FileContinue)
            End If
        End If
    End If
End Sub

The SendToClientReceived event is fired when a message has been sent from the service. In this case, the client will check to see which message was received and process it accordingly. The method below shows that when a FileBeginUpload message is received, the user is prompted to accept or deny the file. If the user does not accept the file, a FileDenyMessage will be sent which will notify the sender to stop sending bytes. If accepted, file bytes are added to a buffer.

private void FileDuplexServiceSendToClientReceived(object sender, SendToClientReceivedEventArgs e)
{
    if (e.Error == null)
    {
        if (e.request.msg is ClientConnectedMessage)
        {
            ClientConnectedMessage msg = (ClientConnectedMessage)e.request.msg;
            AddMsgToListbox(msg.Username + " has just connected.");
            connectedTo = msg.Username;
            UIState = UIState.Chat;
        }

        else if (e.request.msg is HostSessionServerMessage)
        {
            HostSessionServerMessage hssm = e.request.msg as HostSessionServerMessage;
            if (hssm.Failed) {...}
            SessionCreated(hssm);

        }
        else if (e.request.msg is JoinSessionServerMessage)
        {
            JoinSessionServerMessage jssm = e.request.msg as JoinSessionServerMessage;
            if (jssm.Failed) {....}
            SessionJoined(jssm);
        }
        else if (e.request.msg is FileBeginUploadMessage )
        {
            FileBeginUploadMessage fsm = (FileBeginUploadMessage)e.request.msg;

            int sizeInKB = (int)fsm.TotalBytes / 1024;
            totalRevd = 0;
            if (MessageBox.Show(connectedTo + " would like to send you the file: " + fsm.FileName + ", Size: " + sizeInKB + ".  Would you like to receive this file?", "File Upload", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
            {
                bytesReceived = new List<byte>((int)fsm.TotalBytes);
                fileNameReceiving = fsm.FileName;
                ....
            }
            else
            {
                fileDuplexService.SendToServiceAsync(new SendToService(new FileDenyMessage()));
            }
        }
        else if (e.request.msg is FileTransferBytesMessage)
        {
            if (bytesReceived == null)
                return;
            FileTransferBytesMessage fm = (FileTransferBytesMessage)e.request.msg;
            bytesReceived.AddRange(fm.Bytes);
            ....
        }
        else {....}

    }
}

Private Sub FileDuplexServiceSendToClientReceived(ByVal sender As Object, ByVal e As SendToClientReceivedEventArgs)
    If e.Error Is Nothing Then
        If TypeOf e.request.msg Is ClientConnectedMessage Then
            Dim msg As ClientConnectedMessage = CType(e.request.msg, ClientConnectedMessage)
            AddMsgToListbox(msg.Username & " has just connected.")
            connectedTo = msg.Username
            UIState = UIState.Chat

        ElseIf TypeOf e.request.msg Is HostSessionServerMessage Then
            Dim hssm As HostSessionServerMessage = TryCast(e.request.msg, HostSessionServerMessage)
            If hssm.Failed Then ...

            SessionCreated(hssm)

        ElseIf TypeOf e.request.msg Is JoinSessionServerMessage Then
            Dim jssm As JoinSessionServerMessage = TryCast(e.request.msg, JoinSessionServerMessage)
            If jssm.Failed Then ...

            SessionJoined(jssm)
        ElseIf TypeOf e.request.msg Is FileBeginUploadMessage Then
            Dim fsm As FileBeginUploadMessage = CType(e.request.msg, FileBeginUploadMessage)

            Dim sizeInKB As Integer = CInt(Fix(fsm.TotalBytes)) / 1024
            totalRevd = 0
            If MessageBox.Show(connectedTo & " would like to send you the file: " & fsm.FileName & ", Size: " & sizeInKB & " KB.  Would you like to receive this file?", "File Upload", MessageBoxButton.OKCancel) = MessageBoxResult.OK Then
                bytesReceived = New List(Of Byte)(CInt(Fix(fsm.TotalBytes)))
                fileNameReceiving = fsm.FileName
                ...
            Else
                fileDuplexService.SendToServiceAsync(New SendToService(New FileDenyMessage()))
            End If
        ElseIf TypeOf e.request.msg Is FileTransferBytesMessage Then
            If bytesReceived Is Nothing Then
                Return
            End If
            Dim fm As FileTransferBytesMessage = CType(e.request.msg, FileTransferBytesMessage)
            bytesReceived.AddRange(fm.Bytes)
            ...
        ElseIf 
          ...

    End If
End Sub

When the file is complete, the user will be presented with two buttons. One button will allow the user to save, and the other will allow the user to discard/ignore the file. If the user chooses to save, a SaveFileDialog is created, and we use the filename to assign the default extension and filter so that when the user saves the file, no extension needs to be typed in. Once the dialog appears and the user enters the file name, the bytes will be written to disk. Finally we send a message back to the server which will notify the sender that user has done something with the file. During file send operations, the Send File button is disabled, and becomes re-enabled once a file has been received, cancelled, or denied.

private void btnSaveFile_Click(object sender, RoutedEventArgs e)
{
    SaveFileDialog sfd = new SaveFileDialog();
    string extension = GetExtension(fileNameReceiving);
    sfd.DefaultExt = extension;
    sfd.Filter = extension +  " Files|" + extension;

    if (sfd.ShowDialog() == true)
    {
        using (Stream fsx = sfd.OpenFile())
        {
            byte[] fBytes = bytesReceived.ToArray();
            fsx.Write(fBytes, 0, fBytes.Length);
            fsx.Close();
        }

        fileDuplexService.SendToServiceAsync(new SendToService(new FileReceivedMessage()));
        UIState = UIState.Chat;
        btnSendFile.IsEnabled = true;
    }
}

Private Sub btnSaveFile_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    Dim sfd As New SaveFileDialog()
    Dim extension As String = GetExtension(fileNameReceiving)
    sfd.DefaultExt = extension
    sfd.Filter = extension & " Files|" & extension

    If sfd.ShowDialog() = True Then
        Using fsx As Stream = sfd.OpenFile()
            Dim fBytes() As Byte = bytesReceived.ToArray()
            fsx.Write(fBytes, 0, fBytes.Length)
            fsx.Close()
        End Using

        fileDuplexService.SendToServiceAsync(New SendToService(New FileReceivedMessage()))
        UIState = UIState.Chat
        btnSendFile.IsEnabled = True
    End If
End Sub

Conclusion

Overall, the application does what I set out for it to. It allows a user to send a file to another user and even does basic chat. There is definitely a lot of room for improvement, and some general additions that can make this more robust. Right now we keep a list of connections, but never do basic pinging to see if the clients are still there. The only way to know if a client has disconnected is when a message fails, or when the user decides to hit the disconnect button. Better maintenance of this list is needed. The file bytes are basically being stored in memory, which is why i set a file size limit, but I’m sure with things like Silverlight local storage, we can increase the limit.

Thanks

I would like to thank Brian Peek for taking the time to review my article and test the code.

Additional Notes

The ASP.NET project requires a file called System.ServiceModel.PollingDuplex.dll to be added as a reference. Somewhere between Silverlight 3 Beta and Silverlight 3 RTW, the file was no longer available via the basic add .NET reference link. In order to add the file, I had to browse for it in %Program Files%\Microsoft SDKs\Silverlight\v3.0\Libraries\Server. For 64 bit users, it will be the Program Files (x86) folder.

For ease of use, I used a static port (9797) for this project. When deploying to a server, you must rename all references of http://localhost:9797 in the Silverlight project. This will remain true until the config file is supported.

The user interface uses the Silverlight Toolkit TwilightBlue theme. For more information about this, see http://www.codeplex.com/Silverlight

Download and Play Popfly Games Offline

Coding4Fun — Wed, 22 Jul 2009 21:59:47 GMT

With the announcement that the Popfly Game Creator will be shut down starting August 24th, we’ve published the Popfly Game Downloader, a utility to download Popfly games while the Popfly service is still running so you can play them even after the Popfly service is shut down!

Authors: Ben Anderson and Adam Nathan

Download: Popfly Game Downloader (Project Page)

Difficulty: Beginner

Time Required: 15 minutes

Cost: $0

Software Needed: .NET Framework 2.0 or higher, Silverlight 3.0 or higher

Note: This tool hasn’t been fully tested on multiple operating systems. Some games may not work properly offline.

Step 1: Download Popfly Game Downloader

Download the zip file for the Popfly Game Downloader to a directory, say on your desktop and unzip the file as shown in the figure below.

Step 2: Run Popfly Game Downloader

Next, double click “PopflyGameDownloader.exe” and click Run or “Accept” if you get a security warning to run the file.

The Popfly Game Downloader should then open as shown below.

From inside the Popfly Game Downloader, you can download any Popfly Game that has been shared, including:

Popfly games built by the community
Your personal Popfly game projects

Downloading mashups for offline use is not supported given that the mashups require connections to live services. Similarly, private games that have not been shared publicly cannot be downloaded either.

Step 4: Downloading a community game

For example purposes, let’s download the Chicken Long Jump game. To do this, in the Search text box, enter “Chicken Long Jump” and click the Go button to start the search. Click the link for the first option in the search results as shown below.

Step 4a: The Download prompt

This will take you to the game home page and, after a few seconds, you’ll notice a new yellow colored bar at the top of the page that gives you an option to download the game.

Step 4b: Downloading a Game

Click on the link and Popfly Game Downloader will begin downloading the game. You’ll be able to see detailed progress information while Popfly Game downloader builds the offline version of the game.

When it’s finished downloading, you’ll see a notice that the status message changes to Done. You can then click the link to launch a local copy of the game!

Step 5: Run your newly downloaded game

Clicking on the link will open a new browser window to a html file that includes the offline version of the Popfly game.

Step 6: Bulk downloading a user’s projects

Another handy feature that you can use to download either all of your shared projects (the project must be set to shared) or all projects built by a specific Popfly user is the Online Bulk Download feature. Switch back to the Popfly Game Downloader and click on the Online Bulk Download tab.

From here, enter the user name of Popfly user who’s games you want to download. For example, to download all of the games Adam Nathan built (http://popfly.com/users/adam/), enter “adam” in the download text box and hit enter.

This will start downloading all of the games that Adam has created. You can remove a specific game by clicking the X next to the name of the game.

Viewing the Games You’ve Downloaded

Once you’ve finished downloading all of the projects you’re interested in, you can see the list of all of the games you’ve downloaded by switching to the Offline tab Popfly Game Downloader.

Now that you’ve downloaded the games, if you switch back to the directory that you put the PopflyGameDownloader.exe in, you’ll see a folder for each of the games that you downloaded (using the format “PopflyUserName.ProjectName”).

Inside each directory is the Silverlight application for the game (the .xap file) and an index.html file that hosts the .xap file.

You can now play games like Crayon Cannon to your heart’s content :)

How does it work?

When you click the “download” link, Popfly Game Downloader goes to the game you selected and does a number of things, including:

It downloads all of the game assets (audio, images, XAML)
It dynamically builds a .xap file including all of the game assets
It also removes server-side features like the high-score and achievement services
Finally, it builds an index.html file to host the Silverlight game

Conclusion

While it’s sad that one of our favorite Microsoft services is shutting down, we can at least take solace in the fact that Popfly users can download and play with their creations long after the Popfly service is shut down.

Creating Games with Silverlight: A Simple Shooter

Coding4Fun — Tue, 21 Jul 2009 20:19:00 GMT

This article will take you through some of the steps to creating the basics for writing games with Silverlight. This is a simple shooter style game that contains some of the building blocks for games that require abilities such as vectors, collision detection, a game loop, movement, and keyboard input. Please refer to the full source code for this project for any areas of the code that are not covered in detail in this article.

Source Code: http://simpleshooter.codeplex.com/
Difficulty: Beginner/Intermediate
Time Required: 3 hours
Cost: $0
Software Needed:
- Visual Basic or Visual C# Express
- Expression Blend (optional)

Inspiration

There are a number of examples and tutorials out there to help get started creating games. You will find the basics of this game to be very similar to a Visual C# Coding4Fun article here. This article will show you how to create a shooter style game in Silverlight. My first Silverlight game experience was playing with a Asteroids style game by Bill Reiss. My usage of vectors and how to do a game loop came from great examples like his and others. There are a number of sites and blogs where you can get good info on game development with Silverlight. Here are just a few.

Basic Layout

To begin, Open Visual Studio and create a new Silverlight Application in either C# or VB.net. First, we will start with the layout of the screen. First, I added a canvas to the grid inside the Page.xaml that is created for you. I set it's background to black, and named it 'gameRoot'.

<UserControl x:Class="SimpleShooter.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    Width="400" Height="300">
   <Grid x:Name="LayoutRoot">
        <Canvas x:Name="gameRoot" Width="500" Height="400" Background="Black" >
        </Canvas>
    </Grid>
</UserControl>

Next we will start adding controls to our project for things like game entities, and information displays. In this example. To complete layout of the game, add user controls to the progect called: Info, LivesRemaining, Score, and WaveInfo. In those controls, To begin I added basic TextBlocks to display information on the state of the game. Please note there are better ways to arrange things in a user control, beyond what I show here. I am keeping to a simple canvas and direct positioning to introduce the concept of Canvas.Top and Canvas.Left. I have now placed these controls on Page.xaml and assigned an x:Name to each. At this point, the controls have only a TextBlock in them.

<UserControl x:Class="SimpleShooter.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:SimpleShooter="clr-namespace:SimpleShooter"
    Width="500" Height="400">
    <Grid x:Name="LayoutRoot">
        <Canvas x:Name="gameRoot" Width="500" Height="400" Background="Black">
            <SimpleShooter:RemainingLives x:Name="ctlLives" Canvas.Top="380" Canvas.Left="10" />
            <SimpleShooter:Score x:Name="ctlScore" Canvas.Top="10" Canvas.Left="10" />
            <SimpleShooter:WaveInfo x:Name="ctlWaveInfo" Canvas.Left="440" Canvas.Top="10" />
            <SimpleShooter:Info x:Name="ctlInfo" Canvas.Top="10"/>
        </Canvas>
    </Grid>
</UserControl>

To finish our layout lets add a star field. To do this, we will write function to generate random numbers, and another that will randomly distribute ellipses on our base canvas. We will need to inherit from System.Security.Cryptography for this:

public partial class Page : UserControl
{
    public Page()
    {
        InitializeComponent();

        GenerateStarField(350);
    }

    void GenerateStarField(int numberOfStars)
    {

        for (int i = 0; i < numberOfStars; i++)
        {

            Ellipse star = new Ellipse();
            double size = GetRandInt(10, 800) * .01;
            star.Width = size;
            star.Height = size;
            star.Opacity = GetRandInt(1, 5) * .1;
            star.Fill = new SolidColorBrush(Colors.White);
            int x = GetRandInt(0, (int)Math.Round(gameRoot.Height, 0));
            int y = GetRandInt(0, (int)Math.Round(gameRoot.Width, 0));
            star.SetValue(Canvas.TopProperty, (double)x);
            star.SetValue(Canvas.LeftProperty, (double)y);
            gameRoot.Children.Add(star);
        }
    }

    public int GetRandInt(int min, int max)
    {
        Byte[] rndBytes = new Byte[10];
        RNGCryptoServiceProvider rndC = new RNGCryptoServiceProvider();
        rndC.GetBytes(rndBytes);
        int seed = BitConverter.ToInt32(rndBytes, 0);
        Random rand = new Random(seed);
        return rand.Next(min, max);
    }
}

Partial Public Class Page
    Inherits UserControl

    Public Sub New()
        InitializeComponent()
        GenerateStarField(350)
    End Sub

    Private Sub GenerateStarField(ByVal numberOfStars As Integer)

        For i As Integer = 0 To numberOfStars - 1

            Dim star As New Ellipse()
            Dim size As Double = GetRandInt(10, 800) * 0.01
            star.Width = size
            star.Height = size
            star.Opacity = GetRandInt(1, 5) * 0.1
            star.Fill = New SolidColorBrush(Colors.White)
            Dim x As Integer = GetRandInt(0, CInt(Math.Round(gameRoot.Height, 0)))
            Dim y As Integer = GetRandInt(0, CInt(Math.Round(gameRoot.Width, 0)))
            star.SetValue(Canvas.TopProperty, CDbl(x))
            star.SetValue(Canvas.LeftProperty, CDbl(y))
            gameRoot.Children.Add(star)
        Next
    End Sub

    Public Function GetRandInt(ByVal min As Integer, ByVal max As Integer) As Integer
        Dim rndBytes As [Byte]() = New [Byte](9) {}
        Dim rndC As New RNGCryptoServiceProvider()
        rndC.GetBytes(rndBytes)
        Dim seed As Integer = BitConverter.ToInt32(rndBytes, 0)
        Dim rand As New Random(seed)
        Return rand.[Next](min, max)
    End Function
End Class

We now have a function called GenerateStarField. Note that it is adding each ellipse to the 'Children' of our base gameRoot canvas, and how the Top and Left properties determine the positions of those ellipses. Now we have a basic layout of our game and a background.

Sprites and Vectors

I am not going to go in to great detail on sprites or vectors. There are a number of great resources (see other articles linked to in this post), as well as another good Coding4Fun article on this topic. We are however, going to add a class to represent a sprite and a vector to our code:

public abstract class Sprite
{
    public double Width { get; set; }
    public double Height { get; set; }
    public Vector Velocity { get; set; }
    public Canvas SpriteCanvas { get; set; }
    private Point _position;
    public Point Position
    {
        get
        {
            return _position;
        }
        set
        {
            _position = value;
            SpriteCanvas.SetValue(Canvas.TopProperty, _position.Y - (Height / 2));
            SpriteCanvas.SetValue(Canvas.LeftProperty, _position.X - (Width / 2));
        }
    }

    public Sprite(Double width, Double height, Point position)
    {
        Width = width;
        Height = height;

        SpriteCanvas = RenderSpriteCanvas();

        SpriteCanvas.Width = width;
        SpriteCanvas.Height = height;
        //NOTE: because the setter for Position uses both Height and Width, it is important this comes after they are set.
        Position = position;
    }

    public abstract Canvas RenderSpriteCanvas();

    public Canvas LoadSpriteCanvas(string xamlPath)
    {
        System.IO.Stream s = this.GetType().Assembly.GetManifestResourceStream(xamlPath);
        return (Canvas)XamlReader.Load(new System.IO.StreamReader(s).ReadToEnd());
    }

    public virtual void Update(TimeSpan elapsedTime)
    {
        Position = (Position + Velocity * elapsedTime.TotalSeconds);
    }
}

Public MustInherit Class Sprite
    Private _Width As Double
    Public Property Width() As Double
        Get
            Return _Width
        End Get
        Set(ByVal value As Double)
            _Width = value
        End Set
    End Property
    Private _Height As Double
    Public Property Height() As Double
        Get
            Return _Height
        End Get
        Set(ByVal value As Double)
            _Height = value
        End Set
    End Property
    Private _Velocity As Vector
    Public Property Velocity() As Vector
        Get
            Return _Velocity
        End Get
        Set(ByVal value As Vector)
            _Velocity = value
        End Set
    End Property
    Private _SpriteCanvas As Canvas
    Public Property SpriteCanvas() As Canvas
        Get
            Return _SpriteCanvas
        End Get
        Set(ByVal value As Canvas)
            _SpriteCanvas = value
        End Set
    End Property
    Private _position As Point
    Public Property Position() As Point
        Get
            Return _position
        End Get
        Set(ByVal value As Point)
            _position = value
            SpriteCanvas.SetValue(Canvas.TopProperty, _position.Y - (Height / 2))
            SpriteCanvas.SetValue(Canvas.LeftProperty, _position.X - (Width / 2))
        End Set
    End Property

    Public Sub New(ByVal initialWidth As [Double], ByVal initialHeight As [Double], ByVal initialPosition As Point)
        Width = initialWidth
        Height = initialHeight

        SpriteCanvas = RenderSpriteCanvas()

        SpriteCanvas.Width = Width
        SpriteCanvas.Height = Height
        'NOTE: because the setter for Position uses both Height and Width, it is important this comes after they are set. 
        Position = initialPosition
    End Sub

    Public MustOverride Function RenderSpriteCanvas() As Canvas

    Public Function LoadSpriteCanvas(ByVal xamlPath As String) As Canvas
        Dim s As System.IO.Stream = Me.[GetType]().Assembly.GetManifestResourceStream(xamlPath)
        Return DirectCast(XamlReader.Load(New System.IO.StreamReader(s).ReadToEnd()), Canvas)
    End Function

    Public Overridable Sub Update(ByVal elapsedTime As TimeSpan)
        Position = (Position + Velocity * elapsedTime.TotalSeconds)
    End Sub
End Class

This Sprite class will give us the basis for entities in the game such as a ship, aliens, and projectiles. For all these items, we need to know the location of the item, the site, and what it looks like. We will take advantage of Point to track our position, and a property of type Canvas to display the XAML for each of these items. The constructor sets these initial parameters, and calls a RenderSpriteCanvas method to be implemented by each class that inherits from it. This method allows the inheriting class to set the contents of the canvas and therefore as control of the way the sprite looks.

Next we have our vector class that will help us control movement of our sprite. Again, I will not go into detail on vectors as this code is borrowed and adapted from many other readily available sources:

public struct Vector
{
    public double X;
    public double Y;

    public Vector(double x, double y)
    {
        X = x;
        Y = y;
    }

    public double Length
    {
        get
        {
            return Math.Sqrt(LengthSquared);
        }
    }

    public double LengthSquared
    {
        get
        {
            return X * X + Y * Y;
        }
    }

    public void Normalize()
    {
        double length = Length;
        X /= length;
        Y /= length;
    }

    public static Vector operator -(Vector vector)
    {
        return new Vector(-vector.X, -vector.Y);
    }

    public static Vector operator *(Vector vector, double scalar)
    {
        return new Vector(scalar * vector.X, scalar * vector.Y);
    }

    public static Point operator +(Point point, Vector vector)
    {
        return new Point(point.X + vector.X, point.Y + vector.Y);
    }

    static public Vector CreateVectorFromAngle(double angleInDegrees, double length)
    {
        double x = Math.Sin(DegreesToRadians(180 - angleInDegrees)) * length;
        double y = Math.Cos(DegreesToRadians(180 - angleInDegrees)) * length;
        return new Vector(x, y);
    }

    static public double DegreesToRadians(double degrees)
    {
        double radians = ((degrees / 360) * 2 * Math.PI);
        return radians;
    }
}

Public Structure Vector
    Public X As Double
    Public Y As Double

    Public Sub New(ByVal x__1 As Double, ByVal y__2 As Double)
        X = x__1
        Y = y__2
    End Sub

    Public ReadOnly Property Length() As Double
        Get
            Return Math.Sqrt(LengthSquared)
        End Get
    End Property

    Public ReadOnly Property LengthSquared() As Double
        Get
            Return X * X + Y * Y
        End Get
    End Property

    Public Sub Normalize()
        Dim length__1 As Double = Length
        X /= length__1
        Y /= length__1
    End Sub

    Public Shared Operator -(ByVal vector As Vector) As Vector
        Return New Vector(-vector.X, -vector.Y)
    End Operator

    Public Shared Operator *(ByVal vector As Vector, ByVal scalar As Double) As Vector
        Return New Vector(scalar * vector.X, scalar * vector.Y)
    End Operator

    Public Shared Operator +(ByVal point As Point, ByVal vector As Vector) As Point
        Return New Point(point.X + vector.X, point.Y + vector.Y)
    End Operator


    Public Shared Function CreateVectorFromAngle(ByVal angleInDegrees As Double, ByVal length As Double) As Vector
        Dim x As Double = Math.Sin(DegreesToRadians(180 - angleInDegrees)) * length
        Dim y As Double = Math.Cos(DegreesToRadians(180 - angleInDegrees)) * length
        Return New Vector(x, y)
    End Function

    Public Shared Function DegreesToRadians(ByVal degrees As Double) As Double
        Dim radians As Double = ((degrees / 360) * 2 * Math.PI)
        Return radians
    End Function
End Structure

Now we can implement Sprite with a new Ship class. Add a class called Ship, and a file called Ship.xaml to your project. Be sure to set the properties of Ship.xaml to 'Embedded Resource'. We now need to inherit from our Sprite class:

public class Ship : Sprite
{
    public Ship(double width, double height, Point firstPosition)
        : base(width, height, firstPosition)
    {

    }

    public override Canvas RenderSpriteCanvas()
    {
        return LoadSpriteCanvas("SimpleShooter.Sprites.Ship.xaml");
    }
}

Public Class Ship
    Inherits Sprite
    Public Sub New(ByVal width As Double, ByVal height As Double, ByVal firstPosition As Point)
        MyBase.New(width, height, firstPosition)

    End Sub

    Public Overloads Overrides Function RenderSpriteCanvas() As Canvas
        Return LoadSpriteCanvas("SimpleShooter.Ship.xaml")
    End Function
End Class

When Ship is instantiated, it calls the constructor of it's base, Sprite. It also implements the RenderSpriteCanvas method and specifies the XAML (a simple white square) to load into the sprite's canvas. Now we are ready to add a sprite to our main page. In this simple game, we will have only one ship (the others will be aliens), so lets add a property to our page, and a function that will instantiate our ship:

<Canvas x:Name="LayoutRoot" Width="30" Height="30" 
    xmlns="http://schemas.microsoft.com/client/2007"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" >
    <Rectangle Height="30" Width="30" Fill="White" />
</Canvas>

void InitializeGame()
{
    PlayerShip = new Ship(10, 10, new Point(100, 300));
    gameRoot.Children.Add(PlayerShip.SpriteCanvas);
}

Private Sub InitializeGame()
    PlayerShip = New Ship(10, 10, New Point(100, 300))
    gameRoot.Children.Add(PlayerShip.SpriteCanvas)
End Sub

We can now call this method from our page constructor and when we run the project, we get a white square (our ship) at the bottom left of our Page. Taking a closer look, we set our page size to 500 x 400, and the InitializeGame method places our Ship at a point 100 pixels from the left of the gameRoot canvas, and 300pixels from the top.

Keyboard Input and the Game Loop

Now we are ready to make some things move. To start, we need choose keys on the keyboard to allow movement, and act on those events. We then need to capture those key presses and act on them if they are relevant to our game loop. Once again, may examples of key handlers and game loops are readily available, so I won't go into detail. The keyboard handler captures all key up and down events. We can therefore ask our instance of the handler if a key is pressed at any given time. The game loop is just that, a constant loop. It consists of a storyboard that has the start called on it and it immediately ends. The class raises an event, and starts the storyboard again. Subscribers to Update event are provided a value that reports the number of milliseconds since the last update. That value can be applied to vectors to apply smooth movement to sprites. To take advantage of these classes, we need to add an instance of both a KeyHandler and GameLoop to our Page. To do this, we update the InitializeGame and Page constructor, and add a handler for the GameLoop:

public Page()
{
    InitializeComponent();
    keyHandler = new KeyHandler(this);
    GenerateStarField(350);
    InitializeGame();
}

void InitializeGame()
{
    gameLoop = new GameLoop(this);
    gameLoop.Update += new GameLoop.UpdateHandler(gameLoop_Update);

    PlayerShip = new Ship(10, 10, new Point(100, 360));
    gameRoot.Children.Add(PlayerShip.SpriteCanvas);

    gameLoop.Start();
}

void gameLoop_Update(TimeSpan elapsed)
{
    //clear the current vector so the sprite is not moving unless a keys is pressed
    PlayerShip.Velocity = new Vector(0, 0);
    if (keyHandler.IsKeyPressed(Key.Left))
    {
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(270, 125);
    }
    if (keyHandler.IsKeyPressed(Key.Right))
    {
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(90, 125);
    }
    PlayerShip.Update(elapsed);
}

Public Sub New()
    InitializeComponent()
    keyHandler = New KeyHandler(Me)
    GenerateStarField(350)
    InitializeGame()
End Sub

Private Sub InitializeGame()
    gameLoop = New GameLoop(Me)
    AddHandler gameLoop.Update, AddressOf gameLoop_Update

    PlayerShip = New Ship(10, 10, New Point(100, 360))
    gameRoot.Children.Add(PlayerShip.SpriteCanvas)

    gameLoop.Start()
End Sub

Private Sub gameLoop_Update(ByVal elapsed As TimeSpan)
    'clear the current vector so the sprite is not moving unless a keys is pressed 
    PlayerShip.Velocity = New Vector(0, 0)
    If keyHandler.IsKeyPressed(Key.Left) Then
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(270, 125)
    End If
    If keyHandler.IsKeyPressed(Key.Right) Then
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(90, 125)
    End If

    PlayerShip.Update(elapsed)
End Sub

Now we have a functioning game loop. Launch the app, click on the Silverlight control to give it focus, and you can now use the arrow keys to move our ship right and left. One problem however is that you are able to take the ship completely off the screen. To prevent this, we can add MinX and MaxX properties to our ship class and override the Update method it inherits from Sprite. Be sure to also add those min and max values after the Ship is instantiated in InitializeGame of our Page:

public class Ship : Sprite
{
    public double MaxX { get; set; }
    public double MinX { get; set; }

    public Ship(double width, double height, Point firstPosition)
        : base(width, height, firstPosition)
    {

    }

    public override Canvas RenderSpriteCanvas()
    {
        return LoadSpriteCanvas("SimpleShooter.Sprites.Ship.xaml");
    }

    public override void Update(System.TimeSpan elapsedTime)
    {
        //verify that this is a position we can move to
        if (Position.X > MaxX)
        {
            Position = new Point(MaxX, Position.Y);
            Velocity = new Vector(0, 0);
        }
        if (Position.X < MinX)
        {
            Position = new Point(MinX, Position.Y);
            Velocity = new Vector(0, 0);
        }
        base.Update(elapsedTime);
    }
}

Public Class Ship
    Inherits Sprite
    Private _MaxX As Double
    Public Property MaxX() As Double
        Get
            Return _MaxX
        End Get
        Set(ByVal value As Double)
            _MaxX = value
        End Set
    End Property
    Private _MinX As Double
    Public Property MinX() As Double
        Get
            Return _MinX
        End Get
        Set(ByVal value As Double)
            _MinX = value
        End Set
    End Property

    Public Sub New(ByVal width As Double, ByVal height As Double, ByVal firstPosition As Point)
        MyBase.New(width, height, firstPosition)

    End Sub

    Public Overloads Overrides Function RenderSpriteCanvas() As Canvas
        Return LoadSpriteCanvas("SimpleShooter.Ship.xaml")
    End Function

    Public Overloads Overrides Sub Update(ByVal elapsedTime As System.TimeSpan)
        'verify that this is a position we can move to 
        If Position.X > MaxX Then
            Position = New Point(MaxX, Position.Y)
            Velocity = New Vector(0, 0)
        End If
        If Position.X < MinX Then
            Position = New Point(MinX, Position.Y)
            Velocity = New Vector(0, 0)
        End If
        MyBase.Update(elapsedTime)
    End Sub
End Class

Prepare to Fire!

We now have all the basic plumbing to add additional sprites such as aliens or projectiles. To begin, we will add additional classes inheriting from Sprite: Alien, Missle, and Bomb, along with Alien.xaml, Missle.xaml, and Bomb.xaml (these new .xaml files need to be set as Embedded Resources). These xaml files are just like our Ship.xaml with different sizes and colors. Make the Aliens and their bombs red, and shrink the bomb and missile height and width to 5. The xaml is very similar, but the classes themselves are going to have a few differing capabilities. Bomb and Missile are very similar. They only need to load their corresponding xaml. Here is our Bomb class for example:

public class Bomb : Sprite
{
    public double MaxX { get; set; }
    public double MinX { get; set; }

    public Bomb(double width, double height, Point firstPosition)
        : base(width, height, firstPosition)
    {

    }

    public override Canvas RenderSpriteCanvas()
    {
        return LoadSpriteCanvas("SimpleShooter.Sprites.Bomb.xaml");
    }

    public override void Update(System.TimeSpan elapsedTime)
    {
        base.Update(elapsedTime);
    }
}

Public Class Bomb
    Inherits Sprite
    Private _MaxX As Double
    Public Property MaxX() As Double
        Get
            Return _MaxX
        End Get
        Set(ByVal value As Double)
            _MaxX = value
        End Set
    End Property
    Private _MinX As Double
    Public Property MinX() As Double
        Get
            Return _MinX
        End Get
        Set(ByVal value As Double)
            _MinX = value
        End Set
    End Property

    Public Sub New(ByVal width As Double, ByVal height As Double, ByVal firstPosition As Point)
        MyBase.New(width, height, firstPosition)

    End Sub

    Public Overloads Overrides Function RenderSpriteCanvas() As Canvas
        Return LoadSpriteCanvas("SimpleShooter.Sprites.Bomb.xaml")
    End Function

    Public Overloads Overrides Sub Update(ByVal elapsedTime As System.TimeSpan)
        MyBase.Update(elapsedTime)
    End Sub
End Class

We now need to add an Alien class similar to our Ship class. These will both need a bit more capability. For one, we are going to have them both fire at each other. In the case of the Alien, it will be firing down, and it's monition of choice will be a bomb:

public class Alien : Sprite
{
    public double fireRateMilliseconds = 2000;
    public double fireVelocity = 250;
    public double wayPointMin;
    public double wayPointMax;
    public double speed = 100;
    public bool spawnWait;
    public DateTime spawnComplete;
    public double MaxX { get; set; }
    public double MinX { get; set; }

    public Alien(double width, double height, Point firstPosition)
        : base(width, height, firstPosition)
    {

    }

    public void CheckDirection()
    {
        if (Position.X > wayPointMax)
        {
            Velocity = Vector.CreateVectorFromAngle(270, speed);
        }
        if (Position.X < wayPointMin)
        {
            Velocity = Vector.CreateVectorFromAngle(90, speed);
        }
    }

    public override Canvas RenderSpriteCanvas()
    {
        return LoadSpriteCanvas("SimpleShooter.Sprites.Alien.xaml");
    }

    public override void Update(TimeSpan elapsedTime)
    {
        CheckDirection();
        base.Update(elapsedTime);
    }

    public Bomb Fire()
    {
        Bomb bomb = new Bomb(5, 5, Position);
        bomb.Velocity = Vector.CreateVectorFromAngle(180, fireVelocity);
        return bomb;
    }
}

Public Class Alien
    Inherits Sprite
    Public fireRateMilliseconds As Double = 2000
    Public fireVelocity As Double = 250
    Public wayPointMin As Double
    Public wayPointMax As Double
    Public speed As Double = 100
    Public spawnWait As Boolean
    Public spawnComplete As DateTime
    Private _MaxX As Double
    Public Property MaxX() As Double
        Get
            Return _MaxX
        End Get
        Set(ByVal value As Double)
            _MaxX = value
        End Set
    End Property
    Private _MinX As Double
    Public Property MinX() As Double
        Get
            Return _MinX
        End Get
        Set(ByVal value As Double)
            _MinX = value
        End Set
    End Property

    Public Sub New(ByVal width As Double, ByVal height As Double, ByVal firstPosition As Point)
        MyBase.New(width, height, firstPosition)

    End Sub

    Public Sub CheckDirection()
        If Position.X > wayPointMax Then
            Velocity = Vector.CreateVectorFromAngle(270, speed)
        End If
        If Position.X < wayPointMin Then
            Velocity = Vector.CreateVectorFromAngle(90, speed)
        End If
    End Sub

    Public Overloads Overrides Function RenderSpriteCanvas() As Canvas
        Return LoadSpriteCanvas("SimpleShooter.Alien.xaml")
    End Function

    Public Overloads Overrides Sub Update(ByVal elapsedTime As TimeSpan)
        CheckDirection()
        MyBase.Update(elapsedTime)
    End Sub

    Public Function Fire() As Bomb
        Dim bomb As New Bomb(5, 5, Position)
        bomb.Velocity = Vector.CreateVectorFromAngle(180, fireVelocity)
        Return bomb
    End Function
End Class

Now that we are going to add munitions to the game, we need to be able to know when these munitions collide with other sprites. To do this, we are going to add a collision detection method to our sprite class. As a form of simple collision detection, we will give each sprite a CollisionRadius from its center point. To keep it simple we will make the radius one half the width of our sprites. A vector created from these two points can then detect if the sum of those two radius is greater than the length of our vector. If it is, they have collided:

public static bool Collides(Sprite s1, Sprite s2)
{
    Vector v = new Vector((s1.Position.X) - (s2.Position.X), (s1.Position.Y) - (s2.Position.Y));
    if (s1.CollisionRadius + s2.CollisionRadius > v.Length)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Public Shared Function Collides(ByVal s1 As Sprite, ByVal s2 As Sprite) As Boolean
    Dim v As New Vector((s1.Position.X) - (s2.Position.X), (s1.Position.Y) - (s2.Position.Y))
    If s1.CollisionRadius + s2.CollisionRadius > v.Length Then
        Return True
    Else
        Return False
    End If
End Function

We are now ready to extend our game loop of our Page to do more than track the movement of our Ship. We begin by taking action on more than just the arrow keys. We will wire up the space bar for shooting. Lets add an enumeration to track the state of our game. We will also add a supporting class that will handle the firing of munitions and adding those to our game. We will keep this simple for now, but it is an obvious place to being extending this code to take advantage of things like partial classes that could contain functionality like our 'Fire' method:

public enum GameState
{
    Ready = 0,
    Running = 1,
    Paused = 2,
    BetweenWaves = 3,
    GameOver = 4
}

if (keyHandler.IsKeyPressed(Key.Space))
{
    switch (status)
    {
        case GameState.Ready:
            break;
        case GameState.Running:
            EntityFired(PlayerShip);
            break;
        case GameState.Paused:
            break;
        case GameState.BetweenWaves:
            status = GameState.Running;
            ctlInfo.GameInfo = "";
            StartWave();
            break;
        case GameState.GameOver:
            break;
        default:
            break;
    }
}

void EntityFired(Sprite shooter)
{
    Debug.WriteLine(shooter);
    switch (shooter.ToString())
    {
        case "SimpleShooter.Ship":
            if (missles.Count == 0)
            {
                Missle missle = ((Ship)shooter).Fire();
                missles.Add(missle);
                gameRoot.Children.Add(missle.SpriteCanvas);

            }
            break;
        case "SimpleShooter.Alien":
            Bomb bomb = ((Alien)shooter).Fire();
            bombs.Add(bomb);
            gameRoot.Children.Add(bomb.SpriteCanvas);
            break;
        default:
            break;
    }
}

Public Enum GameState
    Ready = 0
    Running = 1
    Paused = 2
    BetweenWaves = 3
    GameOver = 4
End Enum

If keyHandler.IsKeyPressed(Key.Space) Then
    Select Case status
        Case GameState.Ready
            Exit Select
        Case GameState.Running
            EntityFired(PlayerShip)
            Exit Select
        Case GameState.Paused
            Exit Select
        Case GameState.BetweenWaves
            status = GameState.Running
            ctlInfo.GameInfo = ""
            StartWave()
            Exit Select
        Case GameState.GameOver
            Exit Select
        Case Else
            Exit Select
    End Select
End If

Private Sub EntityFired(ByVal shooter As Sprite)
    Debug.WriteLine(shooter)
    Select Case shooter.ToString()
        Case "SimpleShooter.Ship"
            If missles.Count = 0 Then
                Dim missle As Missle = DirectCast(shooter, Ship).Fire()
                missles.Add(missle)

                gameRoot.Children.Add(missle.SpriteCanvas)
            End If
            Exit Select
        Case "SimpleShooter.Alien"
            Dim bomb As Bomb = DirectCast(shooter, Alien).Fire()
            bombs.Add(bomb)
            gameRoot.Children.Add(bomb.SpriteCanvas)
            Exit Select
        Case Else
            Exit Select
    End Select
End Sub

To make it easier to track the state of our game, let's add public properties to our controls and let them be the keepers of those game states. For instance, give the ReamainingLives control a Lives property, and have the setter of that property also update the TextBlock on the control to show the user how many lives are left. Perform a similar task for the other three controls:

public partial class RemainingLives : UserControl
{
    private int _lives;
    public int Lives
    {
        get { return _lives; }
        set
        {
            _lives = value;
            string livesString = string.Empty;
            for (int i = 0; i < _lives - 1; i++)
            {
                livesString = string.Format("{0}{1}", livesString, "A");
            }
            txtRemainingLives.Text = livesString;
        }
    }

    public RemainingLives()
    {
        InitializeComponent();
    }
}

Partial Public Class RemainingLives
    Inherits UserControl
    Private _lives As Integer
    Public Property Lives() As Integer
        Get
            Return _lives
        End Get
        Set(ByVal value As Integer)
            _lives = value
            Dim livesString As String = String.Empty
            For i As Integer = 0 To _lives - 2
                livesString = String.Format("{0}{1}", livesString, "A")
            Next
            txtRemainingLives.Text = livesString
        End Set
    End Property

    Public Sub New()
        InitializeComponent()
    End Sub
End Class

Now we have a number of other things to add to our page class. We are going to have lots of entities to deal with in our game loop. We will have a ship, x number of Aliens, x number of Bombs, and at some points we will have our Missiles, though we restricted that to one at a time in our EntityFired method. We need to, in each game loop check if any missile hits any alien or leaves the game map, if any bomb hits our ship or leaves the game map, and if it is time for a Alien to fire at the ship. Our Page already has a property for our Ship, but the Aliens, Bombs, Missiles need to be collections. When we begin to loop through our Bombs for instance, we will want to remove a bomb if it strikes a Ship or leaves the game map. Since we are going to be iterating these collections, we cannot subtract from those collections as we are looping through them. There are a number of approaches for this, but to keep it simple, we will add a corresponding collection for each of our Bomb, Alien, and Missile collections to track the ones that need to be removed and removed from our game canvas. With this approach, our game loop can add to the "remove these" collection, and then take action on them when we leave the main loop for the parent collection:

List<Alien> aliens;
List<Alien> aliensRemove;
List<Alien> alienShooters;
List<Bomb> bombs;
List<Bomb> bombsRemove;
List<Missle> missles;
List<Missle> misslesRemove;

Private aliens As List(Of Alien)
Private aliensRemove As List(Of Alien)
Private alienShooters As List(Of Alien)
Private bombs As List(Of Bomb)
Private bombsRemove As List(Of Bomb)
Private missles As List(Of Missle)
Private misslesRemove As List(Of Missle)

We also want to add a class to our page that can track the waves of aliens we are going to send one at a time. In addition, we can add a collection to hold these waves. Each wave will track the number of aliens that spawn at once, the total number of aliens faced in the wave, how many aliens get to drop bombs, and how frequently they can fire.

public class WaveData
{
    public WaveData(int count, double fireRate, int atOnce, int fireatonce)
    {
        EnemyCount = count;
        fireRateMilliseconds = fireRate;
        enemiesAtOnce = atOnce;
        fireAtOnce = fireatonce;
        waveEmpty = false;
    }
    public int EnemyCount { get; set; }
    public double fireRateMilliseconds { get; set; }
    public int enemiesAtOnce { get; set; }
    public int fireAtOnce { get; set; }
    public bool waveEmpty { get; set; }
}

Public Class WaveData
    Public Sub New(ByVal count As Integer, ByVal fireRate As Double, ByVal atOnce As Integer, ByVal fireatonce__1 As Integer)
        EnemyCount = count
        fireRateMilliseconds = fireRate
        enemiesAtOnce = atOnce
        fireAtOnce = fireatonce__1
        waveEmpty = False
    End Sub
    Private _EnemyCount As Integer
    Public Property EnemyCount() As Integer
        Get
            Return _EnemyCount
        End Get
        Set(ByVal value As Integer)
            _EnemyCount = value
        End Set
    End Property
    Private _fireRateMilliseconds As Double
    Public Property fireRateMilliseconds() As Double
        Get
            Return _fireRateMilliseconds
        End Get
        Set(ByVal value As Double)
            _fireRateMilliseconds = value
        End Set
    End Property
    Private _enemiesAtOnce As Integer
    Public Property enemiesAtOnce() As Integer
        Get
            Return _enemiesAtOnce
        End Get
        Set(ByVal value As Integer)
            _enemiesAtOnce = value
        End Set
    End Property
    Private _fireAtOnce As Integer
    Public Property fireAtOnce() As Integer
        Get
            Return _fireAtOnce
        End Get
        Set(ByVal value As Integer)
            _fireAtOnce = value
        End Set
    End Property
    Private _waveEmpty As Boolean
    Public Property waveEmpty() As Boolean
        Get
            Return _waveEmpty
        End Get
        Set(ByVal value As Boolean)
            _waveEmpty = value
        End Set
    End Property
End Class

We will need to setup an initialization method for our game, to setup all our collections for sprites, and add progressively difficult waves to our game. The meat of it all now lies in our game loop. For each collection of sprites we call methods that will iterate over its contents and make decisions based on collisions, locations of the sprites. After a loop on each main collection, we can use the 'remove us' collection to clear items from the main collection, remove their canvas from our game canvas, and delete them from the main collection. Finally, we check to see if enough time has elapsed to let the aliens drop another bomb:

void gameLoop_Update(TimeSpan elapsed)
{
    //clear the current Vector so the sprite is not moving unless a keys is pressed
    PlayerShip.Velocity = new Vector(0, 0);
    if (keyHandler.IsKeyPressed(Key.Left))
    {
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(270, 125);
    }
    if (keyHandler.IsKeyPressed(Key.Right))
    {
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(90, 125);
    }
    if (keyHandler.IsKeyPressed(Key.Space))
    {
        switch (status)
        {
            case GameState.Ready:
                break;
            case GameState.Running:
                EntityFired(PlayerShip);
                break;
            case GameState.Paused:
                break;
            case GameState.BetweenWaves:
                status = GameState.Running;
                ctlInfo.GameInfo = "";
                StartWave();
                break;
            case GameState.GameOver:
                break;
            default:
                break;
        }
    }
    PlayerShip.Update(elapsed);

    BombLoop(elapsed);
    MissleLoop(elapsed);
    AlienLoop(elapsed);

    foreach (Alien alien in aliensRemove)
    {
        aliens.Remove(alien);
        gameRoot.Children.Remove(alien.SpriteCanvas);
        AlienShot(alien);
    }
    aliensRemove.Clear();

    foreach (Missle missle in misslesRemove)
    {
        missles.Remove(missle);
        gameRoot.Children.Remove(missle.SpriteCanvas);
    }
    misslesRemove.Clear();

    if (nextShot <= DateTime.Now)
    {
        nextShot = DateTime.Now.AddMilliseconds(enemyShootMilliseonds).AddMilliseconds(elapsed.Milliseconds * -1);

        shotsThisPass = shotsAtOnce;
        if (shotsThisPass > aliens.Count)
        {
            shotsThisPass = aliens.Count;
        }

        if (aliens.Count > 0)
        {
            foreach (Alien alien in aliens)
            {
                alienShooters.Add(alien);
            }
        }

        while (alienShooters.Count > shotsThisPass)
        {
            alienShooters.RemoveAt(GetRandInt(0, alienShooters.Count - 1));
        }

        foreach (Alien alien in alienShooters)
        {
            EntityFired(alien);
        }

        alienShooters.Clear();
    }
}

Private Sub gameLoop_Update(ByVal elapsed As TimeSpan)
    'clear the current Vector so the sprite is not moving unless a keys is pressed 
    PlayerShip.Velocity = New Vector(0, 0)
    If keyHandler.IsKeyPressed(Key.Left) Then
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(270, 125)
    End If
    If keyHandler.IsKeyPressed(Key.Right) Then
        PlayerShip.Velocity = Vector.CreateVectorFromAngle(90, 125)
    End If
    If keyHandler.IsKeyPressed(Key.Space) Then
        Select Case status
            Case GameState.Ready
                Exit Select
            Case GameState.Running
                EntityFired(PlayerShip)
                Exit Select
            Case GameState.Paused
                Exit Select
            Case GameState.BetweenWaves
                status = GameState.Running
                ctlInfo.GameInfo = ""
                StartWave()
                Exit Select
            Case GameState.GameOver
                Exit Select
            Case Else
                Exit Select
        End Select
    End If
    PlayerShip.Update(elapsed)

    BombLoop(elapsed)
    MissleLoop(elapsed)
    AlienLoop(elapsed)

    For Each alien As Alien In aliensRemove
        aliens.Remove(alien)
        gameRoot.Children.Remove(alien.SpriteCanvas)
        AlienShot(alien)
    Next
    aliensRemove.Clear()

    For Each missle As Missle In misslesRemove
        missles.Remove(missle)
        gameRoot.Children.Remove(missle.SpriteCanvas)
    Next
    misslesRemove.Clear()

    If nextShot <= DateTime.Now Then
        nextShot = DateTime.Now.AddMilliseconds(enemyShootMilliseonds).AddMilliseconds(elapsed.Milliseconds * -1)

        shotsThisPass = shotsAtOnce
        If shotsThisPass > aliens.Count Then
            shotsThisPass = aliens.Count
        End If

        If aliens.Count > 0 Then
            For Each alien As Alien In aliens
                alienShooters.Add(alien)
            Next
        End If

        While alienShooters.Count > shotsThisPass
            alienShooters.RemoveAt(GetRandInt(0, alienShooters.Count - 1))
        End While

        For Each alien As Alien In alienShooters
            EntityFired(alien)
        Next

        alienShooters.Clear()
    End If
End Sub

Now we can almost call it a game:

Taking it one step further, I jumped into Expression Blend to create a bit more interesting XAML that our sprites are loading into their SpriteCanvas. This XAML can be found in the full download of the source code. The results make our game just a tad bit more interesting:

Conclusion

Silverlight provides a number of capabilities to enable robust game development. It should be noted that in this game, we are only scratching the surface. The core of this example used a game loop to position sprites on a canvas. Additional capabilities within Silverlight such as animations, styling, templating, and visual states provide even more ways to push the limits of browser based games. If you are at all like me, dabbling with game development is a great way to get your feet wet with Silverlight and learn some basics. Happy coding!

If you want to try this out, the download link for the source code is at the top of the article!

About The Author

Roger Guess is the Director of IT for The Wedge Group where he works with technologies such as Silverlight and WPF. He writes games in his spare time, and blogs at SilverlightAddict.com. He can be reached via email at email@rogerguess.net.

TwitterDrive – Author Interview

Coding4Fun — Wed, 01 Apr 2009 10:10:00 GMT

In case you haven’t heard, TwitterDrive is going to revolutionize the way files are stored and shared on the Internet. Today, we had the rare privilege of sitting down and talking with Brian Peek, creator of this cutting edge product.

Q: Thanks for taking the time to speak with us today. Why don’t you tell us a little bit about yourself?

A: I’m surprised I even considered this. I’m so above you people now. But anyway, my name is Brian Peek, and until I developed this app, I was working, like you people, at a job that was pointless. Now, I’m on the cusp of owning people like you. Once this takes off, I can finally pursue my life’s other passion: hip-hop music.

Q: I don’t doubt it. So why don’t you tell us a little bit about TwitterDrive and how you came up with the idea?

A: TwitterDrive is the next “big thing” in cloud storage. There are a ton of cloud storage providers out there now, most of which cost money or have limited disk space available. But why should we live with limitations like these? Twitter provides their users with unlimited storage for sending and saving their “tweets”. My amazingly brilliant idea was to take this service to the next level: using it to store and share files. That is, free cloud storage. Bet you wish you thought of that.

Q: I sure do. So how does TwitterDrive work?

A: It works perfectly. Simply run the TwitterDrive application, provide your Twitter user credentials, and then start uploading and downloading files. Files are compressed, base64 encoded, and then uploaded to Twitter 140 bytes at a time, fully maximizing the amount of space allowed per tweet.

Imagine…uploading 14 thousand bytes of data per hour! Or downloading two megabytes per hour! Match that, SkyDrive.

Q: That sounds amazing. Unlimited storage for free.

It is amazing. Which is why I thought of it and you didn’t. Welcome to the future.

Q: So are there any limitations?

Only if you consider uploading 14 thousand bytes per hour a limitation. But really, who has that much data? 14k should be enough for everybody.

Q: What about data protection? Is the file data protected in any way?

The data is compressed, encoded and chunked up into bits. Who needs more security than that? Besides, users would need to know your TwitterDrive account username to get at the data. Security through obscurity is a win for everyone!

Q: Do you have any new features planned for TwitterDrive?

New features? No. It’s already the most complete, useful and bug free application ever developed. It doesn’t require any additional features.

Now if you’ll excuse me, I have to start planning which jet I want to buy.

Well there you have it, folks. We are at the cusp of a revolution. Are you ready?

Download TwitterDrive here. Want to learn more? Learn how it was made!

TwitterDrive – The Revolution in Cloud Storage

Coding4Fun — Wed, 01 Apr 2009 10:05:00 GMT

	In this article, Brian Peek will provide a technical overview of TwitterDrive, an application used to store and retrieve files via the Twitter messaging service.
Brian Peek ASPSOFT, Inc. Difficulty: Intermediate Time Required: 2-3 hours Cost: Free Software: Visual C# Express 2008 SP1, Visual Basic Express 2008 SP1, or Visual Studio 2008 SP1, .NET Framework 3.5 SP1 Hardware: None Download: Application, Source Code Discussion Forum: Forum

Introduction

As you’ve probably guessed by now, TwitterDrive is my April Fool’s Day application for Coding4Fun this year. While the application does actually work, the limitations of Twitter make it functionally useless. That said, I’ll still take you through the important parts as there is some value in the code with regard to the Twitter API, LINQ to XML, threading, and a couple other things.

How It Works

Not very well, actually. The concept is we take a file, compress it, uuencode/base64 encode it (that is, make a text representation of the binary contents), and then upload it 140 characters at a time to Twitter as status messages. When the file upload is complete, an index is written of every file that is currently stored on Twitter with some information that can be used to later retrieve the file.

Twitter

Let’s start with the Twitter API. Full documentation on this API can be found at:

http://apiwiki.twitter.com/

TwitterDrive only requires a very small subset of this functionality to work. We need the ability to post a new status message, download a user timeline, destroy a status, and verify the user’s credentials. All of these things are handled in the TwitterService class.

The heart of this class consists of two methods: GetTwitter and PostTwitter. GetTwitter will make a GET request to Twitter of the specified URL, and PostTwitter will make a POST request to Twitter of the specified URL with the supplied data.

private XDocument GetTwitter(string url)
{
    WebClient wc = new WebClient();

    // only authenticate if we have a password
    if(!string.IsNullOrEmpty(Password))
        wc.Credentials = new NetworkCredential(Username, Password);

    Stream s = wc.OpenRead(url);

    // return an XDocument for LINQ
    XmlTextReader xmlReader = new XmlTextReader(s);
    XDocument xdoc = XDocument.Load(xmlReader);
    xmlReader.Close();
    return xdoc;
}

private XDocument PostTwitter(string url, string data)
{
    byte[] bytes = Encoding.ASCII.GetBytes(data);

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
    request.Method = "POST";

    // if we're writing, we need to authenticate
    request.Credentials = new NetworkCredential(Username, Password);

    // if this is 'true', Twitter breaks
    request.ServicePoint.Expect100Continue = false;
    request.ContentType = "application/x-www-form-urlencoded";
    request.ContentLength = bytes.Length;

    Stream reqStream = request.GetRequestStream();
    reqStream.Write(bytes, 0, bytes.Length);

    // turn the response into an XDocument for use with LINQ
    HttpWebResponse resp = (HttpWebResponse)request.GetResponse();
    XmlReader xmlReader = XmlReader.Create(resp.GetResponseStream());
    XDocument xdoc = XDocument.Load(xmlReader);
    xmlReader.Close();
    return xdoc;
}

Private Function GetTwitter(ByVal url As String) As XDocument
    Dim wc As New WebClient()

    ' only authenticate if we have a password
    If (Not String.IsNullOrEmpty(Password)) Then
        wc.Credentials = New NetworkCredential(Username, Password)
    End If

    Dim s As Stream = wc.OpenRead(url)

    ' return an XDocument for LINQ
    Dim xmlReader As New XmlTextReader(s)
    Dim xdoc As XDocument = XDocument.Load(xmlReader)
    xmlReader.Close()
    Return xdoc
End Function

Private Function PostTwitter(ByVal url As String, ByVal data As String) As XDocument
    Dim bytes() As Byte = Encoding.ASCII.GetBytes(data)

    Dim request As HttpWebRequest = CType(WebRequest.Create(url), HttpWebRequest)
    request.Method = "POST"

    ' if we're writing, we need to authenticate
    request.Credentials = New NetworkCredential(Username, Password)

    ' if this is 'true', Twitter breaks
    request.ServicePoint.Expect100Continue = False
    request.ContentType = "application/x-www-form-urlencoded"
    request.ContentLength = bytes.Length

    Dim reqStream As Stream = request.GetRequestStream()
    reqStream.Write(bytes, 0, bytes.Length)

    ' turn the response into an XDocument for use with LINQ
    Dim resp As HttpWebResponse = CType(request.GetResponse(), HttpWebResponse)
    Dim xmlReader As XmlReader = XmlReader.Create(resp.GetResponseStream())
    Dim xdoc As XDocument = XDocument.Load(xmlReader)
    xmlReader.Close()
    Return xdoc
End Function

Each of these methods will use the NetworkCredentials object to authenticate to Twitter for reading or writing, as required. Twitter API methods return simple XML objects. Both GetTwitter and PostTwitter take these XML documents and turn them into XDocument objects that can be easily queried with LINQ to XML later.

We only need to call two Twitter “get” methods: user_timeline and verify_credentials. There are two overloaded methods which call the user_timeline API:

public IList<Status> GetUserTimeline(int page, int count)
{
    XDocument xdoc = GetTwitter(string.Format("http://twitter.com/statuses/user_timeline.xml?count={0}&page={1}&id={2}", count, page, Username));
    IList<Status> statuses = ParseStatuses(xdoc);
    return statuses;
}

public IList<Status> GetUserTimeline(int since_id, int max_id, int page, int count)
{
    XDocument xdoc = GetTwitter(string.Format("http://twitter.com/statuses/user_timeline.xml?since_id={0}&max_id={1}&count={2}&page={3}&id={4}", since_id, max_id, count, page, Username));
    IList<Status> statuses = ParseStatuses(xdoc);
    return statuses;
}

Public Function GetUserTimeline(ByVal page As Integer, ByVal count As Integer) As IList(Of Status)
    Dim xdoc As XDocument = GetTwitter(String.Format("http://twitter.com/statuses/user_timeline.xml?count={0}&page={1}&id={2}", count, page, Username))
    Dim statuses As IList(Of Status) = ParseStatuses(xdoc)
    Return statuses
End Function

Public Function GetUserTimeline(ByVal since_id As Integer, ByVal max_id As Integer, ByVal page As Integer, ByVal count As Integer) As IList(Of Status)
    Dim xdoc As XDocument = GetTwitter(String.Format("http://twitter.com/statuses/user_timeline.xml?since_id={0}&max_id={1}&count={2}&page={3}&id={4}", since_id, max_id, count, page, Username))
    Dim statuses As IList(Of Status) = ParseStatuses(xdoc)
    Return statuses
End Function

Each of these methods creates a URL with the appropriate query string arguments (see the Twitter API docs for the full list) and then calls our ParseStatuses method with the returned XDocument, which will give us a List of Status objects. The Twitter-returned status contains a variety of data, such as:

<status>
<created_at>Mon Mar 30 07:20:57 +0000 2009</created_at>
<id>1234567123</id>
<text>Status text</text>
<source>web</source>
<truncated>false</truncated>
<in_reply_to_status_id/>
<in_reply_to_user_id/>
<favorited>false</favorited>

<user>
<id>12345678</id>
<name>Some Person</name>
<screen_name>myscreenname</screen_name>
<description/>
<location/>

<profile_image_url>
http://static.twitter.com/images/default_profile_normal.png
</profile_image_url>
<url/>
<protected>false</protected>
<followers_count>1</followers_count>
</user>
</status>

We only care about a few elements and only parse those, namely id, text, user (which is in itself an XML chunk), and created_at.

private IList<Status> ParseStatuses(XContainer container)
{
    // return a list of Status objects
    var query = from status in container.Descendants("statuses").Descendants("status")
                select ParseStatus(status);
    return query.ToList();
}

private Status ParseStatus(XDocument xdoc)
{
    // create a Status object from the returned XML
    var query = from status in xdoc.Descendants("status")
                select ParseStatus(status);

    return query.SingleOrDefault();
}

private Status ParseStatus(XElement xelement)
{
    Status s = new Status()
                {
                    ID = (int)xelement.Element("id"),
                    Text = (string)xelement.Element("text"),
                    UserInformation = ParseUserInformation(xelement.Element("user")),
                    // HTTP-formatted date
                    CreatedAt = DateTime.ParseExact(xelement.Element("created_at").Value,
                            "ddd MMM dd HH:mm:ss zzzz yyyy",
                            CultureInfo.GetCultureInfoByIetfLanguageTag("en-us"),
                            DateTimeStyles.AllowWhiteSpaces)
                };

    return s;
}

Private Function ParseStatuses(ByVal container As XContainer) As IList(Of Status)
    ' return a list of Status objects
    Dim query = _
        From status In container.Descendants("statuses").Descendants("status") _
        Select ParseStatus(status)
    Return query.ToList()
End Function

Private Function ParseStatus(ByVal xdoc As XDocument) As Status
    ' create a Status object from the returned XML
    Dim query = _
        From status In xdoc.Descendants("status") _
        Select ParseStatus(status)

    Return query.SingleOrDefault()
End Function

Private Function ParseStatus(ByVal xelement As XElement) As Status
    Dim s As New Status() With { _
        .ID = CInt(xelement.Element("id")), _
        .Text = CStr(xelement.Element("text")), _
        .UserInformation = ParseUserInformation(xelement.Element("user")), _
        .CreatedAt = DateTime.ParseExact(xelement.Element("created_at").Value, _
                    "ddd MMM dd HH:mm:ss zzzz yyyy", CultureInfo.GetCultureInfoByIetfLanguageTag("en-us"), DateTimeStyles.AllowWhiteSpaces) }
    Return s
End Function

These methods use LINQ to XML to drill down into the XML document to parse out individual status objects and return them as a list. You will notice the user element contains a user_information XML chunk, and the ParseUserInformation method parses that data

private UserInformation ParseUserInformation(XContainer container)
{
    // parse and return a UserInformation object
    return new UserInformation
    {
        ID = (int)container.Element("id"),
        Name = (string)container.Element("name"),
        ScreenName = (string)container.Element("screen_name")
    };
}

Private Function ParseUserInformation(ByVal container As XContainer) As UserInformation
    ' parse and return a UserInformation object
    Dim ui As New UserInformation() With { _
        .ID = CInt(container.Element("id")), _
        .Name = CStr(container.Element("name")), _
        .ScreenName = CStr(container.Element("screen_name")) }

    Return ui
End Function

The verify_credentials API is called in a similar manner, but in this case we will “listen” for a 401 (Unauthorized) exception and return true or false appropriately:

public bool VerifyTwitterCredentials(string username, string password)
{
    try
    {
        WebClient wc = new WebClient();
        wc.Credentials = new NetworkCredential(username, password);
        Stream s = wc.OpenRead("http://twitter.com/account/verify_credentials.xml");
        s.Close();
    }
    catch(WebException we)
    {
        if((we.Response as HttpWebResponse).StatusCode == HttpStatusCode.Unauthorized)
            return false;
        throw;
    }

    return true;
}

With the “get” methods out of the way, we can write our “post” methods. We only need two methods here as well: update and destroy. Update is used to write a new tweet to Twitter, and destroy is used to remove an existing tweet.

public Status UpdateStatus(string status)
{
    XDocument doc = PostTwitter("http://twitter.com/statuses/update.xml", "status=" + status);
    Status s =  ParseStatus(doc);

    // if we don't get the text we sent, we hit the rate limit...
    if(s.Text != HttpUtility.UrlDecode(status))
        throw new TwitterRateLimitException("Twitter upload limit reached.");
    return s;
}

public Status Destroy(int status)
{
    XDocument doc = PostTwitter("http://twitter.com/statuses/destroy/" + status + ".xml", "id=" + status);
    return ParseStatus(doc);
}

Public Function VerifyTwitterCredentials(ByVal username As String, ByVal password As String) As Boolean
    Try
        Dim wc As New WebClient()
        wc.Credentials = New NetworkCredential(username, password)
        Dim s As Stream = wc.OpenRead("http://twitter.com/account/verify_credentials.xml")
        s.Close()
    Catch we As WebException
        If (TryCast(we.Response, HttpWebResponse)).StatusCode = HttpStatusCode.Unauthorized Then
            Return False
        End If
        Throw
    End Try

    Return True
End Function

The UpdateStatus method has a bit of code to determine whether we hit Twitter’s upload rate limit. Twitter will limit you to about 100 tweets per hour. The only way to determine if you’ve hit the upload limit (that I found at least) is to compare the text from status element returned from the update to the text that was sent. If the upload limit is hit, the last valid status element will be returned, and therefore the text blocks will not match. If this happens, we throw our own custom TwitterRateLimitException up the stack for the UI to handle.

TwitterDrive

Now that we can talk to Twitter, the next step is to write the code that uses these methods to store and retrieve our file data. This code is located in the TwitterDrive class.

One of the goals I had was to make this application thread-happy to provide a responsive UI while files are uploaded and downloaded. Therefore, this class sets up three events which can be hooked by the UI to receive periodic status information:

public class ChunkEventArgs : EventArgs
{
    public Status Status;
    public int ChunkLength;
    public int Total;

    public ChunkEventArgs(Status status, int length, int total)
    {
        Status = status;
        ChunkLength = length;
        Total = total;
    }
}

...

// event handlers for async file transfer
public event EventHandler<ChunkEventArgs> ChunkUpload;
public event EventHandler<ChunkEventArgs> ChunkDownload;
public event EventHandler<EventArgs> TransferComplete;

Public Class ChunkEventArgs
    Inherits EventArgs
    Public Status As Status
    Public ChunkLength As Integer
    Public Total As Integer

    Public Sub New(ByVal status As Status, ByVal length As Integer, ByVal total As Integer)
        Status = status
        ChunkLength = length
        Me.Total = total
    End Sub
End Class

These events will be called at the appropriate times and provide information to allow the UI to draw a progress bar and other status information.

The UploadFile method does exactly what you think: it uploads the file specified. The file contents are loaded into memory, compressed, base64 encoded, and finally URL encoded. Then, this large string is cut into 140 character chunks and sent to Twitter, one chunk at a time. After each chunk is uploaded, the ChunkUpload event is called. Finally, when all chunks are uploaded, a new FileEntry object is created, added to the in-memory file index, and that index is finally written to the top of the Twitter status list.

public void UploadFile(string path)
{
    Status s = null;
    int startID = 0;
    int length = 0;
    int chunkLength = 140;

    // encode the file
    string file = EncodeFile(path);

    // upload the chunks
    for(int i = 0; i < file.Length; i+= chunkLength)
    {
        // get the proper length (i.e. don't get full 140 if we're at the end)
        string chunk = file.Substring(i, Math.Min(chunkLength, file.Length-i));

        // handle the case where we chopped a chunk in the middle of an encoded character
        // in this case, chop off the encoded data and reset the counter
        if(chunk.EndsWith("%2"))
        {
            chunk = chunk.Substring(0, chunk.Length-2);
            i -= 2;
        }

        if(chunk.EndsWith("%"))
        {
            chunk = chunk.Substring(0, chunk.Length-1);
            i -= 1;
        }

        try
        {
            // upload the chunk
            s = _twitter.UpdateStatus(chunk);

            // notify listeners that we uploaded
            if(ChunkUpload != null)
                ChunkUpload(this, new ChunkEventArgs(s, chunk.Length, file.Length));
        }
        catch(TwitterRateLimitException)
        {
            throw new TwitterDriveException("Twitter upload limit reached.  Please try again later.");
        }

        if(i == 0)
            startID = s.ID;

        length++;
    }

    // create a new FileEntry for this file
    FileEntry fe = new FileEntry()
    {
        Filename = Path.GetFileName(path),
        StartStatus = startID,
        EndStatus = s.ID,
        Length = length,
        FileIndex = GetNextIndex()
    };

    // update the index
    UpdateFileIndex(fe);

    // notify we're done
    if(TransferComplete != null)
        TransferComplete(this, null);
}

Public Function UploadFile(ByVal filepath As String)
    Dim s As Status = Nothing
    Dim startID As Integer = 0
    Dim length As Integer = 0
    Dim chunkLength As Integer = 140

    ' encode the file
    Dim file As String = EncodeFile(filepath)

    ' upload the chunks
    For i As Integer = 0 To file.Length - 1 Step chunkLength
        ' get the proper length (i.e. don't get full 140 if we're at the end)
        Dim chunk As String = file.Substring(i, Math.Min(chunkLength, file.Length-i))

        ' handle the case where we chopped a chunk in the middle of an encoded character
        ' in this case, chop off the encoded data and reset the counter
        If chunk.EndsWith("%2") Then
            chunk = chunk.Substring(0, chunk.Length-2)
            i -= 2
        End If

        If chunk.EndsWith("%") Then
            chunk = chunk.Substring(0, chunk.Length-1)
            i -= 1
        End If

        Try
            ' upload the chunk
            s = _twitter.UpdateStatus(chunk)

            ' notify listeners that we uploaded
            RaiseEvent ChunkUpload(Me, New ChunkEventArgs(s, chunk.Length, file.Length))
        Catch e1 As TwitterRateLimitException
            Throw New TwitterDriveException("Twitter upload limit reached.  Please try again later.")
        End Try

        If i = 0 Then
            startID = s.ID
        End If

        length += 1
    Next i

    ' create a new FileEntry for this file
    Dim fe As New FileEntry() With {.Filename = Path.GetFileName(filepath), .StartStatus = startID, .EndStatus = s.ID, .Length = length, .FileIndex = GetNextIndex()}

    ' update the index
    UpdateFileIndex(fe)

    ' notify we're done
    RaiseEvent TransferComplete(Me, Nothing)
End Function

Let’s take a closer look at the EncodeFile method:

private string EncodeFile(string path)
{
    // load the file
    byte[] buff = File.ReadAllBytes(path);

    // compress
    MemoryStream ms = new MemoryStream();
    GZipStream gs = new GZipStream(ms, CompressionMode.Compress);
    gs.Write(buff, 0, buff.Length);
    gs.Close();

    byte[] buffCompressed = ms.ToArray();

    // base64, urlencode
    return HttpUtility.UrlEncode(Convert.ToBase64String(buffCompressed));
}

Private Function EncodeFile(ByVal path As String) As String
    ' load the file
    Dim buff() As Byte = File.ReadAllBytes(path)

    ' compress
    Dim ms As New MemoryStream()
    Dim gs As New GZipStream(ms, CompressionMode.Compress)
    gs.Write(buff, 0, buff.Length)
    gs.Close()

    Dim buffCompressed() As Byte = ms.ToArray()

    ' base64, urlencode
    Return HttpUtility.UrlEncode(Convert.ToBase64String(buffCompressed))
End Function

The code here reads the bytes of a file into a byte array. Then, a MemoryStream object is created and tied to a GZipStream (compression) object. Next, the byte array is written to the stream which will compress the data on the fly. Once the stream is closed, calling ToArray on the MemoryStream will return a byte array of the compressed data. The byte array is base64 encoded (turned into text) and finally URL encoded so it can be sent to Twitter.

The file index is written at the end of each file upload. The index is comprised of a delimited string which contains the data in the FileEntry object. Each file is uploaded as one tweet, with an end marker to denote where the file index ends.

private void WriteFileEntries()
{
    // write an end marker (write this first since they come out in reverse order later)
    _twitter.UpdateStatus(FileEntryEnd);

    for(int i = 0; i < _fileEntries.Count; i++)
        WriteFileEntry(_fileEntries[i]);
}

private void WriteFileEntry(FileEntry fe)
{
    // simple delimited list of data
    string entry = string.Format(FileEntryHeader +
                                "{0}" + FileEntrySeparator + 
                                "{1}" + FileEntrySeparator +
                                "{2}" + FileEntrySeparator +
                                "{3}" + FileEntrySeparator +
                                "{4}", 
                                fe.Filename, fe.StartStatus, fe.EndStatus, fe.Length, fe.FileIndex);
    _twitter.UpdateStatus(entry);
}

Private Sub WriteFileEntries()
    ' write an end marker (write this first since they come out in reverse order later)
    _twitter.UpdateStatus(FileEntryEnd)

    Dim i As Integer = 0
    Do While i < _fileEntries.Count
        WriteFileEntry(_fileEntries(i))
        i += 1
    Loop
End Sub

Private Sub WriteFileEntry(ByVal fe As FileEntry)
    ' simple delimited list of data
    Dim entry As String = String.Format(FileEntryHeader & "{0}" & FileEntrySeparator & "{1}" & FileEntrySeparator & "{2}" & FileEntrySeparator & "{3}" & FileEntrySeparator & "{4}", fe.Filename, fe.StartStatus, fe.EndStatus, fe.Length, fe.FileIndex)
    _twitter.UpdateStatus(entry)
End Sub

A file list can be retrieved and parsed out with the following code:

public IList<FileEntry> GetFileIndex()
{
    bool end = false;
    int page = 1;

    // the index should be the last things tweeted, but if we have a failed upload, it may not be
    while(!end && page < 5)
    {
        IList<Status> indexes = _twitter.GetUserTimeline(page, 200);

        _fileEntries.Clear();

        // parase out the file entries
        foreach(Status index in indexes)
        {
            FileEntry fe = ParseFileIndexString(index.Text);
            if(fe != null)
            {
                fe.IndexStatusId = index.ID;
                _fileEntries.Add(fe);
            }

            if(index.Text.StartsWith(FileEntryEnd))
            {
                end = true;
                break;
            }
        }
        page++;
    }
    return _fileEntries;
}

private FileEntry ParseFileIndexString(string index)
{
    if(!index.StartsWith(FileEntryHeader))
        return null;

    string[] fileEntry = index.Split(Convert.ToChar(FileEntrySeparator));
    FileEntry fe = new FileEntry()
                    {
                        Filename = fileEntry[0].Replace(FileEntryHeader, string.Empty),
                        StartStatus = int.Parse(fileEntry[1]),
                        EndStatus = int.Parse(fileEntry[2]),
                        Length = int.Parse(fileEntry[3]),
                        FileIndex = int.Parse(fileEntry[4])
                    };
    return fe;
}

Public Function GetFileIndex() As IList(Of FileEntry)
    Dim [end] As Boolean = False
    Dim page As Integer = 1

    ' the index should be the last things tweeted, but if we have a failed upload, it may not be
    Do While (Not [end]) AndAlso page < 5
        Dim indexes As IList(Of Status) = _twitter.GetUserTimeline(page, 200)

        _fileEntries.Clear()

        ' parase out the file entries
        For Each index As Status In indexes
            Dim fe As FileEntry = ParseFileIndexString(index.Text)
            If fe IsNot Nothing Then
                fe.IndexStatusId = index.ID
                _fileEntries.Add(fe)
            End If

            If index.Text.StartsWith(FileEntryEnd) Then
                [end] = True
                Exit For
            End If
        Next index
        page += 1
    Loop
    Return _fileEntries
End Function

Private Function ParseFileIndexString(ByVal index As String) As FileEntry
    If (Not index.StartsWith(FileEntryHeader)) Then
        Return Nothing
    End If

    Dim fileEntry() As String = index.Split(Convert.ToChar(FileEntrySeparator))
    Dim fe As New FileEntry() With {.Filename = fileEntry(0).Replace(FileEntryHeader, String.Empty), .StartStatus = Integer.Parse(fileEntry(1)), .EndStatus = Integer.Parse(fileEntry(2)), .Length = Integer.Parse(fileEntry(3)), .FileIndex = Integer.Parse(fileEntry(4))}
    Return fe
End Function

This code will retrieve the user’s timeline, loop through the tweets, looking for file index entries (those that start with the proper delimiter). When one is found, the data is parsed back into a FileEntry object and added to the in-memory cache. You will note that the GetFileIndex method will read up to 1000 tweets looking for the end marker before giving up.

Now that we can upload files and build the index, we need to be able to download, decode and save a file. This is done in the obviously named DownloadFile method:

public void DownloadFile(FileEntry fe, string path)
{
    StringBuilder sb = new StringBuilder(fe.Length * 140);

    // get statuses for this user starting/ending at the IDs for this file
    IList<Status> chunks = _twitter.GetUserTimeline(fe.StartStatus-1, fe.EndStatus, 1, 200);

    // order them from oldest to newest
    var orderedChunks = from chunk in chunks
                        orderby chunk.ID ascending
                        select chunk;

    foreach(Status chunk in orderedChunks)
    {
        // trim off any extra characters
        string newChunk = chunk.Text.TrimEnd('.').Trim();
        sb.Append(newChunk);

        // notify listeners that we downloaded a chunk
        if(ChunkDownload != null)
            ChunkDownload(this, new ChunkEventArgs(chunk, newChunk.Length, fe.Length * 140));
    }

    // decode and write the file
    byte[] buff = DecodeFile(sb.ToString());
    File.WriteAllBytes(Path.Combine(path, fe.Filename), buff);

    // notify that we're done
    if(TransferComplete != null)
        TransferComplete(this, null);
}

Public Function DownloadFile(ByVal fe As FileEntry, ByVal filepath As String)
    Dim sb As New StringBuilder(fe.Length * 140)

    ' get statuses for this user starting/ending at the IDs for this file
    Dim chunks As IList(Of Status) = _twitter.GetUserTimeline(fe.StartStatus-1, fe.EndStatus, 1, 200)

    ' order them from oldest to newest
    Dim orderedChunks = _
        From chunk In chunks _
        Order By chunk.ID Ascending _
        Select chunk

    For Each chunk As Status In orderedChunks
        ' trim off any extra characters
        Dim newChunk As String = chunk.Text.TrimEnd("."c).Trim()
        sb.Append(newChunk)

        ' notify listeners that we downloaded a chunk
        RaiseEvent ChunkDownload(Me, New ChunkEventArgs(chunk, newChunk.Length, fe.Length * 140))
    Next chunk

    ' decode and write the file
    Dim buff() As Byte = DecodeFile(sb.ToString())
    File.WriteAllBytes(Path.Combine(filepath, fe.Filename), buff)

    ' notify that we're done
    RaiseEvent TransferComplete(Me, Nothing)
End Function

This method returns the user’s timeline starting and ending at the tweets specified in the FileEntry object. The status list is ordered in ascending order (i.e. oldest to newest). Each status is appended to the previous using a StringBuilder object. When all chunks are processed, the file is decoded and saved to the chosen location.

public byte[] DecodeFile(string data)
{
    // base64 to binary
    byte[] buff = Convert.FromBase64String(data);

    // decompress
    MemoryStream ms = new MemoryStream(buff);
    GZipStream gs = new GZipStream(ms, CompressionMode.Decompress, false);

    // original
    byte[] decompressed = ReadAllBytes(gs);
    return decompressed;
}

Public Function DecodeFile(ByVal data As String) As Byte()
    ' base64 to binary
    Dim buff() As Byte = Convert.FromBase64String(data)

    ' decompress
    Dim ms As New MemoryStream(buff)
    Dim gs As New GZipStream(ms, CompressionMode.Decompress, False)

    ' original
    Dim decompressed() As Byte = ReadAllBytes(gs)
    Return decompressed
End Function

To decode the file, we do the opposite of what we did before: the file is converted to bytes from the base64 encoded string, a GZipStream is used to decompress the data, and the final, uncompressed file contents are returned to the caller to be saved to the disk.

Be sure to look through the entire TwitterDrive.cs/vb file for the full picture, but these are the important parts.

User Interface

The final piece is the user interface.

A very simple UI for uploading, downloading and deleting files. At the start of the application, the three TwitterDrive events are hooked: ChunkUpload, ChunkDownload, and TransferComplete. These three event handlers are used to update the progress bar on a dialog box that pops up during the file transfer.

When upload or download is selected, the file is selected, and a new thread is created to start the actual process. Here is what the download process looks like:

// start a new thread to grab the file
Thread t = new Thread(() => _twitterDrive.DownloadFile(fe, fbd.SelectedPath));
t.Start();

if(_progress.ShowDialog() == DialogResult.Cancel)
    t.Abort();
else
    MessageBox.Show("File download complete.", "TwitterDrive", MessageBoxButtons.OK, MessageBoxIcon.Information);

' start a new thread to grab the file
Dim t As New Thread(CType(Function() _twitterDrive.DownloadFile(fe, fbd.SelectedPath), ThreadStart))
t.Start()

If _progress.ShowDialog() = System.Windows.Forms.DialogResult.Cancel Then
    t.Abort()
Else
    MessageBox.Show("File download complete.", "TwitterDrive", MessageBoxButtons.OK, MessageBoxIcon.Information)
End If

A new thread is created, whose ThreadStart parameter is the DownloadFile method of the TwitterDrive class. The thread is started, and the progress dialog box is shown. If the progress box is cancelled, the thread is aborted, otherwise the dialog box is closed in response to the TransferComplete event sent by the TwitterDrive class.

Using the Application

Create a new Twitter account for use in TwitterDrive.
Enter the credentials for this new account in the provided textboxes and click Refresh. Or, if you want to download files from someone else, enter just the username and click Refresh.
Upload and download data at will.

Conclusion

And there we have it. A functionally useless application that actually works. Give it a try and find out what the limitations are. Just be sure to use a Twitter account that isn’t your main feed otherwise you’ll have some pretty angry followers.

Thanks

A special thanks to Mark Zaugg, Dan Fernandez, and Giovanni Montrone for helping me test this application. Giovanni is also partly responsible for this horrible idea after joking that I should Twitter him a file. So blame him.

Also thanks to Clint Rutkas for throwing together the icon (it’s a combo of the SkyDrive icon + the Twitter icon).

Bio

Brian is a Microsoft C# MVP who has been actively developing in .NET since its early betas in 2000, and who has been developing solutions using Microsoft technologies and platforms for even longer. Along with .NET, Brian is particularly skilled in the languages of C, C++ and assembly language for a variety of CPUs. He is also well-versed in a wide variety of technologies including web development, document imaging, GIS, graphics, game development, and hardware interfacing. Brian has a strong background in developing applications for the health-care industry, as well as developing solutions for portable devices, such as tablet PCs and PDAs. Additionally, Brian has co-authored the book "Coding4Fun: 10 .NET Programming Projects for Wiimote, YouTube, World of Warcraft, and More" published O'Reilly. He previously co-authored the book "Debugging ASP.NET" published by New Riders. Brian is also an author for MSDN's Coding4Fun website.

Blu-ray/DVD Comparison Utility

Coding4Fun — Sat, 28 Mar 2009 10:30:00 GMT

In this article, Giovanni Montrone will provide an overview on how to create an image comparison application for DVD and Blu-ray screen captures.
Giovanni Montrone ASPSOFT, Inc. Difficulty: Beginner Time Required: 2-3 hours Cost: Free Software: Visual Web Developer Express SP1 (or Visual Studio 2008 SP1), Silverlight 2 Tools Hardware: None Application: Run the application Source Download: Download the source

Introduction

As a fan of High Definition movies and television, I often find it difficult to explain the benefits of upgrading from DVD to blu-ray to family and friends. Many people believe that DVDs look good enough and/or that you need a really big television to notice the difference, and, even then, feel the improvement is not good enough to justify the upgrade. The best way to convince someone is to show him/her the same movie playing side by side on blu-ray and dvd using the same sized screens. Since it's difficult to do, the next best thing is to look at still images from both the DVD and the blu-ray and compare them. The images should be from the exact same scene. Fortunately there are places on the web such as AVSForum where members take the time to do this. They usually do this to help people determine what kind of an upgrade they can expect when viewing the blu-ray compared to the DVD. Sometimes the differences are easy to see, and other times they are not as clear. I built this comparison tool as a way to see what differences exist, and provided a few ways to make those differences easier to see.

This utility will allow the user to compare two different images using 3 different modes: dual view, swap view, and Rectangle View. Dual view will allow a side by side comparison where you see part of the first image, and the remaining part of the second image. Moving the mouse left or right will show more of one image, and less of the other. The swap mode will allow the user to see one image in its entirety, and then, when placing the mouse over the image, the application will swap the first image with the second one. The last mode will allow the user to specify a region that he or she wishes to compare. They can draw a rectangle using the mouse, and the application will show the first image with a chunk cut out, replacing the rectangle area with the equivalent area on the second image. The image below shows an example of the rectangle view.

Notes

The application is set to handle images that are 1920x1080 in resolution (the standard resolution of blu-ray movies). DVDs have a resolution of 720x480, but are typically up-converted to 1920x1080 in order to do a direct comparison. This upconversion is similar to what happens when you play a DVD on a 1080p high definition television. While it wouldn't be too difficult to handle other image sizes, to keep things simple, the application assumes the user will be providing images at the proper resolution. Using different images with different resolutions will result in incorrect behavior.

At the time of this writing, Silverlight 3 beta has just recently been released, but has not been tested with this application.

Setup

Before beginning, you must have Visual Studio 2008 SP1 or Visual Web Developer Express SP1. Be sure to install Silverlight 2 Tools in order to create and run the project. Once you have that, start a new Silverlight Application and call it BlurayDVDCompare, or whatever you desire. As shown in figure 1, choose the option to host Silverlight with an ASP.NET web application. This will create a web project and a separate Silverlight project.

Creating the UI

Since we will be displaying HD images (1920x1080), our next step is to ensure that the browser adds scrollbars so that the entire Silverlight control can be seen. To do this, we need to open and edit the hosting web page (BlurayDVDCompareTestPage.aspx) and set the Width and Height properties of the Silverlight control to 1920 x 1200 as shown below. The 1200 is extra room for other controls that we will add.

<asp:Silverlight ID="Xaml1" runat="server"
Source="~/ClientBin/BlurayDVDCompare.xap"
MinimumVersion="2.0.31005.0" Width="1920" Height="1200" />

Our UI will be pretty simple. We will have a couple of textboxes which will be used so that a user can specify a URLs to images they wish to compare. We will also add a couple of progress indicators so that we can show progress when the images are being loaded. We will also have three radio buttons to allow the user to select which comparison mode they wish to use.

The main part of our UI, will be the canvas that holds the two images that we are comparing. Each image has a clip region which will be used to display parts of each image or to hide/show an image. For example, in DualView mode, we want to display part of one image, and the remaining part of the second image. If no clip regions were set, the default behavior would force the second image to cover the first. The final thing we add is a border which we will be used to draw a line as a separator between the two images in DualView. In Rectangle view, the border is used to draw the rectangle.

<StackPanel>
    <Canvas x:Name="canvas" Background="White" Width="1920" Height="1080" Margin="0,5,0,0">    
        <Image x:Name="img1" Stretch="None" >        
            <Image.Clip>
                <RectangleGeometry  Rect="0,0,960,1080" x:Name="rcImg1" />
            </Image.Clip>
        </Image>

        <Image x:Name="img2" Stretch="None" >
            <Image.Clip >
                <RectangleGeometry Rect="960,0,1920,1080" x:Name="rcImg2"  />
            </Image.Clip>
        </Image>    
            
        <Border x:Name="border" Width="2" Height="1920" Margin="0,0,0,0" BorderBrush="Bisque" BorderThickness="0" />
    </Canvas>
</StackPanel>

Implementation

Since we want to allow the application to load images from the web, we define the LoadImages() method which accepts two URLs. In order to do this, we create new BitmapImage objects with the given URLs. This will load the images asynchronously and we will assign them as the image Source property for the two UIElements. Once loading has finished, they will automatically appear in the canvas.

private void LoadImages(string s1, string s2)
{
    brLoading.Visibility = Visibility.Visible;
    spLoadingError.Visibility = Visibility.Collapsed;

    if (string.IsNullOrEmpty(s1) || string.IsNullOrEmpty(s2))
    {
        txtLoadingError.Text = "Invalid image location given";
        brLoading.Visibility = Visibility.Collapsed;
        spLoadingError.Visibility = Visibility.Visible;
        return;
    }

    prgLoading1.Value = 0;
    prgLoading2.Value = 0;
    
    _bmi1 = new BitmapImage();
    _bmi2 = new BitmapImage();
    _bmi1.DownloadProgress += new EventHandler<DownloadProgressEventArgs>(bmi1_DownloadProgress);
    _bmi2.DownloadProgress += new EventHandler<DownloadProgressEventArgs>(bmi2_DownloadProgress);

    _bmi1.UriSource = new Uri(s1, UriKind.Absolute);
    _bmi2.UriSource = new Uri(s2, UriKind.Absolute);

    img1.Source = _bmi1;
    img2.Source = _bmi2;           
}

Private Sub LoadImages(ByVal s1 As String, ByVal s2 As String)
    brLoading.Visibility = Visibility.Visible
    spLoadingError.Visibility = Visibility.Collapsed

    If String.IsNullOrEmpty(s1) OrElse String.IsNullOrEmpty(s2) Then
        txtLoadingError.Text = "Invalid image location given"
        brLoading.Visibility = Visibility.Collapsed
        spLoadingError.Visibility = Visibility.Visible
        Return
    End If

    prgLoading1.Value = 0
    prgLoading2.Value = 0

    _bmi1 = New BitmapImage()
    _bmi2 = New BitmapImage()
    AddHandler _bmi1.DownloadProgress, AddressOf bmi1_DownloadProgress
    AddHandler _bmi2.DownloadProgress, AddressOf bmi2_DownloadProgress

    _bmi1.UriSource = New Uri(s1, UriKind.Absolute)
    _bmi2.UriSource = New Uri(s2, UriKind.Absolute)

    img1.Source = _bmi1
    img2.Source = _bmi2
End Sub

Now that we have a way to load images, the next step is to handle the different type of comparison modes. We will start with the dual view since that will be our default mode. As mentioned earlier, the dual view basically shows both images side by side in such a way where both images are presented as one. The first image is partially shown, and the second is shown as a continuation of the first. In order to do this, we track the mouse movement when it is inside of the canvas by setting up a MouseMove event handler. Every time the mouse moves, we grab the new x,y coordinates. Since dual view is only concerned with left/right movement, we only pass in the x coordinate.

void canvas_MouseMove(object sender, MouseEventArgs e)
{
    double x = e.GetPosition(canvas).X;
    double y = e.GetPosition(canvas).Y;
    
    if (_comparisonMode == ComparisonMode.DualView)
        DisplayDualView(x);
    else if (_comparisonMode == ComparisonMode.Rectangle)
    {
        // ...
    }
}

Private Sub canvas_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs)
    Dim x As Double = e.GetPosition(canvas).X
    Dim y As Double = e.GetPosition(canvas).Y

    If _comparisonMode = ComparisonMode.DualView Then
        DisplayDualView(x)
    ElseIf _comparisonMode = ComparisonMode.Rectangle Then            ' .....
    End If
End Sub

private void DisplayDualView(double x)
{
    rcImg1.Rect = new Rect(0, 0, x, IMGHEIGHT);         // Show the first half (left side), up to xCoord
    rcImg2.Rect = new Rect(x, 0, IMGWIDTH, IMGHEIGHT);  // Show the second-half (right side), starting from xCoord

    Canvas.SetLeft(border, x);                          // make the separator start at x
    Canvas.SetTop(border, 0);                           // set the separator to the top
}

Private Sub DisplayDualView(ByVal x As Double)
    rcImg1.Rect = New Rect(0, 0, x, IMGHEIGHT)         ' Show the first half (left side), up to xCoord
    rcImg2.Rect = New Rect(x, 0, IMGWIDTH, IMGHEIGHT)  ' Show the second-half (right side), starting from xCoord

    Canvas.SetLeft(border, x) ' make the separator start at x
    Canvas.SetTop(border, 0)  ' set the separator to the top
End Sub

The DisplayDualView() method sets the image clip region of the first image to be a rectangle starting from pixel 0 to pixel x, then sets the clip region of the second image to be the remaining pixels. It uses our border to represent a break in the two images so that it is clear where our mouse is. Note that the border is defined as having a width of 2 and a height of 1080 in order to display as a single line separating the two images. The border size is defined when the comparison mode is selected.

For the next comparison, we will focus on is the swap view mode. This is the easiest one to implement. In this, we show the first image in its entirety until the user places the mouse inside the canvas. When that happens, the second image is displayed until the user moves the mouse outside of the canvas.

private void DisplaySwapView(bool mouseOver)
{
    if (!mouseOver)
    {
        rcImg1.Rect = new Rect(0, 0, IMGWIDTH, IMGHEIGHT);
        rcImg2.Rect = new Rect(0, 0, 0, 0);
    }
    else
    {
        rcImg1.Rect = new Rect(0, 0, 0, 0);
        rcImg2.Rect = new Rect(0, 0, IMGWIDTH, IMGHEIGHT);
    }
}

Private Sub DisplaySwapView(ByVal mouseOver As Boolean)
    If (Not mouseOver) Then
        rcImg1.Rect = New Rect(0, 0, IMGWIDTH, IMGHEIGHT)
        rcImg2.Rect = New Rect(0, 0, 0, 0)
    Else
        rcImg1.Rect = New Rect(0, 0, 0, 0)
        rcImg2.Rect = New Rect(0, 0, IMGWIDTH, IMGHEIGHT)
    End If
End Sub

Our DisplaySwapView() method is very basic in that it basically uses the clip region to show an entire image, or to show none of the image depending on the value of the passed in bool, mouseOver. When mouseOver is false, we show the first image, when true we show the second image. While we could have used the Visibility property to show/hide the images, we use clipping in order to be consistent with our other modes.

The rectangle view is the last and most involved. Since the user will be drawing a rectangle with the mouse, we must keep track of mouse movement, the state of the mouse button, and the coordinates for the rectangle. We also need to display the rectangle as the user is drawing it and update clipped area of the image in real time in. In order to make this easier, we create a class called MouseRectangle will contain the important information about the mouse state and rectangle size and location.

public class MouseRectangle
{
    public bool MouseLeftButtonDown { get; set;}
    private Rect _rtg;

    private double? _startX;
    private double? _startY;

    public bool RectangleIsDrawn { get; set; }
    public Rect Rectangle { get { return _rtg;} }

    public MouseRectangle()
    {
        RectangleIsDrawn = false;
    }

    public void Reset()
    {
        _startX = null;
        _startY = null;
        RectangleIsDrawn = false;
    }

    public void CalculateRectangle(double x, double y)
    {
        if (_startX == null)
            _startX = x;
        if (_startY == null)
            _startY = y;

        // pick the smaller of the two
        double left = Math.Min(_startX.Value, x);
        double top = Math.Min(_startY.Value, y);

        _rtg = new Rect(left, top, Math.Abs(_startX.Value - x), Math.Abs(_startY.Value - y));             
    }

    public bool InBoundsOfRect(double x, double y)
    {
        if (x > _rtg.Left && x < _rtg.Right &&
            y > _rtg.Top && y < _rtg.Bottom)
            return true;
        return false;
    }

}

Public Class MouseRectangle
    Private privateMouseLeftButtonDown As Boolean
    Public Property MouseLeftButtonDown() As Boolean
        Get
            Return privateMouseLeftButtonDown
        End Get
        Set(ByVal value As Boolean)
            privateMouseLeftButtonDown = value
        End Set
    End Property
    Private _rtg As Rect

    Private _startX? As Double
    Private _startY? As Double

    Private privateRectangleIsDrawn As Boolean
    Public Property RectangleIsDrawn() As Boolean
        Get
            Return privateRectangleIsDrawn
        End Get
        Set(ByVal value As Boolean)
            privateRectangleIsDrawn = value
        End Set
    End Property
    Public ReadOnly Property Rectangle() As Rect
        Get
            Return _rtg
        End Get
    End Property

    Public Sub New()
        RectangleIsDrawn = False
    End Sub

    Public Sub Reset()
        _startX = Nothing
        _startY = Nothing
        RectangleIsDrawn = False
    End Sub

    Public Sub CalculateRectangle(ByVal x As Double, ByVal y As Double)
        If Not _startX.HasValue Then
            _startX = x
        End If
        If Not _startY.HasValue Then
            _startY = y
        End If

        ' pick the smaller of the two
        Dim left As Double = Math.Min(_startX.Value, x)
        Dim top As Double = Math.Min(_startY.Value, y)

        _rtg = New Rect(left, top, Math.Abs(_startX.Value - x), Math.Abs(_startY.Value - y))
    End Sub

    Public Function InBoundsOfRect(ByVal x As Double, ByVal y As Double) As Boolean
        If x > _rtg.Left AndAlso x < _rtg.Right AndAlso y > _rtg.Top AndAlso y < _rtg.Bottom Then
            Return True
        End If
        Return False
    End Function

End Class

The MouseLeftButtonDown property keeps track of whether the left button is currently being held down. There is also a Rect (_rtg) object which contains the location and dimension of the rectangle that has been drawn. The _startX and _startY member variables are nullable doubles used to keep track of the initial location where the mouse button was pressed.

Our CalculateRectangle() method is what we use to create the dimensions and location of the rectangle. We start by looking at the inital x,y coordinates, and if they are not set, it means the rectangle hasn't been drawn. In that case, a 0 pixel rectangle will be created. If those values are already set, we create the rectangle based on the x and y values passed in.

The InBoundsOfRect() method is a simple helper function that will tell us whether or not an x,y coordinate is within the bounds of the rectangle.

When in rectangle mode, the rectangle drawing begins when the mouse's left button is pressed down, and when the mouse is de-pressed, the drawing ends, and we consider the rectangle complete.

void canvas_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    _mouseRectangle.Reset();
    _mouseRectangle.MouseLeftButtonDown = true;
}

void canvas_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
    _mouseRectangle.MouseLeftButtonDown = false;
    _mouseRectangle.RectangleIsDrawn = true;
}

Private Sub canvas_MouseLeftButtonDown(ByVal sender As Object, ByVal e As MouseButtonEventArgs)
    _mouseRectangle.Reset()
    _mouseRectangle.MouseLeftButtonDown = True
End Sub

Private Sub canvas_MouseLeftButtonUp(ByVal sender As Object, ByVal e As MouseButtonEventArgs)
    _mouseRectangle.MouseLeftButtonDown = False
    _mouseRectangle.RectangleIsDrawn = True
End Sub

While in rectangle mode, when the mouse moves over the canvas, there are two different states. If the mouse button is pressed, it means the user is drawing, and our goal is to update the rectangle to match the location where the user's mouse is in relation to the canvas.

...
else if (_comparisonMode == ComparisonMode.Rectangle)
{
    if (_mouseRectangle.MouseLeftButtonDown)
        DrawRectangle(x,y);
    else if (_mouseRectangle.RectangleIsDrawn)
        DisplayRectangleView(x,y);
}
...

...
ElseIf _comparisonMode = ComparisonMode.Rectangle Then
    If _mouseRectangle.MouseLeftButtonDown Then
        DrawRectangle(x,y)
    ElseIf _mouseRectangle.RectangleIsDrawn Then
        DisplayRectangleView(x,y)
    End If
End If
...

The DrawRectangle() method starts out by calculating the rectangle based on the current x,y coordinates. We then set the border to represent our rectangle outline by sitting its location based on the _mouseRectangle's Rectangle property. Finally we draw the first image in its entirety, and the second image will only display the portion of the image based on the rectangle's location and width/height information. This will result in seeing the the first image with the rectangular portion showing the corresponding 2nd image.

private void DrawRectangle(double x, double y)
{
    _mouseRectangle.CalculateRectangle(x,y);

    Canvas.SetLeft(border, _mouseRectangle.Rectangle.Left);
    Canvas.SetTop(border, _mouseRectangle.Rectangle.Top);
    border.Width = _mouseRectangle.Rectangle.Width;
    border.Height = _mouseRectangle.Rectangle.Height;

    rcImg1.Rect = new Rect(0, 0, IMGWIDTH, IMGHEIGHT);
    rcImg2.Rect = _mouseRectangle.Rectangle;
}

Private Sub DrawRectangle(ByVal x As Double, ByVal y As Double)
    _mouseRectangle.CalculateRectangle(x, y)

    Canvas.SetLeft(border, _mouseRectangle.Rectangle.Left)
    Canvas.SetTop(border, _mouseRectangle.Rectangle.Top)
    border.Width = _mouseRectangle.Rectangle.Width
    border.Height = _mouseRectangle.Rectangle.Height

    rcImg1.Rect = New Rect(0, 0, IMGWIDTH, IMGHEIGHT)
    rcImg2.Rect = _mouseRectangle.Rectangle
End Sub

When the mouse button has been de-pressed, and the rectangle has been completed, we add the ability to do a mouse over effect for the rectangular region. While the mouse is located outside of the drawn rectangle, we leave it as is. If the user moves the mouse within the rectangle, we want them to see what the original looked like, so we display only the first image.

private void DisplayRectangleView(double x, double y)
{
    rcImg1.Rect = new Rect(0, 0, IMGWIDTH, IMGHEIGHT);

    if (_mouseRectangle.InBoundsOfRect(x,y))
        rcImg2.Rect = new Rect(0, 0, 0, 0);
    else
        rcImg2.Rect = _mouseRectangle.Rectangle;

}

Private Sub DisplayRectangleView(ByVal x As Double, ByVal y As Double)
    rcImg1.Rect = New Rect(0, 0, IMGWIDTH, IMGHEIGHT)

    If _mouseRectangle.InBoundsOfRect(x, y) Then
        rcImg2.Rect = New Rect(0, 0, 0, 0)
    Else
        rcImg2.Rect = _mouseRectangle.Rectangle
    End If

End Sub

Conclusion & Future Work

Overall, the blu-ray DVD comparison utility is a pretty straight-forward Silverlight application that you can use to see the differences between two images. These images don't even need to be from blu-ray or DVD sources, but as long as they are the right dimension, a user can use it to see subtle differences between the two by allowing three different comparison modes. For blu-ray purchases when you already own the DVD, I think it helps to see what kind of benefit you will get by moving to blu-ray. It has been my experience that almost every blu-ray offers some type of picture upgrade over its DVD counterpart (and sound upgrade as well). Sometimes the differences are subtle, sometimes they are incredibly better. There are a lot of factors involved, but

Some future work that can be done to this is adding the ability to zoom in and out on the images in order to be able to see differences in a closer view. Soon there will be more movies which will be re-released on blu-ray and you can use the tool to compare the old release to the new one. This will require zooming to see some of the more finer differences. Other work can be done by creating a database to hold links, and have a control that allows a user to navigate to different movies and view different comparisons. I have started doing both of these, but they were not ready for this article.

One definite area that needs work is the UI. I am not good at laying out user interfaces or creating new xaml styles, so I left them default.

What would be really useful is a full motion comparison where you can use similar modes to see how two movies compare while in motion, but the biggest problem would be finding or creating the comparison material. Playback would be limiting as well since it requires higher end CPUs/video cards.

Comparisons

Here are a few URLs you can use to play with the comparison utility:

	URL of Standard Def image (DVD) / HD (Blu-ray)
Prince Caspian	http://gmontrone.com/BDCompare/imgs/pc_1_sd.png http://gmontrone.com/BDCompare/imgs/pc_1_hd.png
Prince Caspian	http://gmontrone.com/BDCompare/imgs/pc_2_sd.png http://gmontrone.com/BDCompare/imgs/pc_2_hd.png
Iron Man	http://gmontrone.com/BDCompare/imgs/im_1_sd.png http://gmontrone.com/BDCompare/imgs/im_1_hd.png
Iron Man	http://gmontrone.com/BDCompare/imgs/im_2_sd.png http://gmontrone.com/BDCompare/imgs/im_2_hd.png
Entrapment	http://gmontrone.com/BDCompare/imgs/Ent_4_SD.png http://gmontrone.com/BDCompare/imgs/Ent_4_HD.png

Note: Images were copied from the blu-ray threads of A/V Science Forum: www.avsforum.com .

Thanks

I would like to thank Brian Peek for introducing me to Coding4Fun, and taking the time to review my article and test the code.

Inherited Message Distributing

Coding4Fun — Fri, 12 Sep 2008 00:35:05 GMT

Given a week off of school I found the time to start designing a system that had been thought up in a school class. The idea was simple, a webapp that lets a user reach the widest possible audience by distributing messages across many mediums. One message could be delivered to each recipient as an email, text message, instant message, or phone call to name a few possibilities. With this system, an already overworked teacher could take 30 seconds to send one message that was delivered to each student and parent instantly across multiple mediums. A sports coach could finally reach everyone on the team, without trying to post news on a site that was rarely checked and poorly maintained.

Robert Witoff

http://www.chalk2me.com/

Difficulty: Intermediate

Time Required: 3-6 hours

Cost: Free

Software: Visual Basic or Visual C# Express Editions

Hardware:

Download: Download

Disclaimer: Currently this article is C# only. If you want it in Visual Basic.Net, please comment and tell us so we can transcode it to VB.

Starting Out:

We thought we had come up with a cool concept, and I knew it wouldn’t be that difficult to build. After calling our dev-team into the office I started on it, by myself in my apartment. My goal was to have a single method to send any type of message that would then be picked up by an appropriate thread to deliver the message. As the whole idea here was to create and deliver messages, a logical place to start was a struct to hold our message fields. It’s always good to keep other services in mind while you’re building your own. I started off with the first 4 fields in any email. This covered message content and we only needed a bit more info to deliver the message. The medium type, along with an identifier field for your address (or screen name etc.), would cover this. Just in case a service we end up using needs a second identifier, I added one more. Check it out:

public struct ctMessage
{
    public ctMessage(string sendToUser, string fromUser, string subj, string msg, string

    mediumType, string mediumArg1, string mediumArg)
    {
        this.toUser = sendToUser;
        this.fromUser = fromUser;
        this.subject = subj;
        this.message = msg;
        this.mediumType = mediumType;
        this.mediumArg1 = mediumArg1;
        this.mediumArg2 = mediumArg2;
    }

    public string toUser; //name of recipient
    public string fromUser; //name of sender
    public string subject;
    public string message;
    public string mediumType; //which node should deliver this
    public string mediumArg1; //varies, to identify the recipient
    public string mediumArg2; //varies, to identify the recipient
}

Once we had a message designed I, of course, wanted to be able to send one! Eventually I wanted a bunch of different types of messages being sent, so a solid base class would save a ton of time later. Although all of the messaging services, or ‘nodes’ would undoubtedly send the messages completely different, they would all need to run in a similar thread that sent messages coming from a single location. By doing a good job writing an abstract base class, we could add new services by only overriding the 'send' method later.

This abstract class would have a field identifying the type of messages it will handle, and call an external send method whenever messages of that type existed. A continuous loop to poll for messages, given a modest polling frequency would do the trick. Notice the protected methods and fields that we'll want to override.

public abstract class ctNode
{
    public ctNode()
    {
        this.maxQueueSize = 100; //Set the size according to how long it will take to reach the Nth message
        this.msgQueue = new Queue(maxQueueSize);
        this.msPauseAfterRun = 10000; //If using a DB, polling it with no pause b/w queries is an unnecessary load
        this.runnerThread = new Thread(new ThreadStart(this.run));
    }

    private Thread runnerThread;
    protected int msPauseAfterRun;
    protected Queue msgQueue;
    public int maxQueueSize;

    void run()
    {
        while (true)
        {
            while (this.msgQueue.Count > 0)
            {
                //pop a message and send it
                ctMessage ctm = (ctMessage)msgQueue.Dequeue();

                try
                {
                    sendSingleMessage(ctm);
                }
                catch (Exception e)
                {
                    //Write a more detailed error log here
                    Console.writeLine("the message could not be sent!" + e.toString());
                }
            }

            //get new messages
            ctNode ctn = this;
            ctMessage[] newMessages = messageSender.getMessages(ref ctn, getRoomInQueue());

            //Wait some time before checking for more messages!
            if (newMessages.Length == 0)
                Thread.Sleep(msPauseAfterRun);
            else
                this.EnqueueMessages(newMessages);
        }
    }

    public virtual void EnqueueMessages(ctMessage[] messagesToSend)
    {
        int roomInQueue = maxQueueSize - msgQueue.Count;

        if (messagesToSend.Length > roomInQueue)
            throw new Exception("Too many Messages have been inserted");

        for (int i = 0; i < messagesToSend.Length; i++)
        {
            msgQueue.Enqueue(messagesToSend[i]);
        }
    }

    public virtual void EnqueueMessages(ctMessage messageToSend)
    {
        ctMessage[] ctm = new ctMessage[1];
        ctm[0] = messageToSend;
        this.EnqueueMessages(ctm);
    }

    protected virtual void sendSingleMessage(ctMessage ctm)
    {
        //code to send an individual message
    }

    public void startThread()
    {
        runnerThread.Name = this.nodeType;
        runnerThread.Start();
    }

    protected string nodeType;

    public string getNodeType()
    {
        return this.nodeType;
    }
}

You might have noticed the big thing missing from these classes, a place to store, and retrieve messages! I initially put our message storage into an external static class. This made them centralized, easily accessible from any other objects that might need to access them, simple to ensure thread safety, and gave us room to move to a smarter mechanism later (or database. Notice the simplicity:

public static class messageSender
{
    private static List<ctMessage> messagesToSend = new List<ctMessage>();

    public static ctMessage[] getMessages(ref ctNode nodeRef, int numberOfMessages)
    {
        //We'll do this in a database later, but for now this works similarly
        List<ctMessage> returnMessages = new List<ctMessage>();

        lock (messagesToSend)
            for (int i = 0; i < messagesToSend.Count; i++)
                if (messagesToSend[i].mediumArgs == nodeRef.getNodeType())
                {
                    returnMessages.Add(messagesToSend[i]);
                    messagesToSend.RemoveAt(i);
                    i--;
                }

        return returnMessages.ToArray();
    }

    public static void sendMessage(ctMessage message)
    {
        lock (messagesToSend)
            messagesToSend.Add(message);
    }
}

Now that the groundwork was done, I grabbed some eye drops and an energy drink to refresh for the best part, function! I started simple with an email node, and if you’ve played with email before in .net, you’ve definitely seen and loved the SmtpClient class in the System.Net.Mail Namespace. If you don’t already have a local SMTP client set up, you can easily use a Gmail account as an SMTP server. Check out the following implementation, notice we only had to set the node type, initialize the SmtpClient and override the send method. Send a message through our message sender, and watch the node pick up the message and deliver it. Inheritance rocks!

ctMessage ctm = new ctMessge("Friend", "Developer", "testing", "My first message", "email", "yourEmail@yourDomain.com", "");
messageSender.sendMessage(ctm);

public class ctNodeEmail : ctNode
{
    public ctNodeEmail() : base()
    {
        this.nodeType = "email";

        //
        //SET UP SMTP CLIENT
        //

        //GMAIL SERVER
        this.mSmtpClient = new SmtpClient("gmail.com/mail", 25);
        this.mSmtpClient.Host = "smtp.gmail.com";
        this.mSmtpClient.Port = 25;
        this.mSmtpClient.EnableSsl = true;
        this.mSmtpClient.Credentials = new System.Net.NetworkCredential("YOURADDRESS@gmail.com", "YOUR_PASSWORD");

        //LOCAL SERVER
        //this.mSmtpClient = new SmtpClient("localhost", 25);
    }

    SmtpClient mSmtpClient;

    protected override void sendSingleMessage(ctMessage ctm)
    {
        MailMessage msgMail = new MailMessage(new MailAddress(ctm.fromUser + "@ChalkTalkNow.com"), new MailAddress(ctm.mediumArgs));
        msgMail.Subject = ctm.subject;
        string msg = ctm.message;
        msgMail.Body = msg;

        // Send the mail message
        mSmtpClient.Send(msgMail);
    }
}

After writing this so quickly I wanted something a bit more than email, and knew text messages were only a step away. It’s no secret that all major cell companies give your phone an email address, you just need to append the proper domain to your number. Building off of our email node, we used the first mediumArg to hold a phone number, and put the carrier into the second mediumArg.

public class ctNodeTextMessage : ctNode
{
    public ctNodeTextMessage() : base()
    {
        this.nodeType = "textmessage";

        //
        //SET UP SMTP CLIENT
        //
        this.mSmtpClient = new SmtpClient("gmail.com/mail", 25);
        this.mSmtpClient.Host = "smtp.gmail.com";
        this.mSmtpClient.Port = 25;
        this.mSmtpClient.EnableSsl = true;
        this.mSmtpClient.Credentials = new System.Net.NetworkCredential("GMAIL@gmail.com", "PASSWORD");

    }
    SmtpClient mSmtpClient;

    private string getEmailAddress(string phoneNumber, string provider)
    {
        switch (provider)
        {
            case "t-mobile":
                return phoneNumber + "@tmomail.net";
            case "virginmobile":
                return phoneNumber + "@vmobl.com";
            case "cingular":
                return phoneNumber + "@cingularme.com";
            case "att":
                return phoneNumber + "@cingularme.com";
            case "sprint":
                return phoneNumber + "@messaging.sprintpcs.com";
            case "verizon":
                return phoneNumber + "@vtext.com";
            case "nextel":
                return phoneNumber + "@messaging.nextel.com";
            default:
                //assume cingular/att is the most popular
                return phoneNumber + "@cingularme.com";
        }
    }

    protected override void sendSingleMessage(ctMessage ctm)
    {
        //send a single message
        string emailAddress = getEmailAddress(ctm.mediumArg1, ctm.mediumArg2);

        MailMessage msgMail = new MailMessage(new MailAddress(ctm.fromUser + "@chalktalk.net", ctm.fromUser), new MailAddress(emailAddress));
        msgMail.Subject = ctm.subject;
        msgMail.Body = ctm.message;
        sendEmail(msgMail);
    }

    private void sendEmail(MailMessage msgMail)
    {
        // Send the mail message
        this.mSmtpClient.Send(msgMail);
    }
}

Now to test this out, just like we sent the email we’ll send a text. Cool!

ctMessage ctm = new ctMessge("Friend", "Developer", "testing", "hello world via text", "textmessage", "#########", "verizon");
messageSender.sendMessage(ctm);

Conclusion:

When you’re working on a project with a small team, it’s especially important to build a good foundation like this so you can focus on easily added functionality without getting bogged down in complexity. This portion of the project was written over the course of a week and later on allowed us to focus almost exclusively on adding new services like Instant Messengers and interactive phone calling. Having functionality so quickly was crucial, along with a UI built by my brother, in getting the attention and support of others to build a business around this.

Next Steps:

Build a UI to manage content and run your messaging!
Rewrite your messageSender class to store messages in a database. This will make your app much more extensible, and you can save a record of the messages sent in an ‘outbox’.
Strongly type all textual identifiers in enumerations to avoid any frustrating mistakes.
Find an SDK for your favorite messenger, and build a node for it
Join our team and continue to build with us!

Silverlight Dynamic Video Puzzle

Coding4Fun — Tue, 22 Jan 2008 22:02:00 GMT

My blog title says it all, Monkey see, Monkey Build. I saw Microsoft Surface's video puzzle and I needed to build it. I took this opportunity to play with Microsoft's new technology, Silverlight and build my own puzzle game. I couldn't find anything out on the Internet regarding dynamic video creation with Silverlight so I took it upon myself to do this. The screen shots in this demo will be in c#, however, everything should hold true for VB.

Clint Rutkas - Academic Developer Evangelist - Microsoft
Monkey see, Monkey Build

Difficulty: Intermediate
Time Required: 6-10 hours
Cost: Free
Software: Visual Studio Express, Silverlight SDK and Runtime for ~~1.1~~ 2.0 beta2
Download: ~~Download c#~~ - ~~Download VB~~ Updated to Silverlight 2.0 Beta - Download c#

Updates:

Fixed the Silverlight.Js, used the new version that is included with the 1.1 Refresh SDK so the proper installer will prompt now. Downloads are corrected also too.
6/20/2008 - Verified the solution works with Silverlight 2.0beta2.

Spec's, Requirements and headaches

So I had a few mental requirements for the application to "entertain" myself.

Be able to rotate the video blocks
Be able to translate
Be able to increase the difficulty of the puzzle on the fly.
Zero interaction with the keyboard

Simple, right? You want to see a demo too see some awesomeness? No problem, head over to my site and see it in person.

Microsoft Surface Video Puzzle

Clint's Silverlight Video Puzzle

To the Internet Batman!

To help save time building this, I first when out and attempting to see if anything has been done anything close to this before. I found

Also I need 2 small controls which I found out are in the Silverlight SDK. I needed horizontal slider controls for this app. While I know a text box control would have worked just as well, see requirement 4.

On the Silverlight community site, there is also a very nice demo showing the photo application in Surface with source code. This is where I learned the majority of what I needed. This application was very close to where I needed to go with mine. However, while it was close, it wasn't perfect. Parts of the photo application code are pretty much copied. This isn't the best way of doing this, but it is one way of doing it.

Toolbelt: check, Keyboard: check, Band-aids: check

So on to building it. I first started off with a new project and some XAML.

After clicking "OK", I get a very nice blank project.

We'll want to add an additional XAML object for the video blocks. Go to "Project -> Add New Item", select Silverlight Page, name it "VideoBlock.xaml" and click "OK".

So now we have everything we need for the most part, grab any video you have, if you don't have one, go to a site like TeamXbox and grab one from there. I used Windows Movie Maker and grabbed a snippet from The Office (best show ever).

In addition to all these files, we need to add in a reference to the Silverlight SDK to get a hold of the Slider controls. Go to "Project -> Add Reference", and add in the Silverlight.Samples.Controls.dll.

While we have a reference in the application, we still need the XAML to know about this also. So we'll add a line to link this in. It is the xmlns line that I bolded, XML name space, real clever, eh? We'll also change the background color to a gray so we can see it more easy.

<Canvas x:Name="parentCanvas"
        xmlns="http://schemas.microsoft.com/client/2007" 
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
        Loaded="Page_Loaded" 
        x:Class="c4f_SilverlightVideoDemo.VideoBlock;assembly=ClientBin/c4f_SilverlightVideoDemo.dll"
        xmlns:uicontrol="clr-namespace:Silverlight.Samples.Controls;assembly=ClientBin/Silverlight.Samples.Controls.dll"
        Background="#CCCCCC" Width="640" Height="480">
</Canvas>

Silverlight 101

So in Silverlight, you have brushes which can "painted" onto objects. One of these brushes is called the VideoBrush which I'll talk about later on. For playing videos, one would use the MediaElement. Lets add this to our canvas.

<MediaElement x:Name="media" Source="theOffice.wmv" />

Now if we run the application at this point, we'll get the video playing. Lets sit back with some popcorn and enjoy this victory for a second or two. Now that we have this, lets hide it since this isn't what we want. We do that by adding in an XML attribute Opacity and setting it to 0.

On top of that element, lets add on some TextBlock elements and the sliders.

<Canvas x:Name="parentCanvas"
        xmlns="http://schemas.microsoft.com/client/2007" 
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
        Loaded="Page_Loaded" 
        x:Class="VideoCreatedObjectTest.Page;assembly=ClientBin/VideoCreatedObjectTest.dll"
        xmlns:uicontrol="clr-namespace:Silverlight.Samples.Controls;assembly=ClientBin/Silverlight.Samples.Controls.dll" 
        Background="#CCCCCC" >
    <MediaElement x:Name="media" Source="theOffice.wmv" Opacity="0" />
    
    <TextBlock x:Name="sliderX" Canvas.Top="5" Canvas.Left="5" Text="X (01):" />
    <TextBlock x:Name="sliderY"  Canvas.Top="21" Canvas.Left="5" Text="Y (01):" />
    
    <uicontrol:Slider x:Name="hSliderX" Canvas.Top="8" Canvas.Left="55" />
    <uicontrol:Slider x:Name="hSliderY" Canvas.Top="25" Canvas.Left="55" />
</Canvas>

So now when we run the application, we get a blank screen but we can hear the audio from the video.

Super exciting I know. Now if you resize the browser, you'll notice also the canvas isn't resizing automatically. Lets fix that.

So in the code behind lets add in a new event on the BrowserHost object with the Resize event. We'll attach the Browser_Resize event to it.

private void BrowserHost_Resize(object sender, EventArgs e)
{
    // Set size to host size
    Width = BrowserHost.ActualWidth;
    Height = BrowserHost.ActualHeight;
}

VB.Net

Private Sub BrowserHost_Resize(ByVal sender As Object, ByVal e As EventArgs)
    ' Set size to host size
    Width = BrowserHost.ActualWidth
    Height = BrowserHost.ActualHeight
End Sub

Video as Paint?

So now that we have that small part done, lets get into more of the nitty gritty with video. As I said earlier, you'll use a VideoBrush to paint on the video.

We'll use the brush as the Fill for the rectangle we'll be using to show off the clip of the video we want.

Still not moving? Try explosives?

While doing this project, I discovered an interesting thing when using the VideoBrush and dynamically appending items on. Having items in the XAML rather than programmatically creating everything caused it not to work properly. Nothing would appear.

Throwback to how UI's use to be done

The XAML for this is a simplified version of the Surface demo Photo.XAML. You have a 3 Rectangles, 1 for the video, 1 for translation and 1 for rotation. Simple, no? Doing all this by hand gets a bit annoying since you need to nest everything properly.

Here is the more interesting VideoBrush code. You need the name from the MediaElement along with the how much of an offset you want the video. Since your moving the "camera" in, this value needs to be negative.

public delegate void SetActiveVideo(VideoBlock videoBlock, ActionType actionType, Point photoCenter, Point lastPosition);
public VideoBlock(string mediaName, int offsetX, int offsetY, int rectWidth, int rectHeight, SetActiveVideo functionPointer)
{
    // additional code here
    Rectangle video = new Rectangle();
    VideoBrush vb = new VideoBrush();
    TranslateTransform videoTransform = new TranslateTransform();
    videoTransform.X = -1 * offsetX;
    videoTransform.Y = -1 * offsetY;

    vb.SourceName = mediaName;
    vb.Transform = videoTransform;
    vb.Stretch = Stretch.None;
    vb.AlignmentX = AlignmentX.Left;
    vb.AlignmentY = AlignmentY.Top;

    video.Width = Width;
    video.Height = Height;
    video.Fill = vb;
    // additional code here
}

VB.Net

Public Delegate Sub SetActiveVideo(ByVal videoBlock As VideoBlock, ByVal actionType As ActionType, ByVal photoCenter As Point, ByVal lastPosition As Point)
Public Sub VideoBlock(ByVal mediaName As String, ByVal offsetX As Integer, ByVal offsetY As Integer, ByVal rectWidth As Integer, ByVal rectHeight As Integer, ByVal functionPointer As SetActiveVideo)
      ' additional code here
      Dim video As Rectangle = New Rectangle
      Dim vb As VideoBrush = New VideoBrush
      Dim videoTransform As TranslateTransform = New TranslateTransform
      videoTransform.X = ((1 * offsetX)  * -1)
      videoTransform.Y = ((1 * offsetY)  * -1)
      vb.SourceName = mediaName
      vb.Transform = videoTransform
      vb.Stretch = Stretch.None
      vb.AlignmentX = AlignmentX.Left
      vb.AlignmentY = AlignmentY.Top
      video.Width = Width
      video.Height = Height
      video.Fill = vb
      ' additional code here
End Sub

There is a mouse on my object!

So now we have our video block element prepped and ready. There are additional events added in, but they are fairly boiler plate. When looking at this code, you see I pass in a delegate, a function pointer if you will. Why do I do this? This is how the mouse position is calculated. I bet this could be redone better, but this is how I did it. The parent element, the canvas, has the mouse position I need to calculate proper translation and rotation, however, mouse events on the VideoBlock object will give me the mouse position only on that element. So I may be at point 150, 150 on the screen, on the VideoBlock object, I'm actually at 10,15.

Additionally, this approach allows me to move the VideoBlock to the top of the objects. Once again, this could be done other ways, this is how I chose to do it.

So on all my mouse related all boils down to doing the exact same function. Since events are bubbled, a mouse movement on a VideoBlock is also a mouse movement on the root canvas.

private void root_MouseLeftButtonDown(object sender, MouseEventArgs e)
{
    HandleMouseLeftButtonDown(ActionType.Selecting, e);
}

private void translateControls_MouseLeftButtonDown(object sender, MouseEventArgs e)
{
    HandleMouseLeftButtonDown(ActionType.Moving, e);
}

private void rotateScaleControls_MouseLeftButtonDown(object sender, MouseEventArgs e)
{
    HandleMouseLeftButtonDown(ActionType.RotatingScaling, e);
}

private void HandleMouseLeftButtonDown(ActionType actionType, MouseEventArgs e)
{
    if (functionPointer != null)
        functionPointer(this, actionType,
            new Point(translateTransform.X + rotateTransform.CenterX,
                  translateTransform.Y + rotateTransform.CenterY), e.GetPosition(null));
}

VB.Net

    Private Sub root_MouseLeftButtonDown(ByVal sender As Object, ByVal e As MouseEventArgs)
        HandleMouseLeftButtonDown(ActionType.Selecting, e)
    End Sub
    
    Private Sub translateControls_MouseLeftButtonDown(ByVal sender As Object, ByVal e As MouseEventArgs)
        HandleMouseLeftButtonDown(ActionType.Moving, e)
    End Sub
    
    Private Sub rotateScaleControls_MouseLeftButtonDown(ByVal sender As Object, ByVal e As MouseEventArgs)
        HandleMouseLeftButtonDown(ActionType.RotatingScaling, e)
    End Sub
    
    Private Sub HandleMouseLeftButtonDown(ByVal actionType As ActionType, ByVal e As MouseEventArgs)
        If (Not (functionPointer) Is Nothing) Then
            functionPointer(Me, actionType, New Point((translateTransform.X + rotateTransform.CenterX), 
              (translateTransform.Y + rotateTransform.CenterY)), e.GetPosition(Nothing))
        End If
    End Sub

You built a car out of all these parts?

So we move back from VideoBlock.xaml.cs to Page.xaml.cs

We've created our primary object for painting video, lets populate it. First, how do we know how big the media file is? With the MediaOpened event! And we'll restart the video with the MediaEnded event.

So here is the full Page_Load event from Page.xaml.cs

public void Page_Loaded(object o, EventArgs e)
{
    // Required to initialize variables
    InitializeComponent();

    BrowserHost.Resize +=new EventHandler(BrowserHost_Resize);
    media.MediaOpened += new EventHandler(media_MediaOpened);
    media.MediaEnded += new EventHandler(media_MediaEnded);
    MouseLeftButtonUp += Page_MouseLeftButtonUpOrLeave;
    MouseLeave += Page_MouseLeftButtonUpOrLeave;
    MouseMove += Page_MouseMove;

    hSliderX.Range = new ValueRange(1, 20);
    hSliderY.Range = new ValueRange(1, 20);
    hSliderX.ValueChanged += new EventHandler(slider_ValueChanged);
    hSliderY.ValueChanged += new EventHandler(slider_ValueChanged);

    hSliderX.SetValue(ZIndexProperty, 500);
    hSliderY.SetValue(ZIndexProperty, 500);
    sliderX.SetValue(ZIndexProperty, 500);
    sliderY.SetValue(ZIndexProperty, 500);
}

VB.Net

    Public Sub Page_Loaded(ByVal o As Object, ByVal e As EventArgs)
        ' Required to initialize variables
        InitializeComponent
        AddHandler BrowserHost.Resize, AddressOf Me.BrowserHost_Resize
        AddHandler media.MediaOpened, AddressOf Me.media_MediaOpened
        AddHandler media.MediaEnded, AddressOf Me.media_MediaEnded
        MouseLeftButtonUp = (MouseLeftButtonUp + Page_MouseLeftButtonUpOrLeave)
        MouseLeave = (MouseLeave + Page_MouseLeftButtonUpOrLeave)
        MouseMove = (MouseMove + Page_MouseMove)
        hSliderX.Range = New ValueRange(1, 20)
        hSliderY.Range = New ValueRange(1, 20)
        AddHandler hSliderX.ValueChanged, AddressOf Me.slider_ValueChanged
        AddHandler hSliderY.ValueChanged, AddressOf Me.slider_ValueChanged
        hSliderX.SetValue(ZIndexProperty, 500)
        hSliderY.SetValue(ZIndexProperty, 500)
        sliderX.SetValue(ZIndexProperty, 500)
        sliderY.SetValue(ZIndexProperty, 500)
    End Sub

So now that we have the media loaded, we can use the media.NaturalVideoWidth and media.NaturalVideoHeight properties to find out exactly how big the video is! I have a function that is fired off when the page is first loaded or a slider value has changed. This is how we chop it up.

private void prepVideoObjects()
{
    int totalPhotosX = (int)hSliderX.Value;
    int totalPhotosY = (int)hSliderY.Value;

    if (lastX != totalPhotosX || lastY != totalPhotosY)
    {
        lastX = totalPhotosX;
        lastY = totalPhotosY;

        sliderX.Text = string.Format("X ({0}):", totalPhotosX.ToString("D2"));
        sliderY.Text = string.Format("Y ({0}):", totalPhotosY.ToString("D2"));

        int rectWidth = (int)Math.Floor(media.NaturalVideoWidth / totalPhotosX);
        int rectHeight = (int)Math.Floor(media.NaturalVideoHeight / totalPhotosY);
        Random random = new Random();

        // remove all old videoblocks
        for (int i = Children.Count - 1; i > 0; i--)
        {
            if (Children[i].GetType() == typeof(VideoBlock))
                Children.RemoveAt(i);
        }

        for (int x = 0; x < totalPhotosX; x++)
        {
            for (int y = 0; y < totalPhotosY; y++)
            {
                VideoBlock vb = new VideoBlock(media.Name, x * rectWidth, y * rectHeight, rectWidth, rectHeight, SetActivePhoto);
                shuffle(vb, random);
                Children.Add(vb);
            }
        }
    }
}

VB.Net

Private Sub prepVideoObjects()
        Dim totalPhotosX As Integer = CType(hSliderX.Value,Integer)
        Dim totalPhotosY As Integer = CType(hSliderY.Value,Integer)
        If ((lastX <> totalPhotosX)  _
                    OrElse (lastY <> totalPhotosY)) Then
            lastX = totalPhotosX
            lastY = totalPhotosY
            sliderX.Text = String.Format("X ({0}):", totalPhotosX.ToString("D2"))
            sliderY.Text = String.Format("Y ({0}):", totalPhotosY.ToString("D2"))
            Dim rectWidth As Integer = CType(Math.Floor((media.NaturalVideoWidth / totalPhotosX)),Integer)
            Dim rectHeight As Integer = CType(Math.Floor((media.NaturalVideoHeight / totalPhotosY)),Integer)
            Dim random As Random = New Random
            ' remove all old videoblocks
            Dim i As Integer = (Children.Count - 1)
            Do While (i > 0)
                If (Children(i).GetType = GetType(VideoBlock)) Then
                    Children.RemoveAt(i)
                End If
                i = (i - 1)
            Loop
            Dim x As Integer = 0
            Do While (x < totalPhotosX)
                Dim y As Integer = 0
                Do While (y < totalPhotosY)
                    Dim vb As VideoBlock = New VideoBlock(media.Name, (x * rectWidth), (y * rectHeight), rectWidth, rectHeight, SetActivePhoto)
                    shuffle(vb, random)
                    Children.Add(vb)
                    y = (y + 1)
                Loop
                x = (x + 1)
            Loop
        End If
    End Sub

Last but not least, lets see how the mouse movements are handled on the page.

private void Page_MouseMove(object sender, MouseEventArgs e)
{
    if (null != activeVideoBlock)
    {
        // Perform the appropriate transform on the active photo
        Point position = e.GetPosition(null);
        switch (currentActionType)
        {
            case VideoBlock.ActionType.Moving:
                // Move it by the amount of the mouse move
                activeVideoBlock.Translate(position.X - currentLastPosition.X, position.Y - currentLastPosition.Y);
                break;
            case VideoBlock.ActionType.RotatingScaling:
                // Rotate it according to the angle the mouse moved around the photo's center
                double radiansToDegrees = 360 / (2 * Math.PI);
                double lastAngle = Math.Atan2(currentLastPosition.Y - currentVideoCenter.Y, currentLastPosition.X - currentVideoCenter.X) * radiansToDegrees;
                double currentAngle = Math.Atan2(position.Y - currentVideoCenter.Y, position.X - currentVideoCenter.X) * radiansToDegrees;
                activeVideoBlock.Rotate(currentAngle - lastAngle);

                break;
        }
        currentLastPosition = position;
    }
}

VB.Net

    Private Sub Page_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs)
        If (Not (activeVideoBlock) Is Nothing) Then
            ' Perform the appropriate transform on the active photo
            Dim position As Point = e.GetPosition(Nothing)
            Select Case (currentActionType)
                Case VideoBlock.ActionType.Moving
                    ' Move it by the amount of the mouse move
                    activeVideoBlock.Translate((position.X - currentLastPosition.X), (position.Y - currentLastPosition.Y))
                Case VideoBlock.ActionType.RotatingScaling
                    ' Rotate it according to the angle the mouse moved around the photo's center
                    Dim radiansToDegrees As Double = (360 / (2 * Math.PI))
                    Dim lastAngle As Double = (Math.Atan2((currentLastPosition.Y - currentVideoCenter.Y), (currentLastPosition.X - currentVideoCenter.X)) * radiansToDegrees)
                    Dim currentAngle As Double = (Math.Atan2((position.Y - currentVideoCenter.Y), (position.X - currentVideoCenter.X)) * radiansToDegrees)
                    activeVideoBlock.Rotate((currentAngle - lastAngle))
            End Select
            currentLastPosition = position
        End If
    End Sub

Wrapping it up

So as you can see, Silverlight is pretty powerful once you figure out how to tame it. I used example base code and modified it to suit my own needs to dynamically alter a video in real time. There are a few code tweaks that could happen to improve this code and I'm betting with some additional effort, one could remove the delegate. In addition, you could add in edge detection code and a timer to make this into a true video puzzle game. This was a pet project I worked on while I was at the airport. This demo can be downgraded to Silverlight 1.0 also. I don't believe anything I did was really Silverlight 1.1 (now 2.0) only.

Clint's Bio:

Clint is an academic developer evangelist for Microsoft. His two primary development languages are C# and JavaScript. He has built a Disco Dance Floor too! In his off time, he whips up other random weird projects and does twenty something activities with his friends. His next two big projects are an automated bartender and a skateboard segway. Clint’s blog is betterthaneveryone.com and can be emailed at crutkas@microsoft.com if you have any question.

Silverlight 8-Ball

Coding4Fun — Thu, 20 Sep 2007 03:03:50 GMT

	In this article, I will discuss how I have built a 2 player 8-Ball game in Silverlight (play here). I will explain how I used the Expression tools to design the graphics and various .NET techniques to enable user control and game animation.
Justin Petersen Coding4Fun at Clarity Difficulty: Intermediate Time Required: 6-10 hours Cost: Free Software: Visual Studio 2008 Beta 2, Silverlight 1.1 Alpha Refresh, Expression Design, Expression Blend 2 Preview Hardware: Download: Download

In this article, I will discuss how I have built a 2 player 8-Ball game in Silverlight (play here). I will explain how I used the Expression tools to design the graphics and various .NET techniques to enable user control and game animation.

The following components must be implemented to complete this game:

Graphics (pool table, pool ball, and pool stick)
Vector animation and collision physics
User interaction
Game state and control

Before I continue, I’d like to point out that I did not originate all of the code and XAML for this solution. I came up with the idea of creating a Silverlight 8-Ball game after stumbling upon a 2-D “bouncing bubble” animation here: http://www.bubblemark.com/ created by Alexey Gavrilov.

The original intent for this solution was to compare the performance of the bouncing bubbles across various platforms. I found this very useful, but was personally interested in making something fun and interactive out of it.

Getting Started

Prerequisites

The following tools were used to implement this solution:

Visual Studio 2008 Beta 2
Silverlight 1.1 Alpha Refresh
Expression Design
Expression Blend

Learning more about game development

If you'd like to learn more about game development, I found a number Coding4Fun posts under Gaming helpful. In particular, the 2D Game Primer by "ZMan" gives a good overview of the basics (e.g. GameLoop, Sprites, etc.)

Graphics

I am not much of a graphic designer. In fact, I've spent the majority of my career designing and implementing line of business apps for enterprise customers (typically not a very graphically intensive task). So I believe it is a decent testament to the effectiveness of the Microsoft Expression suite that I could, in short order, create the graphics for this game.

I used Expression Design to build the graphics of the pool table. Modeling my design after the standard dimension of a 9 foot billiards table, I drew the main structure as a rectangle with rounded corners. I drew a smaller green rectangle centered over it for the playing surface (of course following standard dimensions). Next, I created 6 black circles placed one level behind the playing surface to give the impression of pockets. Lastly, I added the wood texture to the outside rectangle (which was super easy as there is a set of wood textures available by default), and drew a simple rounded rectangle beneath the table to serve as a status bar.

I also created the graphics for my pool stick using Expression Design. This consisted of a few tapered polygons and 2 half circles for the butt and tip.

After exporting the associated XAML, I imported each element into my project. From here, I could view and refine the design through a scaled down visual editor or the associated XAML.

Lastly, I inspected the XAML markup for the pool ball I reused from Alexey's Bubblemark solution. I needed to understand the properties of this object so that I could modify the color of the balls later on.

Vector Animation and Collision Physics

The root of Silverlight8Ball is a Storyboard (x:Name=”GameLoop”) that acts as a triggering mechanism for determining ball velocity, direction, and redirection due to collision. Whereas some Storyboards are implemented with predetermined paths and timelines directly in XAML, the action taken at each tick must be determined dynamically in this game. So we simply set the duration to 00:00:0, and handle the Completed event to trigger our positioning logic. This design effectively creates what game developers call a “Game Loop” that triggers continuous processing to determine application state.

The resulting “GameLoop_Completedhandler” becomes the root processing agent for all of the game’s ball movement logic.

   1: void GameLoop_Completed(object sender, EventArgs e)   2: {   3:     switch (m_ActionState)   4:     {   5:         case m_ActionStates.BallsMoving:   6:     7:             // prep   8:             List<Ball> removeList = new List<Ball>();   9:             bool someBallsAreMoving = false;  10:    11:             // move each ball  12:             foreach (Ball ball in m_GameBalls)  13:             {  14:                 ball.Move();  15:                 if (ball.InPocket) removeList.Add(ball);  16:                 else if (ball.IsMoving) someBallsAreMoving = true;  17:             }  18:    19:             // store balls sunk on shot and update ui   20:             foreach (Ball ball in removeList)  21:             {  22:                 sunkBalls.Add(ball);  23:                 RemoveBall(ball);  24:             }  25:    26:             if (someBallsAreMoving)  27:             {  28:                 // update vectors for ball collisions  29:                 for (int i = 0; i < m_GameBalls.Count; i++)  30:                 {  31:                     for (int j = i + 1; j < m_GameBalls.Count; j++)  32:                     {  33:                         m_GameBalls[i].DoCollide(m_GameBalls[j]);  34:                     }  35:                 }  36:             }  37:             else  38:             {  39:                 // determine shot results  40:                 ShotResults results = EvaluateShot();  41:    42:                 // apply state and ui changes  43:                 UpdateGameState(results);  44:             }  45:    46:             break;  47:     }  48:    49:     // restart the storyboard  50:     if (m_IsRunning)  51:     {  52:         GameLoop.Begin();  53:     }  54:    55: }

   1: Private Sub GameLoop_Completed(ByVal sender As Object, ByVal e As EventArgs)   2:     3:     Select Case m_ActionState   4:     5:         Case m_ActionStates.BallsMoving   6:     7:             ' prep   8:             Dim removeList As List(Of Ball) = New List(Of Ball)()   9:             Dim someBallsAreMoving As Boolean = False  10:    11:             ' move each ball  12:             For Each ball As Ball In m_GameBalls  13:                 ball.Move()  14:                 If ball.InPocket Then  15:                     removeList.Add(ball)  16:                 ElseIf ball.IsMoving Then  17:                     someBallsAreMoving = True  18:                 End If  19:             Next ball  20:    21:             ' store balls sunk on shot and update ui   22:             For Each ball As Ball In removeList  23:                 sunkBalls.Add(ball)  24:                 RemoveBall(ball)  25:             Next ball  26:    27:             If someBallsAreMoving Then  28:                 ' update vectors for ball collisions  29:                 For i As Integer = 0 To m_GameBalls.Count - 1  30:                     For j As Integer = i + 1 To m_GameBalls.Count - 1  31:                         m_GameBalls(i).DoCollide(m_GameBalls(j))  32:                     Next j  33:                 Next i  34:             Else  35:                 ' determine shot results  36:                 Dim results As ShotResults = EvaluateShot()  37:    38:                 ' apply state and ui changes  39:                 UpdateGameState(results)  40:             End If  41:    42:     End Select  43:    44:     ' restart the storyboard  45:     If m_IsRunning Then  46:         GameLoop.Begin()  47:     End If  48:    49: End Sub

The above code snippets demonstrate the full functionality of our GameLoop. However, the primary animation and collision logic are handled by "ball.Move();" and "m_GameBalls[i].DoCollide(m_GameBalls[j]);" lines (in C# example). The Move() function of each ball applies its current vector (i.e. x and y "velocities") to determine its next position and updates the ball's UI element coordinates. Once the ball is advanced, the DoCollide function checks if two balls have collided. If so, their vectors are adjusted accordingly.

   1: public bool DoCollide(Ball b)   2: {   3:     // calculate some vectors    4:     double dx = this._x - b._x;   5:     double dy = this._y - b._y;   6:     double dvx = this._vx - b._vx;   7:     double dvy = this._vy - b._vy;   8:     double distance2 = dx * dx + dy * dy;   9:       10:     if (Math.Abs(dx) > this._d || Math.Abs(dy) > this._d)  11:         return false;  12:     if (distance2 > this._d2)  13:         return false;  14:    15:     // make absolutely elastic collision  16:     double mag = dvx * dx + dvy * dy;  17:    18:     // test that balls move towards each other      19:     if (mag > 0)  20:         return false;  21:    22:     mag /= distance2;  23:    24:     double delta_vx = dx * mag;  25:     double delta_vy = dy * mag;  26:    27:     this._vx -= delta_vx;  28:     this._vy -= delta_vy;  29:    30:     b._vx += delta_vx;  31:     b._vy += delta_vy;  32:    33:     return true;  34: }

   1: Public Function DoCollide(ByVal b As Ball) As Boolean   2:     ' calculate some vectors    3:     Dim dx As Double = Me._x - b._x   4:     Dim dy As Double = Me._y - b._y   5:     Dim dvx As Double = Me._vx - b._vx   6:     Dim dvy As Double = Me._vy - b._vy   7:     Dim distance2 As Double = dx * dx + dy * dy   8:     9:     If Math.Abs(dx) > Me._d OrElse Math.Abs(dy) > Me._d Then  10:         Return False  11:     End If  12:     If distance2 > Me._d2 Then  13:         Return False  14:     End If  15:    16:     ' make absolutely elastic collision  17:     Dim mag As Double = dvx * dx + dvy * dy  18:    19:     ' test that balls move towards each other      20:     If mag > 0 Then  21:         Return False  22:     End If  23:    24:     mag /= distance2  25:    26:     Dim delta_vx As Double = dx * mag  27:     Dim delta_vy As Double = dy * mag  28:    29:     Me._vx -= delta_vx  30:     Me._vy -= delta_vy  31:    32:     b._vx += delta_vx  33:     b._vy += delta_vy  34:    35:     Return True  36: End Function

User Interaction

While the GameLoop Storyboard does a good job at managing ball movement, I didn't think it was the best option for handling pool stick and q-ball control. During times of user control (stick aiming and q-ball "ball in hand"), I chose to use mouse movement and click events to determine object position and angle. I created my own enumeration to manage switching between ball movement and user control states. The rest involves some simple statistics and Silverlight XAML transformations.

Pool Stick Aiming and Ball-In-Hand

During a scratch, the MouseMove event allows the affect of moving the q-ball for placement. During aiming, it allows the user to rotate the poolstick around the q-ball.

   1: void Page_MouseMove(object sender, MouseEventArgs e)   2: {   3:     4:     m_MousePoint = e.GetPosition(this);   5:     6:     switch (m_ActionState)   7:     {   8:         case m_ActionStates.Scratch:   9:             m_QBall.MoveAbsolute(m_MousePoint.X, m_MousePoint.Y);  10:             break;  11:         case m_ActionStates.Aiming:  12:             m_PoolStick.Rotate(m_MousePoint.X, m_MousePoint.Y, m_QBall.BallCenterX, m_QBall.BallCenterY);  13:             break;  14:     }        15:       16: }

   1: Private Sub Page_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs)   2:     3:     m_MousePoint = e.GetPosition(Me)   4:     5:     Select Case m_ActionState   6:         Case m_ActionStates.Scratch   7:             m_QBall.MoveAbsolute(m_MousePoint.X, m_MousePoint.Y)   8:         Case m_ActionStates.Aiming   9:             m_PoolStick.Rotate(m_MousePoint.X, m_MousePoint.Y, m_QBall.BallCenterX, m_QBall.BallCenterY)  10:     End Select  11:    12: End Sub

The RotateTransform Rocks

The Silverlight RotateTranform is very powerful in this case. It allows me to simply rotate the pool stick object around a center point (the center of the q-ball) using a relative angle between the mouse point and the ball.

   1: public void Rotate (double mouseX, double mouseY, double ballX, double ballY)   2: {   3:     double vx = ballX - mouseX;   4:     double vy = ballY - mouseY;   5:        6:     radians = Math.Atan2(vy, vx);   7:     double angle = radians * (180/Math.PI);   8:        9:     rootCanvas.RenderTransform = new RotateTransform   10:     {   11:         CenterX = Model.stickBuffer,   12:         CenterY = Model.stickHeight/2,   13:         Angle = angle   14:     };  15:    16: }

   1: Public Sub Rotate(ByVal mouseX As Double, ByVal mouseY As Double, ByVal ballX As Double, ByVal ballY As Double)   2:     Dim vx As Double = ballX - mouseX   3:     Dim vy As Double = ballY - mouseY   4:     5:     radians = Math.Atan2(vy, vx)   6:     Dim angle As Double = radians * (180 / Math.PI)   7:     8:     Dim transform As RotateTransform = New RotateTransform()   9:     transform.CenterX = Model.stickBuffer  10:     transform.CenterY = Model.stickHeight / 2  11:     transform.Angle = angle  12:    13:     rootCanvas.RenderTransform = transform  14:    15: End Sub

Power Control and Q-Ball Placement

Based on the ActionState, the mouse up and mouse down events manage user interaction during power adjustment and q-ball placement.

   1: void Page_MouseLeftButtonUp(object sender, MouseEventArgs e)   2: {   3:     if (this.m_ActionState == m_ActionStates.AdjustingPower)   4:     {   5:         m_QBall.Strike(m_PoolStick.power, m_PoolStick.radians);   6:     7:         m_PoolStick.StopPowerMovement();   8:         this.Children.Remove(m_PoolStick);   9:         this.m_ActionState = m_ActionStates.BallsMoving;  10:     }  11: }  12:    13: void Page_MouseLeftButtonDown(object sender, MouseEventArgs e)  14: {  15:     switch (m_ActionState)  16:     {  17:         case m_ActionStates.Aiming:  18:             m_PoolStick.StartPowerMovement();  19:             this.m_ActionState = m_ActionStates.AdjustingPower;  20:             break;  21:         case m_ActionStates.Scratch:  22:             ResetPoolStick();  23:             m_ActionState = m_ActionStates.Aiming;  24:             break;  25:     }  26: }

   1: Private Sub Page_MouseLeftButtonUp(ByVal sender As Object, ByVal e As MouseEventArgs)   2:     If Me.m_ActionState = m_ActionStates.AdjustingPower Then   3:         m_QBall.Strike(m_PoolStick.power, m_PoolStick.radians)   4:     5:         m_PoolStick.StopPowerMovement()   6:         Me.Children.Remove(m_PoolStick)   7:         Me.m_ActionState = m_ActionStates.BallsMoving   8:     End If   9: End Sub  10:    11: Private Sub Page_MouseLeftButtonDown(ByVal sender As Object, ByVal e As MouseEventArgs)  12:     Select Case m_ActionState  13:         Case m_ActionStates.Aiming  14:             m_PoolStick.StartPowerMovement()  15:             Me.m_ActionState = m_ActionStates.AdjustingPower  16:         Case m_ActionStates.Scratch  17:             ResetPoolStick()  18:             m_ActionState = m_ActionStates.Aiming  19:     End Select  20: End Sub

Game State and Control

The final component to this application is the "business rules" behind the game. A game of 8-Ball is governed by the results of each player's shot. Whether that shot ends the game or whose shot it is next is based on what balls are sunk.

I created another enumeration for ShotResults which defines each potential outcome: GoAgain, NextPlayer, Scratch, ScratchOnEight, PrematureEightBall, and Win.

   1: private void UpdateGameState(ShotResults results)   2: {   3:     string resultText = "";   4:        5:     switch (results)   6:     {   7:         // update game states   8:         case ShotResults.PrematureEightBall:   9:         case ShotResults.ScratchOnEight:  10:             resultText = ProcessGameEnd(false, results);  11:             m_ActionState = m_ActionStates.GameOver;  12:             break;  13:         case ShotResults.NextPlayer:  14:             resultText = "Player looses turn";  15:             ChangeCurrentPlayer();  16:             ResetPoolStick();  17:             m_ActionState = m_ActionStates.Aiming;  18:             break;  19:         case ShotResults.GoAgain:  20:             resultText = "Nice job. Go again.";  21:             ResetPoolStick();  22:             m_ActionState = m_ActionStates.Aiming;  23:             break;  24:         case ShotResults.Scratch:  25:             resultText = "Scratch. Player looses turn.";  26:             ChangeCurrentPlayer();  27:             AddBall(m_QBall);  28:             m_ActionState = m_ActionStates.Scratch;  29:             break;  30:         case ShotResults.Win:  31:             resultText = ProcessGameEnd(true, results);  32:             m_ActionState = m_ActionStates.GameOver;  33:             break;  34:     }  35:    36:     sunkBalls.Clear();  37:    38:     this.Text_Status.Text = resultText;  39: }

   1: Private Sub UpdateGameState(ByVal results As ShotResults)   2:     Dim resultText As String = ""   3:     4:     Select Case results   5:         ' update game states   6:         Case ShotResults.PrematureEightBall, ShotResults.ScratchOnEight   7:             resultText = ProcessGameEnd(False, results)   8:             m_ActionState = m_ActionStates.GameOver   9:         Case ShotResults.NextPlayer  10:             resultText = "Player looses turn"  11:             ChangeCurrentPlayer()  12:             ResetPoolStick()  13:             m_ActionState = m_ActionStates.Aiming  14:         Case ShotResults.GoAgain  15:             resultText = "Nice job. Go again."  16:             ResetPoolStick()  17:             m_ActionState = m_ActionStates.Aiming  18:         Case ShotResults.Scratch  19:             resultText = "Scratch. Player looses turn."  20:             ChangeCurrentPlayer()  21:             AddBall(m_QBall)  22:             m_ActionState = m_ActionStates.Scratch  23:         Case ShotResults.Win  24:             resultText = ProcessGameEnd(True, results)  25:             m_ActionState = m_ActionStates.GameOver  26:     End Select  27:    28:     sunkBalls.Clear()  29:    30:     Me.Text_Status.Text = resultText  31: End Sub

Conclusion

This was a fun and educational exercise for me (always a good combination). I learned enough about graphics design to at least fear it less, especially with the use of the Expression suite. It also opened my perspective of Silverlight to understand how it will empower us to implement more rich interactive applications. The most interesting part for me, however, was the change in perspective I had to take in implementing an "always on" game. As simple as a game of 8-ball is, it definitely required an adjustment in thinking from the event-driven model of programming I'm accustomed to using in my every day work.

If you have any questions about this solution or have suggestions for improvement, feel free to contact me at jpetersen@claritycon.com

Where am I? What am I doing?

Coding4Fun — Sat, 01 Sep 2007 01:17:53 GMT

	Do have a GPS receiver laying around? Do you travel? Do you blog? If you answered yes to these questions, you might be interested in this Windows Live Writer plugin. People who travel and like to blog about it can just click a button to insert their current coordinates along with a Virtual Earth Map.
Arian Kulp Arian's Blog Difficulty: Intermediate Time Required: 1-3 hours Cost: $50 and up (depending on hardware choice) Software: Visual Basic or Visual C# Express Editions, Windows Live Writer Hardware: A GPS receiver that supports the NMEA protocol (they all should...) Download: C# Download VB Download MSI Download (binary only, ready to install!)

Introduction

I've had a yellow Garmin etrex GPS unit in the home for about two years now. My family enjoys geocaching (though we don't go nearly often enough...), and it was a good price. The unit has a small screen, but it lets you enter coordinates, then track your way to them. Really, just having your current coordinates is a pretty cool thing!

I've always enjoyed playing with GPS software, and I've liked the idea of creating my own. Unfortunately, I didn't know how to interface with the hardware, so I was out of luck. After buying a serial/USB cable, I was half-way there, but what to do with the data stream?

In this article, learn how to read the stream of data from (hopefully) any GPS unit, then create a plugin for Windows Live Writer so you can add your current location to any blog entry. Scott Hanselman created a GPS interface in Where the Heck am I? Connecting .NET 2.0 to a GPS back in October of 2006. As always with Scott, it was a great article, but I didn't come across it until I'd made it through a lot of roadblocks already! My result at this point works pretty well so I decided to stick with it, plus it integrates with Windows Live Writer.

Figure 1: The plugin in action

If you want, download the source code from the links above, or just follow along with the article. If you haven't already, download the appropriate version of Visual Studio 2005 Express Edition. The plugin will run on either XP or Vista.

Choosing your Hardware

Though my main GPS receiver is the Garmin etrex, I also recently bought an Ambicom unit with no screen -- just a Bluetooth link. It's the perfect device just for obtaining information for a PDA, laptop, or other Bluetooth-connected device if you don't need display on the device. It uses the SPP profile for data exchange, so it's just another COM port as well.

My other unit, the Garmin, has four metal dots hidden under a rubber flap. A number of sites provide information on the pin-outs, or you can buy a cable (serial). I bought a serial-USB interface to avoid the serial port on the back of the machine. My assumption is that all GPS units end up with a serial connection via virtual or physical COM port. If I'm wrong, you may need to do some extra work to get the data.

Speaking NMEA

Speaking about data... once you have a connection to the unit (4800 bps, 8-N-1), you will have a continuously updated stream of information flowing in. The format of this data is defined by the National Marine Electronics Association (NMEA), and is an older format than most people would expect. Interpreting the information is pretty easy once you understand the format (of course, that's often the case!).

Sample NMEA Data

$GPRMB,V,,,,,,,,,,,,A,N*13

$GPGGA,,,,,,0,00,,,M,,M,,*66

$GPGSA,A,1,,,,,,,,,,,,,,,*1E

$GPGSV,3,1,10,02,60,

$GPRMC,,V,,,,,,,210807,0.2,E,N*36

241,00,04,78,042,00,05,24,314,00,09,20,252,00*7F

$GPGSV,3,2,10,10,07,185,00,12,44,307,00,17,36,089,00,20,08,035,00*7A

$GPGSV,3,3,10,28,05,147,00,30,08,319,00*75

$GPGLL,,,,,,V,N*64

$GPBOD,,T,,M,,*47

$PGRME,,M,,M,,M*00

There are three things to notice at first glance (four if you're really on the ball!). First, every line starts with a dollar sign. Second, that dollar sign is always followed by five upper-case letters (not all begin with "G" though). Third, the data following the capital letters is comma-delimited. If you looked really close, you might have noticed that every line ends with an asterisk, then two more characters that appear to be in hexadecimal format.

The capital letters after the dollar sign represent the message ID. All standard NMEA messages start with "G." In this example, the line beginning with "P" is a Garmin-specific message. It's proprietary, but it's also documented and freely available from their web site.

With each line being comma-delimited, processing is pretty easy at a high-level. From the System.IO.Ports.SerialPort class, you can call ReadLine() to get a line of data as a string. Each line of data is called a "sentence" in the standard. From there, the Split() method can be used to return an array for the "words."

That hexadecimal number is the checksum for the sentence. It's a simple formula too. Take, in order, every character between (not including) the dollar sign and asterisk, and XOR them together. The first character seeds the checksum (in other words, a one-character sentence's checksum would be equal to that one character). The LocationInterface class handles all of the serial I/O and NMEA protocol implementation (the little there is!).

Visual Basic

Public Shared Function GetChecksum(ByVal sentence As String) As String
    ' A sentence can't be shorter than 9 characters ($XXXXX*0x)
    If sentence.Length < 9 Then
        Return ""
    End If

    ' Seed with the second character (remember, skip the $)
    Dim checksum As Integer = Convert.ToByte(sentence(1))
    Dim loc As Integer = 0, [end] As Integer = sentence.Length - 3

    ' Loop through the characters
    For Each c As Char In sentence
        ' XOR every character between the dollar sign and the asterisk
        If loc > 1 AndAlso loc < [end] Then
            checksum = checksum Xor Convert.ToByte(c)
        End If
        loc += 1
    Next

    ' "X2" is the format string for hexadecimal
    Return checksum.ToString("X2")
End Function

Visual C#

// Calculates the checksum for a sentence
public static string GetChecksum(string sentence)
{
    // A sentence can't be shorter than 9 characters ($XXXXX*0x)
    if( sentence.Length < 9 ) return "";

    // Seed with the second character (remember, skip the $)
    int checksum = Convert.ToByte(sentence[1]); // Second character
    int loc = 0, end = sentence.Length - 3;

    // Loop through the characters
    foreach (char c in sentence)
    {
        // XOR every character between the dollar sign and the asterisk
        if (loc > 1 && loc < end)
        {
            c2 = c2 ^ Convert.ToByte(c);
        }
        loc++;
    }
    // "X2" is the format string for hexadecimal
    return checksum.ToString("X2");
}

With this handy method, you can validate every line of data that you have before bothering to process it. If a line's bad, don't make a guess. The nature of NMEA is to repeat data frequently. If you missed it this time, you'll have it a second or so later probably. In my code, when I want to get the next data sentence, I call my ReadNextGoodLine() method. This calls ReadLine() on the SerialPort, and validates the checksum. It will try up to ten times before returning a NULL.

Visual Basic

Private Function ReadNextGoodLine(ByVal port As SerialPort) As String
    ' Must read the next line.  This may not be a complete NMEA line
    ' (or even not an NMEA line at all!)
    Dim line As String = Nothing
    For i As Integer = 0 To 9

        ' Up to ten tries...
        line = port.ReadLine()

        If Not IsSentenceValid(line) Then
            line = Nothing
        Else
            Exit For

        End If
    Next

    Return line
End Function

Visual C#

private string ReadNextGoodLine(SerialPort port)
{
    // Must read the next line.  This may not be a complete NMEA line
    // (or even not an NMEA line at all!)
    string line = null;

    // Up to ten tries...
    for (int i = 0; i < 10; i++)
    {
        line = port.ReadLine();

        if (!IsSentenceValid(line)) line = null;
        else break;
    }

    return line;
}

Now that I can read sentences and validate them, I can also create a basic auto-scan GPS search. From the SerialPort class, I can call GetPortNames(). This returns a string array of port names. I can instantiate each port by name, call open, then call ReadNextGoodLine(). If it returns NULL (couldn't find valid NMEA after ten lines), assume it isn't a GPS unit and keep moving to the next port. The ComPortName property saves the name, and can also be set manually to avoid the search.

Of Latitudes and Longitudes...

One thing I learned from this project, is just how much math is involved with GPS! You take it for granted when the device shows coordinates, but there is so much more going on in there.

Recall that GPS is all about geosynchronous satellites sending out time signals. Based on the time delay from satellites with known geostationary locations, you can locate your position. As any experienced GPS user knows, however, when you first turn on the unit, or if you are in a house, underground, or often even wooded areas, the unit will be searching for a signal and won't display anything. The $GPRMC sentence continues to arrive, but the coordinates may be blank, or indicate the lack of a "fix."

$GPRMC,153538,A,4140.5555,N,09100.0000,W,000.0,246.0,310807,,,A*66

The GPRMC consists of a lot of information, including latitude, longitude, speed, heading, and UTC date/time. If you break up the sentence based on commas, the data words that I concentrate in the sample code are 3 (latitude), 4 (N/S), 5 (longitude), 6 (E/W), and 2 (A means fix, V or blank is no fix).

Visual Basic

Public Function ParseGPRMC(ByVal sentence As String) As CoordinatePair
    Dim loc As CoordinatePair = Nothing
    Dim fix As Boolean = False

    ' Split the sentence into words
    Dim words As String() = sentence.Split(","c)

    ' Not all sentences have data populated
    If words(3) <> "" AndAlso words(4) <> "" AndAlso words(5) <> "" AndAlso words(6) <> "" Then
        ' NMEA coordinates are in DM (Degrees-Minutes) format 
        Dim lat As New Coordinate(Integer.Parse(words(3).Substring(0, 2)), _
            Decimal.Parse(words(3).Substring(2)), _
            DirectCast([Enum].Parse(GetType(HemisphereOptions), words(4)), HemisphereOptions))
        Dim lng As New Coordinate(Integer.Parse(words(5).Substring(0, 3)), _
            Decimal.Parse(words(5).Substring(3)), _
            DirectCast([Enum].Parse(GetType(HemisphereOptions), words(6)), HemisphereOptions))

        loc = New CoordinatePair(lat, lng)

        ' Does the device currently have a satellite fix?
        If words(2) = "A" Then
            ' Fix has been obtained
            loc.Fixed = True
        ElseIf words(2) = "V" Then
            ' Fix has been lost
            loc.Fixed = False
        End If

    End If

    Return loc
End Function

Visual C#

public CoordinatePair ParseGPRMC(string sentence)
{
    CoordinatePair loc = null;

    // Split the sentence into words
    string[] words = sentence.Split(',');

    // Not all sentences have data populated
    if (words[3] != "" && words[4] != "" && words[5] != "" && words[6] != "")
    {
        // NMEA coordinates are in DM (Degrees-Minutes) format 
        Coordinate lat = new Coordinate(int.Parse(words[3].Substring(0, 2)), 
            decimal.Parse(words[3].Substring(2)), 
            (HemisphereOptions)Enum.Parse(typeof(HemisphereOptions), words[4]));
        Coordinate lng = new Coordinate(int.Parse(words[5].Substring(0, 3)), 
            decimal.Parse(words[5].Substring(3)),
            (HemisphereOptions)Enum.Parse(typeof(HemisphereOptions), words[6]));

        loc = new CoordinatePair(lat, lng);
        
        // Does the device currently have a satellite fix?
        if (words[2] == "A") loc.Fixed = true; // Fix has been obtained
        else if (words[2] == "V") loc.Fixed = false; // Fix has been lost
    }

    return loc;
}

The latitude and longitude values in NMEA data are expressed as DM format. DM is short for Degrees-Minutes, and actually the minutes are expressed in decimal form. In the above example, "4140.5555" is meant to be parsed as 41 degrees and 40.5555 minutes. Longitude uses three digits for degrees, so "09100.0000" is 091 degrees and 00.0000 minutes. Degrees-Minutes is just one of three common ways to express coordinates though. Degrees-Minutes-Seconds splits the minutes into minutes and seconds. If you think of it like time, it's easier. If the decimal minutes is .50000, then that's half of 60, or 30 minutes. A number like .55555 would spill into the seconds place as well. You can also use Degrees-Decimal which simply uses one decimal number to express the degrees along with any fractional "extra." Just remember that the source format is Degrees-Minutes, and given any format, you can convert to any other. My Coordinate class provides ToString() methods to return in all three representations, and internally it stores it as int degrees and minutes and decimal seconds. For more information on these numbers, Wikipedia has a great article.

Plugging In

Functioning as a Live Writer plugin requires that you do several things. First of all, you will need to download and install the Windows Live Writer SDK. This gives you access to an assembly to add a reference to in your project. Your entry point class should import the WindowsLive.Writer.Api namespace, and inherit ContentSource. You'll need to add the WriterPlugin attribute with values for a unique GUID (use the Tools | Create GUID menu item in Visual Studio to help with that), and set a name at least.

The EditOptions method must be overridden if you provide an Options dialog (in this sample, it's just a message box. The CreateContent method is the meat of the plugin. This can do anything, then assign a string to the newContent ref parameter. It returns a DialogResult to indicate if it was OK'd or Cancel'd.

The InsertableContentSource attribute lets you set the SideBar text property, and the WriterPlugin attribute has a property for ImagePath to create an image link:

Figure 2: Ready to use

When CreateContent is called, the sample plugin shows the LocationPreviewForm dialog. This in turn triggers the GPSInit method in LocationInterface to find and connect to the GPS unit. If it's found, the COM port and coordinates are shown. All GPS activity is performed in a BackgroundWorker to maintain a responsive user interface. The Title and Description fields are used for a pushpin in a Virtual Earth embedded AJAX map. This is a full-blown instance with the scrolling and zooming.

Figure 3: The plugin dialog

Actually, I would have liked to use a static bitmap, but I'm not sure how to obtain good free mapping images in a small amount of code, other than services like MapPoint which aren't free. Changing this aspect of the code would be very easy in the GetOutput method, and you could remove the image/map altogether and simply show the coordinates or other information. It's not exactly extensible, but it's easy to modify.

Finally, in order to simplify debugging, I created a post-build event to copy the plugin DLL to the Windows Live Writer Plugins directory:

XCOPY /D /Y /R "$(TargetPath)" "C:\Program Files\Windows Live Writer\Plugins\"

I also went into the Debug settings for the project for the project and set the Start Action to Start external program, setting it to the path to the EXE:

C:\Program Files\Windows Live Writer\WindowsLiveWriter.exe

Now, when you press F5, it copies the DLL and attaches the debugger to a new instance of Windows Live Writer for Edit-and-Continue and other debugging. It works well!

One thing to remember, is that Live Writer locks the DLL's when it's running, so you will get an error if you even build while it's running, since the DLL can't be copied.

Next Steps

At this point, I'd like to create more flexibility on what the plugin does with the coordinates. It could locate images through various sources, include altitude, speed, and heading when available, or just pretty up the embedded information. I'd like to work on the GPS classes a bit to make them more robust, handling some of the other messages, and support raising events to be used in other applications. Developing GPS applications is conceptually pretty easy once you have the data. It's just a matter of exposing the data in a good way.

Conclusion

Working with GPS data was much easier than I expected. I had some Bluetooth/USB issues at first, but working with the data was fun and gave me lots of ideas! See what you can do with location information to enhance some existing application, or think up something entirely new. Have fun with the code and as usual, contact me through my blog for comments, complaints, or questions.

Arian Kulp is an independent software developer and writer working in the Midwest. He has been coding since the fifth grade on various platforms, and also enjoys photography, nature, and spending time with his family. Arian can be reached through his web site at http://www.ariankulp.com.

Outlook Webmail Add-in for Windows Home Server

Coding4Fun — Fri, 10 Aug 2007 14:33:56 GMT

In this article, Brian Peek will demonstrate how to create an add-in for Windows Home Server that will allow users to view their Outlook mail from a web browser.

Brian Peek

ASPSOFT, Inc.

Difficulty: Intermediate

Time Required: 2-3 hours

Cost: Free

Software: Windows Home Server, Microsoft Outlook 2000/XP/2003/2007 (not Outlook Express/Windows Mail), Visual Basic or Visual C# Express Editions, Visual Web Developer Express Edition, Microsoft .NET Framework 3.0 runtime, Outlook/Office Primary Interop Assemblies (more on this below), Windows SDK (Vista or later, which includes the .NET 3.0 bits. Note that this installs and works just fine under Windows XP. The SDK can build applications for Windows XP and greater.)

Hardware: None

Download: CodePlex Project

Introduction

Windows Home Server is a new product from Microsoft which allows home users to manage and share data, including photos, documents, videos, music, etc. It also provides a very easy way to backup all computers on your home network to a central storage server.

Windows Home Server can also be extended via add-ins to enhance the experience and provide new and interesting functionality other than what comes in the box.

One feature not present in WHS that I would find useful is the ability to view my Outlook mail box from the web at any time. I have 6 or 7 email accounts that are all setup to retrieve via POP3 to Outlook. Most of these accounts do not support IMAP or have a web-based interface. Therefore, Outlook is generally open all day and checking messages. When I'm away from home for work or pleasure, it's very often inconvenient to have to remote desktop into the machine with Outlook running to read my email, so it would be nice to have a web-based version of my current Outlook folders so I can view all email (old and new) at any time simply by browsing to a web server at home. Windows Home Server comes with Internet Information Services 6 (IIS6) and one can easily add a new web application to IIS on the server.

So, this article will attempt to show how to build a new web site using ASP.NET that can be added to your Windows Home Server installation that will allow one to view the Outlook folders running on whatever computer contains your current Outlook installation and message store.

If you wish to just use the application, download the sample from above and skip down to the deployment section for installation instructions.

NOTE: This application will only work with Microsoft Outlook. It will not work with Outlook Express, Windows Mail, or any other mail client.

Setup

Setup can be a bit tricky. Office/Outlook will need to be installed on your development machine. It does not need to be the same machine which contains your store at this point, but that too would help. Once Office/Outlook is installed, the Primary Interop Assemblies for the version of Office you are using need to be installed. For Office 2003/2007, this can be done choosing .NET Programming Support from the list of sub-items in the Microsoft Office Outlook section of the setup program.

Unfortunately I do not have an earlier copy of Office with which to check, but the procedure should be the same. If anyone happens to try this with Office XP/2000, please let me know if/how it works.

If you will be developing on an OS earlier than Vista, install the .NET Framework 3.0 runtime.

Finally, install the Windows SDK linked above accepting all defaults.

Architecture

The architecture we will be using is very similar that to an N-tier application. The machine running Outlook with the message store to be viewed is, in essence, the server machine. That machine will run a host process that we will develop which will expose several methods via Windows Communication Foundation. These methods will be consumed by an ASP.NET application running on the Windows Home Server.

The Host

Let's start by building the host application. This will run on the computer where Outlook is installed and the messages are stored. The application will be written to run in the notification area next to the Windows system clock.

To start, create a new Windows Application project named WHSMailHost. Rename the default Form1.cs/.vb file to frmMain.cs/.vb. Double-click on the file in the Solution Explorer to bring up the design surface.

In order to get the application to run in the notification area, drag and drop a NotifyIcon control from the Toolbox to the design surface, name it niIcon. Also, drag over a ContextMenuStrip to the design surface and name it cmsMenu. This will be used to pop up a context menu when the icon in the notification area is clicked. Finally, set the following properties on the niIcon control:

Text	WHS Mail Host
ContextMenuStrip	cmsMenu
Visible	True

Select the cmsMenu control and add a single menu item named Exit to the list. Double-click on that menu item to create a default Click event. In the code for the Click event, simply close the form as follows:

private void mnuExit_Click(object sender, EventArgs e)
{
    // exit the application
    this.Close();
}

Private Sub mnuExit_Click(ByVal sender As Object, ByVal e As EventArgs) Handles mnuExit.Click
    ' exit the application
    Me.Close()
End Sub

Finally, add the following events to frmMain by selecting them from the Event Property window and implementing them with the following code:

private void frmMain_Resize(object sender, EventArgs e)
{
    // hide the form
    this.Hide();
}

private void frmMain_Load(object sender, EventArgs e)
{
    // start the WCF service
    MyServiceHost.StartService();
}

private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
{
    // stop the WCF service
    MyServiceHost.StopService();
}

Private Sub frmMain_Resize(ByVal sender As Object, ByVal e As EventArgs) Handles MyBase.Resize
    ' hide the form
    Me.Hide()
End Sub

Private Sub frmMain_Load(ByVal sender As Object, ByVal e As EventArgs) Handles MyBase.Load
    ' start the WCF service
    MyServiceHost.StartService()
End Sub

Private Sub frmMain_FormClosing(ByVal sender As Object, ByVal e As FormClosingEventArgs) Handles MyBase.FormClosing
    ' stop the WCF service
    MyServiceHost.StopService()
End Sub

The code above references a class named MyServiceHost. This is what starts the WCF host and will be discussed next.

Windows Communication Foundation (WCF)

Windows Communication Foundation (formerly known as Indigo) is a feature of the .NET Framework 3.0 that allows one to build and run connected systems. The simplest definition that fits with what we will be doing here is that it allows an application running on one machine (the client, in this case, the ASP.NET application) to execute a method on another machine (the host, in this case, the application we're currently building).

First, add a reference to the System.ServiceModel assembly. Then, add a class to the project named WHSMailService. Open the class and add the following code beneath the generated WHSMailService class implementation:

internal class MyServiceHost
{
    internal static ServiceHost myServiceHost = null;

    internal static void StartService()
    {
        // Instantiate new ServiceHost 
        myServiceHost = new ServiceHost(typeof(WHSMailService));
        myServiceHost.Open();
    }

    internal static void StopService()
    {
        // Call StopService from your shutdown logic (i.e. dispose method)
        if (myServiceHost.State != CommunicationState.Closed)
            myServiceHost.Close();
    }
}

Friend Class MyServiceHost
    Friend Shared myServiceHost As ServiceHost = Nothing

    Friend Shared Sub StartService()
        ' Instantiate new ServiceHost 
        myServiceHost = New ServiceHost(GetType(WHSMailService))
        myServiceHost.Open()
    End Sub

    Friend Shared Sub StopService()
        ' Call StopService from your shutdown logic (i.e. dispose method)
        If myServiceHost.State <> CommunicationState.Closed Then
            myServiceHost.Close()
        End If
    End Sub
End Class

This code simply creates a new WCF ServiceHost of the type WHSMailService (which we will implement next) and then opens that host so that it may receive incoming connections. We will look at how this connections are configured later in the article.

Remember that the code in the form above above called the StartService and StopService methods located here when the main form loads and closes. This very easily allows to immediately start the service host when the application starts and closes the service host when the application exits.

Contracts and Entities

A contract is an interface that defines which methods are exposed by the service host that can be consumed by the client application. Both the client application and the server application will need to know what is in this interface, so we will need to create a second project that will contain the interface definition. Additionally, we will need a way to pass folder and email information to and from each application, so we will define some custom classes to encapsulate those objects.

Create a new Class Library project in the current solution named WHSMailCommon. In this new project, create a directory named Contracts and a directory named Entities.

Inside the Entities directory, create a new class named Folder. This will represent an Outlook message folder. The class should look like the following:

using System;
using System.Collections.Generic;

namespace WHSMailCommon.Entities
{
    // entity object representing an Folder
    [Serializable]
    public class Folder : IComparable
    {
        private string _entryID;
        private string _name;
        private List<Folder> _folders;
        private int _unreadMessages;
        private int _totalMessages;

        public Folder(string entryID, string name, int unreadMessages, int totalMessages)
        {
            _entryID = entryID;
            _name = name;
            _unreadMessages = unreadMessages;
            _totalMessages = totalMessages;
        }

        // MAPI unique identifier
        public string EntryID
        {
            get { return _entryID; }
            set { _entryID = value; }
        }

        // subfolders of this folder
        public List<Folder> Folders
        {
            get { return _folders; }
            set { _folders = value; }
        }

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public int UnreadMessages
        {
            get { return this._unreadMessages; }
            set { this._unreadMessages = value; }
        }

        public int TotalMessages
        {
            get { return this._totalMessages; }
            set { this._totalMessages = value; }
        }

        // used so we can sort the folders alphabetically later on
        public int CompareTo(object obj)
        {
            return string.Compare(this.Name, ((Folder)obj).Name);
        }
    }
}

Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic

Namespace WHSMailCommon.Entities
    ' entity object representing an Folder
    <Serializable> _
    Public Class Folder
        Implements IComparable
        Private _entryID As String
        Private _name As String
        Private _folders As List(Of Folder)
        Private _unreadMessages As Integer
        Private _totalMessages As Integer

        Public Sub New(ByVal entryID As String, ByVal name As String, ByVal unreadMessages As Integer, ByVal totalMessages As Integer)
            _entryID = entryID
            _name = name
            _unreadMessages = unreadMessages
            _totalMessages = totalMessages
        End Sub

        ' MAPI unique identifier
        Public Property EntryID() As String
            Get
                Return _entryID
            End Get
            Set(ByVal value As String)
                _entryID = value
            End Set
        End Property

        ' subfolders of this folder
        Public Property Folders() As List(Of Folder)
            Get
                Return _folders
            End Get
            Set(ByVal value As List(Of Folder))
                _folders = value
            End Set
        End Property

        Public Property Name() As String
            Get
                Return _name
            End Get
            Set(ByVal value As String)
                _name = value
            End Set
        End Property

        Public Property UnreadMessages() As Integer
            Get
                Return Me._unreadMessages
            End Get
            Set(ByVal value As Integer)
                Me._unreadMessages = value
            End Set
        End Property

        Public Property TotalMessages() As Integer
            Get
                Return Me._totalMessages
            End Get
            Set(ByVal value As Integer)
                Me._totalMessages = value
            End Set
        End Property

        ' used so we can sort the folders alphabetically later on
        Public Function CompareTo(ByVal obj As Object) As Integer Implements IComparable.CompareTo
            Return String.Compare(Me.Name, (CType(obj, Folder)).Name)
        End Function
    End Class
End Namespace

This class defines several properties to describe the folder (EntryID, Name, etc.) and additionally implements the IComparable interface's CompareTo method so that we can easily sort the folders alphabetically later on.

Next, create a class named Email. The code for this class looks like the following:

using System;
using System.Collections.Generic;
using System.Text;

namespace WHSMailCommon.Entities
{
    // entity object representing an Email
    [Serializable]
    public class Email
    {
        private string _entryID;
        private string _from;
        private string _fromName;
        private string _subject;
        private DateTime _received;
        private int _size;
        private string _body;

        public Email(string entryID, string from, string fromName, string subject, DateTime received, int size)
        {
            _entryID = entryID;
            _from = from;
            _fromName = fromName;
            _subject = string.IsNullOrEmpty(subject) ? "(no subject)" : subject;
            _received = received;
            _size = size;
        }

        public Email(string entryID, string from, string fromName, string subject, DateTime received, int size, string body) :
            this(entryID, from, fromName, subject, received, size)
        {
            _body = body;
        }

        // MAPI unique ID
        public string EntryID
        {
            get { return _entryID; }
            set { _entryID = value; }
        }

        // email address of sender
        public string From
        {
            get { return _from; }
            set { _from = value; }
        }

        // name of sender
        public string FromName
        {
            get { return _fromName; }
            set { _fromName = value; }
        }

        public string Subject
        {
            get { return _subject; }
            set { _subject = value; }
        }

        public string Body
        {
            get { return _body; }
            set { _body = value; }
        }

        public DateTime Received
        {
            get { return _received; }
            set { _received = value; }
        }

        public int Size
        {
            get { return _size; }
            set { _size = value; }
        }
    }
}

Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Text

Namespace WHSMailCommon.Entities
    ' entity object representing an Email
    <Serializable> _
    Public Class Email
        Private _entryID As String
        Private _from As String
        Private _fromName As String
        Private _subject As String
        Private _received As DateTime
        Private _size As Integer
        Private _body As String

        Public Sub New(ByVal entryID As String, ByVal From As String, ByVal fromName As String, ByVal subject As String, ByVal received As DateTime, ByVal size As Integer)
            _entryID = entryID
            _from = From
            _fromName = fromName
            If String.IsNullOrEmpty(subject) Then
                _subject = "(no subject)"
            Else
                _subject = subject
            End If
            _received = received
            _size = size
        End Sub

        Public Sub New(ByVal entryID As String, ByVal From As String, ByVal fromName As String, ByVal subject As String, ByVal received As DateTime, ByVal size As Integer, ByVal body As String)
            Me.New(entryID, From, fromName, subject, received, size)
            _body = body
        End Sub

        ' MAPI unique ID
        Public Property EntryID() As String
            Get
                Return _entryID
            End Get
            Set(ByVal value As String)
                _entryID = value
            End Set
        End Property

        ' email address of sender
        Public Property From() As String
            Get
                Return _from
            End Get
            Set(ByVal value As String)
                _from = value
            End Set
        End Property

        ' name of sender
        Public Property FromName() As String
            Get
                Return _fromName
            End Get
            Set(ByVal value As String)
                _fromName = value
            End Set
        End Property

        Public Property Subject() As String
            Get
                Return _subject
            End Get
            Set(ByVal value As String)
                _subject = value
            End Set
        End Property

        Public Property Body() As String
            Get
                Return _body
            End Get
            Set(ByVal value As String)
                _body = value
            End Set
        End Property

        Public Property Received() As DateTime
            Get
                Return _received
            End Get
            Set(ByVal value As DateTime)
                _received = value
            End Set
        End Property

        Public Property Size() As Integer
            Get
                Return _size
            End Get
            Set(ByVal value As Integer)
                _size = value
            End Set
        End Property
    End Class
End Namespace

This class simply contains properties to describe an email message.

You will note that both of these classes have the [Serializable] attribute attached to them. When objects are passed through WCF, they are serialized at the source and deserialized at the destination. By marking the objects with the [Serializable] attribute, the .NET CLR can do this for us automatically since we are not using any complex data types in our entities.

With our entities out of the way, we can define our contract. Inside the Contracts directory, create a new Interface file named IWHSMailService.

This interface/contract will define three methods: one method to return a tree of objects which represent the folder tree in Outlook (GetFolders), one method to return a list of messages inside that folder (GetMessages), and one method to return the contents of a specific message (GetMessages). The interface will look like the following:

using System.Collections.Generic;
using System.ServiceModel;
using WHSMailCommon.Entities;

namespace WHSMailCommon.Contracts
{
    // list of methods of the WHSMailService service
    [ServiceContract()]
    public interface IWHSMailService
    {
        [OperationContract]
        List<Folder> GetFolders();

        [OperationContract]
        List<Email> GetMessages(string entryID, int numPerPage, int pageNum);

        [OperationContract]
        Email GetMessage(string entryID);
    }
}

Imports Microsoft.VisualBasic
Imports System.Collections.Generic
Imports System.ServiceModel
Imports WHSMailCommon.Entities

Namespace WHSMailCommon.Contracts
    ' list of methods of the WHSMailService service
    <ServiceContract()> _
    Public Interface IWHSMailService
        <OperationContract> _
        Function GetFolders() As List(Of Folder)

        <OperationContract> _
        Function GetMessages(ByVal entryID As String, ByVal numPerPage As Integer, ByVal pageNum As Integer) As List(Of Email)

        <OperationContract> _
        Function GetMessage(ByVal entryID As String) As Email
    End Interface
End Namespace

As with the entities, this interface is also decorated with several attributes. First, any WCF contract interface must be tagged with the [ServiceContract()] attribute to define it as a contract to WCF. Additionally, all methods which will be exposed for consumption by a client must be marked with the [OperationContract] attribute.

The implementation and description of these methods will come later when we write the contract implementation.

Configuration

The final thing to setup on the WCF server is the configuration file. The service can very easily be configured using an application configuration file. Add an Application Configuration file to the project named App.config. Set the contents of the file to the following:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <bindings>
            <netTcpBinding>
                <binding name="NewBinding0">
                    <security mode="None" />
                </binding>
            </netTcpBinding>
        </bindings>
        <services>
            <service name="WHSMailHost.WHSMailService">
                <endpoint address="net.tcp://localhost:12345/IWHSMailService"
                    binding="netTcpBinding" bindingConfiguration="NewBinding0"
                    contract="WHSMailCommon.Contracts.IWHSMailService" />
            </service>
        </services>
    </system.serviceModel>
</configuration>

The <services> section defines the services that the WCF host will enable. This creates a single <service> named WHSMailHost.WHSMailService, which is the full name of the service class that we will implement shortly. Inside the <service> tag an endpoint is defined. And endpoint is essentially the "port" on which the client connects. The endpoint defined here is using the net.tcp protocol and is set to listen on the localhost on port 12345 at the name IWHSMailService. The next thing defined is a binding. This sets protocol by which the service will communicate, its configuration, and the contract it implements. The binding configuration named NewBinding0 (a default name) can be found above inside the <bindings> tag. The only configuration item that is specified is that security will be turned off for communication between the client and server. Given that these two machines will be connecting to each other on your own local network, security is not a great concern. If you were to use this over a real internet connection where the client and server were open to the outside world, you would definitely not want to do this.

There are around several billion other options, protocols, bindings, etc. etc. etc. that can be configured here. At the end of the article you will find several links to WCF documentation that you can explore to learn more about the WCF internals. Also note that you can configure WCF with a windows UI by selecting the Service Configuration Editor application installed with the Windows SDK. You'll find this in the Microsoft Windows SDK program group off your Start menu.

Outlook and MAPI

MAPI (Messaging Application Programming Interface) is what allows one to develop applications and plugins for Microsoft Outlook and other messaging applications which support it (Exchange, Windows Messaging, etc.). We will be using MAPI to get the data we require from Outlook for our application.

Earlier we created a contract named IWHSMailService. This contract will be implemented by the WHSMailService class that was also created earlier. To do this, set a reference to the project's WHSMailCommon assembly. Then, bring the Contracts and Entities namespaces into the WHSMailService class with the following:

using WHSMailCommon.Contracts;
using WHSMailCommon.Entities;

Imports WHSMailCommon.Contracts
Imports WHSMailCommon.Entities

Then, setup the class to implement the interface as follows:

public class WHSMailService : IWHSMailService

Public Class WHSMailService
    Implements IWHSMailService

Visual Studio will then create the 3 methods that must be implemented according to the interface (GetFolders, GetMessages, GetMessage). We will fill those in shortly. But first, we must implement our constructor. When WCF calls the service, a new instance of the object will be created on each call. Therefore, it is easy to setup any initialization code for the service in the default constructor method. In this case, we will initialize the MAPI layer and logon to the default instance.

First, set a reference to the Microsoft Outlook XX.0 Object Library which you will find under the COM tab assuming Outlook is installed as per the instructions above. Note that the version will depend on what version of Outlook you have installed on your local machine. I'm using Outlook 2007, so version 12 is what the sample code above is referencing. If you are using a different version, reference the appropriate version before continuing.

Once the reference is set, bring the namespace into the WHSMailService class with the following line which will import the namespace and setup an alias named Outlook to save some typing:

using Outlook = Microsoft.Office.Interop.Outlook;

Imports Outlook = Microsoft.Office.Interop.Outlook

Now the constructor can be implemented. We need to get an instance of the Outlook ApplicationClass. From there we can get an instance of the MAPI namespace. All methods that we will be using hang off that namespace object. The code for the constructor follows:

private readonly Outlook.NameSpace _nameSpace = null;

public WHSMailService()
{
    // get an instance of the MAPI namespace and login
    Outlook.Application app = new Outlook.ApplicationClass();
    _nameSpace = app.GetNamespace("MAPI");
    _nameSpace.Logon(null, null, false, false);
}

Private ReadOnly _nameSpace As Outlook.NameSpace = Nothing

Public Sub New()
    ' get an instance of the MAPI namespace and login
    Dim app As Outlook.Application = New Outlook.ApplicationClass()
    _nameSpace = app.GetNamespace("MAPI")
    _nameSpace.Logon(Nothing, Nothing, False, False)
End Sub

With a handle to the namespace, we can write our GetFolders method. This method will get the default Inbox folder in the default Outlook message store, look at the parent node, recursively enumerate from there, pulling out only folders that contain mail items, and finally sort them alphabetically (recall the CompareTo method of the IComparable interface we implemented earlier).

public List<Folder> GetFolders()
{
    List<Folder> list = new List<Folder>();

    // get the inbox and then go up one level...that *should* be the root of the default store
    Outlook.MAPIFolder root = (Outlook.MAPIFolder)_nameSpace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox).Parent;

    // add root folder
    Folder folder = new Folder(root.EntryID, root.Name, root.UnReadItemCount, root.Items.Count);
    list.Add(folder);

    // Enumerate the sub-folders
    EnumerateFolders(root.Folders, folder);

    return list;
}

private void EnumerateFolders(Outlook.Folders folders, Folder rootFolder)
{
    foreach(Outlook.MAPIFolder f in folders)
    {
        // ensure it's a folder that contains mail messages (i.e. no contacts, appointments, etc.)
        if(f.DefaultItemType == Outlook.OlItemType.olMailItem)
        {
            if(rootFolder.Folders == null)
                rootFolder.Folders = new List<Folder>();

            // add the current folder and enumerate all sub-folders
            Folder subFolder = new Folder(f.EntryID, f.Name, f.UnReadItemCount, f.Items.Count);
            rootFolder.Folders.Add(subFolder);
            if(f.Folders.Count > 0)
                this.EnumerateFolders(f.Folders, subFolder);
        }
    }

    // alphabetize the list (Folder implements IComparable)
    rootFolder.Folders.Sort();
}

Public Function GetFolders() As List(Of Folder) Implements IWHSMailService.GetFolders
    Dim list As List(Of Folder) = New List(Of Folder)()

    ' get the inbox and then go up one level...that *should* be the root of the default store
    Dim root As Outlook.MAPIFolder = CType(_nameSpace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox).Parent, Outlook.MAPIFolder)

    ' add root folder
    Dim folder As Folder = New Folder(root.EntryID, root.Name, root.UnReadItemCount, root.Items.Count)
    list.Add(folder)

    ' Enumerate the sub-folders
    EnumerateFolders(root.Folders, folder)

    Return list
End Function

Private Sub EnumerateFolders(ByVal folders As Outlook.Folders, ByVal rootFolder As Folder)
    For Each f As Outlook.MAPIFolder In folders
        ' ensure it's a folder that contains mail messages (i.e. no contacts, appointments, etc.)
        If f.DefaultItemType = Outlook.OlItemType.olMailItem Then
            If rootFolder.Folders Is Nothing Then
                rootFolder.Folders = New List(Of Folder)()
            End If

            ' add the current folder and enumerate all sub-folders
            Dim subFolder As Folder = New Folder(f.EntryID, f.Name, f.UnReadItemCount, f.Items.Count)
            rootFolder.Folders.Add(subFolder)
            If f.Folders.Count > 0 Then
                Me.EnumerateFolders(f.Folders, subFolder)
            End If
        End If
    Next f

    ' alphabetize the list (Folder implements IComparable)
    rootFolder.Folders.Sort()
End Sub

This code will return a generic hierarchal list of our Folder entity objects which will be displayed in the web application. Note that one of the items assigned to the Folder entity is the EntryID property from the MAPIFolder object. All MAPI items, be they email messages, folders, appointments, etc. have a unique identifier which is stored in the EntryID field. We will need this unique value later on to retrieve messages from that folder.

Next, let's implement the GetMessages method. This method will return a list of messages (minus the bodies) from the folder specified using the GetFolderFromID method, sorted by the received date with the most current first. It will also handle paging so that the entire folder is not returned at once.

public List<Email> GetMessages(string entryID, int numPerPage, int pageNum)
{
    List<Email> list = new List<Email>();

    Outlook.MAPIFolder f;

    // if no ID specified, open the inbox
    if(string.IsNullOrEmpty(entryID))
        f = _nameSpace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox);
    else
        f = _nameSpace.GetFolderFromID(entryID, "");

    // to handle the sorting, one needs to cache their own instance of the items object
    Outlook.Items items = f.Items;

    // sort descending by received time
    items.Sort("[ReceivedTime]", true);

    // pull in the correct number of items based on number of items per page and current page number
    for(int i = (numPerPage*pageNum)+1; i <= (numPerPage*pageNum)+numPerPage && i <= items.Count; i++)
    {
        // ensure it's a mail message
        Outlook.MailItem mi = (items[i] as Outlook.MailItem);
        if(mi != null)
            list.Add(new Email(mi.EntryID, mi.SenderEmailAddress, mi.SenderName, mi.Subject, mi.ReceivedTime, mi.Size));
    }

    return list;
}

Public Function GetMessages(ByVal entryID As String, ByVal numPerPage As Integer, ByVal pageNum As Integer) As List(Of Email) Implements IWHSMailService.GetMessages
    Dim list As List(Of Email) = New List(Of Email)()

    Dim f As Outlook.MAPIFolder

    ' if no ID specified, open the inbox
    If String.IsNullOrEmpty(entryID) Then
        f = _nameSpace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox)
    Else
        f = _nameSpace.GetFolderFromID(entryID, "")
    End If

    ' to handle the sorting, one needs to cache their own instance of the items object
    Dim items As Outlook.Items = f.Items

    ' sort descending by received time
    items.Sort("[ReceivedTime]", True)

    ' pull in the correct number of items based on number of items per page and current page number
    Dim i As Integer = (numPerPage*pageNum)+1
    Do While i <= (numPerPage*pageNum)+numPerPage AndAlso i <= items.Count
        ' ensure it's a mail message
        Dim mi As Outlook.MailItem = (TryCast(items(i), Outlook.MailItem))
        If Not mi Is Nothing Then
            list.Add(New Email(mi.EntryID, mi.SenderEmailAddress, mi.SenderName, mi.Subject, mi.ReceivedTime, mi.Size))
        End If
        i += 1
    Loop

    Return list
End Function

The method takes a string parameter named entryID which is the unique identifier of the folder (from the code above) from which to return the messages. If no ID is specified, messages are returned from the Inbox. This code also handles paging by indexing into the array of Items of the MAPIFolder object at the specified position and counting out numPerPage records to be returned. A list of Email entity objects is returned from this method to be displayed on the web interface.

Finally, let's implement the GetMessage method. This will return a specific message based on the MAPI EntryID using the GetItemFromID method and format the body for plain text or HTML display.

public Email GetMessage(string entryID)
{
    // pull the message
    Outlook.MailItem mi = (_nameSpace.GetItemFromID(entryID, "") as Outlook.MailItem);

    if (mi != null)
    {
        string body;

        // if it's a plain format message, wrap it in <pre> tags for nice output
        if(mi.BodyFormat == Outlook.OlBodyFormat.olFormatPlain)
            body = "<pre>" + mi.Body + "</pre>";
        else
            body = mi.HTMLBody;

        return new Email(mi.EntryID, mi.SenderEmailAddress, mi.SenderName, mi.Subject, mi.ReceivedTime, mi.Size, body);
    }
    else
        return null;
}

Public Function GetMessage(ByVal entryID As String) As Email Implements IWHSMailService.GetMessage
    ' pull the message
    Dim mi As Outlook.MailItem = (TryCast(_nameSpace.GetItemFromID(entryID, ""), Outlook.MailItem))

    If Not mi Is Nothing Then
        Dim body As String

        ' if it's a plain format message, wrap it in <pre> tags for nice output
        If mi.BodyFormat = Outlook.OlBodyFormat.olFormatPlain Then
            body = "<pre>" & mi.Body & "</pre>"
        Else
            body = mi.HTMLBody
        End If

        Return New Email(mi.EntryID, mi.SenderEmailAddress, mi.SenderName, mi.Subject, mi.ReceivedTime, mi.Size, body)
    Else
        Return Nothing
    End If
End Function

With these three methods in place, we can get our folders, get messages in those folders, and get a specific message from a folder. Now we can switch our attention to the web-based "client" application which will plug into WHS.

ASP.NET "Client"

The client we are going to produce is going to be a very simple 3-paned screen much like Outlook with folders on the left, messages on the top right, and message text on the bottom right.

Create a new ASP.NET Web Application named WHSMailWeb (if you are using the Express editions of Visual Studio, you will need to do this in Visual Web Developer Express). Set a reference to the WHSMailCommon assembly along with the System.ServiceModel assembly. Again, if you are in Express, you will have to set the reference to WHSMailCommon in the other project's bin directory.

First, let's configure the ASP.NET application so it can properly call our WCF service running on the host machine. Open the web.config file and add the following after the end </system.web> tag and before the end </configuration> tab:

<system.serviceModel>
    <bindings>
        <netTcpBinding>
            <binding name="NewBinding0" maxReceivedMessageSize="1048576">
                <readerQuotas maxStringContentLength="1048576" />
                <security mode="None" />
            </binding>
        </netTcpBinding>
    </bindings>
    <client>
        <endpoint address="net.tcp://SERVERNAME:12345/IWHSMailService"
            binding="netTcpBinding" bindingConfiguration="NewBinding0"
            contract="WHSMailCommon.Contracts.IWHSMailService" name="WHSMailService" />
    </client>
</system.serviceModel>

This looks very similar to the configuration information from our host service. An endpoint is defined which points to the host server. YOU WILL NEED TO CHANGE THE "SERVERNAME" HOST TO THE NAME OR IP ADDRESS OF THE MACHINE THAT WILL RUN THE HOST SERVICE WE CREATED ABOVE!

You will see the same setup for the binding and contract. The name parameter will be used by the code a bit later so WCF knows how to contact the host to instantiate the remote object.

The one thing that is different here is the netTcpBinding configuration. The security mode is set to none as it was before, but we have the addition of the maxReceivedMessageSize and maxStringContentLength. Both of these are set at 1 megabyte to allow that much data to be transferred from the host to the client. The default is only 64K which is not enough to return most of the data we need to serialize and transmit between the two machines.

Next, add a page to the project named BasePage. This page will be inherited by all pages in the project to easily startup and shutdown the WCF channel required to retrieve the message data.

Open the code-behind file for BasePage and add the following code:

using System;
using System.ServiceModel;
using WHSMailCommon.Contracts;

namespace WHSMailWeb
{
    public partial class BasePage : System.Web.UI.Page
    {
        ChannelFactory<IWHSMailService> _factory = null;
        private IWHSMailService _channel = null;

        protected void Page_Init(object sender, EventArgs e)
        {
            // create a channel factory and then instantiate a proxy channel
            _factory = new ChannelFactory<IWHSMailService>("WHSMailService");
            _channel = _factory.CreateChannel();
        }

        protected void Page_Unload(object sender, EventArgs e)
        {
            try
            {
                _factory.Close();
            }
            catch
            {
                // for the moment, we don't really care what happens here...if it fails, so be it
            }
        }

        public IWHSMailService WHSMailService
        {
            get { return _channel; }
        }
    
    }
}

Imports Microsoft.VisualBasic
Imports System
Imports System.ServiceModel
Imports WHSMailCommon.Contracts

Namespace WHSMailWeb
    Public Partial Class BasePage
        Inherits System.Web.UI.Page
        Private _factory As ChannelFactory(Of IWHSMailService) = Nothing
        Private _channel As IWHSMailService = Nothing

        Protected Sub Page_Init(ByVal sender As Object, ByVal e As EventArgs)
            ' create a channel factory and then instantiate a proxy channel
            _factory = New ChannelFactory(Of IWHSMailService)("WHSMailService")
            _channel = _factory.CreateChannel()
        End Sub

        Protected Sub Page_Unload(ByVal sender As Object, ByVal e As EventArgs)
            Try
                _factory.Close()
            Catch
                ' for the moment, we don't really care what happens here...if it fails, so be it
            End Try
        End Sub

        Public ReadOnly Property WHSMailService() As IWHSMailService
            Get
                Return _channel
            End Get
        End Property

    End Class
End Namespace

This code overrides the page's Init and Unload methods. Page_Init is called at the beginning of a page request and Page_Unload is called just before the request completes.

The Page_Init method here uses WCF to create a ChannelFactory object factory that will return proxy objects of type IWHSMailService. Recall that this is the interface which defines the contract of our service. The name passed as a parameter to the ChannelFactory constructor must match the name of the service in the configuration file, as discussed earlier.

Next, a channel object is created by calling CreateChannel from the ChannelFactory. This is what returns the fake, proxy object defined by our contract. A property named WHSMailService at the bottom of the class exposes this so that the inherited pages can easily use the object to call the host service. We'll see this a bit later.

The Page_Unload method simply closes the factory object and very poorly handles any exceptions that may occur when doing so. An error on close isn't critical to this application, but that is certainly not always the case.

Now we will implement the default page. I'm not going to repeat the entire HTML of the page itself here, and I'm certainly not a HTML/CSS designer, so I wouldn't recommend learning from that anyhow. It does, however, get the job done.

What you do need to know is that the page contains 4 <DIV> tags: one contains an ASP.NET TreeView object (the left-most pane), one contains an ASP.NET GridView object (the top-right pane), one contains 2 ASP.NET LinkButton's which implement a Next/Back paging scheme (the middle-right pane), and the last contains a table to display some header information, and a <DIV> to display the message contents.

After that poor description, here's what the application looks like in an instance of Internet Explorer with my instance of Outlook (with some blurring over the (not really) sensitive data):

Now let's implement the actual logic for the page. Open the Default.aspx page's code behind file. Bring in the WHSMailCommon.Entities namespace as follows:

using WHSMailCommon.Entities;

Imports WHSMailCommon.Entities

Next, change the _Default class to inherit from BasePage instead of System.Web.UI.Page:

public partial class _Default : BasePage

Public Partial Class _Default
    Inherits BasePage

Then, implement the Page_Load method. This method will be called after the Page_Init method which is implemented in our parent object and will be called automatically.

private string _folderEntryID = string.Empty;
private int _pageNum = 0;

protected void Page_Load(object sender, EventArgs e)
{
    // first time in (tvFolders has viewstate enabled
    if(tvFolders.Nodes.Count == 0)
    {
        // get the folder tree
        List<Folder> folderList = this.WHSMailService.GetFolders();

        // add the root node and expand it
        TreeNode node = new TreeNode(folderList[0].Name, folderList[0].EntryID);
        node.Expanded = true;
        tvFolders.Nodes.Add(node);

        // load up the sub-folders
        LoadNode(folderList[0].Folders, node);

        // get the inbox list and bind it to the grid
        List<Email> list = GetMessages();
        BindMessages(list);

        // save off the default page number and folder ID
        ViewState["PageNum"] = _pageNum;
        ViewState["FolderID"] = _folderEntryID;
    }

    _pageNum = int.Parse(ViewState["PageNum"].ToString());
    _folderEntryID = ViewState["FolderID"].ToString();
}

private void LoadNode(List<Folder> folders, TreeNode node)
{
    foreach(Folder f in folders)
    {
        // add the node with the format of Folder (Unread/Total)
        TreeNode subNode = new TreeNode(f.Name + " (" + f.UnreadMessages + "/" + f.TotalMessages + ")", f.EntryID);

        // expand and select the inbox
        subNode.Expanded = subNode.Selected = (f.Name == "Inbox");
        node.ChildNodes.Add(subNode);

        // load the subfolders
        if(f.Folders != null)
            LoadNode(f.Folders, subNode);
    }
}

private List<Email> GetMessages()
{
    // get a group of messages based on the current page number and size
    return this.WHSMailService.GetMessages(_folderEntryID, GridView1.PageSize, _pageNum);
}

private void BindMessages(List<Email> list)
{
    // load the grid
    GridView1.DataSource = list;
    GridView1.DataBind();

    // save off the new page number
    ViewState["PageNum"] = _pageNum;
}

Private _folderEntryID As String = String.Empty
Private _pageNum As Integer = 0

Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
    ' first time in (tvFolders has viewstate enabled
    If tvFolders.Nodes.Count = 0 Then
        ' get the folder tree
        Dim folderList As List(Of Folder) = Me.WHSMailService.GetFolders()

        ' add the root node and expand it
        Dim node As TreeNode = New TreeNode(folderList(0).Name, folderList(0).EntryID)
        node.Expanded = True
        tvFolders.Nodes.Add(node)

        ' load up the sub-folders
        LoadNode(folderList(0).Folders, node)

        ' get the inbox list and bind it to the grid
        Dim list As List(Of Email) = GetMessages()
        BindMessages(list)

        ' save off the default page number and folder ID
        ViewState("PageNum") = _pageNum
        ViewState("FolderID") = _folderEntryID
    End If

    _pageNum = Integer.Parse(ViewState("PageNum").ToString())
    _folderEntryID = ViewState("FolderID").ToString()
End Sub

Private Sub LoadNode(ByVal folders As List(Of Folder), ByVal node As TreeNode)
    For Each f As Folder In folders
        ' add the node with the format of Folder (Unread/Total)
        Dim subNode As TreeNode = New TreeNode(f.Name & " (" & f.UnreadMessages & "/" & f.TotalMessages & ")", f.EntryID)

        ' expand and select the inbox
        subNode.Selected = (f.Name = "Inbox")
        subNode.Expanded = subNode.Selected
        node.ChildNodes.Add(subNode)

        ' load the subfolders
        If Not f.Folders Is Nothing Then
            LoadNode(f.Folders, subNode)
        End If
    Next f
End Sub

Private Function GetMessages() As List(Of Email)
    ' get a group of messages based on the current page number and size
    Return Me.WHSMailService.GetMessages(_folderEntryID, GridView1.PageSize, _pageNum)
End Function

Private Sub BindMessages(ByVal list As List(Of Email))
    ' load the grid
    GridView1.DataSource = list
    GridView1.DataBind()

    ' save off the new page number
    ViewState("PageNum") = _pageNum
End Sub

If the tvFolders tree-view has not been filled in, we call our host service's GetFolders method from the WHSMailService property as defined above. The method then enumerates through the hierarchical list of folders returned, building the same tree structure that exists in Outlook. The Text property of each TreeNode is set to the folder name with a count of messages unread and total count of messages. The Value property of the node is set to the unique MAPI-defined EntryID so that we can later grab that value to return the list of messages from that specific folder.

Next, we call our service's GetMessages method to return messages from the Inbox. We pass in the value from the grid view's PageSize property and a member variable named _pageNum. This will handle our paging scheme as we discussed earlier. Once that list of messages is returned, is it bound to the data grid for display.

Finally, the default page number and folder entry ID (0 and "" respectively) are stored in the ViewState so they can be assigned back to our member variables on each page request.

If you were to run the application right now, you would see the same page that you do above, minus the message text at the bottom.

Next, we will implement what occurs when a user clicks on a folder in the tree view. We simply pull out the MAPI unique EntryID which is stored in the Value field of the selected node, assign it to the local member variable and view state, and then call the GetMessages method from our service to return a list of messages from that folder, just as we did with the inbox above. The code below shows the process:

protected void tvFolders_SelectedNodeChanged(object sender, EventArgs e)
{
    // new folder, so reset the view
    _pageNum = 0;
    _folderEntryID = this.tvFolders.SelectedNode.Value;
    ViewState["FolderID"] = _folderEntryID;

    List<Email> list = GetMessages();
    BindMessages(list);
}

Protected Sub tvFolders_SelectedNodeChanged(ByVal sender As Object, ByVal e As EventArgs)
    ' new folder, so reset the view
    _pageNum = 0
    _folderEntryID = Me.tvFolders.SelectedNode.Value
    ViewState("FolderID") = _folderEntryID

    Dim list As List(Of Email) = GetMessages()
    BindMessages(list)
End Sub

Next, we can implement the Next/Back link buttons. These methods simply increment or decrement the current page number, assign it to the view state for use on the next request, and then, just as before, gets the list of messages specific to the currently selected folder, using the unique ID stored in the view state.

protected void btnPrev_Click(object sender, EventArgs e)
{
    // first page
    if(_pageNum > 0)
        _pageNum--;

    List<Email> list = GetMessages();
    BindMessages(list);
}

protected void btnNext_Click(object sender, EventArgs e)
{
    // next page
    _pageNum++;
    List<Email> list = GetMessages();

    // if we're out of messages, go back to the previous page
    if(list == null || list.Count == 0)
    {
        _pageNum--;
        list = GetMessages();
    }
    BindMessages(list);
}

Protected Sub btnPrev_Click(ByVal sender As Object, ByVal e As EventArgs)
    ' first page
    If _pageNum > 0 Then
        _pageNum -= 1
    End If

    Dim list As List(Of Email) = GetMessages()
    BindMessages(list)
End Sub

Protected Sub btnNext_Click(ByVal sender As Object, ByVal e As EventArgs)
    ' next page
    _pageNum += 1
    Dim list As List(Of Email) = GetMessages()

    ' if we're out of messages, go back to the previous page
    If list Is Nothing OrElse list.Count = 0 Then
        _pageNum -= 1
        list = GetMessages()
    End If
    BindMessages(list)
End Sub

And finally, we need to implement what happens when the user selects a message from the top pane. If you look at the HTML for the Default page, you will see that the Subject field is bound to a LinkButton control in the grid view via a TemplateField (the rest of the fields are standard BoundFields. The LinkButton sets the CommandArgument property to the unique EntryID of that message as defined by MAPI. So, all we need to do is listen on the server for the LinkButton's Command event, grab the unique ID and call our service's GetMessage method with that ID to return the message itself.

protected void btnLink_Command(object sender, CommandEventArgs e)
{
    Email email = this.WHSMailService.GetMessage(e.CommandArgument.ToString());

    // fill out the header with some basic info
    lblFrom.Text = email.FromName + "&nbsp;(" + email.From + ")";
    lblSubject.Text = email.Subject;
    lblReceived.Text = email.Received.ToString();

    // when a message is selected, write out the content
    msgContent.InnerHtml = email.Body;
}

Protected Sub btnLink_Command(ByVal sender As Object, ByVal e As CommandEventArgs)
    Dim email As Email = Me.WHSMailService.GetMessage(e.CommandArgument.ToString())

    ' fill out the header with some basic info
    lblFrom.Text = email.FromName & "&nbsp;(" & email.From & ")"
    lblSubject.Text = email.Subject
    lblReceived.Text = email.Received.ToString()

    ' when a message is selected, write out the content
    msgContent.InnerHtml = email.Body
End Sub

The Email entity is retrieved, its properties are set to the labels in the header, and the message content is assigned to the InnerHtml property of the content holding <DIV>.

Voila! A very simple mail reader.

That's it for code. Now we need to deploy the applications and configure Windows Home Server.

Deployment

WHSMailHost

If you are deploying to a machine that is not your development machine, install the .NET Framework 3.0 runtime on the machine to which you will be running the host service. Then, copy the WHSMailHost.exe, WHSMailHost.exe.config, and WHSMailCommon.dll files to the machine running Outlook that will be connected to by the web application. You may want to create a shortcut in the Startup group so it will launch when you log into Windows.

Next, open Outlook and select Trust Center from the Tools menu. Choose Programmatic Access and set the option to Never warn me about suspicious activity. Unfortunately this must be disabled, otherwise Outlook will prompt you every time the host process attempts to retrieve any data. There is no way to bypass this on an application-by-application basis, so we have to turn it off for all applications.

If you are running firewall software on the PC, ensure that port 12345 will allow traffic to pass through. You may also change port 12345 to a different port, but you must change it in the configuration files for both applications.

Finally, note that Outlook does not need to remain open to use this application. You do, however, need to be logged into the machine with the host running.

WHSMailWeb

On your Windows Home Server machine, install the .NET Framework 3.0 Runtime. This is needed to use WCF. Next, create a new directory named mail (or anything you wish, but it is assumed it is named mail) in the c:\inetpub directory. Copy all .aspx pages, web.config, icon.png and the bin directory to the mail directory. You could also share out the mail directory and use Visual Studio's Publish command to automatically copy the files to that share. Then, open the Internet Information Services (IIS) Manager application from the Administrative Tools group on the Start menu. Open Web Sites and then Default Web Site in the left pane. Right-click on Default Web Site and select New -> Virtual Directory... from the context menu. When prompted, use the following values:

Alias	mail
Path	c:\inetpub\mail
Permissions	Read, Run Scripts

The next part is a bit tricky. We want to integrate with the security already provided by Windows Home Server. The WHS remote website uses Forms security from ASP.NET. Ideally, you should be able to log into the main page of the WHS remote website and then open the webmail link without having to log in again. Additionally, if the mail URL is used directly, you should be prompted for your login credentials.

To achieve this, open the web.config file from c:\inetpub\remote in Notepad. In the XML, between the start and end <system.web> tags you will find the configuration for the Forms-based authentication used by WHS. In order to use the cookie that is created by this authentication method, we need to have the same key values in our web.config file. The easiest way to achieve this is to copy all of the the text between the two <system.web> tags. Next, open the web.config file from the mail directory that you just copied over and paste the text between the two lines informing you to do so. Finally, we need to update the loginUrl and defaultRedirect paths in the forms and customErrors keys. Add /remote/ to the beginning of each to make them /remote/login.aspx and /remote/error.aspx. Be sure that the SERVERNAME item in the endpoint configuration is updated to the name/IP address of the machine running the host process.

With the files copied and edited, ensure that permissions on the file are propagated from the root mail directory to the files inside.

Finally, open the websites.xml file in the /remote directory and add the following XML before the end </WebSites> tag:

<WebSite name="Outlook Webmail" uri="/mail" imageUrl="/mail/icon.png" absolute="false"></WebSite>

With the configuration done, we need to enable web site connectivity in WHS. Double-click the Windows Home Server Console icon on the desktop. When it loads, click the Settings button in the top right corner. When the Settings dialog appears, select Remote Access in the left pane and then click the Turn On button in the right pane, assuming web site connectivity is off. If it already enabled, skip this step.

With all that done, create a user account for yourself in WHS so that you can login remotely. That's it!

Running the Application

Ensure the WHSMailHost application is running on the PC with Outlook installed. Then, browse to your Windows Home Server's default website. After logging in, you should see a link on the right side of the screen named Outlook Webmail.

Click that to start our application and if everything is working, you should see the web page as shown above.

Troubleshooting

If the web page displays an error message, open the web.config file in the mail directory on your Windows Home Server. Look for the <customErrors> tag and change the mode parameter to Off. This should allow you to see the actual error that is occurring and provide more information as to the status of the application.

Conclusion

Phew! Two applications and one shared assembly later, we have a web-based add-in for Windows Home Server that allows one to remotely access their Outlook message store. Currently the application is read-only and provides only minimal functionality. It's a great starting point to create a full-fledged webmail client interface. The project is hosted on CodePlex so I'm hoping to see you readers implement additional features and functionality that you find useful.

Additional Information

Here are a few links with additional information on the items discussed here:

Bio

Brian is a Microsoft C# MVP and a recognized .NET expert with over 6 years experience developing .NET solutions, and over 9 years of professional experience architecting and developing solutions using Microsoft technologies and platforms, although he has been "coding for fun" for as long as he can remember. Outside the world of .NET and business applications, Brian enjoys developing both hardware and software projects in the areas of gaming, robotics, and whatever else strikes his fancy for the next ten minutes. He rarely passes up an opportunity to dive into a C/C++ or assembly language project. You can reach Brian via his blog at http://www.brianpeek.com/.

Synthesized Podcasts for your Zune and iPod using SAPI

Coding4Fun — Tue, 10 Jul 2007 06:18:48 GMT

The guide takes you on your new speech-enabled adventure, as you'll learn to mix text with speech into a simple program that synthesizes XHTML transitional blog posts into the Wave format - for your iPod - using SAPI 5.3 and encodes them into the Windows Media Audio format - for your Zune - using Windows Media Encoder 9 Series API. In the end, you'll be able to make podcasts having just a standard plain text RSS 2.0 feed; plus, you'll be able to play them on at least two of the most popular media players available on the market.

Paul-Valentin Borza

Difficulty: Intermediate

Time Required: 6-10 hours

Cost: Free

Software: Microsoft .NET Framework 3.0 Redistributable Package Windows Media Encoder 9 Series Visual Studio Express C# or VB

Hardware:

Download: Source Code

Introduction

You probably read technology news (e.g. Coding4Fun) daily... Coding4Fun does not deliver podcasts - yet - and many web sites are in a similar situation. Microsoft Anna, the new text-to-speech (TTS) voice in Windows Vista, sounds more human than previous Microsoft voices like Mary, Mike or Sam; as time goes by, voices will become more and more natural and you won't even be able to tell the difference between a synthesized and a real human voice.
Wouldn't it be great to be able to convert blog posts into podcasts? You’ll even get to sync these synthesized podcasts with your Zune and iPod and listen to them wherever you are and whenever you want.

Prerequisites

Please download the Microsoft .NET Framework 3.0 Redistributable Package and install it on your computer (there is no need to install the package on Windows Vista). .NET Framework 3.0 gives you the opportunity to take advantage of the latest Speech API (SAPI 5.3); however, only Windows Vista comes with Microsoft Anna, as the voice is built right into the OS. In case you're running a previous version of Windows, the program will use a previous version of the TTS engine and won't sound as clear and crisp as you would expect.
You'll also need the Windows Media Encoder 9 Series to encode a Wave to a Windows Media Audio.
I hope you are already using Visual Studio Express C# or VB since you’re on the Coding4Fun web site (you're ok with any choice, as the sample is available is both languages).

Devices and Audio Formats

Synthesized podcasts should work on at least these devices:

The Zune supports the Windows Media Audio Standard (.wma) audio format as described on the Microsoft Zune Technical Specifications web page;
The iPod supports the Wave (.wav) audio format as described on the Apple iPod Technical Specifications web page;
The HP iPaq hw6915 comes with Windows Media Player 10 Mobile that supports both the Wave and the Windows Media Audio format;
In case you don't own a portable media player, you can always listen to these audio files on your computer.

Now that you have everything up and ready, let's get started: it's Coding4Fun time!

Getting Started with the Speech Synthesizer

The Speech Synthesizer is initialized with a -1 Rate (values can range between -10 and +10), a 80 Volume (values can range between 0 and 100) and a Female Adult EN-US Voice (Microsoft Anna); please note that a voice will be selected regardless of installed voices. The SpeechSynthesizerRate and SpeechSynthesizerVolume etc. can be easily modified inside "SpeakRssPodcast.exe.config".

Visual C#

   41 // Synthesizer
   42 this._synthesizer = new SpeechSynthesizer();
   43 // Rate
   44 this._synthesizer.Rate = this._settings.SpeechSynthesizerRate;
   45 // Volume
   46 this._synthesizer.Volume = this._settings.SpeechSynthesizerVolume;
   47 // Voice
   48 this._synthesizer.SelectVoiceByHints(this._settings.SpeechSynthesizerVoiceGender,
   49     this._settings.SpeechSynthesizerVoiceAge, this._settings.SpeechSynthesizerVoiceAlternate,
   50     this._settings.SpeechSynthesizerVoiceCulture);
   51 // Speak Progress
   52 this._synthesizer.SpeakProgress += new EventHandler<SpeakProgressEventArgs>(_synthesizer_SpeakProgress);

Visual Basic

   38 '' Synthesizer
   39 Me._synthesizer = New SpeechSynthesizer()
   40 '' Rate
   41 Me._synthesizer.Rate = Me._settings.SpeechSynthesizerRate
   42 '' Volume
   43 Me._synthesizer.Volume = Me._settings.SpeechSynthesizerVolume
   44 '' Voice
   45 Me._synthesizer.SelectVoiceByHints(Me._settings.SpeechSynthesizerVoiceGender, _
   46     Me._settings.SpeechSynthesizerVoiceAge, Me._settings.SpeechSynthesizerVoiceAlternate, _
   47     Me._settings.SpeechSynthesizerVoiceCulture)
   48 '' Speak Progress
   49 AddHandler _synthesizer.SpeakProgress, AddressOf Me._synthesizer_SpeakProgress

Getting Started with the Windows Media Encoder

The Windows Media Encoder is initialized with a default source group that has a single audio source; the source uses the Windows Media Audio 8 for Dial-up Modem (32 Kbps) profile for encoding a voice-only Wave, which is enough to keep the audio quality high and the size small.

Visual C#

   54 // Encoder
   55 this._encoder = new WMEncoder();
   56 // Source Group Collection
   57 IWMEncSourceGroupCollection sourceGroupColl = this._encoder.SourceGroupCollection;
   58 // Source Group
   59 IWMEncSourceGroup sourceGroup = sourceGroupColl.Add(this._settings.WindowsMediaEncoderSourceGroup);
   60 // Source
   61 this._source = sourceGroup.AddSource(WMENC_SOURCE_TYPE.WMENC_AUDIO);
   62 // Profile
   63 foreach (IWMEncProfile profile in this._encoder.ProfileCollection)
   64 {
   65     //Console.WriteLine(profile.Name);
   66     if (profile.Name == this._settings.WindowsMediaEncoderProfile)
   67         sourceGroup.set_Profile(profile); // Use Profile in VB
   68 }

Visual Basic

   51 '' Encoder
   52 Me._encoder = New WMEncoder()
   53 '' Source Group Collection
   54 Dim sourceGroupColl As IWMEncSourceGroupCollection = Me._encoder.SourceGroupCollection
   55 '' Source Group
   56 Dim sourceGroup As IWMEncSourceGroup = sourceGroupColl.Add(Me._settings.WindowsMediaEncoderSourceGroup)
   57 '' Source
   58 Me._source = sourceGroup.AddSource(WMENC_SOURCE_TYPE.WMENC_AUDIO)
   59 '' Profile
   60 For Each profile As IWMEncProfile In Me._encoder.ProfileCollection
   61     'Console.WriteLine(profile.Name);
   62     If (profile.Name = Me._settings.WindowsMediaEncoderProfile) Then
   63         sourceGroup.Profile = profile '' Use set_Profile in C#
   64     End If
   65 Next

Removing XHTML Tags

When you write a post on your blog, you're probably also embedding tags like IMG, DIV and SPAN etc.; such tags should not be spoken as they don't contain relevant audio data. The following piece of code removes these tags from an XHTML document and returns the inner text. You could use regular expressions to achieve the same result as it's just a matter of choice - I like it this way because it's easier to understand.

Visual C#

  242 private string buildPlainTextFromXHTML(string xhtmlText)
  243 {
  244     try
  245     {
  246         XmlDocument xhtmlDoc = new XmlDocument();
  247         xhtmlDoc.LoadXml(@"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>" +
  248             "<html xmlns='http://www.w3.org/1999/xhtmlDoc'>" +
  249             "<head><title></title></head>" +
  250             "<body>" + xhtmlText + "</body>" +
  251             "</html>");
  252         return xhtmlDoc.InnerText;
  253     }
  254     catch (Exception ex)
  255     {
  256         return this._settings.SpeechPromptException;
  257     }
  258 }

Visual Basic

  224 Private Function buildPlainTextFromXHTML(ByVal xhtmlText As String) As String
  225     Try
  226         Dim xhtmlDoc As XmlDocument = New XmlDocument
  227         xhtmlDoc.LoadXml("<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>" & _
  228             "<html xmlns='http://www.w3.org/1999/xhtmlDoc'>" & _
  229             "<head><title></title></head>" & _
  230             "<body>" & xhtmlText & "</body>" & _
  231             "</html>")
  232         Return xhtmlDoc.InnerText
  233     Catch ex As Exception
  234         Return Me._settings.SpeechPromptException
  235     End Try
  236 End Function

Building Prompts

What are prompts? A Prompt is an object that describes what the speech synthesizer should say (the text to be spoken), but also how it should say it (emphasis, rate and volume). For more details, please check the PromptBuilder class. The following function gets called every time a post is processed - my sample takes the latest three available posts.

Visual C#

  225 private Prompt buildItemPrompt(string itemTitle, DateTime itemPubDate, string itemDescription)
  226 {
  227     PromptBuilder pb = new PromptBuilder(this._settings.SpeechSynthesizerVoiceCulture);
  228     pb.StartParagraph(this._settings.SpeechSynthesizerVoiceCulture);
  229     pb.AppendText(String.Format(this._settings.SpeechPromptRssItem,
  230         itemTitle, itemPubDate.ToLongDateString(), 
  231         buildPlainTextFromXHTML(itemDescription)), PromptEmphasis.Moderate);
  232     pb.EndParagraph();
  233 
  234     return new Prompt(pb);
  235 }

Visual Basic

  208 Private Function buildItemPrompt(ByVal itemTitle As String, ByVal itemPubDate As DateTime, ByVal itemDescription As String) As Prompt
  209     Dim pb As PromptBuilder = New PromptBuilder(Me._settings.SpeechSynthesizerVoiceCulture)
  210     pb.StartParagraph(Me._settings.SpeechSynthesizerVoiceCulture)
  211     pb.AppendText(String.Format(Me._settings.SpeechPromptRssItem, _
  212         itemTitle, itemPubDate.ToLongDateString(), _
  213         buildPlainTextFromXHTML(itemDescription)), PromptEmphasis.Moderate)
  214     pb.EndParagraph()
  215 
  216     Return New Prompt(pb)
  217 End Function

Speaking Wave Podcasts

I have explicitly told the speech synthesizer to change its output to a file; otherwise, the prompts would have been played to the default audio device (the speakers). It then speaks two prompts: the first prompt contains the name of the channel, and the second prompt contains the title, publish date and description of the post.

Visual C#

  126 try
  127 {
  128     // Start Speak
  129     this._synthesizer.SetOutputToWaveFile(waveFullPath);
  130     this._synthesizer.Speak(buildChannelPrompt(channelTitle));
  131     this._synthesizer.Speak(buildItemPrompt(itemTitle, itemPubDate, itemDescription));
  132     // Console
  133     Console.WriteLine();
  134     Console.WriteLine();
  135     // Stop Speak
  136     this._synthesizer.SetOutputToNull();
  137     if (this._settings.EncodeAsWindowsMediaAudio)
  138         encodeWave(waveFullPath);
  139 }
  140 catch (Exception ex)
  141 {
  142     // Console
  143     Console.ForegroundColor = ConsoleColor.Red;
  144     Console.WriteLine(String.Format(this._settings.ConsoleExceptionMessage, ex.Message));
  145     Console.ResetColor();
  146 }

Visual Basic

  117 Try
  118     '' Start Speak
  119     Me._synthesizer.SetOutputToWaveFile(waveFullPath)
  120     Me._synthesizer.Speak(buildChannelPrompt(channelTitle))
  121     Me._synthesizer.Speak(buildItemPrompt(itemTitle, itemPubDate, itemDescription))
  122     '' Console
  123     Console.WriteLine()
  124     Console.WriteLine()
  125     '' Stop Speak
  126     Me._synthesizer.SetOutputToNull()
  127     If Me._settings.EncodeAsWindowsMediaAudio Then
  128         encodeWave(waveFullPath)
  129     End If
  130 Catch ex As Exception
  131     '' Console
  132     Console.ForegroundColor = ConsoleColor.Red
  133     Console.WriteLine(String.Format(Me._settings.ConsoleExceptionMessage, ex.Message))
  134     Console.ResetColor()
  135 End Try

Encoding as Windows Media Audio Podcasts

Encoding from one format to the other is quite simple to do, as seen below. Be careful to always call Flush when the encoder has finished (stopped) encoding, so that you don't leave the newly converted file in an inconsistent state.

Visual C#

  154 private void encodeWave(string waveFileName)
  155 {
  156     try
  157     {
  158         this._source.SetInput(waveFileName, String.Empty, String.Empty);
  159         this._encoder.File.LocalFileName = String.Format(this._settings.WindowsMediaAudioFile, waveFileName);
  160         // Start Encode
  161         this._encoder.PrepareToEncode(true);
  162         this._encoder.Start();
  163         // Wait for the encoder to catch up
  164         while (this._encoder.RunState != WMENC_ENCODER_STATE.WMENC_ENCODER_STOPPED)
  165         { Console.WriteLine(this._encoder.Statistics.EncodingTime); }
  166         this._encoder.Flush();
  167     }
  168     catch (Exception ex)
  169     {
  170         // Console
  171         Console.ForegroundColor = ConsoleColor.Red;
  172         Console.WriteLine(String.Format(this._settings.ConsoleExceptionMessage, ex.Message));
  173         Console.ResetColor();
  174     }
  175 }

Visual Basic

  143 Private Sub encodeWave(ByVal waveFileName As String)
  144     Try
  145         Me._source.SetInput(waveFileName, String.Empty, String.Empty)
  146         Me._encoder.File.LocalFileName = String.Format(Me._settings.WindowsMediaAudioFile, waveFileName)
  147         '' Start Encode
  148         Me._encoder.PrepareToEncode(True)
  149         Me._encoder.Start()
  150         '' Wait for the encoder to catch up
  151         While (Me._encoder.RunState <> WMENC_ENCODER_STATE.WMENC_ENCODER_STOPPED)
  152               Console.WriteLine(Me._encoder.Statistics.EncodingTime) : End While
  153         Me._encoder.Flush()
  154     Catch ex As Exception
  155         '' Console
  156         Console.ForegroundColor = ConsoleColor.Red
  157         Console.WriteLine(String.Format(Me._settings.ConsoleExceptionMessage, ex.Message))
  158         Console.ResetColor()
  159     End Try
  160 End Sub

Works on iPod

I own a Black 30GB iPod (Video) and can confirm that the synthesized podcasts sound as expected on the device.

However, I do not own a Zune and can not vouch that it will play these podcasts - it should work!

Demo

To illustrate how these synthesized podcasts sound, please listen to this Wave sample (.wav) or this Windows Media Audio (.wma) that were created using the Microsoft Windows Vista RSS, Windows Vista Editions: What's right for you?. You'll agree that it sounds pretty good... Why don't you give it a try? Change the RssFeedUri to target your blog and run the program; there you go, you have created your own podcasts without a microphone or a recording studio.

Conclusion

You have reached the end of this short guide that showed you how to enhance the world of standard plain text blogs; I hope you have enjoyed reading the article as much as I have enjoyed writing and coding the sample. Please use my Windows Live Messenger Id windowslive@borza.ro to talk with me in case you need further assistance. Thanks to the Microsoft Academic Program Team Romania for support.

Improvements

What should you do to improve what I have already done?

Use the PromptBuilder.AppendAudio member to add extra flavor to the podcasts; more, you could alternate sounds (use melodies that were released under a Creative Commons license).
Use the Regex class to convert HTML posts to plain text.
Encode synthesized audio to the MP3 format; in addition, you should also add tags.

Bio

Paul-Valentin Borza is in its second year of study at the Babes-Bolyai University of Cluj-Napoca, Faculty of Mathematics and Computer Science. Since 2005, he is involved in the Microsoft Student Partners - Microsoft Academic Program Romania. He can be reached through his web site at www.borza.ro.