Coding4Fun : windows

Shutdown/Restart/Logoff your PC using TweetMyPC

Coding4Fun — Tue, 23 Jun 2009 22:01:00 GMT

In this article I will show you how you can use Twitter API to Shutdown/Restart/Logoff your PC remotely using VB.net.

Compiled version: CodePlex.com
Source Code: Codeplex.com
Difficulty: Beginner
Time Required: 2 hours
Cost: Free
Software Needed: Visual Basic or Visual C# Express
Libraries: Yedda Twitter Library

Introduction

I have a very slow internet connection at home and most of the time Downloads takes hours to complete. I decided to write an application which will help me Shutdown my PC from a remote location. I wanted to use it to shutdown when I go out when some downloading is going on in my laptop. Instead of using a server and client architecture I decided to use Twitter API and use “My Timeline” to supply commands. One other reason to use Twitter is that I will be able to tweet from my mobile as well. I don’t need to look for a computer with an internet connection when I am on the move.

Why Yedda Twitter framework?

The Twitter REST API methods allow developers to access core Twitter data. This includes update timelines, status data, and user information. It’s very easy to connect to Twitter and get user time line using .net. But I dint wanted to reinvent wheel and decided to use an existing Twitter library. Yedda Twitter framework is the best open source Twitter library available in the internet. You can learn more and download the library from yedda’s home page.

Designing the Interface

I wanted the interface to be as simple as possible. Below is the screenshot of TweetMyPC’s interface which does not have more than 2 Text Boxes, 1 Check Box, Label and a Button.

The form also has a Notify Icon, Context Menu Strip and a Timer. Following are the names of all the controls in the form.

From : frmTweetMyPc
Text Boxes : txtUserName, txtPassword
Button : btnSave
Check Box : chkStartAutomatic
Timer : tmrTweet (Interval : 10000)
Label : lblSatus

There are few My.settings properties to store user information. These properties are shown below.

The Code
Add the following code which minimizes the Form on Load and Enable Timer to check for Tweets every 1 minute.

Me.WindowState = FormWindowState.Minimized
Me.ShowInTaskbar = False
tmrTweet.Enabled = True

The following code in Button’s Click event will validate Twitter username, Password and save it to My.Settings.

If txtUserName.Text.Trim = "" Then
    lblSatus.Text = "Please enter Twitter Username"
    txtUserName.Focus()
    Exit Sub
End If
If txtPassword.Text.Trim = "" Then
    lblSatus.Text = "Please enter Twitter Password"
    txtPassword.Focus()
    Exit Sub
End If

lblSatus.Text = ""


'Check for valid Username and Password and then Save Settings
Dim objTwitter As New Yedda.Twitter
Dim Updates As XmlDocument

Try 'Try Logging in
    Updates = objTwitter.GetUserTimelineAsXML(txtUserName.Text.Trim, txtPassword.Text.Trim)
    My.Settings.UserName = txtUserName.Text.Trim
    My.Settings.Password = txtPassword.Text.Trim
    Me.WindowState = FormWindowState.Minimized
    Me.ShowInTaskbar = False
    tmrTweet.Enabled = True
Catch ex As Exception
    MsgBox("Failed to Login to Twitter with the values supplied. Please check your login details.")
    txtUserName.Focus()
    Exit Sub
End Try

Yedda library is used to login to Twitter to check for valid username and password. The Label lblSatus is used to display any error messages.

Add the following code to the Checkbox’s CheckChanged event which will add the required registry keys to start this app on Window’s startup

If chkStartAutomatic.Checked = True Then       My.Settings.AutomaticStart = True
      Dim regKey As RegistryKey
      regKey = Registry.CurrentUser.OpenSubKey("Software\Microsoft\Windows\CurrentVersion\Run", True)
      regKey.SetValue(Application.ProductName, Application.ExecutablePath)
      regKey.Close()
Else
      My.Settings.AutomaticStart = False
      Dim regKey As RegistryKey
      regKey = Registry.CurrentUser.OpenSubKey("Software\Microsoft\Windows\CurrentVersion\Run", True)
      regKey.DeleteValue(Application.ProductName)
      regKey.Close()
End If

The following code in Timer’s Tick event will do the job of checking Twitter Timeline every one minute and Shutdown/Restart/Log off the system based on the Tweet.

If My.Settings.UserName.Trim = "" Then
    Exit Sub
Else
    'Check for new Tweet 
    Dim objTwitter As New Yedda.Twitter
    Dim Updates As XmlDocument
    Dim node As XmlNode
    Try 'Try Logging in
        Updates = objTwitter.GetUserTimelineAsXML(My.Settings.UserName.Trim, My.Settings.Password.Trim)
        Catch ex As Exception
        MsgBox("Error : Failed to Login to Twitter with the values supplied. Please check your login details.")
        Exit Sub
    End Try
    Try
        node = Updates.SelectSingleNode("/statuses/status/id")
        If node.InnerText.Trim <> My.Settings.LastID.Trim Then 
            'Compare the Tweet ID to check for new tweets
            My.Settings.LastID = node.InnerText.Trim
            node = Updates.SelectSingleNode("/statuses/status/text")
            ProcessTweet(node.InnerText.Trim)
          End If
    Catch ex As Exception
        Exit Sub
    End Try
End If

If the Tweet is new then we process the tweet.

Private Sub ProcessTweet(ByVal Tweet As String)
    If Tweet = "Shutdown" Then
        System.Diagnostics.Process.Start("shutdown", "-s -f -t 100") 'Shutdown
    ElseIf Tweet = "Logoff" Then
        System.Diagnostics.Process.Start("shutdown", "-l -f -t 100") 'Logoff
    ElseIf Tweet = "Restart" Then
        System.Diagnostics.Process.Start("shutdown", "-r -f -t 100") ' Restart
    End If
End Sub

The Context Menu strip has two menu items. They are Edit Setting and Exit.

Add the following code the “Edit Settings” Client event and Notify Icon’s Mouse Double Click Event.

tmrTweet.Enabled = False
txtUserName.Text = My.Settings.UserName.Trim
txtPassword.Text = My.Settings.Password.Trim
If My.Settings.AutomaticStart = True Then chkStartAutomatic.Checked = True
Me.WindowState = FormWindowState.Normal
Me.ShowInTaskbar = True

TweetMyPC runs silently on startup. To Edit Settings double click/Right Click the notify icon.

Working

Conclusion

Even though TweetMyPC is a simple app it has lot of interesting potential. Think about switching off your TV or washing machine using Twitter. It is possible with a little extra hardware and a simple .net program. TweetMyPC is free and open source. Feel free to download the sour code and add more functionality.

About The Author

Shoban Kumar is a Senior Software Engineer working for Allianz Cornhill India. Programming is his passion. He also writes about .net in http://www.dotnetcurry.com/ and an active participator in stackoverflow and speaker in Microsoft user group sessions. You also can follow him in Twitter.

Adding Sidetone to Skype

Coding4Fun — Wed, 10 Jun 2009 00:44:00 GMT

Ever use a headset with Skype – and were frustrated that it was too quiet? This article shows how to add the sound of your own voice to the headset and not feel exhausted from shouting to be heard.

Compiled version: Download
Source Code: Download C#
Difficulty: Intermediate
Time Required: 1-3 hours
Cost: free
Software Needed: Skype (Sype4Com), DirectX, Visual Basic or Visual C# Express
Hardware: none

Skype: I find your lack of feedback disturbing.

This article will discuss how to build a software tool that makes it easier to talk into Skype with a headset.

Recently my family began experimenting with Skype, but we found that talking over Skype can be exhausting with headphones. After doing a little research, I learned that the problem was that we only heard the other party. You’d think that this is a good thing, but we have a social brain that works hard to gauge our behavior and adjust.

The answer is to feed a little bit of the microphone back into the earpiece, so that our brain knows how loud we're talking. This is called side tone in the telecommunication industry. Without it, we talk louder and louder until we’re sure that we’ll be heard.

I couldn’t find a Skype plug-in to do this… but I had just read a Coding4Fun article, by Mark Heath, about adding audio effects to Skype. I decided I was going to write a tool to add this feedback.

How to use the tool

First, let’s take a look at how to use the application. Once it is running, there will be a microphone icon in the lower right hand corner of the screen:

Figure 1: Icon in the system notification tray

Clicking on it, will get the application control window:

Figure 2: The application's controls

Let’s look at the side tone controls:

The “Side Tones” check box enables or disables the side tone. If you have headphones, you'll want this on; if you have loud speakers, you'll want it off.
The slider controls the volume of the microphone in the headset. You can change it while talking. The volume will vary with microphone and headset.

You can do a “sound check” to see if the feedback is working by clicking on the Sound Check button, and adjusting the volume. I found that the volume setting that works best in a conversation is much, much lower than what works in a sound check.

Next, let’s look at the AGC (“Automatic Gain Control”) section. When making a call, the software can automatically adjust how loud you sound to the other party:

When “Low Pass” is checked, the headphone feedback is at 44100 samples/sec. The microphone sound is filtered to keep only the sounds below 8 Khz, converted to 16000/samples per second and sent to Skype. When it is not checked, headphone feedback is at 16000 samples/sec, and sent to Skype without the low pass filter.
When "Skype AutoGain" is checked, it signals to Skype that Skype can use its own algorithm. When clear, Skype is told not to apply any adjustments.
When "AutoGain" is checked, the custom Automatic Gain Control algorithm is used.

The Automatic Gain Control has three sliders:

The “Cutoff” slider controls the distinction between background noise and conversation. Sound below this level is cutoff and silence is sent to Skype. This will vary with microphone – more sensitive (expensive) microphones will pick more background noise and be better with a higher setting.
The “Normal” slider controls the volume when you are talking normally. The Gain Control tries to raise the volume to this level.
The “Loud” slider controls the volume when you talk exceptionally loud. This rarely happens, but when you do talk louder than the Normal level, the Gain Control tries to adjust the volume to this level.

How the Software Works

I originally started this project by creating an effect for the Skype Voice Changer. My plan was to open a WaveStream, begin playing it on the headphones and copy the microphone stream to it.

I quickly found that this was not the way to add feedback. The underlying “WaveOut” system had a huge latency: Everything I heard in the headphones was at least a second or more behind what I was saying. This made it even harder to talk than before, and I had to abandon it.

While researching the problem I found a DirectSound code sample that I could modify into doing what I wanted. (This initial prototype didn’t coordinate with Skype – it attached to the microphone and copied the sounds to the output, at a lower volume. But it was on always on.) The sound in the headphones is still slightly behind (the microphone) but is barely perceptible, and we’ll muffle it a bit more to make it less distinguishable.

From here on I shall describe the major – or technically interesting – components of the program. We’ll look at:

DirectSound and Circular buffers
Sample Window and Sizing the buffers
Using WaitHandle’s to Synchronize with DirectSound
IIR Filters
Automatic Gain Control
Estimating loudness

Note: I won’t be describing how to connect to Skype. Mark Heath’s description is very good.

DirectSound and Circular Buffers

The DirectSound code is in AudioLoop.cs. The module sets DirectSound to capture sound from the default recording device at 16bits / sample at either 16000 or 44100 samples per second. The capture and playback buffers are configured in “looping” mode to act as circular buffers. The capture buffer eventually overwrites samples, and we’ll lose them if we don’t act fast enough; if we don’t update the playback buffer, it will repeat the same sound over and over.

The StartMicrophone() procedure sets up the capture and playback buffers. Then it creates a thread to do the work. The thread is at a high priority so that if the OS has a choice between (say) email or processing sound, it does the sound.

The StopMicrophone() procedure stops the worker thread and cleans up the resources.

The software processes a fixed number of samples at a time, called the “sample window.” The buffers are several times the size of sample window, so that the system can keep capturing and playing while the software is processing them. The sound processing loop is the heart of the application:

Wait for the next sample window to be ready
Copy the samples from the capture buffer
Process the samples and send the results to the playback buffer
Process the samples and sends the results to Skype

while (Runnable)
{
    for (int I = 0, offset = 0; Runnable && I < _bufferPositions; I++, offset += bufferSize)
    {
        // Wait for the sample areas to be ready
        notificationEvent[I].WaitOne(Timeout.Infinite, true);

        // Get the sound samples
        byte[] buffer = (byte[]) captureBuffer.Read(offset, typeof (byte), LockFlag.None, bufferSize);

        // Convert samples to 16bit PCM 
        for (int L = buffer.Length, J = 10, K = 0; K < L; K += 2)
            PCM16Buffer[J++] = (Int16) ((UInt16) buffer[K] | (((UInt16) buffer[K + 1]) << 8));

        // Play them out to the ear, if applicable
        if (null != playbackBuffer)
        {
            // Perform a low pass filter to "muffle" the sound
            Butterworth(PCM16Buffer, 10, LPSample, Coefs);

            // put the muffled sample into the output buffer
            // -- The lock flag seems to work, but others may work too
            playbackBuffer.Write(Idx, LPSample, LockFlag.None);
            Idx += buffer.Length;
            if (Idx >= 4*bufferSize)
                Idx -= 4*bufferSize;
            if (!playing)
            {
                playbackBuffer.Volume = _Volume;
                playbackBuffer.Play(0, BufferPlayFlags.Looping);
                playing = true;
            }
        }

        // Process the sound and deliver it to Skype
        if (null != outStream)
        {
            int L = AGC.Process(PCM16Buffer, 10, buffer);
            if (0 != L)
                outStream.BeginSend(buffer, 0, L, SocketFlags.None, SendCallback, null);
            // Note: could send out pink noise if L == 0
        }

        // Move the sliding window of the previous 10 samples into the start
        // of the PCM16Buffer
        for (int K = 0, J = PCM16Buffer.Length - 10; K < 10; K++, J++)
            PCM16Buffer[K] = PCM16Buffer[J];
    }
}

Note the “for” loop at the bottom of the code. This preserves the last 10 incoming samples at the start of the buffer. This is needed to make the sound processing smooth, and will be discussed a bit later.

Sample Window and Sizing the Buffers

How big should the sample window be? This is bit of a trade off in responsiveness and design complexity.

I chose a window big enough to hold 10 milliseconds of sound. Since the ear is sensitive sound to delays of even 30 milliseconds, I cut this done so that a delay wouldn’t be perceptible. (When I tried a 50 millisecond window, my voice came out the headphone sounding like an echo... and I found myself talking slower and slower.) The sample window could be made smaller, but I am sure that there is a point where the OS won’t schedule the audio loop to wake-n-run more frequently. And, as the sample window gets smaller, the processing may drop in quality, because it doesn’t have enough to work with.

