Jan Smessaert introduces his session called 'The Future of Business Productivity'

Introduction

Windows 7 brings with it a large number of new features that will be available to developers from day one.  These are really nice additions that will make applications more natural to work with.  One of the new areas of enhancements is the taskbar.  The taskbar has always been a pretty simple way to see what's running and switch between tasks.  Moving from XP to Vista, we got cool previews, but that's about it.  With Windows 7, now we can drag-and-drop minimized app icons to change their order, we can pin apps there even if they aren't running (replacing Quick Launch functionality).  You can also right-click the icons to restore or close the window.  Better still, many apps give you additional information upon right-click, such as Recent lists, or actions like changing your Live Messenger status:

Image 1: Jump list for Windows Live Messenger

In this article, I would like to dig into the following notable new features:

• Customizable preview
• Icon overlays
• Progress indication
• Toolbar buttons

None of these features are very difficult to use due to the Windows API Code Pack.  This download is a free (but unsupported) package from Microsoft on the MSDN Code Gallery.  Version 1.0 was released on August 6, after a number of earlier pre-releases.  Since many of the new features are specific to Windows 7, they are not in the .NET Base Class Libraries.  This package exposes them for .NET so you don't have to do any of your own interop.

This sample is written for Windows Forms, but it works equally well with WPF.  These four features are easy to integrate into any application that you write.

Customizable Previews

To start with, we'll dig into customizable previews.  This refers to the ability to change the Aero Peek preview that shows up in the task bar when you hover over a minimized application. 

Image 2: Aero Peek preview for Windows Live Writer

If you create any basic application and launch it (F5), the taskbar preview will be an exact copy of the application's main window.  In fact, Windows gets this from the DWM, or Desktop Window Manager.  This is cached already so it makes sense to use it here.  Overriding it though is fairly easy.  In a photo editing application, it might be better to have the preview show the current image by itself -- without all of the toolbars and menus.  You can also choose to take the cached thumbnail from the DWM and just crop a portion of it - like to remove a ribbon UI from the top.

The TaskbarManager class is responsible for exposing progress state, thumbnail, overlay icons, and other similar properties.  These functions would otherwise be scattered across various Win32 API calls, but the Windows API Code Pack simplifies this immensely.  The first step is to create a reference to it and obtain the static reference:

Visual Basic

Private windowsTaskbar As TaskbarManager = TaskbarManager.Instance

Visual C#

private TaskbarManager windowsTaskbar = TaskbarManager.Instance;

You'll use this reference throughout your application for any taskbar manipulation.  In order to clip your preview, just specify the window handle and the region.  An easy way is to specify the Location and Size properties of a control.  In this sample, it's a GroupBox, but in another application it might make more sense to clip to a PictureBox or other control:

Visual Basic

windowsTaskbar.TabbedThumbnail.SetThumbnailClip(Me.Handle, New Rectangle(groupBox2.Location, groupBox2.Size))

Visual C#

windowsTaskbar.TabbedThumbnail.SetThumbnailClip(this.Handle, new Rectangle(groupBox2.Location, groupBox2.Size));

Icon Overlays

Icon overlays allow you to display a visual representation of your program's state.  This has been possible for some time using icons in the notification area (battery level low, anti-virus disabled), but until now it hasn't been possible as part of your taskbar icon.  Now you can choose any icon (from an ICO file or extracted from an executable or DLL) and the taskbar manager will display it directly in the task bar overlaid on your application icon.  This is used in Windows Live Messenger to show your login status (offline, busy, available, etc.):

Image 3: Windows Live Messenger with overlay for offline status

This is great for providing information at a glance.  Especially as more and more users are hiding their cluttered notification tray icons and wouldn't see the indicator otherwise.

The beautiful thing is that the TaskbarManager class allows you to set this with one line of code:

Visual Basic

windowsTaskbar.SetOverlayIcon(me.Handle, My.Resources.Green, "Green")

Visual C#

windowsTaskbar.SetOverlayIcon(this.Handle, TaskbarDemo.Properties.Resources.Green, "Green");

The same API call can also lets you clear an overlay:

Visual Basic

windowsTaskbar.SetOverlayIcon(Me.Handle, Nothing, Nothing)

Visual C#

windowsTaskbar.SetOverlayIcon(this.Handle, null, null);

Progress Indication