The capture buffer is 8 times the size of the sample window. This ratio is arbitrary, but I wanted the buffer to be about an order of magnitude larger. My rationale is that if the processing falls behind, the sound – for the Skype call – won’t be dropped. I feel that it is more important to preserve sound quality for the other party than to preserve the quality of feedback.

The playback buffer is four times the sample window. I wanted it small, so that if the processing fell behind, the replaying of a sound will seem to be a continuation of a current sound.

When writing the sound to the playback buffer, we have to track where in the buffer to put the samples. I tried to use GetCurrentPosition() to find where to write to next into the playback buffer; this created terrible sound. Instead, the software uses a local variable to track where to write next.

DirectSound and Notifications

How do we keep in sync with the sound capture – how do we know when a sample buffer is ready?

The application gives a table of buffer indices and WaitHandle’s to DirectSound. When the capture buffer’s write index reaches one of those indices, it signals the corresponding WaitHandle. The worker thread cycles performs a WaitOne() one each of the WaitHandle’s, one at a time. As a convenience, we use a specific kind of WaitHandle called AutoResetEvent. This type of WaitHandle sets itself back to a “wait” state once WaitOne() returns.

If the thread has gotten behind, the WaitOne will return immediately, the loop processes the sample, and begins to catch up with the work.

We must use a separate AutoResetEvent for each of the 8 capture windows. The AutoResetEvent doesn’t tell us if it was signaled multiple times. If only one AutoResetEvent handle were used, it wouldn’t know that two (or more) sample windows were ready. Instead, it would process just one, falling further behind, adding latency. This would happen randomly overtime, and be hard to test consistently.

IIR: Infinite Impulse Response Filters

This project came together so quickly, so easy – once I found the right approach – that I couldn't resist getting fancy. I added a low-pass filter to muffle the feedback a little. And I added automatic gain control, as an experimental option.

For both of these I used a filtering algorithm called “IIR” (this stands for Infinite Impulse Response – but that term is a confusing mouthful, so let’s just call it IIR). IIR is a special purpose virtual machine. Low-pass filters, high-pass filters, combinations of those filters, and even equalizers, can be specified, and use very specific techniques (like a compiler) to convert them into an IIR implementation.

(You could, instead, “compile” the filters to be the resistor values to use in a hardware circuit. That’s programming in solder!)

The machine code for these IIR virtual machines is just two list of coefficients, called A & B. The software emulator is code that looks like the following bit of code:

Out[0] = Sample[0];
Out[1] = Sample[1];
for (int Idx = 2; Idx < N; Idx++)
{
    Out[Idx] =
    B0 * Sample[Idx]
 + B1 * Sample[Idx - 1]
 + B2 * Sample[Idx - 2]
        // … more like this …
        // Next, the feed back
 - A1 * Out[Idx - 1]
 - A2 * Out[Idx - 2]
        // … more like this …
 ;
}

IIRs are easy to implement - and take less CPU power than other methods. But sometimes they sound poor; if they sound too bad, you’ll want to use a different technique. I found that the low-pass filters in this project work will for some microphones, and add a slight crackle to others.

Example Low Pass Filter

For the low pass filter to create the muffling, I used a Butterworth filter, using the code below. It takes a buffer of signed, 16-bit samples, and then converts the 16-bit values into a byte array suitable for the sound buffer.

The filter code is a bit different than the example code in the previous section. Most of the differences are for speed.

This code doesn’t use a buffer for the old values, instead uses separate variables for the elements of the buffer. It uses I_0,I_1,I_2 instead of Sample[Idx], Sample[Idx-1], and Sample[Idx-2]. It also uses O_1, and O_2 instead of Out[Idx-1] and Out[Idx-2].
The A and B coefficients are put into a single array. It also adds two of the sample input values, and is missing a coefficient; this is because the B0 and B2 coefficients are always the same for this kind of filter.

There is one difference that is not for speed. These are tricks done to make the filter smooth, and needed because the sample window is so small. They preserve the state of filter. If we didn’t preserve them, the filter would be starting and stopping so frequently that it would add distracting clicks to the output sound. The filters performance would be weakened, because the sample window isn’t big enough to hold sounds lower than (about) 200 Hz. Preserving these values, the filter isn’t starting and stopping, and doesn’t really know about the sample window. All of the IIR filters in this program use similar techniques.

O_1, O_2 are explicitly preserved across calls by being stored in class variables
I_1 and I_2 are preserved by the audio loop (remember the warning about preserving 10 samples at the bottom of the loop?) The audio loop preserves the last 10 samples at the start of InBuffer. When this procedure is called, it retrieves the last two samples.

static double O_1 = 0.0, O_2=0.0;

static void Butterworth(Int16[] InBuffer, int Ofs, byte[] OutBuffer, double[] Coefs)
{
  double C0=Coefs[0], C1=Coefs[1], C2 = Coefs[2], C3=Coefs[3];
  double I_1=InBuffer[Ofs-1], I_2= InBuffer[Ofs-2];
  for (int L = InBuffer . Length, J=0, I = Ofs; I < L; I++)
  {
     double I_0 = InBuffer[I];

     // Filter the samples
     double A = (I_0 + I_2) * C0 + I_1 * C1;
     I_2 = I_1;
     I_1 = I_0;

     A = A - O_1 * C2 - O_2 * C3;
     O_2 = O_1;
     O_1 = A;

     // Convert it back to 16 bit
     Int16 S;
     if (A < -32767) S = -32767;
     if (A > 32767)  S = 32767;
     else S = (Int16) A;

     // Store it
     OutBuffer[J++] = (byte)(S & 0xFF);
     OutBuffer[J++] = (byte)(((UInt16)S >> 8) & 0xFF);
  }
}

Automatic Gain Control

I decided next to tackle a problem where my wife's voice did not carry well on calls. This happens a lot to her with cell phones – and answering machines. I was pretty sure that the problem was poor automatic-gain-control (AGC). The typical amplifier in a headset (and in Skype) estimates how loud our voice is, then increases – or decreases – the volume to a reasonable level. It was deciding that my wife's voice was background noise, and cutting her off.

I chose to write an alternate gain control that amplified the sound and passed it to Skype. That way we'd have four to choose from: The one built into the Microphone, the Soundcard’s, Mine, and Skype’s. (To be fair, these automatic gain controls work well in most cases).

The main portion of the gain control is implemented in the file GainControl.cs. The control algorithm is:

Calculate (or estimate) how loud we are currently talking (using the Analyze() procedure)
If the loudness is very low, no one is talking… so set the output to zero. (Without this step, the volume of noise and hum would be cranked up)
Otherwise, compute the guess-gain by dividing how loud the sound of our voice should be by how loud it currently is
Compute the gain (called MaxGain) at which the sound will start clipping. If the guess-gain is louder than this, reduce it to MaxGain.
The software adjusts the gain for a gentle transition – especially in the case when we go from absolute quiet, to the start of talking. It does this by tracking the gain (called PrevGain) used in previous sample and the current one.
Multiple all the samples by this gain value.
If the sample rate is greater than 16000 samples/sec
1. Do a low pass filter at 8 khz (again in IIR form). This helps prevent artifacts from down sampling
2. Resample the sound to 16000

The portion of code that calculates the gain looks like (CutOff_dB, LowGain_dB, and TgtGain_dB are the three slider values):

if (!AutoGain)
    Gain = 1.0;
else
{
    double MaxGain;
    double dB = Analyze(InBuffer, Ofs, out MaxGain);

    if (dB < CutOff_dB)
        Gain = 0.0;
    else if (dB < LowGain_dB + 4.0)
    {
        Gain = Math.Exp((LowGain_dB - dB) * db2log);
    }
    else
    {
        Gain = Math.Exp((TgtGain_dB - dB) * db2log);
    }
    Gain = (0.4 * Gain + 0.6 * PrevGain);
    if (Gain > MaxGain)
        Gain = MaxGain;
    PrevGain = Gain;
}

// Skip further process if there is silence
if (0.0 == Gain)
{
    return 0;
}

If you look at the code, you’ll see that we don’t compare directly with LowGain_db; rather we compare the estimate volume with LowGain_db+4. This gives a little “hysteresis” – if we raise our voice momentarily, the software won’t suddenly make it the highest possible volume. Instead, the software lowers the volume a little bit.

When the software changes the sample rate, it basically needs to know how many input samples to skip. At the start of a call, the software computes this, calling it InInc:

// Calculate how we resample to 16Khz
InInc = (int)(1024.0 * SampleRate / 16000.0);

The process of applying the gain adjustment, performing a low pass filter and re-sampling is below:

int NumSamples = InBuffer.Length;
int End = OutBuffer.Length;
int NextIdxForOut = -InInc;
int OutIdx = 0;
for (int I = Ofs; OutIdx < End && I < NumSamples; I++)
{
    // Retrieve the sample
    Int16 S = InBuffer[I];
    double I_0 = S;

    // Apply Gain
    I_0 *= Gain;

    // 8khz low pass filter 
    if (DoLP)
    {
        // Simple Butterworth 8KHz low-pass filter
        double A = (I_0 + DS_I_2) * LP[0] + DS_I_1 * LP[1];
        DS_I_2 = DS_I_1;
        DS_I_1 = I_0;
        I_0 = A - DS_O_1 * LP[2] - DS_O_2 * LP[3];
        DS_O_2 = DS_O_1;
        DS_O_1 = I_0;

        // Change sample rate
        int Tmp = NextIdxForOut / 1024;
        if (I < Tmp)
            continue;
        NextIdxForOut += InInc;
    }

    // Convert it back to 16 bit
    S = (Int16)I_0;

    // Store it
    OutBuffer[OutIdx++] = (byte)(S & 0xFF);
    OutBuffer[OutIdx++] = (byte)(((UInt16)S >> 8) & 0xFF);
}

Estimating Volume

How loud “it should be” is controlled by a slider on the screen. The software estimates how loud the sound is by using an algorithm devised by David Robinson that takes into account how it sounds to a person. This way we can increase the gain on hard to hear sounds, and reduce the gain on sounds that a person is very sensitive to.

The loudness estimator, implemented in the Analysis procedure in GainAnalysis.cs, uses the following algorithm:

Uses a combination of two (IIR) filters to make the sound to reflect how our ears hear it.
Compute the Mean-Square value of the filtered sound (called MS)
Track the last 750 ms of these values.
Make a sorted copy of these.
Retrieve the first non-zero value at least 95% of the way into the buffer. This is so that we don’t take the loudest sample and assume that is how the person is talking.
If MS (the value computed in step 2) is much quieter, use that one instead
Convert this value into dB scale by performing a logarithm on it.

The code to “normalize” the sound into how a person hears it is below. Along the way it computes the square of the samples (used in step 2). Like the earlier IIR filters, these preserves their variables across the calls. The first IIR is a yulewalk filter, but it preserves it old intermediary values in an array. Like the trick in AudioLoop, where we copy the last 10 samples into the start of the current buffer, the analysis procedure copies the last 10 immediate values into the start of YuleTmp array.

The output of the yulewalk filter is feed into a 150Hz high pass filter. It is essentially the same as the low-pass filter described earlier.

for (int L = Samples.Length, N = Ofs; N < L; N++)
{
    int _V = Samples[N];
    double V = _V;
    if (_V > MaxSample) MaxSample = _V;
    if (-_V > MaxSample) MaxSample = -_V;

    // Perform yulewalk filter
    double S = V * YuleCoefs[0];
    for (int J = N - 1, I = 1; I < 11; I++, J--)
        S += Samples[J] * YuleCoefs[I];
    for (int J = N - 1, I = 11; I < 21; I++, J--)
        S -= YuleTmp[J] * YuleCoefs[I];

    // Store for the feedback into the next stage of the yule walk
    YuleTmp[N] = S;


    // Perform butterworth high-pass filter stage, using S as an input
    double Accum =
       (S + GA_I_2) * HPCoefs[0]
       + GA_I_1 * HPCoefs[1];
    GA_I_2 = GA_I_1;
    GA_I_1 = S;
    Accum = Accum - GA_O_1 * HPCoefs[2] - GA_O_2 * HPCoefs[3];

    GA_O_2 = GA_O_1;
    GA_O_1 = Accum;

    // The square of the filtered results
    Sum += Accum * Accum;
}

// Copy the intermediate yulewalk state for the next
// (this is needed since we are looking at a fairly small time window)
for (int I = 0, J = YuleTmp.Length - 10; I < 10; I++)
    YuleTmp[I] = YuleTmp[J];

The mean-squared is computed:

// The mean square of the filtered results
double MS = Sum / NumSamples;

Tracking the last 750ms of samples is a simple matter of putting it into a circular queue:

MSQueue[QIdx++] = MS;
if (QIdx >= MSQueue . Length)
   QIdx = 0;

Next, is the code to finding the first non-zero value 95% of the way into the buffer. It is a straightforward copy-the-array, sort it, and fetch:

Array.Copy(MSQueue, SortedQ, MSQueue.Length);
Array.Sort(SortedQ);

// Return the 95% 
double X = SortedQ[Q95Idx]; 
for (int I = Q95Idx +1; X < 400.0 && I < SortedQ . Length; I++)
      X = SortedQ[I];

Next, override this value if the current sample window is very, very quiet – that is, the user stopped talking. (If we don’t do this, we’ll amplify background noise between words)

if (MS < X * 0.40 && MS < 12800.0)
   X = MS;

Finally, convert the result into decibels (or a reasonable approximation of a decibel)

return 10.0 * Math . Log10 (X * 0.5 + double . Epsilon);

Note: The logarithm function takes a positive, non-zero floating point number. However, the value we pass to it can be zero; if we pass a zero, though, the Logarithm function would return a bad value. The simplest thing to do is check to see if the value we are passing is “zero” and not call Logarithm. However, I learned a long time ago to just add “epsilon” to the value to whatever we pass. This can really improve performance on number crunching.

Conclusion

This concludes how to add a little bit feedback and fancy amplification to you Skype phone calls.

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

If you’d like to experiment further, here are ideas of what can be done:

DirectSound has echo cancellation and noise suppression. These seem desirable, esp. if you wanted to try making your own speakerphone. I was not able to get them to work and I would love to learn how.
I’m sure it is possible to trim even more latency off of the side-tone playback, and I would be interested in learning better techniques to do so.
Another would be to create the ideal equalizer from Robinson’s Equal Loudness model, and use that filter and amplify the sound.
It might be useful for the other party to control the settings, so that they decide when your voice has the right volume.

Resources and References

David Robinson (while doing his PhD at University of Essex on human hearing). His algorithm is intended to find the overall loudness of an album. He includes MATLAB scripts to compute coefficients at custom sample rates, as well as some pre-computed coefficients.
Mark Heath’s Skype Voice Changer
Derek Pierson’s DirectX tutorial

About The Author

Randall Maas writes firmware for medical devices, and consults in embedded software. Before that he did a lot of other things… like everyone else in the software industry. You can contact him at randym@acm.org.

Creating a Utility Framework

Coding4Fun — Tue, 14 Apr 2009 19:00:00 GMT

In this article I demonstrate how you can take advantage of a light application framework when creating simple utilities. Instead of working on lower-level plumbing, just create the code for whatever tool you need, and this framework can get you working faster.

Arian Kulp, blog

Source Code: CodePlex.com

Difficulty: Intermediate
Time Required: 4 hours
Cost: Free
Software Needed: Visual Basic or Visual C# Express 2008
Libraries: MEF

Introduction

When you write small utilities, there’s a certain amount of tedious repetitive work to get it up and going. Creating the main window, the tray icon (including the icon and context menu), and other common tasks just get in the way. In this article, I’ve created a reusable utility framework and will show you how to make use of it.

To run this code, you’ll need to use Visual Studio 2008 SP1, Express Edition or higher. If you haven’t downloaded it yet, go to http://www.microsoft.com/express. You can either use Visual Basic or Visual C# to work with the main project or create add-ins for this project.

A Framework?

So what did I actually create for this article? We all know that using base classes is a great way to tie together closely-related objects. As a very practical example, a base window or control class lets you add functionality to something that already exists without reinventing the wheel, so to speak. Windows exposes a number of code execution models such as services, console apps, Sidebar gadgets, Windows forms, WPF, COM, and more. Each of these provides a certain amount of functionality that you don’t need to worry about, such as start/stop hooks for services, or the system message loop for Windows forms and WPF.

Having built a good number of small utilities over the years, I’ve definitely realized that I’m copying or rewriting too much code. What a waste! Since I always create a notification icon (shows up by the system clock), and I like to hide to tray on minimize, and remember window settings, I implement these in each project. I probably should have created a project template in Visual Studio as a shortcut, but this has a disadvantage. If I added a cool new feature to my framework, I’d need to recompile and rework the older apps to take advantage of it

The better solution was to create a “base application.” This would actually be its own application that exposes a notification icon and menu, and a main window. If you move the window, the location is saved. Individual utilities can then be added as plugins. I originally envisioned a framework able to host multiple applications, but that creates some interesting design challenges with visual apps. In the end, I settled on a reusable application which can host a single utility.

A Common User Interface

I decided to write this in WPF since it affords so many great options for layout and interactivity. I still write some Winforms code, but WPF is just an incredible way to build your application declaratively (not that XAML is required…) and it enables a nice clean code layout. If you are really tied to Windows Forms, you can always use the WindowsFormsHost control to expose it.

The basic application isn’t very complicated. It lets you set the application name which it uses in the tray menu and in the main window title. You can also set whether it minimizes to tray or not. If not, the close button will actually kill the application. Minimize always minimizes as normal.

Finally, the main window shows both the preferences UI. Most small utility apps don’t really have a UI other than settings. You can always show dialogs and windows, but if all you have is a few settings, you can just create a UserControl to contain them and the application will host it.

As an example, I created a utility add-in. It looks like some sort of file watching utility. It’s not actually functional – it’s just a collection of controls in a UserControl. This is paired up with the application name, icon, and more.

Figure 1 : Main Application Window

Modularity

So I mentioned before that one of my motivations with this project was to allow me to update the framework without needing to recompile the utilities themselves. To be clear, this won’t be possible 100% of the time, but as long as I leave the public interfaces alone, it should work well. So here’s the cool implementation: Managed Extensibility Framework, or MEF.

MEF allows you to build extensibility into your applications with little effort. Build your interfaces or contracts, and as long as plugins use that contract, code can be compiled into separate assemblies with no dependencies. When the application starts up, you tell it where to find extensions and it takes care of loading them. The contract for addins (IWpfService) is defined as:

Visual C#

public interface IWpfService
{
    // Gets the custom control to display in the host preferences dialog.
    UserControl OptionsUserControl { get; }

    string Name { get; }
    System.Drawing.Icon TrayIcon { get; }
    string Description { get; }
    string Author { get; }
    Version Version { get; }
    Uri AuthorUri { get; }
    bool HideOnClose { get; }
    string Status { get; set; }

    void Initialize();
    void Start();
    void Stop();

    event EventHandler StatusUpdated;
}

Visual Basic

Public Interface IWpfService
    ' Gets the custom control to display in the host preferences dialog.
    ReadOnly Property OptionsUserControl() As UserControl

    ReadOnly Property Name() As String
    ReadOnly Property TrayIcon() As System.Drawing.Icon
    ReadOnly Property Description() As String
    ReadOnly Property Author() As String
    ReadOnly Property Version() As Version
    ReadOnly Property AuthorUri() As Uri
    ReadOnly Property HideOnClose() As Boolean
    Property Status() As String

    Sub Initialize()
    Sub Start()
    Sub [Stop]()

    Event StatusUpdated As EventHandler

End Interface

The UserControl reference is a composite control with any necessary user interface elements for configuring the application. This could be a file dialog, checkboxes for options, buttons to start or stop processing threads, or whatever makes sense. The base application (the host) then provides access to them based on user request. The Name, TrayIcon, Description, and other such properties are used to generate information such as found in an About dialog. The methods are used by the host to control the lifecycle, similar to a Windows service. The Initialize() method is called on startup, followed by Start(). Stop() is called at shutdown/close. The hosted utility doesn’t need to worry about many of the general application logic – just specific units of work.

Figure 2 : Showing About this Application

The ExtensibleWpfApp project contains a base class called ApplicationWindow, which descends from Window. This can be used by any application that wants a simple tray menu, position and size saving, and minimize to tray. On top of that is the MainAppWindow class. This descends from ApplicationWindow and also implements IWpfHost. This takes care of creating a main window that displays the application metadata and settings. You’re welcome to take either class as a base class, but then you wouldn’t get the benefit of MEF extensibility.

During the instantiation of the MainAppWindow class it also initializes itself and its base class using properties from the add-in:

Visual C#

public MainAppWindow()
{
    InitializeComponent();

    Compose();

    // Settings menu item on or off, ShowApp menu item on or off, Wire up callbacks, etc.
    CurrentAddin.Start();

    this.ApplicationName = CurrentAddin.Name;
    this.HideOnClose = CurrentAddin.HideOnClose;

    // Sets a custom icon or leaves it as default
    if( CurrentAddin.TrayIcon != null )
    {
        this.TrayIcon = CurrentAddin.TrayIcon;
    }

    dockPanelAddinInfo.DataContext = CurrentAddin;

    Application.Current.Exit += new ExitEventHandler(CurrentApp_Exit);
    CurrentAddin.StatusUpdated += new EventHandler(CurrentAddin_StatusUpdated);
}

Visual Basic

Public Sub New()
    InitializeComponent()

    Compose()

    ' Settings menu item on or off, ShowApp menu item on or off, Wire up callbacks, etc.
    CurrentAddin.Start()

    Me.ApplicationName = CurrentAddin.Name
    Me.HideOnClose = CurrentAddin.HideOnClose

    ' Sets a custom icon or leaves it as default
    If CurrentAddin.TrayIcon IsNot Nothing Then
        Me.TrayIcon = CurrentAddin.TrayIcon
    End If

    dockPanelAddinInfo.DataContext = CurrentAddin

    AddHandler Application.Current.Exit, AddressOf CurrentApp_Exit
    AddHandler CurrentAddin.StatusUpdated, AddressOf CurrentAddin_StatusUpdated
End Sub

Notice how it has the concept of application name and a tray icon – something a standard application doesn’t have. It’s easy enough to add these things, but it can be tedious, and beginner programmers just have that much more to figure to get started.

Next Steps

Though the application is a good start, I see a need for more. The application could invoke add-in features on a timer with the framework prompting the user for the interval and handling that automatically. The concept of saving and cancelling settings changes should really be built into the framework. It might also be good for the add-in to have access to show/hide the window as needed. Hooking into the system Event Log or other logging and other tracing mechanisms could also be handled by the framework.

The key is to find common services that applications can use which also normally require some user configuration. If the framework can handle that automatically, it makes for less work for each utility.

Conclusion

First of all, this is only the first part of this article. Next time I’ll dig into the MEF implementation and explain how an add-in works in better detail. I’ll flesh out the sample add-in a bit as a point of reference and hopefully you’ll see how you might benefit from it as well.

Building reusable application code can make a huge difference over time. Unfortunately it always takes longer the first time to do it right. Good code ends up being reused, but copy-and-paste reuse isn’t as good as binary reuse (referencing an assembly/DLL), and that’s still not as good as composition where new components bind to a framework at runtime. Frameworks like MEF, System.Addin, PRISM, and others make it much easier than it used to be to create extension points so code can fit in later. Used wisely this can lead to a more streamlined code base where you can rely on other contributors or communities to implement new features instead of coming to you each time. You can focus on creating a solid foundation and let people create niche or mainstream features as they see fit. You’ll be happier and your users will love it too!

If you haven’t already, download Visual Studio Express Edition today and get started.

About the Author

Arian Kulp is a software developer living in the Midwest. He has been writing software since the fifth grade (though not always professionally). Arian creates developer evangelism stuff, speaks at INETA and Code Camps, and loves to stay on the cutting edge of technology. In his spare time, he enjoys nature, photography, and his family.

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.

WiiEarthVR – A Fully Immersive 3D Experience with Virtual Earth 3D

Coding4Fun — Fri, 14 Nov 2008 11:57:58 GMT

In this article, Brian Peek will demonstrate how to use a Nintendo Wii Remote (Wiimote), a Wii Fit Balance Board, and Vuzix VR920 glasses as input devices for Microsoft Virtual Earth 3D, providing a fully immersive, 3D experience.

Brian Peek

ASPSOFT, Inc.

Difficulty: Intermediate

Time Required: 2-3 hours

Cost: $60 for Wiimote and Nunchuk, $90 for Wii Fit (which includes Balance Board), $400 for Vuzix VR920 glasses

Software: Managed Library for Nintendo's Wiimote, Visual Basic or Visual C# Express Editions

Hardware: Nintendo Wii Remote (Wiimote) with Nunchuk, Wii Fit Balance Board, Vuzix VR920 glasses, a compatible PC Bluetooth adapter and stack

Download: Download

Discussion Forum: Forum

Introduction

Virtual Earth is the 3D interface to Microsoft's Live Maps service. Normally this control is loaded via the web browser and allows interaction with a keyboard, mouse, and Xbox 360 controller. In this article, we will take the Virtual Earth 3D control out of the web browser, use it in a WinForms application, and control it with a Nintendo Wii Remote (Wiimote) and a pair of Vuzix VR920 glasses, while also providing a stereoscopic 3D image to the glasses, creating the illusion of a fully three dimensional environment. Note that use of the Virtual Earth 3D control in this way is undocumented and unsupported at the moment. Because of this, some of the descriptions in this article are educated guesses and may not be 100% accurate…

Originally, this project started as a simple Wiimote interface to Virtual Earth 3D as shown in the video below. Since I wrote that application, I learned of the VR920 glasses and the Wii Fit Balance Board was released, so I’ve decided to create a more immersive experience using all of these controls which was demonstrated at PDC2008, shown here:

Setup

Before we get started, you will need to install the Virtual Earth 3D control. If you haven't done this already, browse to http://maps.live.com/ and click on the 3D link to install the control and supporting software.

Additionally, if you haven't already, please review my Managed Library for Nintendo's Wiimote article on this site. We will be using the library in this article, but I will not repeat the basic information that is located in the original article. You will also need to have the Vuzix VR920 glasses installed and setup according to its own user manual. That will also not be covered here.

Implementation

The Virtual Earth 3D Control

The Virtual Earth 3D (VE3D) control is intended to be used through a well documented JavaScript interface from a web page, however we would not be able to access the Wiimote or VR920 glasses from JavaScript. Therefore, we will be using the VE3D control through its native, but wholly undocumented interface.

Start by creating a new Windows Forms application named WiiEarthVR in C# or VB. As with all controls and 3rd party libraries, a reference needs to be set to the Virtual Earth 3D libraries. Add references to the following items:

Microsoft.MapPoint.Data
Microsoft.MapPoint.Data.VirtualEarthTileDataSource
Microsoft.MapPoint.Geometry
Microsoft.MapPoint.Rendering3D
Microsoft.MapPoint.Rendering3D.Utility

If they do not show up in the .NET references, they can be found by selecting the Browse tab and navigating to C:\Program Files\Virtual Earth 3D\ or C:\Program Files (x86)\Virtual Earth 3D\ . With the references in place, the project file can now be opened and the references will be seen in the References folder in the Solution Explorer as usual.

Creating an instance of the control can be done in code just like any other control. Used in the constructor or load event of the form, the following code will create a VE3D control and add it to the form as fully docked:

     private GlobeControl _globeControl;

    public MainForm()

    {

        InitializeComponent();

        _globeControl = new GlobeControl();

        SuspendLayout();

        _globeControl.Location = new System.Drawing.Point(0, 0);

        _globeControl.Name = "_globeControl";

        _globeControl.Size = ClientSize;

        _globeControl.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top | AnchorStyles.Bottom;

        _globeControl.TabIndex = 0;

        _globeControl.SendToBack(); // we want the button to be on top

        pnlGlobe.Controls.Add(_globeControl);

        ResumeLayout(false);

    }

    Private _globeControl As GlobeControl

    Public Sub New()

        InitializeComponent()

        _globeControl = New GlobeControl()

        SuspendLayout()

        _globeControl.Location = New System.Drawing.Point(0, 0)

        _globeControl.Name = "_globeControl"

        _globeControl.Size = ClientSize

        _globeControl.Anchor = AnchorStyles.Left Or AnchorStyles.Right Or AnchorStyles.Top Or AnchorStyles.Bottom

        _globeControl.TabIndex = 0

        _globeControl.SendToBack() ' we want the button to be on top

        pnlGlobe.Controls.Add(_globeControl)

        ResumeLayout(False)

    End Sub