As your application works through something, such as file copying, downloading, or processing a data set, you might be tempted to display a progress bar in a popup dialog.  If you're really diabolical you might even make this a modal dialog!  In our brave new world of Windows 7 though, we no longer need to subject our users to this.  Instead of cluttering up the screen, we can reflect the current progress of any single operation by displaying a progress bar behind our application icon, such as Windows Explorer during a file copy:

Image 4: Windows Explorer with file copy progress indication

It's faint, but you should be able to see the bar at around the 15-20% point behind the folder.  There are actually a number of states that you can instruct the taskbar to display, then you just provide progress value updates as needed.

In this sample application, we display the various TaskbarProgressBarState enumerated values in a ComboBox:

Visual Basic

comboBoxProgressState.DataSource = System.Enum.GetNames(GetType(TaskbarProgressBarState))

Visual C#

comboBoxProgressState.DataSource = Enum.GetNames(typeof(TaskbarProgressBarState));

When changes are made, we update the state using the SetProgressState call:

Visual Basic

windowsTaskbar.SetProgressState(CType(System.Enum.Parse(GetType(TaskbarProgressBarState), comboBoxProgressState.Text), TaskbarProgressBarState))

Visual C#

windowsTaskbar.SetProgressState((TaskbarProgressBarState)Enum.Parse(typeof(TaskbarProgressBarState), comboBoxProgressState.Text));

Then, we use a TrackerBar to select the current value which gets posted using the SetProgressState call:

Visual Basic

windowsTaskbar.SetProgressValue(trackProgress.Value, 100)

Visual C#

windowsTaskbar.SetProgressValue(trackProgress.Value, 100);

Toolbar Buttons

One of the new features that really has me excited is the ability to add buttons to the preview image.  This is a very underutilized feature so far, though it's visible in Windows Media Player:

Image 5: Windows Media Player preview with toolbar buttons for media control

Notice the Pause, Previous, and Next buttons under the Aero Peek.  Those are fully-functional.  The great thing is that you can add them to your application easily, and bind event handlers to them like any other buttons.  You don't get design-time support like for forms and menus, but you really don't need it.

Start by decaring a ThumbnailToolbarButton:

Visual Basic

Private WithEvents buttonFirst As ThumbnailToolbarButton

Visual C#

private ThumbnailToolbarButton buttonFirst; 

You can set the image, a label (shown on hover), enabled or not, and other common Button properties.  Here I will create the button and point it to an image stored as a resource, and a label:

Visual Basic

buttonFirst = New ThumbnailToolbarButton(My.Resources.search, "Search")

Visual C#

buttonFirst = new ThumbnailToolbarButton(Properties.Resources.first, "First Image");

Next, I need to attach an event handler to it.  In Visual Basic, since buttonFirst was declared using WithEvents, you can use the Handles keyword in the declaration of the event handler.  In C#, you can type "buttonFirst.Click +=" and then press the TAB key twice.  This will fill out the rest of the line *and* create an event handler stub:

Visual Basic

Private Sub buttonFirst_Click(ByVal sender As Object, ByVal e As ThumbnailButtonClickedEventArgs) Handles buttonFirst.Click

Visual C#

buttonFirst.Click += new EventHandler<ThumbnailButtonClickedEventArgs>(buttonFirst_Click); 

Finally, add the buttons using the TaskbarManager instance.  The AddButtons call takes a list of parameters, so you can just add other buttons by separating them with commas:

Visual Basic

windowsTaskbar.ThumbnailToolbars.AddButtons(Me.Handle, buttonFirst)

Visual C#

windowsTaskbar.ThumbnailToolbars.AddButtons(this.Handle, buttonFirst);

Just fill in something for your event handler to do (a simple MessageBox in the sample application), and you're done!  It's super-easy and it adds a new dimension of interactivity with your application.  This could replace menu commands in a notification icon, or simply present common actions.  It doesn't make sense in every application, but it's easy to add when you need it.

Next Steps

The next step is to evaluate your own applications to see what makes to add.  While custom previews and toolbar buttons don't make sense for every application, progress indication and custom overlays can often be a good fit.  Of course, remember that if you implement any of this, it won't be visible in Windows Vista or earlier.  Be sure to have a secondary way to access these same functions.  Toolbar buttons and overlays can be accomplished in the notification icon, and progress can always be displayed in a popup dialog as a fallback.

Conclusion

Windows 7 makes it easier to create very user-friendly applications.  You may be able to augment existing applications to take advantage of these features, or at least keep them in mind when designing new applications.  Pretty quickly, these will be considered common place and you'll want your application to play well on the desktop.

If you haven't yet, download Visual Studio 2008 Express Edition (Visual Basic or Visual C#), and then download the Windows API Code Pack so you can get started!  Of course you'll need at least the Windows 7 RC build in order to actually test any of this, but the final release is in just a few months.  Get ready for it now!

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!

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.

C#

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;
}

VB

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:

C#

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;
}

VB

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://ecn.channel9.msdn.com/o9/c4fcontent/migration/9525376/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.

C#

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;
}

VB

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

C#

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")
    };
}

VB

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:

C#

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.

C#

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);
}

VB

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:

C#

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;

VB

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.

C# 

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);
}

VB

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:

C#

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));
}

VB

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.

C#

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);
}

VB

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:

C#

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;
}

VB

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:

C#

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);
}

 VB

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.

C#

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;
}

VB

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:

C#

// 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);

VB

' 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

1. Create a new Twitter account for use in TwitterDrive.
2. 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.
3. 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.

Although some of the functions in Taglocity can already be done with crafty use of Outlook’s rules and views - not to mention Outlook 2007’s labels -the plugin aims to make that process easier. This is especially true for the conversation threading feature which displays emails in chronological order with all the related conversations grouped together. Some Outlook 2007 users won’t see the need for this addition, but for users of Outlook 2003, this plugin delivers some great additional features. You can check it out for yourself here.

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!

Bluetooth is now found in a variety of devices and enable the user to use wireless accessories.  The Bluetooth protocol allows a user to “discover” any device that is in proximity to your Bluetooth radio.  Why not see who is in proximity to you?  Why not have the presence of a device execute programs or alert you?

Andy Konkol – http://copyandwaste.com

Hardware:

• Bluetooth radio (USB dongle)

• SMA Female Jack

• SMA male to N-male pigtail

• 2.4 GHz antenna (with N-female connector)

Software:

• Coding4fun Developer Kit

• Robert Misiak's Notify Window

Download:

• Source / Binary Download

Bluetooth and Hardware:

Bluetooth was designed for devices to communicate wirelessly over short distances.  However, with a very simple hardware modification you can extend the range of your Bluetooth radio with standard 2.4ghz antennas used in wireless networking (802.11 a/b/g).

Modifying Bluetooth dongles to accept external antennas is documented all over the Internet.  In principle it is very easy: find the antenna lead and solder on a connector/antenna.  I purchased a very cheap Bluetooth USB dongle on eBay and opened the casing.  After finding the antenna trace on the circuit board I soldered on a SMA Female connector to it.  After soldering the antenna jack in place I slipped a 3 inch chunk of heatshrink and heated it to cover the exposed circuit board.  Now I had a Bluetooth radio that accepts external antennas. Adding an antenna simply increases the range of your radio, allowing you to “see” devices from a farther distance.

To connect an external antenna to the dongle I needed to use a connector converter called a pigtail.  I used a SMA male to N-male pigtail.  I connected one end of the pigtail to my dongle and the other to an omni-directional 9dbi panel antenna that had an N-female connector.

Software:

To take advantage of my newly modified hardware I needed to download the Coding4Fun Toolkit.  Included in the toolkit is an API for Bluetooth devices.  This API allows you to do a wide variety of things with your Bluetooth radio but I focused on two methods from the ServiceAndDeviceDiscovery library: DiscoverAllDevices and DiscoverDeviceByName.

DiscoverAllDevices allows you to “scan” the airwaves on the 2.4 GHz band and report back what devices your radio sees.

DiscoverDeviceByName allows you to scan for a particular device with a specified name and report back if it is present or not.

private bool DevicePresent()
{
    BluetoothDeviceServicesManager workerBTMgr = new BluetoothDeviceServicesManager();
    Device workerDevice = workerBTMgr.DiscoverDeviceByName(_watchItem.DeviceName);

    return (workerDevice != null);
}

public void Run(String Operation)
{
    switch (Operation)
    {
        case "SingleDevice":
            if (DevicePresent())
            {
                _parentForm.Invoke(_parentForm.AddToDeviceSeenList, new object[] { _watchItem });
            }
            else
            {
                _parentForm.Invoke(_parentForm.RemoveFromDeviceSeenList, new object[] { _watchItem });
            }
            break;
        case "AllDevices":
            BluetoothDeviceServicesManager workerBTMgr = new BluetoothDeviceServicesManager();
            List<Device> Devices = workerBTMgr.DiscoverAllDevices();
            _parentForm.Invoke(_parentForm.ThreadUpdateDiscoverBox, new object[] { Devices });
            break;
    }
}