This sets up the VE3D control in its default state. If you were to run an application with only this code, you would see nothing but the earth. The navigation controls and other extras would be missing.

We can start adding items to the VE3D control by listening for the FirstFrameRendered event of the GlobeControl and then setting the appropriate properties. Setting these properties prior to this point can lead to some unexpected results.

In the FirstFrameRendered event handler, if you wish to add the default navigation controls to the screen, the PlugInLoader object is used. The PlugInLoader is created by using the CreateLoader static method, passing in an instance of the GlobeControl's Host object. Then, the NavigationPlugIn can be loaded and activated as shown:

    // load all the spiffy UI navigation goodies

    PlugInLoader loader = PlugInLoader.CreateLoader(this.globeControl.Host);

    loader.LoadPlugIn(typeof(NavigationPlugIn));

    loader.ActivatePlugIn(typeof(NavigationPlugIn).GUID, null);

    ' load all the spiffy UI navigation goodies

    Dim loader As PlugInLoader = PlugInLoader.CreateLoader(Me.globeControl.Host)

    loader.LoadPlugIn(GetType(NavigationPlugIn))

    loader.ActivatePlugIn(GetType(NavigationPlugIn).GUID, Nothing)

The last thing to be added for basic functionality is the data. As it stands, the only data that will appear on the globe is the image of the continents. Zooming in only produces a blurry representation of that base image.

Data layers are created from specially formatted data sources provided by maps.live.com known as content manifests. These are XML files which tell the VE3D control how to load the data required for any view. Content layers can be added by adding them to the DataSources object of the GlobeControl. We can add any of the following layers (note that there may be other content manifests provided by maps.live.com, but these are the only 5 that I am aware of):

URL	DataSourceUsage Type	Description
http://local.live.com/Manifests/HD.xml	ElevationMap	Terrain data
http://local.live.com/Manifests/MO.xml	Model	3D buildings
http://local.live.com/Manifests/AT.xml	TextureMap	Unlabeled aerial
http://local.live.com/Manifests/HT.xml	TextureMap	Labeled aerial
http://local.live.com/Manifests/RT.xml	TextureMap	Roads only

For the best display, add the ElevationMap, Model and Aerial TextureMap layers as shown:

    // set various data sources, here for elevation data, terrain data, and model data.

    _globeControl.Host.DataSources.Add(new DataSourceLayerData("Elevation", "Elevation", @"http://maps.live.com//Manifests/HD.xml", DataSourceUsage.ElevationMap));

    _globeControl.Host.DataSources.Add(new DataSourceLayerData("Texture", "Texture", @"http://maps.live.com//Manifests/AT.xml", DataSourceUsage.TextureMap));

    _globeControl.Host.DataSources.Add(new DataSourceLayerData("Models", "Models", @"http://maps.live.com//Manifests/MO.xml", DataSourceUsage.Model));

    ' set various data sources, here for elevation data, terrain data, and model data.

    _globeControl.Host.DataSources.Add(New DataSourceLayerData("Elevation", "Elevation", "http://maps.live.com//Manifests/HD.xml", DataSourceUsage.ElevationMap))

    _globeControl.Host.DataSources.Add(New DataSourceLayerData("Texture", "Texture", "http://maps.live.com//Manifests/AT.xml", DataSourceUsage.TextureMap))

    _globeControl.Host.DataSources.Add(New DataSourceLayerData("Models", "Models", "http://maps.live.com//Manifests/MO.xml", DataSourceUsage.Model))

By passing the URL of the content manifest, a name for the layer, and what the manifest represents, a new DataSource is created, which is in turn used to create a DataSourceLayerData object which is then given to the VE3D control to consume. This should be done in the FirstFrameRendered event handler as well.

We also need to setup VE3D to turn off any UI elements, turn on the atmosphere effects, and ensure we have a full unobstructed view. Again, in the FirstFrameRendered event handler, we can use the following code to achieve this:

    // turn on the nice atmosphere

    _globeControl.Host.WorldEngine.Environment.AtmosphereDisplay = Microsoft.MapPoint.Rendering3D.Atmospherics.EnvironmentManager.AtmosphereStyle.Scattering;

    // default to all off

    _globeControl.Host.WorldEngine.Display3DCursor = false;

    _globeControl.Host.WorldEngine.SetWindowsCursor(null);

    _globeControl.Host.WorldEngine.ShowNavigationControl = false;

    _globeControl.Host.WorldEngine.ShowCursorLocationInformation = false;

    _globeControl.Host.WorldEngine.ShowScale = false;

    _globeControl.Host.WorldEngine.ShowUI = false;

    _globeControl.Host.WorldEngine.Environment.SunPosition = null;

    _globeControl.Host.WorldEngine.Environment.LocalWeatherEnabled = true;

    _globeControl.Host.WorldEngine.BaseCopyrightText = " "; // workaround for a display issue

    ' turn on the nice atmosphere

    _globeControl.Host.WorldEngine.Environment.AtmosphereDisplay = Microsoft.MapPoint.Rendering3D.Atmospherics.EnvironmentManager.AtmosphereStyle.Scattering

    ' default to all off

    _globeControl.Host.WorldEngine.Display3DCursor = False

    _globeControl.Host.WorldEngine.SetWindowsCursor(Nothing)

    _globeControl.Host.WorldEngine.ShowNavigationControl = False

    _globeControl.Host.WorldEngine.ShowCursorLocationInformation = False

    _globeControl.Host.WorldEngine.ShowScale = False

    _globeControl.Host.WorldEngine.ShowUI = False

    _globeControl.Host.WorldEngine.Environment.SunPosition = Nothing

    _globeControl.Host.WorldEngine.Environment.LocalWeatherEnabled = True

    _globeControl.Host.WorldEngine.BaseCopyrightText = " " ' workaround for a display issue

If you were to run the application at this point, you would see a fully functioning Virtual Earth 3D control with proper data and navigation.

Control Scheme and Bindings

The user will control VE3D with the Wiimote by holding the nunchuk in the left hand, which will move the user forward/back/left/right using the joystick. The C and Z buttons on the front of the nunchuk will be used to raise and lower the altitude of the camera. The Wiimote, held in the right hand, will be used to toggle various things on or off and interact with menus. The user will also stand on the Balance Board which will use their center of gravity to turn them in the environment.

VE3D bindings allow you to change or create new control schemes for VE3D by placing an XML file in a specific directory as follows:

Vista: C:\Users\<username>\AppData\LocalLow\Microsoft\Virtual Earth 3D
XP: C:\Documents and Settings\<username>\Local Settings\Microsoft\Virtual Earth 3D

In this directory you will find a Bindings.xml file. This XML schema defines the default keyboard, mouse, Gamepad and other input device properties. Open the file to see the schema used to define events and parameters.

By default, VE3D will load any file named Bindings*.xml from this directory. For the Wiimote control scheme, create a new file named BindingsWiiEarthVR.xml in this directory. Set the contents of the file to the following:

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

    <Bindings>

        <BindingSet Name="WiiEarthVRBindings" AutoUse="True" Cursor="Drag">

            <!-- Nunchuk joystick -->

            <Bind Event="Wiimote.NunchukX" Factor="0.5"><Action Name="Strafe"/></Bind>

            <Bind Event="Wiimote.NunchukY" Factor="1"><Action Name="Move"/></Bind>

            <!-- Nunchuk buttons -->

            <Bind Event="Wiimote.NunchukC" Factor="0.20"><Action Name="Ascend"/></Bind>

            <Bind Event="Wiimote.NunchukZ" Factor="-0.20"><Action Name="Ascend"/></Bind>

            <!-- Balance Board -->

            <Bind Event="Wiimote.BalanceBoardX" Factor="-0.0009"><Action Name="Turn"/></Bind>

            <Bind Event="Wiimote.BalanceBoardY" Factor="0.0009"><Action Name="Ascend"/></Bind>

            <!-- Wiimote buttons -->

            <Bind Event="Wiimote.Home"><Action Name="ResetOnCenter"/></Bind>

            <Bind Event="Wiimote.A" Factor="1"><Action Name="Locations, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Wiimote.Left" Factor="-1"><Action Name="Locations, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Wiimote.Up" Factor="-1"><Action Name="LocationsMove, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Wiimote.Down" Factor="1"><Action Name="LocationsMove, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <!-- FPS-style keyboard controls in case we don't have a nunchuk -->

            <Bind Event="Key.W" Factor="22"><Action Name="Move" /></Bind>

            <Bind Event="Key.S" Factor="-22"><Action Name="Move" /></Bind>

            <Bind Event="Key.D" Factor="22"><Action Name="Strafe" /></Bind>

            <Bind Event="Key.A" Factor="-22"><Action Name="Strafe" /></Bind>

            <Bind Event="Key.Space" Factor="20"><Action Name="Ascend" /></Bind>

            <Bind Event="Key.C" Factor="-20"><Action Name="Ascend" /></Bind>

            <!-- Other keys -->

            <Bind Event="Key.F1"><Action Name="VR920SetZero, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Key.F2"><Action Name="BalanceBoardSetZero, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Key.F3"><Action Name="ToggleVR920Stereo, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Wiimote.Minus" Factor="-0.1"><Action Name="VR920SetEyeDistance, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Wiimote.Plus" Factor="0.1"><Action Name="VR920SetEyeDistance, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Wiimote.One"><Action Name="ToggleBalanceBoard, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Wiimote.Two"><Action Name="ToggleVR920, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Key.B"><Action Name="ToggleBalanceBoard, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Key.V"><Action Name="ToggleVR920, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

            <Bind Event="Key.F"><Action Name="FullScreen, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></Bind>

        </BindingSet>

    </Bindings>

The <BindingSet> tags wrap groups of control bindings. It requires a Name and optionally a Cursor. If the binding set is to be used automatically, as it would be in most cases, set the AutoUse parameter to True. Inside of that are <Bind> tags. The tag requires the Event parameter and optionally the Factor parameter. The Event parameter will be used to match the binding to its handler which will be written later. The syntax is <Handler Name>.<Event Name>. The Factor parameter is optional and can be used to scale the data value up or down to increase or decrease sensitivity of the input method. The Action tag inside the Bind tag is used to map the specific binding to a particular method. Once the handler is written, these will make more sense.

The bindings above create the control scheme described above: NunchukX/Y describe what happens when the analog joystick is moved, NunchukC/Z describe what happens with the C/Z buttons are pressed, and so on.

The bindings also allow for several variations. Bindings are defined for both the IR position (IRX, IRY) and accelerometer values (AX, AY). If an IR sensor bar is not available, the accelerometer values of the Wiimote can be used instead. Additionally, keyboard bindings are created in the style of a first person shooter using WASD. These can be used if a Nunchuk is not available.

Note that some bindings append two Events together with a + sign. This allows for button combinations. In this case, for the accelerometer and/or IR sensor, we only want to register the action if a button is pressed down. So, those events which require the button to be held down contain Wiimote.B+ and the event it is combined with.

For those events which require a custom action that will be written separately and not part of the VE3D control, the Action parameter must contain the action name, followed by a comma, and then the full assembly name:

<Bind Event="Wiimote.One">
    <Action Name="ToggleBalanceBoard, WiiEarthVR, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
</Bind>

You can change any of these button bindings simply by changing this XML file and deploying to the directory above.

Event Source

An EventSource is needed which will grab data from the Wiimote and pass it along to VE3D as defined by the bindings file above. Create a new class named WiimoteEventSource which derives from Microsoft.MapPoint.Binding.EventSource as follows:

Next, add an enumeration named WiimoteEvent (the name isn't important) which contains all of the Name items from the bindings XML file above. It should look like this:

// all events handled by this event source from XML file
public enum WiimoteEvent
{
    IRX,        // IR X position
    IRY,        // IR Y position
    NunchukX,    // Nunchuk joystick X position
    NunchukY,    // Nunchuk joystick Y position
    NunchukC,    // Nunchuk C button
    NunchukZ,    // Nunchuk Z button
    AX,            // Wiimote accelerometer X
    AY,            // Wiimote accelerometer Y
    Up,            // Dpad up
    Down,        // Dpad down
    Left,        // Dpad left
    Right,        // Dpad right
    A,            // A button
    B,            // B button
    Minus,        // Minus button
    Home,        // Wiimote Home button
    Plus,        // Plus button
    One,        // Wiimote One button
    Two,        // Wiimote Two button
    BalanceBoardX,    // Balance Board COG X
    BalanceBoardY    // Balance Board COG Y
}

' all events handled by this event source from XML file
Public Enum WiimoteEvent
    IRX ' IR X position
    IRY ' IR Y position
    NunchukX ' Nunchuk joystick X position
    NunchukY ' Nunchuk joystick Y position
    NunchukC ' Nunchuk C button
    NunchukZ ' Nunchuk Z button
    AX ' Wiimote accelerometer X
    AY ' Wiimote accelerometer Y
    Up ' Dpad up
    Down ' Dpad down
    Left ' Dpad left
    Right ' Dpad right
    A ' A button
    B ' B button
    Minus ' Minus button
    Home ' Wiimote Home button
    Plus ' Plus button
    One ' Wiimote One button
    Two ' Wiimote Two button
    BalanceBoardX ' Balance Board COG X
    BalanceBoardY ' Balance Board COG Y
End Enum

Next, several methods from the EventSource object need to be overridden: GetEventData, IsModifier, CanModify, TryGetEventId, TryGetEventName, Name. The methods do the following:

Method/Property	Description
GetEventData	Unsure at the moment...does not need to be implemented?
IsModifier	Returns a boolean stating whether the passed in event ID is a modifier (such as the Wiimote.B event above)
CanModify	Returns a boolean stating whether the current event is allowed as a modifier
TryGetEventID	Maps a string event name from the bindings file to the integer value in the enumeration above
TryGetEventName	Maps an integer event ID to the string name in the enumeration above
Name (property)	Returns the name of the handler which must match the name in the XML file above (Wiimote in this case)

The code for these methods is presented below:

    // return out value of the passed enum

    public override bool TryGetEventId(string eventName, out int eventId)

    {

        eventId = (int)Enum.Parse(typeof(WiimoteEvent), eventName);

        return true;

    }

    // return out the string name of the passed in enum value

    public override bool TryGetEventName(int eventId, out string eventName)

    {

        eventName = ((WiimoteEvent)eventId).ToString();

        return true;

    }

    // unknown

    public override EventData GetEventData(int eventId, EventActivateState state)

    {

        throw new NotImplementedException();

    }

    // can the event be used as a modifier?

    public override bool IsModifier(int eventId)

    {

        // yes to all for now

        return true;

    }

    // can the supplied event be used as a modifier?

    public override bool CanModify(int eventId, EventKey other)

    {

        // only if it's from us

        return (other.Source == this);

    }

    // this must match the Source name in the bindings XML file

    public override string Name

    {

        get { return "Wiimote"; }

    }

    ' return out value of the passed enum

    Public Overrides Function TryGetEventId(ByVal eventName As String, <System.Runtime.InteropServices.Out()> ByRef eventId As Integer) As Boolean

        eventId = CInt(Fix(System.Enum.Parse(GetType(WiimoteEvent), eventName)))

        Return True

    End Function

    ' return out the string name of the passed in enum value

    Public Overrides Function TryGetEventName(ByVal eventId As Integer, <System.Runtime.InteropServices.Out()> ByRef eventName As String) As Boolean

        eventName = (CType(eventId, WiimoteEvent)).ToString()

        Return True

    End Function

    ' unknown

    Public Overrides Function GetEventData(ByVal eventId As Integer, ByVal state As EventActivateState) As EventData

        Throw New NotImplementedException()

    End Function

    ' can the event be used as a modifier?

    Public Overrides Function IsModifier(ByVal eventId As Integer) As Boolean

        ' yes to all for now

        Return True

    End Function

    ' can the supplied event be used as a modifier?

    Public Overrides Function CanModify(ByVal eventId As Integer, ByVal other As EventKey) As Boolean

        ' only if it's from us

        Return (other.Source Is Me)

    End Function

    ' this must match the Source name in the bindings XML file

    Public Overrides ReadOnly Property Name() As String

        Get

            Return "Wiimote"

        End Get

    End Property

With that in place, the constructor can be implemented which will call the base constructor and connect to the Wiimote. It is assumed you read the Wiimote article above and know how the library works.

The constructor must take one argument passed from the main from: an instance of the GlobeControl's ActionSystem. This just gets passed directly to the parent object's constructor untouched. The constructor code looks like the following:

public WiimoteEventSource(ActionSystem actionSystem) : base(actionSystem)
{
    // get all connected Wiimotes
    WiimoteCollection wc = new WiimoteCollection();
    wc.FindAllWiimotes();

    // setup wiimotes and event handlers
    foreach(Wiimote wm in wc)
    {
        wm.WiimoteChanged += new EventHandler<WiimoteChangedEventArgs>(OnWiimoteChanged);
        wm.WiimoteExtensionChanged += new EventHandler<WiimoteExtensionChangedEventArgs>(OnWiimoteExtensionChanged);
        wm.Connect();

        // if we don't have an extension, set the report type to IR and accel's only
        if(!wm.WiimoteState.Extension && wm.WiimoteState.ExtensionType != ExtensionType.BalanceBoard)
            wm.SetReportType(InputReport.IRAccel, true);

        if(wm.WiimoteState.ExtensionType == ExtensionType.BalanceBoard)
            _bb = wm;
        else
            _wm = wm;

        // turn off all LEDs
        wm.SetLEDs(0x00);
    }
}

Public Sub New(ByVal actionSystem As ActionSystem)
    MyBase.New(actionSystem)

    ' get all connected Wiimotes
    Dim wc As New WiimoteCollection()
    wc.FindAllWiimotes()

    ' setup wiimotes and event handlers
    For Each wm As Wiimote In wc
        AddHandler wm.WiimoteChanged, AddressOf OnWiimoteChanged
        AddHandler wm.WiimoteExtensionChanged, AddressOf OnWiimoteExtensionChanged
        wm.Connect()

        ' if we don't have an extension, set the report type to IR and accel's only
        If (Not wm.WiimoteState.Extension) AndAlso wm.WiimoteState.ExtensionType <> ExtensionType.BalanceBoard Then
            wm.SetReportType(InputReport.IRAccel, True)
        End If

        If wm.WiimoteState.ExtensionType = ExtensionType.BalanceBoard Then
            _bb = wm
        Else
            _wm = wm
        End If

        ' turn off all LEDs
        wm.SetLEDs(&H00)
    Next wm
End Sub

The OnWiimoteExtensionChanged method simply sets the report mode for the Wiimote based on whether or not a Nunchuk is inserted as shown:

private void OnWiimoteExtensionChanged(object sender, WiimoteExtensionChangedEventArgs args)
{
    if(_wm == null)
        return;

    // if nunchuk inserted, set the report type to return extension data
    if(args.ExtensionType == ExtensionType.Nunchuk && args.Inserted)
        _wm.SetReportType(InputReport.IRExtensionAccel, true);
    else // in all other cases, set it to the default IR and accel's
        _wm.SetReportType(InputReport.IRAccel, true);
}

Private Sub OnWiimoteExtensionChanged(ByVal sender As Object, ByVal args As WiimoteExtensionChangedEventArgs)
    If _wm Is Nothing Then
        Return
    End If

    ' if nunchuk inserted, set the report type to return extension data
    If args.ExtensionType = ExtensionType.Nunchuk AndAlso args.Inserted Then
        _wm.SetReportType(InputReport.IRExtensionAccel, True)
    Else ' in all other cases, set it to the default IR and accel's
        _wm.SetReportType(InputReport.IRAccel, True)
    End If
End Sub

The OnWiimoteChanged event handler is where the Wiimote data is handled and sent off to the VE3D control to reflect the changes. First, we handle the Balance Board. If the Balance Board is the controller reporting data, we take the center of gravity values and pass them to VE3D. This code looks at the appropriate values, determines if they are beyond the specified thresholds for the dead zones, and, if they are, activates the event for that value using the Execute method. Execute is a method in the base EventSource class. This method will activate the event specified from the enumeration (which, remember, is contained in the bindings XML file) with the value associated with that event. An EventData object of some type must be created and passed to the Execute method. There are two EventData types to know about: AxisEventData and ButtonEventData. AxisEventData should be used when an event is activated that will modify the map position in some way. That is, if the map is being turned, elevation is changing, etc. ButtonEventData should be used if the event is a simple toggle like pressing a button down and releasing it.

The Balance Board code can be seen below:

    if(ws.ExtensionType == ExtensionType.BalanceBoard && this.BalanceBoardEnabled)

    {

        float x1 = ws.BalanceBoardState.CenterOfGravity.X;

        if(x1 > Properties.Settings.Default.BBDeadX || x1 < -Properties.Settings.Default.BBDeadX)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.BalanceBoardX), x1 - _zero.X));

        float y1 = ws.BalanceBoardState.CenterOfGravity.Y;

        if(y1 > Properties.Settings.Default.BBDeadY || y1 < -Properties.Settings.Default.BBDeadY)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.BalanceBoardY), y1 - _zero.Y));

    }

    If ws.ExtensionType = ExtensionType.BalanceBoard AndAlso Me.BalanceBoardEnabled Then

        Dim x1 As Single = ws.BalanceBoardState.CenterOfGravity.X

        If x1 > My.Settings.Default.BBDeadX OrElse x1 < -My.Settings.Default.BBDeadX Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.BalanceBoardX))), x1 - _zero.X))

        End If

        Dim y1 As Single = ws.BalanceBoardState.CenterOfGravity.Y

        If y1 > My.Settings.Default.BBDeadY OrElse y1 < -My.Settings.Default.BBDeadY Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.BalanceBoardY))), y1 - _zero.Y))

        End If

Next, let's handle the IR and accelerometer data. The IR midpoint of the X and Y axes will be used from the WiimoteState object to activate the IRX and IRY events we defined above in the bindings XML file. The accelerometer X and Y values will be used to activate the AX and AY events.

This snippet assumes that there is a boolean property named UseIR created in the project to determine whether IR or motion values are used. Additionally, it assumes there are property settings created which contain values for the X/Y "dead zones" for the IR and accelerometers. These dead zones are used as a way to only activate the event when the values are pushed beyond the thresholds. This allows there to be a margin where the user's hand will not be read as movement, allowing the user to not have to worry about keeping a steady hand.

The application linked above uses the following default values for dead zones:

NunchukDeadX/Y -> 0.025
WiimoteDeadX/Y -> 0.15
IRDeadX/Y -> 0.1
BBDeadX/Y –> 3

    // if we're using the IR

    if(Properties.Settings.Default.UseIR)

    {

        // and both LEDs are found

        if(ws.IRState.Found1 && ws.IRState.Found2)

        {

            // normalize the midpoints to -0.5 to 0.5 (from 0 to 1.0)

            float x = ws.IRState.MidX - 0.5f;

            float y = ws.IRState.MidY - 0.5f;

            // if we're beyond the thresholds, activate the events

            if(x > Properties.Settings.Default.IRDeadX || x < -Properties.Settings.Default.IRDeadX)

                this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.IRX), x));

            if(y > Properties.Settings.Default.IRDeadY || y < -Properties.Settings.Default.IRDeadY)

                this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.IRY), y));

            // save the last IR settings...these get used if we go beyond the range of the IRs.

            // in that case, the last used positions will be used until the Wiimote comes back in range

            this._lastIRX = x;

            this._lastIRY = y;

        }

        else // one or both LEDs aren't seen

        {

            // activate events based on the last known positions

            if(this._lastIRX > Properties.Settings.Default.IRDeadX || this._lastIRX < -Properties.Settings.Default.IRDeadX)

                this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.IRX), this._lastIRX));

            if(this._lastIRY > Properties.Settings.Default.IRDeadY || this._lastIRY < -Properties.Settings.Default.IRDeadY)

                this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.IRY), this._lastIRY));

        }

    }

    else // we're using motion controls

    {

        // activate the events based on the accelerometer values

        if(ws.AccelState.X > Properties.Settings.Default.WiimoteDeadX || ws.AccelState.X < -Properties.Settings.Default.WiimoteDeadX)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.AX), ws.AccelState.X));

        if(ws.AccelState.Y > Properties.Settings.Default.WiimoteDeadY || ws.AccelState.Y < -Properties.Settings.Default.WiimoteDeadY)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.AY), ws.AccelState.Y));

    }

    ' if we're using the IR

    If My.Settings.Default.UseIR Then

        ' and both LEDs are found

        If ws.IRState.Found1 AndAlso ws.IRState.Found2 Then

            ' normalize the midpoints to -0.5 to 0.5 (from 0 to 1.0)

            Dim x As Single = ws.IRState.MidX - 0.5f

            Dim y As Single = ws.IRState.MidY - 0.5f

            ' if we're beyond the thresholds, activate the events

            If x > My.Settings.Default.IRDeadX OrElse x < -My.Settings.Default.IRDeadX Then

                Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.IRX))), x))

            End If

            If y > My.Settings.Default.IRDeadY OrElse y < -My.Settings.Default.IRDeadY Then

                Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.IRY))), y))

            End If

            ' save the last IR settings...these get used if we go beyond the range of the IRs.

            ' in that case, the last used positions will be used until the Wiimote comes back in range

            Me._lastIRX = x

            Me._lastIRY = y

        Else ' one or both LEDs aren't seen

            ' activate events based on the last known positions

            If Me._lastIRX > My.Settings.Default.IRDeadX OrElse Me._lastIRX < -My.Settings.Default.IRDeadX Then

                Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.IRX))), Me._lastIRX))

            End If

            If Me._lastIRY > My.Settings.Default.IRDeadY OrElse Me._lastIRY < -My.Settings.Default.IRDeadY Then

                Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.IRY))), Me._lastIRY))

            End If

        End If

    Else ' we're using motion controls

        ' activate the events based on the accelerometer values

        If ws.AccelState.X > My.Settings.Default.WiimoteDeadX OrElse ws.AccelState.X < -My.Settings.Default.WiimoteDeadX Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.AX))), ws.AccelState.X))

        End If

        If ws.AccelState.Y > My.Settings.Default.WiimoteDeadY OrElse ws.AccelState.Y < -My.Settings.Default.WiimoteDeadY Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.AY))), ws.AccelState.Y))

        End If

    End If

Next, the nunchuk values need to be read and the associated events activated. This is done as follows:

    // if the nunchuk is connected

    if(ws.Extension && ws.ExtensionType == ExtensionType.Nunchuk)

    {

        // activate the nunchuk-based events

        if(ws.NunchukState.X > Properties.Settings.Default.NunchukDeadX || ws.NunchukState.X < -Properties.Settings.Default.NunchukDeadX)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.NunchukX), ws.NunchukState.X));

        if(ws.NunchukState.Y > Properties.Settings.Default.NunchukDeadY || ws.NunchukState.Y < -Properties.Settings.Default.NunchukDeadY)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.NunchukY), ws.NunchukState.Y));

        if(ws.NunchukState.C)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.NunchukC), 1.0f));

        if(ws.NunchukState.Z)

            this.Execute(new AxisEventData(new EventKey(this, (int)WiimoteEvent.NunchukZ), 1.0f));

    }

    ' if the nunchuk is connected

    If ws.Extension AndAlso ws.ExtensionType = ExtensionType.Nunchuk Then

        ' activate the nunchuk-based events

        If ws.NunchukState.X > My.Settings.Default.NunchukDeadX OrElse ws.NunchukState.X < -My.Settings.Default.NunchukDeadX Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.NunchukX))), ws.NunchukState.X))

        End If

        If ws.NunchukState.Y > My.Settings.Default.NunchukDeadY OrElse ws.NunchukState.Y < -My.Settings.Default.NunchukDeadY Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.NunchukY))), ws.NunchukState.Y))

        End If

        If ws.NunchukState.C Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.NunchukC))), 1.0f))

        End If

        If ws.NunchukState.Z Then

            Me.Execute(New AxisEventData(New EventKey(Me, CInt(Fix(WiimoteEvent.NunchukZ))), 1.0f))

        End If

    End If