Both of these methods require that the device you are scanning for is in discoverable mode (which most manufacturers enable by default).  Using the two methods described above I was able to tell if a device is in proximity. And ultimately enabling me create alerts and execute programs based on what device is present.

To perform device discovery and not have my UI lag I had to create two worker threads.  One worker thread to discover all devices and display it under my devices listbox, and another to discover devices by name specified in the “watchlist.”  I am not an expert at multi-threaded programs but I managed to implement them without any major headaches.

User Interface:

Since the “Add to watchlist” and “Edit” buttons essentially do the same thing, I decided to overload a windows form.  I also wanted to keep track of the parent form and disable it when the WatchItemForm was shown.

The second overload allows me to fill in the form control's text based on the data that is already set for the WatchItem that has been selected (the Edit button). 

public WatchItemForm(Form1 f, String DeviceName)
{
    InitializeComponent();
    this._parentForm = f;
    lblDeviceName.Text = DeviceName;
}

public WatchItemForm(Form1 f, WatchItem item)
{
    InitializeComponent();
    this._parentForm = f;

    lblDeviceName.Text = item.DeviceName;
    tbxPicturePath.Text = item.ImagePath;
    tbxProgramPath.Text = item.ProgramPath;
    this._parentForm.Enabled = true;
}

I wanted to have a pop up notify window similar to outlook and was able to find Robert Misiak's NotifyWindow. This is a very simple library which allows you to create pop up notify windows very easily. I edited NotifyWindow to include a “picturepath” variable as well as picturebox on the form. As you can see creating a NotifyWindow is quite easy:

public void NotifyDeviceWindow(WatchItem x)
{
    NotifyWindow nw;
    nw = new NotifyWindow();
    //validate Alert Message
    if (x.AlertMessage == null)
    {
        nw.Text = x.DeviceName;
    }
    else
    {
        nw.Text = x.AlertMessage;
    }
    //validate picture
    if (x.ImagePath != null)
    {
        FileInfo imgfile = new FileInfo(x.ImagePath);
        if (imgfile.Exists)
        {
            nw.PicturePath = x.ImagePath;
        }
        else
        {
            MessageBox.Show("Image does not exist");
        }
    }
    nw.Notify();

    if (x.ProgramPath != null)
    {
        RunProcess(x.ProgramPath);
    }
}

Process Flow/Software Operation:

1. User clicks the “Discover” button, a thread is spawned which enumerates all Bluetooth devices in proximity
2. Thread finishes and updates the Devices listbox
3. User selects a discovered device and clicks “Add to watchlist” A watch item form is spawned and asks you for an alert message, a picture path, and an executable path
4. User clicks save , a WatchItem object is created and added to the watchList object
5. A timer starts and every 10 seconds a thread is spawned to discover that device by name
6. If the device is discovered, it is added to the “deviceSeenList” and a notify alert is sent and the executable is executed.
7. If that device is still present after the next timer click, no notification is sent, If that device is not present it is removed from the “deviceSeenList”

Screenshots:

His list was short and sweet, but it was no match for the super massive list of all shortcuts for Word 2002, Word 2003, and Word 2007 found here. Wow, you really don't even need a mouse, do you?

	Does Windows take too long starting up before you can get to work?  Wouldn't it better if things could startup at a lower priority?  Learn how to launch processes, use performance counters, monitor files, and run tasks in the background.
Arian Kulp Arian's Blog Difficulty: Intermediate Time Required: 1-3 hours Cost: Free Software: Visual Basic or Visual C# Express Editions Hardware: None Download: C# Download VB Download

Introduction

Starting up Windows usually takes longer than I'd like it to.  It seems like the system is churning away for ages.  I've often thought that it would make more sense to wait as each item starts up before starting the next item.  The problem is Windows has no idea how long an application takes to initialize itself.  After launching it, it's just another running process.  It would be nice to be able to configure a delay after each application so it can perform its potentially expensive startup before another application starts.  I decided to put this idea into action.

This application requires Visual Studio 2005 Express Editions (C# or Visual Basic) or higher.  This will be my last Coding 4 Fun article targeting Visual Studio 2005.  If you haven't downloaded a Visual Studio 2008 Express Edition yet, definitely check them out.  The upgrade is very much worth it!

Starting Up

The basic idea of the program is very simple: launch each startup item with a configurable delay between each one.  Beyond a simple delay though, it might be good to see how active the system is.  If the CPU is working hard, maybe it would be good to wait until it settles down before launching something else.

In case you've never looked closely, there are a few ways that Windows knows what to startup with the system.  The three most common ways to start things are by using the Registry, the Startup folder, or by configuring services.  The Registry and Startup folder methods are pretty similar.  Of course Services are background processes that run even if a user isn't logged in.

Once a user logs in, the Registry and Startup folders take effect.  The system Registry is a collection of keys, values, and data that applications (and Windows itself) use for configuration.  One such use is to contain a list of programs to launch with Windows.  There is a system-level and user-level list.  System-level programs are started up for every user that logs in, while user-level programs are started only for the specific user.

The Startup folder works the same way.  As part of each user's profile folder there is a Startup folder.  There is also one at the Default User level.  These folders contain shortcuts to applications.  Whenever a user logs in, all of these shortcuts are launched.  We just need to take over this process.  To do this though, we'll need to take the shortcuts out of the system Startup folders.

The Basics

The Startup Optimizer works by scanning the user's Startup folder looking for shortcuts.  As a new shortcut is found, a StartupEntry object is created.  This object holds the filename, a display name and a few flags.  The key flag is Managed.  An object with Managed set to True is launched by the application and moved to a new ManagedStartup folder in the user's profile.

When a file or shortcut is detected in the Startup folder, a popup will occur to let a user decide if the program should manage it or not.  If so, it moves the shortcut to its ManagedStartup folder.  If not, it leaves it alone but sets the Managed flag to False.  Next time it notices the same shortcut, it will just now to ignore it and let Windows handle it.

Figure 1: The dialog shown when a startup item is found

If you click the button to show the advanced options, you can specify a display name, the low CPU flag, and how to long to wait before launching the next application.

Figure 2: The dialog with advanced settings shown 

Notice the icon.  There's no included support for extracting the icon from a file, but you can use the Win32 SHGetFileInfo function in the shell32.dll library like so:

Visual Basic

<DllImport("shell32.dll")> _
Public Shared Function SHGetFileInfo(ByVal pszPath As String, ByVal dwFileAttributes As UInteger, ByRef psfi As SHFILEINFO, ByVal cbSizeFileInfo As UInteger, ByVal uFlags As UInteger) As IntPtr
End Function

Visual C#

[DllImport("shell32.dll")] 
public static extern IntPtr SHGetFileInfo(string pszPath, uint dwFileAttributes,
       ref SHFILEINFO psfi, uint cbSizeFileInfo, uint uFlags);

All StartupEntry objects are added to the StartupEntryList collection which is a subclass of List<StartupEntry>.  Creating a subclass like this allows you to add helper methods for finding or removing objects or other useful functions.  This collection is what is saved to disk to retain the properties of each item.  The basic .NET binary serialization method is used due to its simplicity in code.  Note that any class to be serialized must be decorated with the Serializable attribute.

Visual Basic

Public Shared Function FromDisk() As StartupEntryList
    If Not File.Exists("StartupEntryList.ser") Then
        Return New StartupEntryList()
    End If

    Dim c As StartupEntryList
    Dim s As Stream = File.Open("StartupEntryList.ser", FileMode.Open)
    Dim b As New BinaryFormatter()
    c = DirectCast(b.Deserialize(s), StartupEntryList)

    s.Close()

    Return c
End Function

Public Sub SaveToDisk()
    Dim s As Stream = File.Open("StartupEntryList.ser", FileMode.Create)
    Dim b As New BinaryFormatter()
    b.Serialize(s, Me)
    s.Close()
End Sub

Visual C#

public static StartupEntryList FromDisk() 
{ 
    if (!File.Exists("StartupEntryList.ser")) return new StartupEntryList(); 

    StartupEntryList c; 
    Stream s = File.Open("StartupEntryList.ser", FileMode.Open); 
    BinaryFormatter b = new BinaryFormatter(); 
    c = (StartupEntryList)b.Deserialize(s); 

    s.Close(); 

    return c; 
} 

public void SaveToDisk() 
{ 
    Stream s = File.Open("StartupEntryList.ser", FileMode.Create); 
    BinaryFormatter b = new BinaryFormatter(); 
    b.Serialize(s, this); 
    s.Close(); 
} 

Notice how the FromDisk() method is static.  This works as a factory method on the StartupEntryList class itself.  Subclassing that simple generic list has made it easy to encapsulate all related functionality into the same place.

Working in the Background

Of course at some point the application needs to perform its startup magic.  Obviously the main work is just launching each shortcut.  This is done using the Process.Start() method in the System.Diagnostics namespace.  If we were just launching the shortcuts one after another, it would be over quickly, but it would defeat the purpose of the program!  With delays and waiting for the CPU to go idle, this startup process could potentially take a few minutes.  This is important because it means that we can't just start the sequence in the Form_Load event handler on startup.  The application would be unresponsive and there would be no way to abort.

Enter the BackgroundWorker class.  I've used this in articles before and they make it really easy to run things in the background.  It's much easier than creating threads -- especially if you need to update the user interface.  You get to avoid the Invoke calls that are otherwise required and you even get Form Designer support.

Similar to the StartupEntryList, subclassing is a good idea in order to keep things nicely encapsulated.  There's actually only one method that matters in this case: the event handler for the DoWork event.  This is where work is done.  You never call it directly (it's marked private) -- it's invoked when the RunWorkerAsync method is called.  Anything that happens in the event handler is automatically on a thread other than the UI thread.  It couldn't be simpler!  In order to cause the UI to be updated (you can't ever directly reference it due to cross-threading concerns) call the ReportProgress method.  Periodically check the CancellationPending flag to see if you need to exit.

The StartupBackgroundWorker_DoWork event handler method basically just iterates over the entries that have Managed set to true, waits for an idle CPU if necessary, and waits the specified delay time if set before moving to the next one.  At several points it checks to see if a cancellation has been requested.  The best thing though, is regardless of how long the sequence takes the UI will run smoothly.

Visual Basic

    Private Sub StartupBackgroundWorker_DoWork(ByVal sender As Object, ByVal e As DoWorkEventArgs)
        Dim entries As List(Of StartupEntry) = TryCast(e.Argument, List(Of StartupEntry))

        If entries Is Nothing OrElse entries.Count = 0 Then
            e.Cancel = True
            Throw New Exception("No entries passed in")
        End If

        Try
            ' Don't bother if there aren't any entries!
            If entries.Count > 0 Then
                Me.ReportProgress(0, "Startup Optimizer will begin in five seconds.  Click to cancel.")
                Dim i As Integer = 0
                While i < 5 AndAlso Not Me.CancellationPending
                    Thread.Sleep(1000)
                    i += 1
                End While

                If Me.CancellationPending Then
                    e.Cancel = True
                    Return
                End If
            End If

            systemIdleComponent1.Enabled = True

            ' Process entries to perform startup
            For Each entry As StartupEntry In entries
                If entry.Managed Then
                    If entry.WaitForLowCPU Then
                        Me.ReportProgress(0, "Waiting for idle CPU to launch: " + entry.DisplayName)

                        ' CPU wait routine...
                        ' TODO: Give up if we never go idle?  This would be the place..!
                        While Not systemIdleComponent1.WaitForIdle(1000)
                            If Me.CancellationPending Then
                                e.Cancel = True
                                Return
                            End If
                        End While
                    End If

                    Me.ReportProgress(0, "Starting: " + entry.DisplayName)

                    ' Don't actually start if we are debugging
                    If Not Debugger.IsAttached Then
                        Process.Start(Path.Combine(My.Settings.ManagedStartupPath, entry.FileName))
                    Else
                        'SIMULATE STARTUP DELAY
                        Thread.Sleep(2000)
                    End If

                    Me.ReportProgress(0, "Started: " + entry.DisplayName)

                    If entry.DelayTime > 0 Then
                        Me.ReportProgress(0, "Waiting: " + entry.DelayTime + " seconds until next item")
                        For x As Integer = 0 To entry.DelayTime - 1

                            ' Wait the number of seconds but check for cancel flag each second
                            If Me.CancellationPending Then
                                e.Cancel = True
                                Return
                            End If

                            Thread.Sleep(1000)
                        Next
                    End If
                End If
            Next
        Catch
            e.Cancel = True
        Finally
            systemIdleComponent1.Enabled = False
        End Try

    End Sub

Visual C#

private void StartupBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
    List<StartupEntry> entries = e.Argument as List<StartupEntry>;

    if (entries == null || entries.Count == 0 )
    {
        e.Cancel = true;
        throw new Exception("No entries passed in");
    }

    try
    {
        // Don't bother if there aren't any entries!
        if (entries.Count > 0)
        {
            this.ReportProgress(0, "Startup Optimizer will begin in five seconds.  Click to cancel.");
            for (int i = 0; i < 5 && !this.CancellationPending; i++)
                Thread.Sleep(1000);

            if (this.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
        }

        systemIdleComponent1.Enabled = true;

        // Process entries to perform startup
        foreach (StartupEntry entry in entries)
        {
            if (entry.Managed)
            {
                if (entry.WaitForLowCPU)
                {
                    this.ReportProgress(0, "Waiting for idle CPU to launch: " + entry.DisplayName);

                    // CPU wait routine...
                    // TODO: Give up if we never go idle?  This would be the place..!
                    while( !systemIdleComponent1.WaitForIdle(1000) )
                    {
                        if (this.CancellationPending)
                        {
                            e.Cancel = true;
                            return;
                        }
                    }
                }

                this.ReportProgress(0, "Starting: " + entry.DisplayName);

                // Don't actually start if we are debugging
                if( !Debugger.IsAttached)
                    Process.Start(Path.Combine(Properties.Settings.Default.ManagedStartupPath, entry.FileName));
                else
                    Thread.Sleep(2000); //SIMULATE STARTUP DELAY

                this.ReportProgress(0, "Started: " + entry.DisplayName);

                if (entry.DelayTime > 0)
                {
                    this.ReportProgress(0, "Waiting: " + entry.DelayTime + " seconds until next item");

                    // Wait the number of seconds but check for cancel flag each second
                    for (int x = 0; x < entry.DelayTime; x++)
                    {
                        if (this.CancellationPending)
                        {
                            e.Cancel = true;
                            return;
                        }

                        Thread.Sleep(1000);
                    }
                }
            }
        }
    }
    catch
    {
        e.Cancel = true;
    }
    finally
    {
        systemIdleComponent1.Enabled = false;
    }

}

There are a few things to callout in this block.  I have a few sanity checks in there to be sure that the list isn't NULL or empty.  Defensive programming is always a good idea!  Notice also that I have pauses built in with the Thread.Sleep() command.  Where it would be convenient to pause for several seconds, it would render the thread unresponsive if a cancellation was requested.  Note that cancellation is completely passive.  The framework doesn't ever abort your BackgroundWorker.  It's up to your code to catch it if cancellation is requested.  So for pauses, I wait a second, check the flag, and repeat for the number of seconds.  The code is slightly bulky but it works well.

Notice also how I don't launch the startup applications if System.Diagnostics.Debugger.IsAttached is true.  When I'm troubleshooting/testing, I don't really want the applications launching every time!  It's a simple check to see if the application is currently being debugged (as in Visual Studio).

Detecting Idleness

In addition to the simple time-based delays, I also wanted the option to wait for the system to be idle before launching applications.  There's no direct way to see this though, so I created the SystemIdleComponent.  This is completely modular and could be plugged into other applications easily.  It all comes down to system Performance Counters.  If you've never worked with these before, don't let them intimidate you.  They're actually very easy to work with.  From the Visual Studio Toolbox you can easily drag a counter and set its properties (category, counter,and instance), but unfortunately there's no support for events when the value changes.  A pretty big deal I think!

My component builds on the PerformanceCounter object and creates a System.Threading.Timer object behind the scenes to monitor the state of the counter periodically.  If a change is measured and it falls outside of the tolerance limits, it raises an event.  It also raises an event when it returns to the tolerance.  This allows you to receive an event both when the system becomes idle and when it returns to non-idle.

Visual Basic

    Private Sub timerCpu_Tick(ByVal state As Object)
        Dim currentValue As Integer = 100 - CInt(performanceCounterProcessorIdle.NextValue())

        ' If we are below the threshold, start counting...
        If currentValue <= _thresholdIdlePercent Then
            idleTimer.Start()
        Else
            idleTimer.[Stop]()
            idleTimer.Reset()
        End If


        ' See if we've been idle long enough
        If idleTimer.ElapsedMilliseconds / 1000 > _thresholdIdleTime Then
            ' We've just gone idle
            RaiseIdleEvent()
        Else
            ' We are not idle
            LowerIdleEvent()
        End If

        _lastCpuValue = CInt(currentValue)
    End Sub

Visual C#

private void timerCpu_Tick(object state)
{
    int currentValue = 100 - (int)performanceCounterProcessorIdle.NextValue();

    // If we are below the threshold, start counting...
    if (currentValue <= _thresholdIdlePercent)
        idleTimer.Start();
    else
    {
        idleTimer.Stop();
        idleTimer.Reset();
    };

    // See if we've been idle long enough
    if (idleTimer.ElapsedMilliseconds / 1000 > _thresholdIdleTime)
    {
        // We've just gone idle
        RaiseIdleEvent();
    }
    else
    {
        // We are not idle
        LowerIdleEvent();
    }

    _lastCpuValue = (int)currentValue;
}

What is idle?  This is defined by properties ThresholdIdlePercent and ThresholdIdleTime.  The statement is "the system is idle when it has been at {ThresholdIdlePercent}% for {ThresholdIdleTime} seconds."  A consuming application just sets the properties and subscribes to events.  Alternately, you can check the SystemIdle property when you need to.  A final way is to call WaitForIdle with our without a timeout value.  The call will not return until the system is idle.

This works by using an System.Threading.EventWaitHandle object.  This very cool construct (system-based, not just .NET) lets two threads coordinate via a shared semaphore.  The BackgroundWorker thread goes to sleep until the SystemIdleComponent's timer fires and detects an idle state.  It can be dangerous to wait too long locked like this, so the worker will only call it for a second at a time in-between checking for a cancellation request.  I've added additional attributes to this object to make it easier to reuse and for a good design-time experience.  Drag it to your form and work with it like any other object.

Usage

It currently reads the user's Startup folder upon startup and shows the dialog to take action.  There's no Cancel button since it wouldn't make sense.  If you want to cancel, chances are you really just don't want the application to manage that shortcut.  It won't know that next time unless it creates an entry for it though.

Something to think about is that some applications are going to check the Startup folder every time they launch and add their shortcut if it isn't there.  Once that StartupEntry is in the StartupEntryList collection, the application will know what to do with it and you won't be prompted again.

A FileSystemWatcher object enables the application to see new shortcuts added.  It then takes action only on shortcuts for which no StartupEntry is found.  You can modify the display name, delay, wait-for-idle flag, or the managed property at any time.  Unless you're debugging, you won't have any way to execute the launch sequence except when it's initially started with the "/startup" command line flag.  If you launch it without the flag it won't launch anything so it's safer that way.

There's not much else to worry about.  Tell it which startup entries to manage, then let it do it's thing upon restarts.  It could really exit after the list is complete, except that it wouldn't see new entries that way.

Conclusion

The application ended up taking considerably longer than I ever imagined it would!  I tried to create a good experience while demonstrating some good concepts.  I was surprised at some of the subtleties I ran into to make this work as well as it does.  It's not perfect by any means, but it's a good start and it should be useable as-is.

I tried to keep things out of MainForm where it made sense, though there is still room for more encapsulation.  Individual classes should always be fairly light-weight.  It's the way that they interact with each other that provides their power.

Next Steps

For this article, you can use Visual Studio 2005 Express, or make the upgrade to Visual Studio 2008 Express.  As I mentioned at the beginning, I'll be upgrading to VS2008 for future articles, and with the Express products being free, there's no reason not to upgrade today at http://www.microsoft.com/express/.

I left a number of TODO comments in the code.  These were cool things that I just didn't have time to implement.  For one thing, it would be good to be able to just drag an application to the main window to add it to the Managed Startup list.  Even more useful would be scanning the Registry Current User (HKCU) Run list.  Probably more entries end up there than the Startup folder.  I'd also like to extend my SystemIdleComponent to be a generalized PerformanceCounter event broker.  That would make it easy to add code to wait for low disk I/O in addition to CPU load.  Finally, I really wanted to add entry reordering to specify which applications should have the higher priority of starting first.  Not difficult, so give it a try!  If you end up adding any interesting features, let me know.  I'd love to see where it goes!

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.

• Open Office 2007 files with older office versions via the Office Compatibility Pack
• Use CenoPDF to build PDFs without ever having to leave Word, PowerPoint, or Excel.
• Become a meeting power user with MeetingSense, which provides an extensive dashboard for meetings, agendas, creating minutes, etc.
• Organize your data with ClearContext (See? I told you so!)

For the full list, check out the article at PCWorld.