Finally, the button events need to be activated. A helper method which will check the current button state will be used for determining which button of all the Wiimote buttons is pressed. For those that are, the appropriate event is activated with a call to Execute.

    private void HandleButton(WiimoteEvent we, bool buttonState, bool lastButtonState)

    {

        if(buttonState == lastButtonState)

            return;

        else

        {

            if(buttonState)

                this.Execute(new ButtonEventData(new EventKey(this, (int)we), EventActivateState.Activate));

            else

                this.Execute(new ButtonEventData(new EventKey(this, (int)we), EventActivateState.Deactivate));

        }

    }

    // handle all the Wiimote buttons

    HandleButton(WiimoteEvent.Up, ws.ButtonState.Up, _lastBS.Up);

    HandleButton(WiimoteEvent.Down, ws.ButtonState.Down, _lastBS.Down);

    HandleButton(WiimoteEvent.Left, ws.ButtonState.Left, _lastBS.Left);

    HandleButton(WiimoteEvent.Right, ws.ButtonState.Right, _lastBS.Right);

    HandleButton(WiimoteEvent.A, ws.ButtonState.A, _lastBS.A);

    HandleButton(WiimoteEvent.B, ws.ButtonState.B, _lastBS.B);

    HandleButton(WiimoteEvent.Minus, ws.ButtonState.Minus, _lastBS.Minus);

    HandleButton(WiimoteEvent.Home, ws.ButtonState.Home, _lastBS.Home);

    HandleButton(WiimoteEvent.Plus, ws.ButtonState.Plus, _lastBS.Plus);

    HandleButton(WiimoteEvent.One, ws.ButtonState.One, _lastBS.One);

    HandleButton(WiimoteEvent.Two, ws.ButtonState.Two, _lastBS.Two);

    ...

    // save off the current button state for next time

    _lastBS = ws.ButtonState;

    _lastNunchuk = ws.NunchukState;

    Private Sub HandleButton(ByVal we As WiimoteEvent, ByVal buttonState As Boolean, ByVal lastButtonState As Boolean)

        If buttonState = lastButtonState Then

            Return

        Else

            If buttonState Then

                Me.Execute(New ButtonEventData(New EventKey(Me, CInt(Fix(we))), EventActivateState.Activate))

            Else

                Me.Execute(New ButtonEventData(New EventKey(Me, CInt(Fix(we))), EventActivateState.Deactivate))

            End If

        End If

    End Sub

    ...

    ' handle all the Wiimote buttons

    HandleButton(WiimoteEvent.Up, ws.ButtonState.Up, _lastBS.Up)

    HandleButton(WiimoteEvent.Down, ws.ButtonState.Down, _lastBS.Down)

    HandleButton(WiimoteEvent.Left, ws.ButtonState.Left, _lastBS.Left)

    HandleButton(WiimoteEvent.Right, ws.ButtonState.Right, _lastBS.Right)

    HandleButton(WiimoteEvent.A, ws.ButtonState.A, _lastBS.A)

    HandleButton(WiimoteEvent.B, ws.ButtonState.B, _lastBS.B)

    HandleButton(WiimoteEvent.Minus, ws.ButtonState.Minus, _lastBS.Minus)

    HandleButton(WiimoteEvent.Home, ws.ButtonState.Home, _lastBS.Home)

    HandleButton(WiimoteEvent.Plus, ws.ButtonState.Plus, _lastBS.Plus)

    HandleButton(WiimoteEvent.One, ws.ButtonState.One, _lastBS.One)

    HandleButton(WiimoteEvent.Two, ws.ButtonState.Two, _lastBS.Two)

    ' save off the current button state for next time

    _lastBS = ws.ButtonState

    _lastNunchuk = ws.NunchukState

And, the current button values are stored away to check on the next event so button events are only fired once.

Now that the event source object is written, it needs to be hooked up to the GlobeControl so it can be used. This can be done by creating an instance of the WiimoteEventSource object, passing in the VE3D's ActionSystem from the BindingsManager object. Then, the event source instance is passed to the ActionSystem's EventSourceManager and registered using the RegisterEventSource method. Event sources should re registered before the control is added to the form.

    // wiimote events

    private WiimoteEventSource _wiimoteEventSource;

    ...

    // create a new instance of the Wiimote event handler

    _wiimoteEventSource = new WiimoteEventSource(this.globeControl.Host.BindingsManager.ActionSystem, this);

    // register it in the event source list

    _globeControl.Host.BindingsManager.ActionSystem.EventSourceManager.RegisterEventSource(this._wiimoteEventSource);

    ' wiimote events

    Private _wiimoteEventSource As WiimoteEventSource

    ...

    ' create a new instance of the Wiimote event handler

    _wiimoteEventSource = New WiimoteEventSource(Me.globeControl.Host.BindingsManager.ActionSystem, Me)

    ' register it in the event source list

    _globeControl.Host.BindingsManager.ActionSystem.EventSourceManager.RegisterEventSource(Me._wiimoteEventSource)

Actions and the BindingManager

Our binding list contains several action types that are not defined by the default VE3D actions. These actions and their handlers must be registered with the VE3D control. The actions can be registered as follows in the FirstFrameRendered event handler:

    BindingsSource bs = new BindingsSource(base.GetType());

    _globeControl.Host.BindingsManager.RegisterAction(bs, "Locations", LocationsHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "LocationsMove", LocationsMoveHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "ToggleVR920", ToggleVR920Handler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "VR920SetZero", VR920SetZero);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "BalanceBoardSetZero", BalanceBoardSetZero);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "ToggleBalanceBoard", ToggleBalanceBoardHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "FullScreen", FullScreenHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "ToggleVR920Stereo", ToggleVR920Stereo);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "VR920SetEyeDistance", VR920SetEyeDistance);

    BindingsSource bs = new BindingsSource(base.GetType());

    _globeControl.Host.BindingsManager.RegisterAction(bs, "Locations", LocationsHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "LocationsMove", LocationsMoveHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "ToggleVR920", ToggleVR920Handler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "VR920SetZero", VR920SetZero);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "BalanceBoardSetZero", BalanceBoardSetZero);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "ToggleBalanceBoard", ToggleBalanceBoardHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "FullScreen", FullScreenHandler);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "ToggleVR920Stereo", ToggleVR920Stereo);

    _globeControl.Host.BindingsManager.RegisterAction(bs, "VR920SetEyeDistance", VR920SetEyeDistance);

With the actions registered and handlers associated with them, the actual handlers need to be implemented. All event handler methods must be of the following signature:

public bool EventHandler(EventData cause)

Public Function EventHandler(ByVal cause As EventData) As Boolean

Let’s take a look at the FullScreen binding which simply turns the status bar at the bottom of the window on and off:

private bool FullScreenHandler(EventData eventData)
{
    if(eventData.Activate)
        BeginInvoke(new UIEventHandlerDelegate(FullScreen), eventData);
    return true;
}

Private Function FullScreenHandler(ByVal eventData As EventData) As Boolean
    If eventData.Activate Then
        BeginInvoke(New UIEventHandlerDelegate(AddressOf FullScreen), eventData)
    End If
    Return True
End Function

Private Sub FullScreen(ByVal eventData As EventData)
    statusStrip1.Visible = Not statusStrip1.Visible
End Sub

Because we are in the VE3D thread when this handler is called, we need to use BeginInvoke to call the real method on the UI thread.

Be sure to check the source code for the full demo linked above for the location handler methods. I omitted them here since it is just more of the same type of code above.

VR920 Head Tracker

Once the VR920 glasses and driver are installed on your PC, getting the data required from the glasses is quite easy. We are going to create an object named VR920Tracker which will pull data from the device and send it to VE3D.

First we need to setup a few P/Invoke signatures to talk to the glasses as follows:

    [DllImport("IWEARDRV.dll", SetLastError = true, CharSet = CharSet.Auto)]

    private static extern int IWROpenTracker();

    [DllImport("IWEARDRV.dll", SetLastError = true, CharSet = CharSet.Auto)]

    private static extern void IWRZeroSet();

    [DllImport("IWEARDRV.dll", SetLastError = true, CharSet = CharSet.Auto)]

    private static extern int IWRGetTracking(out int yaw, out int pitch, out int roll);

    private const int ERROR_SUCCESS  = 0;

    <DllImport("IWEARDRV.dll", SetLastError := True, CharSet := CharSet.Auto)> _

    Private Shared Function IWROpenTracker() As Integer

    End Function

    <DllImport("IWEARDRV.dll", SetLastError := True, CharSet := CharSet.Auto)> _

    Private Shared Sub IWRZeroSet()

    End Sub

    <DllImport("IWEARDRV.dll", SetLastError := True, CharSet := CharSet.Auto)> _

    Private Shared Function IWRGetTracking(<System.Runtime.InteropServices.Out()> ByRef yaw As Integer, <System.Runtime.InteropServices.Out()> ByRef pitch As Integer, <System.Runtime.InteropServices.Out()> ByRef roll As Integer) As Integer

    End Function

    private const int ERROR_SUCCESS  = 0;

These 3 methods will allows to open access to the glasses, set its zero position, and get the roll, pitch and yaw information from the sensors.

In the constructor for this object, we will open a handle to the glasses and startup a timer that will poll the glasses at a regular interval to get the sensor data as shown below:

    private const int TimerPeriod = 1;

    private MainForm _mainForm;

    private Timer _timer;

    public VR920Tracker(MainForm mainForm)

    {

        _mainForm = mainForm;

        int openResult = IWROpenTracker();

        if(openResult != ERROR_SUCCESS)

            throw new ApplicationException("Could not connect to VR920: " + openResult);

        _timer = new Timer(VR920Poller, null, Timeout.Infinite, TimerPeriod);

    }

    Private Const TimerPeriod As Integer = 1

    Private _mainForm As MainForm

    Private _timer As Timer

    Public Sub New(ByVal mainForm As MainForm)

        _mainForm = mainForm

        Dim openResult As Integer = IWROpenTracker()

        If openResult <> ERROR_SUCCESS Then

            Throw New ApplicationException("Could not connect to VR920: " & openResult)

        End If

        _timer = New Timer(AddressOf VR920Poller, Nothing, Timeout.Infinite, TimerPeriod)

    End Sub

The VR920Poller method referenced above will be called at a specific interval and read the values from the glasses as shown below:

    // collection of values for averaging

    private List<double> _yawValues = new List<double>();

    private List<double> _rollValues = new List<double>();

    private List<double> _pitchValues = new List<double>();

    // last calculated values

    private double _lastYaw;

    private double _lastPitch;

    private double _lastRoll;

    private void VR920Poller(object state)

    {

        lock(this)

        {

            int yaw, pitch, roll;

            int result = IWRGetTracking(out yaw, out pitch, out roll);

            if(result != ERROR_SUCCESS)

                throw new ApplicationException("Could not get VR920 tracking information: " + result);

            _yawValues.Add(VR920ToRadians(yaw));

            _rollValues.Add(VR920ToRadians(roll));

            _pitchValues.Add(VR920ToRadians(pitch));

            if(_yawValues.Count == 5)

            {

                double y = Average(_yawValues, _lastYaw);

                if(Math.Abs(y - _lastYaw) > 0.026)

                    _lastYaw = y;

                double p = Average(_pitchValues, _lastPitch);

                if(Math.Abs(p - _lastPitch) > 0.017)

                    _lastPitch = p;

                _lastRoll = Average(_rollValues, _lastRoll);

                _yawValues.Clear();

                _pitchValues.Clear();

                _rollValues.Clear();

                RollPitchYaw rollPitchYaw = new RollPitchYaw(_lastRoll, _lastPitch, _lastYaw);

                _mainForm.SetRollPitchYaw(rollPitchYaw);

                _mainForm.lblAxes.Text = VR920ToDegrees(yaw) + ", " + VR920ToDegrees(pitch) + ", " + VR920ToDegrees(roll);

            }

        }

    }

    private double Average(List<double> values, double last)

    {

        double total = 0;

        foreach(double value in values)

            total += value;

        total += last;

        return total / (values.Count+1);

    }

    private double VR920ToRadians(int vr920Value)

    {

        return (vr920Value * .00549) * (Math.PI/180);

    }

    private double VR920ToDegrees(int vr920Value)

    {

        return (vr920Value * .00549);

    }

    ' collection of values for averaging

    Private _yawValues As List(Of Double) = New List(Of Double)()

    Private _rollValues As List(Of Double) = New List(Of Double)()

    Private _pitchValues As List(Of Double) = New List(Of Double)()

    ' last calculated values

    Private _lastYaw As Double

    Private _lastPitch As Double

    Private _lastRoll As Double

    Private Sub VR920Poller(ByVal state As Object)

        SyncLock Me

            Dim yaw, pitch, roll As Integer

            Dim result As Integer = IWRGetTracking(yaw, pitch, roll)

            If result <> ERROR_SUCCESS Then

                Throw New ApplicationException("Could not get VR920 tracking information: " & result)

            End If

            _yawValues.Add(VR920ToRadians(yaw))

            _rollValues.Add(VR920ToRadians(roll))

            _pitchValues.Add(VR920ToRadians(pitch))

            If _yawValues.Count = 5 Then

                Dim y As Double = Average(_yawValues, _lastYaw)

                If Math.Abs(y - _lastYaw) > 0.026 Then

                    _lastYaw = y

                End If

                Dim p As Double = Average(_pitchValues, _lastPitch)

                If Math.Abs(p - _lastPitch) > 0.017 Then

                    _lastPitch = p

                End If

                _lastRoll = Average(_rollValues, _lastRoll)

                _yawValues.Clear()

                _pitchValues.Clear()

                _rollValues.Clear()

                Dim rollPitchYaw As New RollPitchYaw(_lastRoll, _lastPitch, _lastYaw)

                _mainForm.SetRollPitchYaw(rollPitchYaw)

                _mainForm.lblAxes.Text = VR920ToDegrees(yaw) & ", " & VR920ToDegrees(pitch) & ", " & VR920ToDegrees(roll)

            End If

        End SyncLock

    End Sub

    Private Function Average(ByVal values As List(Of Double), ByVal last As Double) As Double

        Dim total As Double = 0

        For Each value As Double In values

            total += value

        Next value

        total += last

        Return total / (values.Count+1)

    End Function

    Private Function VR920ToRadians(ByVal vr920Value As Integer) As Double

        Return (vr920Value *.00549) * (Math.PI/180)

    End Function

    Private Function VR920ToDegrees(ByVal vr920Value As Integer) As Double

        Return (vr920Value *.00549)

    End Function

This chunk calls the IWRGetTracking method and tosses the results in 3 lists for roll, pitch and yaw. then, when the list has 5 members in it, the values are averaged and, if that resulting values is past a certain threshold, the values are passed back to the MainForm’s SetRollPitchYaw method as shown below:

    private double _lastYaw;

    public void SetRollPitchYaw(RollPitchYaw rollPitchYaw)

    {

        if(!_initialized || _globeControl.IsDisposed || (_globeControl.Host) == null || _globeControl.Host.CameraControllers.Current == null)

            return;

        double y = ((_globeControl.Host.CameraControllers.Current as ActionCameraController).LastReportedViewpoint.LocalOrientation.Yaw - _lastYaw) + rollPitchYaw.Yaw;

        RollPitchYaw rpw = new RollPitchYaw(rollPitchYaw.Roll, rollPitchYaw.Pitch, y);

        (_globeControl.Host.CameraControllers.Current as ActionCameraController).LastReportedViewpoint.LocalOrientation.RollPitchYaw = rpw;

        _lastYaw = rollPitchYaw.Yaw;

    }

    Private _lastYaw As Double

    Public Sub SetRollPitchYaw(ByVal rollPitchYaw As RollPitchYaw)

        If (Not _initialized) OrElse _globeControl.IsDisposed OrElse (_globeControl.Host) Is Nothing OrElse _globeControl.Host.CameraControllers.Current Is Nothing Then

            Return

        End If

        Dim y As Double = ((TryCast(_globeControl.Host.CameraControllers.Current, ActionCameraController)).LastReportedViewpoint.LocalOrientation.Yaw - _lastYaw) + rollPitchYaw.Yaw

        Dim rpw As New RollPitchYaw(rollPitchYaw.Roll, rollPitchYaw.Pitch, y)

        TryCast(_globeControl.Host.CameraControllers.Current, ActionCameraController).LastReportedViewpoint.LocalOrientation.RollPitchYaw = rpw

        _lastYaw = rollPitchYaw.Yaw

    End Sub

This method takes the roll, pitch and yaw values provided and applies them to the current CameraController used by VE3D (which, by default, is an ActionCameraController).

So, this code ultimately takes the roll, yaw and pitch of the user’s head and translates that directly to the roll, yaw and pitch of the camera in VE3D providing an accurate, real-time view into the VE3D world.

Stereoscopic Images

The final piece of the puzzle is drawing frames to the VR920 glasses in such a way that the final view to the user will be three dimensional. This works similarly to those Magic Eye puzzles you may have seen. Essentially, for every frame, we want to take the current VE3D camera position and move it several units to the left, render that to the left eye of the glasses, and then move the camera several units to the right and render that to the right eye of the glasses. To handle this we, can create an object named VR920StereoStep which derives from the Step class provided by VE3D and add this to the StepManager. When this is done, the VR920StereoStep will be called at the end of every frame drawn by VE3D.

As with the VR920Tracker class, we will need to setup a few P/Invoke method signatures to talk to the stereo driver as shown below:

    [DllImport("iWrstDrv.dll", EntryPoint = "IWRSTEREO_Open", SetLastError=true)]

    public static extern IntPtr OpenStereo();

    [DllImport("iWrstDrv.dll", EntryPoint = "IWRSTEREO_SetStereo")]

    public static extern Boolean SetStereoEnabled(IntPtr handle, Boolean enabled);

    [DllImport("iWrstDrv.dll", EntryPoint = "IWRSTEREO_SetLR")]

    public static extern Boolean SetStereoLR(IntPtr handle, Boolean eye);

    [DllImport("iWrstDrv.dll", EntryPoint = "IWRSTEREO_WaitForAck")]

    public static extern Byte WaitForOpenFrame(IntPtr handle, Boolean eye);

    <DllImport("iWrstDrv.dll", EntryPoint := "IWRSTEREO_Open", SetLastError:=True)> _

    Public Shared Function OpenStereo() As IntPtr

    End Function

    <DllImport("iWrstDrv.dll", EntryPoint := "IWRSTEREO_SetLR")> _

    Public Shared Function SetStereoLR(ByVal handle As IntPtr, ByVal eye As Boolean) As Boolean

    End Function

    <DllImport("iWrstDrv.dll", EntryPoint := "IWRSTEREO_SetStereo")> _

    Public Shared Function SetStereoEnabled(ByVal handle As IntPtr, ByVal enabled As Boolean) As Boolean

    End Function

    <DllImport("iWrstDrv.dll", EntryPoint := "IWRSTEREO_WaitForAck")> _

    Public Shared Function WaitForOpenFrame(ByVal handle As IntPtr, ByVal eye As Boolean) As Byte

    End Function

In the constructor for this object, we will open a handle to the stereo driver and turn on the stereo functionality of the glasses as shown below:

    private static readonly IntPtr INVALID_FILE_HANDLE = (IntPtr)(-1);

    private IntPtr _hStereo = INVALID_FILE_HANDLE;

    private Host _host;

    private bool _stereoEnabled = true;

    public double EyeDistance { get; set; }

    public VR920StereoStep(StepManager manager, Host host) : base(manager)

    {

        EyeDistance = 10;

        _host = host;

        _hStereo = OpenStereo();

        if(_hStereo != INVALID_FILE_HANDLE)

            SetStereoEnabled(_hStereo, true);

        else

            _stereoEnabled = false;

    }

    Private Shared ReadOnly INVALID_FILE_HANDLE As IntPtr = CType(-1, IntPtr)

    Private _hStereo As IntPtr = INVALID_FILE_HANDLE

    Private _host As Host

    Private _stereoEnabled As Boolean = True

    Private privateEyeDistance As Double

    Public Property EyeDistance() As Double

        Get

            Return privateEyeDistance

        End Get

        Set(ByVal value As Double)

            privateEyeDistance = value

        End Set

    End Property

    Public Sub New(ByVal manager As StepManager, ByVal host As Host)

        MyBase.New(manager)

        EyeDistance = 10

        _host = host

        _hStereo = OpenStereo()

        If _hStereo <> INVALID_FILE_HANDLE Then

            SetStereoEnabled(_hStereo, True)

        Else

            _stereoEnabled = False

        End If

    End Sub

Next, we need to override the OnExecute method provided by the base Step class as shown below:

    private bool _rightEye = true;

    private Vector3D _position;

    public override void OnExecute(SceneState state)

    {

        if(_hStereo != INVALID_FILE_HANDLE && _stereoEnabled && (_host.CameraControllers.Current as ActionCameraController).LastReportedViewpoint != null)

        {

            if(!_rightEye)

            {

                _position = (_host.CameraControllers.Current as ActionCameraController).LastReportedViewpoint.Position.Vector;

                (_host.CameraControllers.Current as ActionCameraController).LastReportedViewpoint.Position.Vector = _position + new Vector3D(-EyeDistance, 0, 0);

            }

            else

            {

                _position = (_host.CameraControllers.Current as ActionCameraController).LastReportedViewpoint.Position.Vector;

                (_host.CameraControllers.Current as ActionCameraController).LastReportedViewpoint.Position.Vector = _position + new Vector3D(EyeDistance, 0, 0);;

            }

            SetStereoLR(_hStereo, _rightEye);

            WaitForOpenFrame(_hStereo, _rightEye);

            _rightEye = !_rightEye;

        }

    }

    Private _rightEye As Boolean = True

    Private _position As Vector3D

    Public Overrides Sub OnExecute(ByVal state As SceneState)

        If _hStereo <> INVALID_FILE_HANDLE AndAlso _stereoEnabled AndAlso (TryCast(_host.CameraControllers.Current, ActionCameraController)).LastReportedViewpoint IsNot Nothing Then

            If (Not _rightEye) Then

                _position = (TryCast(_host.CameraControllers.Current, ActionCameraController)).LastReportedViewpoint.Position.Vector

                TryCast(_host.CameraControllers.Current, ActionCameraController).LastReportedViewpoint.Position.Vector = _position + New Vector3D(-EyeDistance, 0, 0)

            Else

                _position = (TryCast(_host.CameraControllers.Current, ActionCameraController)).LastReportedViewpoint.Position.Vector

                TryCast(_host.CameraControllers.Current, ActionCameraController).LastReportedViewpoint.Position.Vector = _position + New Vector3D(EyeDistance, 0, 0)

            End If

            SetStereoLR(_hStereo, _rightEye)

            WaitForOpenFrame(_hStereo, _rightEye)

            _rightEye = Not _rightEye

        End If

    End Sub

OnExecute will be called at the end of each VE3D frame rendered. In this method, we obtain the current position of the VE3D camera and then set its position several units to the left or right (- or + EyeDistance). SetStereoLR from the VR920 API is called, setting the appropriate eye to be active (left = false, right = true). Then WaitForOpenFrame is called which will pause the action long enough for the glasses to draw the entire frame to eye to avoid image tearing. Essentially, this call “sits and spins” at this location until the glasses report back that the entire frame is drawn in the proper eye and that we can continue on drawing the opposite eye for the next frame. Finally, the _rightEye member variable is togged to the opposite value, so the next time through this method the opposite eye is drawn.

With this class in place, back in our MainForm in the FirstFrameRendered event handler, we can instantiate the object and add it to the StepManager as shown below:

    private VR920StereoStep _vr920StereoStep;

    _vr920StereoStep = new VR920StereoStep(_globeControl.Host.RenderEngine.StepManager, _globeControl.Host);

    _globeControl.Host.RenderEngine.StepManager.Add(_vr920StereoStep);

    Private _vr920StereoStep As VR920StereoStep

    _vr920StereoStep = New VR920StereoStep(_globeControl.Host.RenderEngine.StepManager, _globeControl.Host)

    _globeControl.Host.RenderEngine.StepManager.Add(_vr920StereoStep)

Running the Application

To run the demo, do the following:

Copy BindingsWiimote.xml to the appropriate directory listed above
Pair the Wiimote and Balance Board to the computer. See the WiimoteLib article for more information on how to do that
Run the executable
Stand on the Balance Board
Put on the glasses
Zero both the Balance Board and glasses
Toggle everything on or off at will

Controls

F1 – Set VR920 glasses to zero position
F2 – Set Balance Board to zero position
F3 – Toggle stereo mode on and off
Wiimote 1 or B – Toggle Balance Board on or off
Wiimote 2 or V – Toggle VR920 head tracking on or off
F – Toggle full-screen on or off
Nunchuk joystick X/Y – Strafe/Move
Nunchuk C/Z buttons – Raise/lower altitude
Wiimote A – Open location menu/Select location (note that if a new location is selected, the Balance Board is turned off and must be re-enabled after “landing”
Wiimote Dpad Up/Down – Move through List
Balance Board – Lean your body left or right to turn in the VE3D environment

Conclusion

With the above code, we have created a very interesting interface for Virtual Earth 3D. The demo and source code linked above contain a few more features and bindings which enhance the application a bit more. Be sure to give the full demo a try and check out the full source code for a few more implementation details.

Additional Information

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 "Debugging ASP.NET" published by New Riders, and is currently co-authoring a book titled "Coding4Fun: 10 .NET Programming Projects for Wiimote, YouTube, World of Warcraft, and More" to be published by O'Reilly in December 2008. Brian is also an author for MSDN's Coding4Fun website. You can reach Brian via vis website at http://www.brianpeek.com/ .

BlueBoss - Bluetooth Proximity Detection

Coding4Fun — Fri, 27 Jun 2008 01:09:42 GMT

Summary:

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:

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:

User clicks the “Discover” button, a thread is spawned which enumerates all Bluetooth devices in proximity
Thread finishes and updates the Devices listbox
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
User clicks save , a WatchItem object is created and added to the watchList object
A timer starts and every 10 seconds a thread is spawned to discover that device by name
If the device is discovered, it is added to the “deviceSeenList” and a notify alert is sent and the executable is executed.
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:

WPF Custom Screen Saver Art

Coding4Fun — Fri, 20 Jun 2008 21:24:00 GMT

Summary

Creating custom wallpaper is easy. But what about custom screen savers? This post will detail how to build a custom saver using Windows Presentation Framework (WPF). The posted code also provides some insight on how to create interesting particle effects using WPF’s animation engine, and how to implement multiple monitor support in .Net.

Erik Klimczak - Clarity Consulting

Download

http://wpfscreensaverart.codeplex.com/

Introduction

Microsoft Unified Communications (UC) is a new technology that has been getting a lot of hype in the past couple of months. UC is essentially the integration of messaging, voice, and video across the applications and devices that people use every day. More information about UC can be found here. One of the coolest things about UC is the concept of “presence” (see below). The Presence indicator effectively allows the user to reflect his/her status in other Office Communicator Server friendly applications (i.e. Outlook, Office communicator, Live Meeting, etc.)

While building out some communicator functionality on another project I found myself recreating the presence “bubbles” in xaml so that they could scale without losing quality (see below). I used Expression Design to re-create the presence bubbles and export then to xaml.

In doing so it occurred to me that the presence “bubbles” would make for some excellent art sprites.

So after a hop-skip-and a jump to Photoshop I found myself with a shiny new “presence art” wallpaper.

Immediately after creating the wallpaper I thought to myself, “this would also make a great screen saver”. This article will attempt to show how to build a custom WPF screen saver that implements a simple physics particle effect using the WPF animation engine.

Particle Animation

With my graphic designer hat on I knew that I wanted to create a floating particle effect. Particle effects can be used to simulate anything from rain, snow, fire to bubbles and clouds. Then by varying the presence “bubbles” in size and opacity the illusion of depth and space can be created. After some research I found the CompositionTarget.Rendering event handler in WPF. Essentially, this event is a timer that ticks all the time and fires once each time WPF decides to render a frame. Inside the event handler you have complete freedom to do whatever you want to any object. In other words, hooking CompositionTarget.Rendering is very much a "do it yourself" animation system. This event is especially good for physics-based animations and is very similar to the way Flash’s rendering engine works. The MSDN entry for this event handler can be found here.

Once I had found the appropriate animation hook I created the particle user control. This control holds the various particle attributes that will be animated. The code below shows the various properties that can be used to create very interesting physics-based effects. These properties can be used to calculate collision detection, gravitational pull and other kinetics-related effects.

   1: public partial class Particle : UserControl   2:    {   3:     4:        public Particle()   5:        {   6:     7:            InitializeComponent();   8:        }   9:    10:        public static readonly DependencyProperty StatusProperty = DependencyProperty.Register("Status", typeof(Status), typeof(Particle), new UIPropertyMetadata(Particle.StatusValueChanged));  11:        public Status Status  12:        {  13:            get { return (Status)GetValue(StatusProperty); }  14:            set { SetValue(StatusProperty, value); }  15:        }  16:    17:        private static void StatusValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)  18:        {  19:            Particle myclass = (Particle)d;  20:            myclass.imgStatus.Source = Application.Current.FindResource(((Status)e.NewValue).ToString() + "Png") as BitmapImage;  21:        }  22:    23:        public double Radius  24:        {  25:            get { return this.imgStatus.Height / 2; }  26:            set { this.imgStatus.Height = this.imgStatus.Width = value * 2; }  27:        }  28:    29:        private double vy;  30:        public double VY  31:        {  32:            get { return this.vy; }  33:            set { this.vy = value; }  34:        }  35:    36:        private double vx;  37:        public double VX  38:        {  39:            get { return this.vx; }  40:            set { this.vx = value; }  41:        }  42:    43:        private double mass;  44:        public double Mass  45:        {  46:            get { return this.mass; }  47:            set { this.mass = value; }  48:        }  49:        private double x;  50:        public double X  51:        {  52:            get { return this.x; }  53:            set { this.x = value; }  54:        }  55:    56:        private double y;  57:        public double Y  58:        {  59:            get { return this.y; }  60:            set { this.y = value; }  61:        }  62:    }

VB

   1: Partial Public Class Particle   2:     Inherits UserControl   3:     4:     5:     Public Sub New()   6:         InitializeComponent()   7:     End Sub   8:     9:     Public Shared ReadOnly StatusProperty As DependencyProperty = DependencyProperty.Register("Status", GetType(Status), GetType(Particle), New PropertyMetadata(AddressOf Particle.StatusValueChanged))  10:     Public Property Status() As Status  11:         Get  12:             Return CType(GetValue(StatusProperty), Status)  13:         End Get  14:         Set(ByVal value As Status)  15:             SetValue(StatusProperty, value)  16:         End Set  17:     End Property  18:    19:     Private Shared Sub StatusValueChanged(ByVal d As DependencyObject, ByVal e As DependencyPropertyChangedEventArgs)  20:         Dim [myclass] As Particle = CType(d, Particle)  21:         [myclass].imgStatus.Source = TryCast(Application.Current.FindResource((CType(e.NewValue, Status)).ToString() & "Png"), BitmapImage)  22:     End Sub  23:    24:     Public Property Radius() As Double  25:         Get  26:             Return Me.imgStatus.Height / 2  27:         End Get  28:         Set(ByVal value As Double)  29:             Me.imgStatus.Width = value * 2  30:             Me.imgStatus.Height = Me.imgStatus.Width  31:         End Set  32:     End Property  33:    34:     Private _vy As Double  35:     Public Property VY() As Double  36:         Get  37:             Return Me._vy  38:         End Get  39:         Set(ByVal value As Double)  40:             Me._vy = value  41:         End Set  42:     End Property  43:    44:     Private _vx As Double  45:     Public Property VX() As Double  46:         Get  47:             Return Me._vx  48:         End Get  49:         Set(ByVal value As Double)  50:             Me._vx = value  51:         End Set  52:     End Property  53:    54:     Private _mass As Double  55:     Public Property Mass() As Double  56:         Get  57:             Return Me._mass  58:         End Get  59:         Set(ByVal value As Double)  60:             Me._mass = value  61:         End Set  62:     End Property  63:    64:     Private _x As Double  65:     Public Property X() As Double  66:         Get  67:             Return Me._x  68:         End Get  69:         Set(ByVal value As Double)  70:             Me._x = value  71:         End Set  72:     End Property  73:    74:     Private _y As Double  75:     Public Property Y() As Double  76:         Get  77:             Return Me._y  78:         End Get  79:         Set(ByVal value As Double)  80:             Me._y = value  81:         End Set  82:     End Property  83:    84: End Class  85:    86:  

Once I had the particle class created, I decided to use a variation of a spring physics equation to get the desired float animation. The spring equation forces the particles toward each other and then springs them past each other similar to how a ball on the end of a rubber band would act when pulling it and letting it spring back and forth. Then by tweaking the force and velocity applied to each particle I successfully simulated a floating effect (I am by no means a physicist and I am sure there is a better way of implementing this equation). By combining the CompositionTarget.Rendering event and the positioning logic we can effectively scatter and animate the particles on our Canvas. The math involved looks something like this:

   1: void Spring(Particle a, Particle b)   2:         {   3: double dx = b.X - a.X;   4: double dy = b.Y - a.Y;   5:     6: double dist = Math.Sqrt(dx * dx + dy * dy);   7: if (dist < _minDist)   8:             {   9: double ax = dx * _spring;  10: double ay = dy * _spring;  11:    12:                 a.VX += ax;  13:                 a.VY += ay;  14:    15:                 b.VX -= ax;  16:                 b.VY -= ay;  17:    18: Canvas.SetLeft(a, a.X);  19: Canvas.SetTop(a, a.Y);  20:    21: Canvas.SetLeft(b, b.X);  22: Canvas.SetTop(b, b.Y);  23:    24:    25:             }  26:    27: Canvas.SetLeft(a, a.X);  28: Canvas.SetTop(a, a.Y);  29:    30: Canvas.SetLeft(b, b.X);  31: Canvas.SetTop(b, b.Y);  32:    33:    34:         }  35:    36: VB:  37: PrivateSub Spring(ByVal a As Particle, ByVal b As Particle)  38: Dim dx AsDouble = b.X - a.X  39: Dim dy AsDouble = b.Y - a.Y  40:    41: Dim dist AsDouble = Math.Sqrt(dx * dx + dy * dy)  42: If dist < _minDist Then  43: Dim ax AsDouble = dx * _spring  44: Dim ay AsDouble = dy * _spring  45:    46:             a.VX += ax  47:             a.VY += ay  48:    49:             b.VX -= ax  50:             b.VY -= ay  51:    52:             Canvas.SetLeft(a, a.X)  53:             Canvas.SetTop(a, a.Y)  54:    55:             Canvas.SetLeft(b, b.X)  56:             Canvas.SetTop(b, b.Y)  57:    58:    59: EndIf  60:    61:         Canvas.SetLeft(a, a.X)  62:         Canvas.SetTop(a, a.Y)  63:    64:         Canvas.SetLeft(b, b.X)  65:         Canvas.SetTop(b, b.Y)  66:    67:    68: EndSub  69:    70: And the main animation loop looks like this:  71:    72: C#:  73: void CompositionTarget_Rendering(object sender, EventArgs e)  74:         {  75: for (int i = 0; i < _numParticles; i++)  76:             {  77:                 _particles[i].X += _particles[i].VX;  78:                 _particles[i].Y += _particles[i].VY;  79:    80: Particle p = _particles[i];  81:    82: if (p.X >this.Width)  83:                 {  84:                     p.X = 0;  85:                 }  86:    87: elseif (p.X < 0)  88:                 {  89:                     p.X = this.Width;  90:                 }  91:    92: if (p.Y >this.Height)  93:                 {  94:                     p.Y = 0;  95:                 }  96: elseif (p.Y < 0)  97:                 {  98:                     p.Y = this.Height;  99:                 } 100:             } 101:   102:   103: for (int i = 0; i < _numParticles - 1; i++) 104:             { 105: var partA = _particles[i]; 106: for (int j = i + 1; j < _numParticles; j++) 107:                 { 108: var partB = _particles[j]; 109:                     Spring(partA, partB); 110:   111:                 } 112:             } 113:         }

   1: Sub CompositionTarget_Rendering(ByVal sender As System.Object, ByVal e As System.EventArgs)   2: For i AsInteger = 0 To _numParticles - 1   3:             _particles(i).X += _particles(i).VX   4:             _particles(i).Y += _particles(i).VY   5:     6: Dim p As Particle = _particles(i)   7:     8: If p.X >Me.Width Then   9:                 p.X = 0  10:    11: ElseIf p.X < 0 Then  12:                 p.X = Me.Width  13: EndIf  14:    15: If p.Y >Me.Height Then  16:                 p.Y = 0  17: ElseIf p.Y < 0 Then  18:                 p.Y = Me.Height  19: EndIf  20: Next i  21:    22:    23: For i AsInteger = 0 To _numParticles - 2  24: Dim partA = _particles(i)  25: For j AsInteger = i + 1 To _numParticles - 1  26: Dim partB = _particles(j)  27:                 Spring(partA, partB)  28:    29: Next j  30: Next  31:    32: EndSub  33:  

Supporting Multiple Monitors

After the animation was rendering correctly the next step was getting it to run on multiple monitors. To make this happen I wrote some code in the application entry point to get a handle to the active screens. The System.Windows.Forms namespace has a Screen class which contains a collection of screens and their attributes including working area, width, and height. By looping through the screen collection I measure the screen boundaries and set the window size dynamically based on the available screen real estate.

   1: private void Application_Startup(object sender, StartupEventArgs e)   2:         {   3:     4: Window1 _window = null;   5:     6:             System.Windows.Forms.Cursor.Hide();   7:     8: foreach (Screen screen inScreen.AllScreens)   9:             {  10: if (screen.Primary)  11:                 {  12: Rectangle location = screen.Bounds;  13:                     _window = newWindow1(location.Height, location.Width);  14:                     _window.Width = location.Width;  15:                     _window.Height = location.Height;  16:                     _window.Left = 0;  17:                     _window.Top = 0;  18:                     _window.WindowState = WindowState.Maximized;  19:                     _window.Show();  20:                 }  21:    22: elseif (!screen.Primary)  23:                 {  24:    25: Rectangle location = screen.Bounds;  26:                     _window = newWindow1(location.Height, location.Width);  27:                     _window.Left = screen.WorkingArea.Left;  28:                     _window.Top = screen.WorkingArea.Top;  29:                     _window.Width = location.Width;  30:                     _window.Height = location.Height;  31:                     _window.Show();  32:                 }  33:    34:             }  35:    36:         }

   1: private void Application_Startup(object sender, StartupEventArgs e)   2:         {   3:     4: Window1 _window = null;   5:     6:             System.Windows.Forms.Cursor.Hide();   7:     8: foreach (Screen screen inScreen.AllScreens)   9:             {  10: if (screen.Primary)  11:                 {  12: Rectangle location = screen.Bounds;  13:                     _window = newWindow1(location.Height, location.Width);  14:                     _window.Width = location.Width;  15:                     _window.Height = location.Height;  16:                     _window.Left = 0;  17:                     _window.Top = 0;  18:                     _window.WindowState = WindowState.Maximized;  19:                     _window.Show();  20:                 }  21:    22: elseif (!screen.Primary)  23:                 {  24:    25: Rectangle location = screen.Bounds;  26:                     _window = newWindow1(location.Height, location.Width);  27:                     _window.Left = screen.WorkingArea.Left;  28:                     _window.Top = screen.WorkingArea.Top;  29:                     _window.Width = location.Width;  30:                     _window.Height = location.Height;  31:                     _window.Show();  32:                 }  33:    34:             }  35:    36:         }

Making it a Screen Saver

The last step to this application is making it a screen saver. By implementing mouse and keyboard event handlers to shut down the application we essentially can mimic the interaction of a screen saver.

   1: MouseMove += newMouseEventHandler(Window2_MouseMove);   2:   MouseDown += newMouseButtonEventHandler(Window2_MouseDown);   3:   KeyDown += newKeyEventHandler(Window2_KeyDown);   4: void Window2_KeyDown(object sender, KeyEventArgs e)   5:         {   6: Application.Current.Shutdown();   7:         }   8:     9: void Window2_MouseDown(object sender, MouseButtonEventArgs e)  10:         {  11: Application.Current.Shutdown();  12:         }  13:    14: void Window2_MouseMove(object sender, MouseEventArgs e)  15:         {  16: Point currentPosition = e.MouseDevice.GetPosition(this);  17:    18: if (!isActive)  19:             {  20:                 mousePosition = currentPosition;  21:                 isActive = true;  22:             }  23: else  24:             {  25:    26: if ((Math.Abs(mousePosition.X - currentPosition.X) > 10) ||  27:                     (Math.Abs(mousePosition.Y - currentPosition.Y) > 10))  28:                 {  29: Application.Current.Shutdown();  30:                 }  31:             }  32:         }

   1: AddHandlerMe.MouseMove, AddressOf Window_MouseMove   2: AddHandlerMe.MouseDown, AddressOf Window_MouseDown   3: AddHandlerMe.KeyDown, AddressOf Window_KeyDown   4:     5: PrivateSub Window_KeyDown(ByVal sender AsObject, ByVal e As KeyEventArgs)   6:         Application.Current.Shutdown()   7: EndSub   8:     9: PrivateSub Window_MouseDown(ByVal sender AsObject, ByVal e As MouseButtonEventArgs)  10:         Application.Current.Shutdown()  11: EndSub  12:    13: PrivateSub Window_MouseMove(ByVal sender AsObject, ByVal e As MouseEventArgs)  14: Dim currentPosition As Point = e.MouseDevice.GetPosition(Me)  15: If (Not isActive) Then  16:             mousePosition = currentPosition  17:             isActive = True  18: Else  19: If (Math.Abs(mousePosition.X - currentPosition.X) > 10) OrElse (Math.Abs(mousePosition.Y - currentPosition.Y) > 10) Then  20:                 Application.Current.Shutdown()  21: EndIf  22: EndIf  23: EndSub  24:  

Lastly, simply set the build configuration to Release mode and build it. In the output bin->Release directory find the built executable. Rename the file extension from .exe to .scr then right click and choose Install from the context menu.

That’s it!

Challenges to You

One of the interesting things about Office Communicator Server is that it comes with an SDK to build your own custom Unified Communications applications.

I would love to see the presence bubbles actually hooked up to real users’ status, and maybe a cool animation to indicate when a users’ status is changed.
Create a config file to let the user specify his/her own images and tweak other settings like speed and velocity.

Conclusion

This was a great opportunity to brush up on my physics skills and play with some of the animation possibilities in WPF. This application is also a great example of alternative data visualization. Sometimes I get tired of seeing everything in tabular form and I think that “presence art” is a great example of Art + Code (aesthetically pleasing and functional). I hope you enjoy it.

A Better Startup Experience

Coding4Fun — Mon, 17 Mar 2008 18:55:47 GMT

	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.