POKE 53280,0: Pete Brown's Blog

Getting Camtasia to work with the E-MU 1616 Sound Card

Pete.Brown — Sat, 07 Nov 2009 05:51:04 GMT

I just got sound working in my C64 emulator and I wanted to record a short WMV of M.U.L.E. to send to a few friends, but couldn’t figure out how to get sound recorded. I just tonight got both M.U.L.E. and sound working, so I just had to let people know :)

If you have a usb headset soundcard, you’re generally out of luck. You can’t record that sound as nothing is coming “back” to the PC.

However, I also have a pro sound card, used mostly for ASIO stuff, MIDI, and recording. It’s an EMU 1616 PCI card with an external box. It has a boatload of inputs, as well as MIDI in/out. Cost me half a leg when I bought it, so I get annoyed if it won’t do every last thing I demand of it :)

Anyway, couldn’t get Camtasia to pick up the audio for that until I started playing with the sound card’s mixing software.

It’s pretty simple once you get down to it:

Open up PatchMix DSP
Make sure you have a strip for Wave 1 / 2 in there – the default wave source on your computer
Crank up its aux 1 send to zero (the knob below all the inserts)
Over on the right, insert the WAVE/WDM (Camtasia doesn’t use ASIO) send to Aux 1, and make sure you have the volume up.
In Camtasia recorder, pick the E-MU 1616 device as the audio source.

Right-click the Aux 1 insert (where it says Send in the shot above) and you’ll get this menu:

Pick the Wave L / R and ok the dialog.

Verify by clicking the Send insert. You should see this

You may need to lower the master volume to a reasonable level, but other than that, you’re good.

Viola! Now I can record the awesome SID music from my emulator :)

Creating Custom Easing Functions in WPF 4 (and Silverlight)

Pete.Brown — Wed, 04 Nov 2009 21:59:00 GMT

In a previous post and video, I went through how to use the stock easing functions in your WPF 4 applications. Now, let’s look at how to create your own easing functions.

Once you know the formula you want to use, the mechanics of creating custom easing functions is pretty simple.

Example Project

We’ll use something almost identical to what was used in the easing function post and video. Create a standard WPF project, and set up the MainWindow so it looks like this:

Here’s the xaml

<Window x:Class="CustomEasingDemo.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="600" Width="825">
    <Window.Resources>
        <Storyboard x:Key="AnimateTarget">
            <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                           Storyboard.TargetProperty="X">
                <EasingDoubleKeyFrame KeyTime="0:0:0"
                                      Value="0.0" />
                <EasingDoubleKeyFrame KeyTime="0:0:3"
                                      Value="202.0">
                    <EasingDoubleKeyFrame.EasingFunction>
                        <ElasticEase EasingMode="EaseOut"
                                     Oscillations="3"
                                     Springiness="8" />
                    </EasingDoubleKeyFrame.EasingFunction>
                </EasingDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                           Storyboard.TargetProperty="Y">
                <EasingDoubleKeyFrame KeyTime="0:0:0"
                                      Value="0.0" />
                <EasingDoubleKeyFrame KeyTime="0:0:3"
                                      Value="202.0">
                    <EasingDoubleKeyFrame.EasingFunction>
                        <ElasticEase EasingMode="EaseOut"
                                     Oscillations="3"
                                     Springiness="8" />
                    </EasingDoubleKeyFrame.EasingFunction>
                </EasingDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
        </Storyboard>
    </Window.Resources>

    <Grid>
        <Rectangle Height="20"
                   Width="20"
                   RenderTransformOrigin="0.5,0.5"
                   Fill="BlueViolet">
            <Rectangle.RenderTransform>
                <TranslateTransform x:Name="Transform" />
            </Rectangle.RenderTransform>
        </Rectangle>

        <Button x:Name="StartAnimation"
                Click="StartAnimation_Click"
                Content="Start"
                Width="100"
                Height="40"
                HorizontalAlignment="Center"
                VerticalAlignment="Bottom"
                Margin="5" />
    </Grid>

</Window>

And here’s the code-behind

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void StartAnimation_Click(object sender, RoutedEventArgs e)
    {
        ((Storyboard)this.Resources["AnimateTarget"]).Begin();
    }
}

If you run that project, you’ll see how the ElasticEase works on the position of the cube. We’ll replace that elastic ease with a function of our own.

Custom Easing Basics

The WPF and Silverlight teams put together a pretty comprehensive set of standard easing functions. Most folks will never need or want to write one of their own.

That said, you may come up with a specialized function and want to package that in a way that enables others to use it from xaml or code in their own animation.

To create your own easing function, you derive from EasingFunctionBase and override both EaseInCore and CreateInstanceCore.

EasingFunctionBase.CreateInstanceCore

This method is WPF-specific, and wouldn’t be used in Silverlight as Silverlight has no concept of Freezables. In WPF, this function is used to return a new instance of the Freezable class.

EasingFunctionBase.EaseInCore

This is where your easing code goes. You provide the implementation for EaseIn, and the runtime will figure out how to derive EaseOut and EaseInOut.

EaseInCore takes a double representing normalized time, and expects you to return the progress for that point in time. If you think of time as the x-axis on a graph and progress as the y-axis, you’re taking in x and returning y.

A standard linear ease would return the value passed in. f(x) = x . Instantaneous movement would be f(x) = 1. No movement (ever) would be f(x) = 0. The interesting stuff happens when the result is between those numbers.

Custom Easing Functions

I created two simple easing functions to demonstrate the process. If you come up with your own functions (that are more useful than these) comment here and let us know about them.

PowerOfSixEase

Here’s the code for a simple “Power of 6” ease. This uses the built-in math library and simply calls the Pow function on the normalized time.

class PowerOfSixEase : EasingFunctionBase
{
    protected override double EaseInCore(double normalizedTime)
    {
        return Math.Pow(normalizedTime, 6);
    }

    protected override System.Windows.Freezable CreateInstanceCore()
    {
        return new PowerOfSixEase();
    }
}

To use this in xaml, we first need to set up a namespace to refer to our local code.

xmlns:local="clr-namespace:CustomEasingDemo"

Then replace the ElasticEase with our own function

<EasingDoubleKeyFrame.EasingFunction>
    <local:PowerOfSixEase EasingMode=”EaseIn”/>
</EasingDoubleKeyFrame.EasingFunction>

When you run it, you see the block move smoothly to the right bottom, but with a delay while the numbers build up enough to actually move the block. Of course, we could simply have used the built-in PowerEase and supplied a parameter of 6, but that wouldn’t have demonstrated creating your own function.

RandomEase

Now let’s try something a little crazier. Why not return a random number? At the same time, let’s see how to add parameters to the easing function.

class RandomEase : EasingFunctionBase
{
    Random _random;

    public RandomEase() 
        : base()
    {
        _random = new Random();
    }

    private int _seed;
    public int Seed
    {
        get { return _seed; }
        set { _seed = value; _random = new Random(value); }
    }

    private int _randomness = 5;
    public int Randomness
    {
        get { return _randomness; }
        set { _randomness = value; }
    }
    

    protected override double EaseInCore(double normalizedTime)
    {
        return ((double)_random.Next(-10000, 10000) / 10000) * (double)_randomness/100 + normalizedTime;
    }

    protected override System.Windows.Freezable CreateInstanceCore()
    {
        return new RandomEase();
    }
}

We’ll use different easing function parameters for X and Y. The Seed parameter provides the seed to the random number generator. The Randomness parameter helps control how wild the jittering is. A low number like 1 just looks like choppy animation. After about 2-4, it jitters, and a number like 100 animates all over the map.

The Seed doesn’t do much other than demonstrate using a parameter (and let me work in some trivia-based numbers *)

<Storyboard x:Key="AnimateTarget">
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="X">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="202.0">
            <EasingDoubleKeyFrame.EasingFunction>
                <local:RandomEase EasingMode="EaseIn" Seed="3263827" Randomness="100"/>
            </EasingDoubleKeyFrame.EasingFunction>
        </EasingDoubleKeyFrame>
    </DoubleAnimationUsingKeyFrames>
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="Y">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="202.0">
            <EasingDoubleKeyFrame.EasingFunction>
                <local:RandomEase EasingMode="EaseIn" Seed="8675309" Randomness="5"/>
            </EasingDoubleKeyFrame.EasingFunction>
        </EasingDoubleKeyFrame>
    </DoubleAnimationUsingKeyFrames>
</Storyboard>

* 3263827 was the Novell Netware IPX address of the server for the first network I ever set up. Given the junk files that people put on that box, the number was fitting :)

That’s it for creating your own easing functions. As you can see, the hardest part is coming up with a formula that represents some interesting movement, and hasn’t already been included in the base class library. The plumbing code itself couldn’t get much simpler.

Source code and a video version of this example will be up on windowsclient.net soon. I’ll update this post with links at that time.

Windows 7 Bootcamp at PDC 09

Pete.Brown — Tue, 03 Nov 2009 17:35:28 GMT

There are still a few seats left for the FREE Windows 7 Developer Bootcamp the day before PDC09 officially starts.

If you are developing for Windows using C++, WPF, Windows Forms or Silverlight, this is a can’t-miss opportunity.

I’ve been playing with a number of the new Windows 7 APIs (especially the sensors and touch). There’s a ton of stuff in there that can be used in applications ranging from packaged products to your typical windows line-of-business application.

I’ll be there. Hope to see you there too :)

The Win7 Sensor and Location API Part 2: Accelerometer as a Joystick

Pete.Brown — Sun, 01 Nov 2009 23:29:24 GMT

This is part 2 of a series. If you don’t yet have the Freescale board configured and tested with Windows 7, please refer to Part 1.

Now that we have the Freescale board working, I thought it would be fun to play with the accelerometer. In this post, I’ll show how to use the accelerometer on the board as a traditional 4 or 8 position joystick.

API Choices

There are three different ways you can use the accelerometer API. You can, of course, go directly against the COM API and generate you own wrappers and pinvokes. You can use the managed wrappers provided in the SDK, or you can use the Windows API Code Pack which includes support for the sensor API and a number of other Windows 7-specific enhancements.

In this case, I decided to use the code pack in concert with WPF 4.

Solution Structure

I intend to use the joystick functionality in another project, so I am wrapping that into a separate project. I also added just the sensor project from the Windows API Code Pack. You have a few choices there, including compiling the whole code pack as a separate assembly and simply referencing it. I decided to include only the bare minimum of assemblies required to support the example.

PeteBrown.Accelerometer is the reusable Accelerometer joystick class lib. The “Sensors” project is the Windows API Code Pack sensors project. The “Core” project is the required Windows API Code Pack core project

Sample Code

One great thing about the Windows API Code Pack is it includes a ton of example code. It just so happens that the accelerometer code is included in that.

Application Code

Typically I’m a binding fiend. I like to set up notification in my classes and just let binding handle all the dirty work. In this case, though, I wanted to go with a model that would work better in apps that used a type of GameLoop and instead of responding to events or binding, simply polled all input devices on an interval of their own design. For that reason, I’m using simple properties in this class, am not implementing INotifyPropertyChanged, and did not chose to raise any events.

If you’re a game programmer, or have that type of background, this decision probably won’t surprise you at all.

AccelerometerJoystick Class

The core class is the AccelerometerJoystick class.

I snagged some of the code right out of the Accelerometer sample from the code pack. One of the methods I borrowed and then messed with a bit was the Initialize method (called HookUpAccelerometer in the sample code). I changed it to only report X and Y, and to use an inline lambda event handler to cut down on code.

public void Initialize()
{
    SensorList<Accelerometer3D> sl = SensorManager.GetSensorsByTypeId<Accelerometer3D>();

    if (sl.Count > 0)
    {
        Accelerometer3D accel = sl[0];
        accel.AutoUpdateDataReport = true;
        accel.DataReportChanged += (s, e) =>
            {
                _rawXValue = accel.CurrentAcceleration[AccelerationAxis.X];
                _rawYValue = accel.CurrentAcceleration[AccelerationAxis.Y];
            };
    }
}

The code finds the first accelerometer and then wires up the DataReportChanged event to catch changes in the X/Y values in the accelerometer. I don’t call Initialize from the constructor, as it may throw an exception. Instead, I have the using code call it explicitly. I may change that

I first tested by watching the raw values on a regular interval. The raw values are two simple properties on the same class:

private float _rawXValue;
public float RawXValue
{
    get { return _rawXValue; }
}

private float _rawYValue;
public float RawYValue
{
    get { return _rawYValue; }
}

Once I had the values set, and they made sense to me, I implemented properties to report the direction the accelerometer is pointing.

There were a couple different ways I could have gone here. I could have created a N, S, E, W enum, and had a single method that reported which direction the mouse was pointed. However, to support NW, NE, SW, SE, I’d have to add four more branches to that code and four more enum members.

I think it is more flexible to simply report true/false for each of the four cardinal directions, and let the calling code decide how to handle it from there. So, that’s the way I went.

public bool IsJoystickPointedNorth
{
    get { return RoundValue(_rawYValue) > 0; }
}

public bool IsJoystickPointedSouth
{
    get { return RoundValue(_rawYValue) < 0; }
}

public bool IsJoystickPointedWest
{
    get { return RoundValue(_rawXValue) < 0; }
}

public bool IsJoystickPointedEast
{
    get { return RoundValue(_rawXValue) > 0; }
}


private int RoundValue(float value)
{
    return (int)Math.Round((double)value, 0);

    // example making the joystick more sensitive
    // return Math.Abs(value) > 0.25 ? 1 * Math.Sign(value) : 0;
}

A note on rounding: If you want to change the sensitivity, which you probably will, change the RoundValue method so that instead of using Math.Round, it does a check to see if the ABS of the value is, say, greater than 0.25 and return 1. That way you can have the joystick be a bit more sensitive to movement. Similarly, you can change it to return 1 only if the ABS of the value is greater than 0.75 for less sensitivity. Try it out to see how you prefer it.

MainWindow.xaml

The main window is pretty simple. I have a space in the middle where I report the raw X/Y values, and then four rectangles which light up (red in this case) when the joystick is pointed in that direction.

<Window x:Class="WpfAccelerometerApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    
    <Window.Resources>
        <SolidColorBrush x:Key="ActiveDirectionBrush"
                         Color="Red" />
        <SolidColorBrush x:Key="InactiveDirectionBrush"
                         Color="Gray" />
    </Window.Resources>
    
    
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="*" />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
            <RowDefinition Height="*" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <Rectangle x:Name="North"
                   Grid.Row="0"
                   Grid.Column="1"
                   Margin="20"/>

        <Rectangle x:Name="South"
                   Grid.Row="2"
                   Grid.Column="1"
                   Margin="20" />

        <Rectangle x:Name="East"
                   Grid.Row="1"
                   Grid.Column="2"
                   Margin="20" />

        <Rectangle x:Name="West"
                   Grid.Row="1"
                   Grid.Column="0"
                   Margin="20" />
        
        <Grid Grid.Row="1" Grid.Column="1">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="2*" />
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="*" />
                <RowDefinition Height="*" />
            </Grid.RowDefinitions>

            <TextBlock Text="X"
                       Grid.Row="0"
                       Grid.Column="0" />

            <TextBlock Text="Y"
                       Grid.Row="1"
                       Grid.Column="0" />

            <TextBlock x:Name="xValue" 
                       Text="0"
                       Grid.Row="0"
                       Grid.Column="1" />

            <TextBlock x:Name="yValue" 
                       Text="0"
                       Grid.Row="1"
                       Grid.Column="1" />
        
        </Grid>
    </Grid>
</Window>

There’s nothing WPF-specific about this app other than the specific timer I use below, and the use of xaml in the window. If you code in Windows forms or another client technology, you should be able to port this pretty easily.

MainWindow.xaml.cs

Here’s the code-behind for the main window. First, I keep two private member variables, one for the joystick and one for the DispatcherTimer I use to poll the joystick (again, because I’m going with a gameloop-type approach rather than event-driven. In my other app, the joystick poll is actually one step in a big loop)

private AccelerometerJoystick _joystick = new AccelerometerJoystick();
private DispatcherTimer _timer = new DispatcherTimer();

The constructor simply does the usual initialization, and then wires up the loaded event. I tend to do significant work in Loaded events to avoid race conditions with controls not being ready yet, and to avoid exceptions in constructors. It’s not a bad habit to be in.

public MainWindow()
{
    InitializeComponent();

    Loaded += new RoutedEventHandler(MainWindow_Loaded);
}

The MainWindow_Loaded event handler is where I’m doing the dirty work. In here, I first initialize the joystick, then start the timer. The timer’s tick event is handled as an inline lanbda event handler. That handler polls the joystick, updates the display values and then sets the brush used by the rectangles based on whether or not the joystick reports that it is pointed in that direction.

void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
    _joystick.Initialize();


    _timer.Interval = TimeSpan.FromMilliseconds(PollingIntervalMilliseconds);
    _timer.Start();

    _timer.Tick += (s, ea) =>
        {
            // display position
            xValue.Text = _joystick.RawXValue.ToString();
            yValue.Text = _joystick.RawYValue.ToString();

            Brush ActiveBrush = (Brush)this.Resources["ActiveDirectionBrush"];
            Brush InactiveBrush = (Brush)this.Resources["InctiveDirectionBrush"];

            if (_joystick.IsJoystickPointedSouth)
                South.Fill = ActiveBrush;
            else
                South.Fill = InactiveBrush;

            if (_joystick.IsJoystickPointedWest)
                West.Fill = ActiveBrush;
            else
                West.Fill = InactiveBrush;

            if (_joystick.IsJoystickPointedNorth)
                North.Fill = ActiveBrush;
            else
                North.Fill = InactiveBrush;

            if (_joystick.IsJoystickPointedEast)
                East.Fill = ActiveBrush;
            else
                East.Fill = InactiveBrush;
        };
}

Runtime

At runtime, the directions light up as expected, and the raw X and Y values are displayed in the middle. Now to use this in a real application :)

The source code and a video walkthrough of this will be available on windowsclient.net soon. I’ll update this post with the link once that happens.

Showing Progress in the Windows 7 Taskbar with WPF 4 (and a short romp through Windows 7 cleartype settings)

Pete.Brown — Fri, 30 Oct 2009 03:25:10 GMT

Have you ever copied a large number of files, or downloaded something big using IE? If so, you’ve probably seen the taskbar download progress indicator. This is a green progress bar that fills the area behind the application icon in the taskbar.

You can achieve the same effect in Windows 7 using .NET 4, with very little code. Let’s run through how.

Project Setup

I created a simple WPF application in Visual Studio 2010. Nothing fancy, I kept the original MainWindow and simply worked with that. I named the project “Win7ProgressBar”.

Next I added an icon to the project. I have a C64 logo icon I created for my Silverlight C64 emulator handy, so I used that.

MainWindow

I resized the main window to be a little smaller, gave it the title “Long Task” and assigned the icon to it. The resulting opening tag looks like this:

<Window x:Class="Win7ProgressBar.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Long Task" Height="241" Width="432"
        Icon="/Win7ProgressBar;component/AppIcon032.png">

Next, I added a progress bar and a textblock to the window:

<Grid>
    <ProgressBar Height="23"
                 HorizontalAlignment="Left"
                 Margin="36,88,0,0"
                 Name="progressBar1"
                 VerticalAlignment="Top"
                 Width="334" />
    <TextBlock Height="23"
               HorizontalAlignment="Left"
               Margin="36,24,0,0"
               Name="textBlock1"
               Text="This is a really long-running task"
               VerticalAlignment="Top"
               Width="201" />
</Grid>

Here’s how the window looks in the VS2010 designer.

So far so good. I have a window and a progress bar, but no activity, and nothing that would as yet hook it up to the taskbar.

Taskbar wireup isn’t automatic; it’s something you need to opt into. You can do it in xaml, and you can do it in code. I used a mixture of both for this example. Since we still have the window xaml open, let’s put that in there now.

Right after the opening tag for the window, and before the opening grid tag, add in this snip:

<Window.TaskbarItemInfo>
    <TaskbarItemInfo />
</Window.TaskbarItemInfo>

That simply news up a TasbarItemInfo class for us. If you look at the TasbarItemInfo tag, you’ll see there’s quite a bit more you can do right from within xaml. But I always do everything in xaml, so let’s try some code instead :)

An aside on ClearType

The rather ugly font in the drop down is due to the settings on the monitor on which I took this shot (I have three displays). I need to readjust my cleartype settings for that display. If you have crappy-looking fonts in apps, you can simply go to Control Panel –> Fonts and then select the option to adjust the cleartype settings on your monitor.

Run through the wizard and answer the questions for which one looks best. You’re better off not thinking and simply acting. The more you think about the answer, the less accurate you’ll be. Go with your first impressions.

By way of comparison, here’s the same thing, only snapped from my primary monitor, with good cleartype settings:

Notice the massive difference in the drop-down list? If not, scroll back up and look again.

Now, most people won’t have to go through that wizard unless they get a drastically different display from what they started with. I needed to simply because I tested a special build of SL3 before it went live, and was specifically asked to look at the cleartype rendering. I played with the wizard and forgot to go back and fix it :)

Back to the TaskBar

Now that we have all the xaml in place, let’s take a look at the code. I’m going to simulate a long-running activity simply by throwing in a background worker and having it run a tight loop with a bunch of thread sleeps in there.

Wire up the loaded event handler for the window, and let the IDE help you wire up the events for DoWork, ProgressChanged, RunWorkerCompleted.

Next, be sure to set the worker.WorkerReportsProgress to true, and then call the RunWorkerAsync() method to kick off the process. The resulting load event looks like this:

void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
    BackgroundWorker worker = new BackgroundWorker();
    worker.DoWork += new DoWorkEventHandler(worker_DoWork);
    worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);
    worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
    worker.WorkerReportsProgress = true;
    worker.RunWorkerAsync();
}

Before we start reporting progress to the taskbar and the progress bar, let’s set the starting ProgressState for the taskbar. You can set this multiple times throughout the life of the process to control various states. Here’s what the states look like:

Normal (green progress bar)

Indeterminate (pulsing green wave)

Paused (yellow progress bar)

Error (red progress bar)

So, let’s start it off at Normal. You could do this in the loaded event or in the constructor, or at any point during the process. I initialized it in the constructor.

public MainWindow()
{
    InitializeComponent();

    TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Normal;

    Loaded += new RoutedEventHandler(MainWindow_Loaded);
}

Next, we need to handle reported background thread process status and use it to update both the progress bar in the window and the taskbar. That’s really simple to do. Note, however, that the TaskbarItemInfo.ProgressValue is a double between 0 and 1 while the progressBar value is an integer between two numbers supplied by you (typically 0 and 100), so we’ll need to adjust when we report progress.

void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressBar1.Value = e.ProgressPercentage;
    TaskbarItemInfo.ProgressValue = (double)e.ProgressPercentage/100;
}

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    progressBar1.Value = 100;
    TaskbarItemInfo.ProgressValue = 1.0;
}

Finally, we need our worker itself. This is where you’d be doing something real, and time-consuming. Instead, I’ll just do something really time-consuming :) It sleeps one second per iteration and then reports the current progress.

void worker_DoWork(object sender, DoWorkEventArgs e)
{
    for (int i = 0; i < 100; i += 10)
    {
        Thread.Sleep(1000);
        ((BackgroundWorker)sender).ReportProgress(i);
    }
}

Runtime

When you run the app, you’ll see both the window and the taskbar update.

That was really easy. There are other things you can do with TaskbarItemInfo, such as changing your thumbnail and adding overlay icons. We’ll look at those in an upcoming post.

A Word on Use

Be judicious with how you use progress reporting on Windows 7. You should only use it when the progress status will be meaningful to a user when running other applications. Consider the scenario of your app doing something that the user will typically alt-tab away from. If the app is doing something that the user will want to know when it has completed so they can take an action (like opening a downloaded zip) then the taskbar progress reporting will be good. If, however, you are doing something which will have other progress indicators (like playing a video, where it’s obvious when the video ends because the user can see/hear it) or which won’t have the user waiting with bated breath for it to finish, consider just using a regular old progress bar, preferably a non-modal one.

A video version of those, with source code, will be available on windowsclient.net I’ll update this post with a link once that is up.

The Win7 Sensor and Location API Part 1: Introduction and Freescale Board Setup and Testing

Pete.Brown — Thu, 29 Oct 2009 07:16:20 GMT

I’ve always been interested in ways that your PC can reach outside itself and interact with things in the world. That’s what fueled my interest in CNC, as well as things like Lego robotics, and the new sensor and location API.

When I was in Redmond for my first week, I sought out Gavin Gear and Dino Natucci, and chatted about the Sensors and Location platform. I saw some really cool stuff there, some of which I can talk about :)

Gavin also hooked me up with a couple Freescale sensor boards. If you don’t yet have one, they are available for order for a pretty reasonable price. As Windows 7 is still new (at the time of this writing, it has only been released for six days), you won’t find too many sensors out there yet, but this board and the API will allow you to try things out in the meantime. The location API has some companies on board and producing product already. I’ll cover that in a future post.

Sensor and Location Platform

The Windows 7 Sensor and Location platform is something completely new to Windows. It’s a framework helps eliminate the old com (or *gasp* parallel) port programming model that we’ve used for communicating with sensors in the past. It provides standards for drivers as well as a set of APIs for Sensor and Location (specialized and common sensors), and a control panel app to handle access to the sensors.

(image source MSDN)

The Sensor and Location APIs are COM-based APIs usable from native code, scripting languages, and anything which can talk COM. To use them from .NET code, you’ll want to use the friendly interop classes which we’ll cover in a future post.

Install the SDK

Install the Sensor Developer Kit for Windows 7. I simply unpacked the zip into a subfolder of Program Files on my machine.

Install the Sensor Diagnostic Tool. The tool comes in Visual Studio project source format, so I put that in my projects folder. It converted for use with VS2010 just fine.

We’ll cover .NET programming APIs in the next post on this topic.

Don’t have the board, get the Virtual Light Sensor from the Windows SDK.

Install the Drivers

Once you have the SDK downloaded and unpacked somewhere on your machine, open the folder and find SensorKitDriverInstaller.exe

Run that installer, following the directions to connect the board to the computer. Then turn the board on. You should get the two flashing lights. If you do not, you may need to update the firmware.

Configure and Test the Board

For the examples below, I’m using the 32 bit version of Windows 7. The Sensor DK includes drivers for both 32 and 64 bit versions of Windows 7.

Connect the Board

With the board switched “off” connect it to a USB port on your PC. I have a mini-usb plug always connected that I use for my camera, gps, phone, and now this board. I love standard connections. That said, the board will be easier to control if you pick a really cheap USB cable with thin wire and no ferrite toroid.

Update the Firmware

I did not need to update the firmware on the Rev D board I received, it may have been updated in a past life. If you do need to, the directions are included in the README in the SDK. It’s pretty much just a file copy like you would do with any USB stick.

Enable the Board

It took me a couple times before I remembered I had to do this. In control panel, you’ll see the applet for Location and Sensors. You want the “Enable location and other sensors” item

You can also control security on a per-user basis using that applet, but we’ll skip that for this.

Test the Board

Once you go through those steps, you’ll want to test the board to make sure everything is working. The compiled version and C++ source code for the test application are included in the SDK. The read-to-run binaries are in Tools\DiagnosticTool\Binaries

That’s fun for about 2 minutes, about the amount of time it takes you to verify that everything is working. Let’s really test it with something more interesting.

Testing the Board Take 2

Let’s test using Xna.

You’ll need:

Microsoft XNA Game Studio 3.0 (I haven’t tried with 3.1. If you do, comment below and let me know if it works for you)
Microsoft XNA Racing Game Starter kit (you’ll want the RacingGameWindows-3.0.msi file)
Windows 7 Sensors XNA Racing Game

Once you install the first two, go into VS2008 (the templates don’t install under 2010 unless you manually move them) and create a new XNA racing game starter kit project

Inside the racing game zip file from msdn, you’ll see a Word document with instructions on how to modify the racing game starter kit project for use with the sensor API. You’ll be replacing a few files and recompiling the sample.

Now run it and try out the accelerometer!

So…..

Nothing happened, right? Well, the sky responded to the light sensor, but the accelerometer did pretty much nothing.

I ran into the same problem. Luckily, I found a person who had blazed this trail before me: Pietro Brambati. He had a few tweaks to the source code to make the accelerometer work. Scroll down to section 4 (XNA) and you’ll see some code you’ll need to add. FWIW, he also has a great write-up on the rest of the board install process. I encourage you to check it out.

Changes to the Source to Support Motion

Add to CarPhysics.cs Update() method

if (Input.IsAccelerometerConnected)
{
    rotationChange -= effectiveSensitivity * 
        (Input.AccelerometerAxisX_Force / 3.0f) * 
        MaxRotationPerSec * moveFactor;
}

Then to the same method, down in the “Handle Speed” section add

else if (Input.IsAccelerometerConnected)
{
    if (Input.AccelerometerAxisY_Force > 0)
        newAccelerationForce += maxAccelerationPerSec;
    else
        newAccelerationForce -= maxAccelerationPerSec;
}

Finally, in the Graphics\BaseGame class add this code right below Sound.Initialize();

Input.Initialize();

Run the App

NOW run it, and it should behave as you would expect.

From the video I recorded (link to be posted shortly) you’ll see I am a horrible driver. I’m thinking I should stick to Pole Position on the C64 :)

Uses for Sensors

Just considering the sensors available on the Freescale board, I can think of a few ways you could use them in your own applications or hardware:

Adjust application theme (contrast, colors, font size) based on ambient light. For example, if you’re out in the full sun, you may want to bump up the UI size and increase the contrast. This would be great for field applications, especially on tablets. In fact, here’s a great whitepaper on that very topic.
Accelerometer based games: use your whole laptop/notebook/tablet as a controller, or have an external device you hold, like the video I did along with this posting.
A friend of mine in DPE suggested controlling music based on the light level in the room. (Presumably if the lights go out, it’s Barry White time <g>)
I’d be curious to see if you could hang this on your car dash and get larger-scale acceleration readings. Worth trying out, but probably don’t want to tell your SO about this one.
Accelerometers are crucial in laptops that still use the soon-to-be-outdated spinning platter form or storage. If you can park the heads before the crunch, your data will have a better chance of staying safe.
Of course, environmental sensors (temperature, , pressure, humidity, etc.) have a ton of uses from IT to museums to portable weather stations.

I’ll have the video walkthrough of this and the test apps up shortly. For grins, here’s the setup I used to record the board:

Dig that high-tech camera stand :)

The XNA game I recorded with a Canon HD camera on a tripod to my right.

Easing Functions in WPF 4 (and Silverlight)

Pete.Brown — Tue, 27 Oct 2009 17:02:39 GMT

One of my favorite design features added to WPF 4 is the ability to use easing functions with animation.

Easing functions provide a way to liven up what would otherwise be pretty flat and boring animation. They provide acceleration/deceleration, and even bounce or spring to the approach into or departure from a key frame in an animation.

Let’s take a look at how to use easing functions with storyboards in your WPF 4 projects. We’re going to do everything from xaml here so you get a taste of what is happening under the covers when you work in a tool like Expression Blend.

Basic Animation

In Visual Studio 2010, create a new Windows Application – WPF. Open up the MainWindow.xaml and add a rectangle sized 20x20 to the grid.

To the rectangle, add a single ScaleTransform named “Transform”

Then add a button somewhere on the same grid and name it “StartAnimation”. Wire up an event handler for the Click event. The xaml in your window should look something like this:

<Grid>
    <Rectangle Height="20"
               Width="20"
               RenderTransformOrigin="0.5,0.5"
               Fill="BlueViolet">
        <Rectangle.RenderTransform>
            <ScaleTransform x:Name="Transform" />
        </Rectangle.RenderTransform>
    </Rectangle>

    <Button x:Name="StartAnimation"
            Click="StartAnimation_Click"
            Content="Start"
            HorizontalAlignment="Center"
            VerticalAlignment="Bottom"
            Margin="5" />
</Grid>

The key items in there are the ScaleTransform named “Transform” and the button to start the animation.

You should end with a window that looks something like this:

I sized my window to 800x600 in order to better support other types of transforms. Your window will be smaller if you stayed with the defaults.

Create the Storyboard

Next, we’ll add the storyboard that will contain the animation, as well as the shells of the two animations we’ll be using.

In your Window, add a Window.Resources section and add a single storyboard named “AnimateTarget”. That storyboard will have two DoubleAnimationUsingKeyFrames animations: one will target the ScaleX property of the Transform, and the other will target ScaleY.

<Window.Resources>
    <Storyboard x:Key="AnimateTarget">
        <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                       Storyboard.TargetProperty="ScaleX">
            <!-- We'll add key frames here -->
        </DoubleAnimationUsingKeyFrames>
        <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                       Storyboard.TargetProperty="ScaleY">
            <!-- We'll add key frames here -->
        </DoubleAnimationUsingKeyFrames>
    </Storyboard>
</Window.Resources>

Wire Up the Event Handler

Before we add the keyframes, crack open the codebehind and find the StartAnimation_Click event handler. If that isn’t present, check your button’s xaml and make sure you specified the Click event handler and allowed Visual Studio to create it for you. If not, just wipe out the Click=”…” bit and recreate it. Optionally, you could wire up the event handler in the constructor of the window.

Once you have the event handler wired up, we’ll put in a single line of code which will start the animation.

private void StartAnimation_Click(object sender, RoutedEventArgs e)
{
    ((Storyboard)this.Resources["AnimateTarget"]).Begin();
}

There are multiple ways to handle that ranging from behaviors to commands to the approach we took here. Use whatever you are comfortable with.

Add Key Frames

Without key frames, the animation doesn’t yet do anything useful. A key frame is a specified value at a specified point in time. The animation system will interpolate all the other frames in between the key frames you provide. Typically, this is done in a linear fashion, as we’ll see when we first run this.

Next we’ll add the key frames to our two animations. We’ll use EasingDoubleKeyFrames, but won’t put the easing functions in just yet. The animation will take the size of our shape and scale it from 0 to 2x its size on both the X and Y axes.

<Storyboard x:Key="AnimateTarget">
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="ScaleX">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="2.0" />
    </DoubleAnimationUsingKeyFrames>
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="ScaleY">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="2.0" />
    </DoubleAnimationUsingKeyFrames>
</Storyboard>

Test the Animation

Save the project and run it. You’ll see the shape expand as though it is flying towards you. The animation is linear, though. That is, the frames are interpolated using a constant ratio of value vs. time. The end result is something which looks very computer-generated, and not at all interesting.

Making the Animation Pop - Easing

We’ll start with one of the more dramatic easing functions: the ElasticEase. The elastic easing function interpolates the value over time using a formula that simulates elastic motion. That is, the element in this case, appears to be suspended from a rubber band.

<Storyboard x:Key="AnimateTarget">
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="ScaleX">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="2.0">
            <EasingDoubleKeyFrame.EasingFunction>
                <ElasticEase EasingMode="EaseOut" />
            </EasingDoubleKeyFrame.EasingFunction>
        </EasingDoubleKeyFrame>
    </DoubleAnimationUsingKeyFrames>
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="ScaleY">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="2.0">
            <EasingDoubleKeyFrame.EasingFunction>
                <ElasticEase EasingMode="EaseOut" />
            </EasingDoubleKeyFrame.EasingFunction>
        </EasingDoubleKeyFrame>
    </DoubleAnimationUsingKeyFrames>
</Storyboard>

Note that I applied the easing function only to the final keyframe in both animations, and I used the EaseOut parameter. If you change EaseOut to EaseIn, you’ll see the elastic action happen at the start of the animation instead of the end. It will appear to hesitate to get going. The result, in this case, is pretty unnatural, but the elastic ease is one of the easiest to use to identify what happens in EaseIn vs. EaseOut. Note also that you can use EaseInOut which will perform the easing both at the start and the end.

(Image source: MSDN)

Controlling the Easing

The ElasticEase function takes a few parameters, you can set the springiness, as well as the number of oscillations. For a crazy effect, set the Oscillations parameter high.

<ElasticEase EasingMode="EaseOut"
             Oscillations="25" />

I don’t recommend using values like that in your own apps, though, or you’ll have legions of end-users and interactive designers marching up your driveway with pitchforks and torches.

Another parameter this particular easing function recognizes is Springiness. The higher this value, the stronger the spring/eslastic and therefore the less dramatic the bounce. Low values, like 1, give you a really weak spring that bounces all over. High values like 8 result in a super-stiff spring. The default value is 3.

<Storyboard x:Key="AnimateTarget">
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="ScaleX">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="2.0">
            <EasingDoubleKeyFrame.EasingFunction>
                <ElasticEase EasingMode="EaseOut"
                             Oscillations="3"
                             Springiness="8" />
            </EasingDoubleKeyFrame.EasingFunction>
        </EasingDoubleKeyFrame>
    </DoubleAnimationUsingKeyFrames>
    <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                   Storyboard.TargetProperty="ScaleY">
        <EasingDoubleKeyFrame KeyTime="0:0:0"
                              Value="0.0" />
        <EasingDoubleKeyFrame KeyTime="0:0:3"
                              Value="2.0">
            <EasingDoubleKeyFrame.EasingFunction>
                <ElasticEase EasingMode="EaseOut"
                             Oscillations="3"
                             Springiness="8" />
            </EasingDoubleKeyFrame.EasingFunction>
        </EasingDoubleKeyFrame>
    </DoubleAnimationUsingKeyFrames>
</Storyboard>

Animating other Transforms

If you want to animate something other than a ScaleTransform, like a TranslateTransform (affects location/movement) simply swap out the transform in the Rectangle.RenderTransform section, add your own in, and then change the Storyboard.TargetProperty to affect the appropriate value, and the Value in the key frame to reflect something more appropriate.

Here’s an example using a TranslateTransform. It animates the position from the middle of the window to the bottom right:

<Window.Resources>
    <Storyboard x:Key="AnimateTarget">
        <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                       Storyboard.TargetProperty="X">
            <EasingDoubleKeyFrame KeyTime="0:0:0"
                                  Value="0.0" />
            <EasingDoubleKeyFrame KeyTime="0:0:3"
                                  Value="202.0">
                <EasingDoubleKeyFrame.EasingFunction>
                    <ElasticEase EasingMode="EaseOut"
                                 Oscillations="3"
                                 Springiness="8" />
                </EasingDoubleKeyFrame.EasingFunction>
            </EasingDoubleKeyFrame>
        </DoubleAnimationUsingKeyFrames>
        <DoubleAnimationUsingKeyFrames Storyboard.TargetName="Transform"
                                       Storyboard.TargetProperty="Y">
            <EasingDoubleKeyFrame KeyTime="0:0:0"
                                  Value="0.0" />
            <EasingDoubleKeyFrame KeyTime="0:0:3"
                                  Value="202.0">
                <EasingDoubleKeyFrame.EasingFunction>
                    <ElasticEase EasingMode="EaseOut"
                                 Oscillations="3"
                                 Springiness="8" />
                </EasingDoubleKeyFrame.EasingFunction>
            </EasingDoubleKeyFrame>
        </DoubleAnimationUsingKeyFrames>
    </Storyboard>
</Window.Resources>

<Grid>
    <Rectangle Height="20"
               Width="20"
               RenderTransformOrigin="0.5,0.5"
               Fill="BlueViolet">
        <Rectangle.RenderTransform>
            <TranslateTransform x:Name="Transform" />
        </Rectangle.RenderTransform>
    </Rectangle>

    <Button x:Name="StartAnimation"
            Click="StartAnimation_Click"
            Content="Start"
            HorizontalAlignment="Center"
            VerticalAlignment="Bottom"
            Margin="5" />
</Grid>

For More Information

I’ll have a video version of this post, with full source code, available on windowsclient.net soon.

Both WPF 4 and Silverlight include a number of easing functions you may use in your animations. The best way to understand them is to use the interactive Silverlight Easing Functions Explorer. The functions are the same as those available in WPF 4.

You can also create your own easing functions - a topic I’ll cover in another post.

Introducing the WPF 4 Calendar control

Pete.Brown — Mon, 26 Oct 2009 04:17:56 GMT

WPF 4 now includes, in the core runtime libraries, the calendar control. This control previously existed only in the WPF Toolkit, but has been promoted in the latest WPF release. Inclusion in the core runtime library makes it easier to develop with as there is no additional namespace declaration or reference required.

The Calendar control is located in the System.Windows.Controls namespace in the PresentationFramework DLL.

Let’s start with the key properties and then move on to a couple common tasks such as scaling and binding.

Key Properties

Note that all date properties use the DateTime Xaml Syntax for parsing. Not also that unless noted, the control is shown with FlowDirection set to LeftToRight and FirstDateOfWeek set to Sunday. Both may be overridden if desired.

DisplayDate, SelectedDate and SelectedDates

When the control is first displayed, a date is shown highlighted – the DisplayDate. By default, that date is Today’s date. But you may change it to whatever date you would like.

Use the SelectedDate scalar property when the calendar is in SingleDate selection mode. Use the SelectedDates collection property when the calendar is in any of the multi-select modes.

The DisplayDate is shown on the right, the SelectedDate is shown on the left

<Grid>
    <Calendar x:Name="CalendarControl"
              HorizontalAlignment="Center"
              VerticalAlignment="Center"
              
              SelectionMode="MultipleRange"
              DisplayMode="Month">
    </Calendar>

    <TextBlock Text="{Binding SelectedDate, ElementName=CalendarControl}"
               VerticalAlignment="Bottom"
               HorizontalAlignment="Left" />

    <TextBlock Text="{Binding DisplayDate, ElementName=CalendarControl}"
               VerticalAlignment="Bottom"
               HorizontalAlignment="Right" />
</Grid>

The above example also shows simple element binding using the SelectedDate (and DisplayDate) properties

DisplayMode

The DisplayMode property sets the calendar to display in one of three different modes: Decade, which shows the current decade and the year before and after, for three years total, Year which displays the months of the current year, and Month which displays the usual tabular calendar view of days in the month. At runtime, broader display modes drill-down into more specific display modes as described below.

Not that in all modes, Control + Up Arrow will drill back up the DisplayMode and Control + Down Arrow will drill down into the next mode. For example, if in Year Mode, Control + Up will show Decade and Control + Down will show Month.

Decade

In decade mode, clicking on a year will drill down into Year display mode, and will not affect SelectedDate.

In decade mode, the arrow key changes the year of the DisplayDate, the Home key changes the DisplayDate to the first year of the decade, and the End key changes the DisplayDate to the last year of the decade. The spacebear drills into the selected year. In all cases, the SelectedDate is not changed.

Year

In year mode, clicking on a month will drill down into Month display mode, and will not affect SelectedDate

In year mode, the arrow key changes the month of the DisplayDate, the Home key changes the DisplayDate to the first month of the year, and the End key changes the DisplayDate to the last month of the year. The spacebar drills into the selected month. In all cases, the SelectedDate is not changed.

Month

In month mode, clicking on a day sets the SelectedDate, or SelectedDates depending on the value for the SelectionMode property.

In month mode, the arrow key changes the SelectedDate property, Shift+Arrow will add/select an adjacent day if the SelectionMode allows multi-select. Home changes the selected date to the first day of the month, and End changes it to the last.

SelectionMode

Selection mode controls the selection behavior for the dates in the Month mode of the calendar.

None

The calendar is effectively read-only. No dates may be selected. Clicking on a date changes the focus, but does not change the SelectedDate

SingleDate

Allows selection of a single date. This is the default mode. Clicking on a date selects the date.

SingleRange

Allows selection of a single contiguous range of dates. Click on the start date, then shift-click on the end date.

SelectedDate controls the first selected date, SelectedDates contains the full set of selected dates.

MultipleRange

Allows selection of multiple non-contiguous dates or ranges of dates. Click on one date, shift-click to set a range if desired, then control-click on other dates to add them.

SelectedDate contains the first date selected (not necessarily the oldest date, just the first one selected), SelectedDates contains the full set of selected dates.

DisplayDateStart / DisplayDateEnd

If you wish to limit the date range that may be picked using the control, set the bounds using the DisplayDateStart and End properties. Those set a date window out of which the user may not navigate using the UI.

BlackoutDates

Another way to restrict date selection is to use the BlackoutDates property. This property allows you to mark specific date ranges as non-selectable in the UI. In the default control template, this is represented by an X over the date.

<Calendar x:Name="CalendarControl"
          HorizontalAlignment="Center"
          VerticalAlignment="Center"
          DisplayMode="Month">
    <Calendar.BlackoutDates>
        <CalendarDateRange Start="10/4/2009"
                           End="10/15/2009" />
        <CalendarDateRange Start="10/23/2009"
                           End="10/28/2009" />
    </Calendar.BlackoutDates>
</Calendar>

When the user clicks on a blackout date, the SelectedDate property is not changed.

FlowDirection

Like most other control, the Calendar control respects the FlowDirection property in order to support right-to-left or left-to-right text directions. Below is an example of the control with FlowDirection set to RightToLeft

Scaling the Control

The Calendar control includes no built-in scaling. If you set the size of the control, or put it in a grid, it will clip but it will not expand. To visually resize, you’ll need to scale it using a ScaleTransform or by putting the control into a ViewBox.

Scaling with a ScaleTransform

The Calendar control scales like any other WPF control, using a simple ScaleTransform.

<Calendar x:Name="CalendarControl" 
          HorizontalAlignment="Left" 
          VerticalAlignment="Top"
          DisplayMode="Month">
    <Calendar.RenderTransform>
        <ScaleTransform ScaleX="1.5"
                        ScaleY="1.5" />
    </Calendar.RenderTransform>
</Calendar>

The result looks like this:

Scaling with a ViewBox

A viewbox is simply a convenient way to abstract a ScaleTransform. It handles automatic centering and bounds checking for you, as well as dynamic resizing, so it’s a good way to handle scaling.

<Viewbox>
    <Calendar x:Name="CalendarControl"
              HorizontalAlignment="Left"
              VerticalAlignment="Top"
              DisplayMode="Month">
    </Calendar>
</Viewbox>

Binding to SelectedDate

When working in WPF and Silverlight, I write my code and structure my applications using variations on the ViewModel (or MVVM) pattern. I’ll use a very simple form of that pattern here to show how to bind to the SelectedDate property of the control.

First, add a folder named ViewModels and then an appropriately named ViewModel class in that folder. I typically name the VMs after their screen, so in this case it is simply MainWindowViewModel.

The ViewModel code itself is pretty simple. We have a class that implement INotifyPropertyChanged in order to inform the binding system that a value has changed, then we have a public property as our binding source.

class MainWindowViewModel : INotifyPropertyChanged
{
    private DateTime _dateOfBirth;
    public DateTime DateOfBirth
    {
        get { return _dateOfBirth; }
        set { _dateOfBirth = value; NotifyPropertyChanged("DateOfBirth"); }
    }

    public event PropertyChangedEventHandler  PropertyChanged;
    protected void NotifyPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }

}

The property changed event handler allows us to set the property value from code or from other controls and still ensure that all bound targets know the value changed.

Next we need to set the ViewModel as the datacontext for our window. You can do this a number of ways including newing up the VM in the code-behind and setting the DataContext there, or using dependency injection to create the relationship between the two. In this case, I’m going to set it right in the xaml as a resource. To do that, I need to add a namespace and a resource to the xaml

<Window x:Class="WpfApplication6.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:viewModels="clr-namespace:WpfApplication6.ViewModels"
        Title="Calendar Control Demo" Height="300" Width="425">
    <Window.Resources>
        <viewModels:MainWindowViewModel x:Key="vm" />
    </Window.Resources>

You can see the viewModel namespace declaration tied to the window class, and the reference to the viewmodel itself right inside the Window.Resources section.

Next, I set the Grid’s DataContext property to be the static resource

<Grid DataContext="{StaticResource vm}">

Finally, set the SelectedDate property of the calendar to bind to the DateOfBirth property of the view model.

<Calendar x:Name="CalendarControl"
          HorizontalAlignment="Center"
          VerticalAlignment="Center"
          SelectedDate="{Binding DateOfBirth}"
          DisplayMode="Month">
</Calendar>

If you now run the application and set a breakpoint on the property setter for DateOfBirth in the ViewModel, you’ll see the binding in action.

Working with SelectedDates

The SelectedDates property is a little trickier. Rather than a simple scalar property like SelectedDate, this is a read-only property that returns a collection which may be modified, but not bound to.

If you working from code-behind and using the control as the source of record for the data, then it is pretty easy. If you’re using a pattern like the VM pattern, you’ll need to have an adapter that sits between the control and the viewmodel and updates each end with the other changes. Essentially, your own custom mini binding system.

If you use the ViewModel/MVVM pattern and have a different or better approach to handling the binding, please share.

For more information, please visit www.windowsclient.net . I’ll have a video version of this article up there soon.

Samson C01U microphone and Windows 7 (and Vista)

Pete.Brown — Sun, 25 Oct 2009 04:28:32 GMT

Today I picked up a Samson C01U mic so that I can have better audio in my WindowsClient.net videos than I had in some previous screencasts. The mic is the same one that Scott Hanselman has used when recording podcasts from his setup.

I spent the better part of the afternoon messing around with the mic, trying to get something with usable audio. The gain just seemed way too low, barely registering one bar in the Windows 7 audio device setup dialog.

I made sure to crank up the gain in that dialog (it’s set really low by default). but that made only marginal difference.

I tried it on my netbook to check levels (which seemed slightly higher there, but still not usable) I even tried switching it around between different USB ports on my PC in case power was an issue. I tried it both on-board and in an external powered USB hub. The tip for that came from Bill Reiss in the Camtasia forums here (excerpted below, emphasis mine).

I had an issue with the Samson C01U microphone levels on Windows 7 (Vista should be very similar), the microphone was very quiet. It turns out that it was the USB port I was plugging it into, it must not provide enough power. I switched to another USB port on the other side of the laptop and it was fine.
If you try switching to another USB port and this doesn't help, you may want to consider a USB hub that has external AC power.
Hope this helps, I didn't find any advice like this online and was about to give up on this microphone before I figured it out. Now I'm very happy with it.

So, before I completely gave up on what I was sure would be a good mic, I decided to try some other ports. My external powered hub has two ports sticking out of the top which look like they might be special. I tried one of those and bam! I suddenly had sound levels in the red. I guess those two are the only ones getting additional juice.

Condenser mics need external power because they rely on voltage changes in a capacitor to capture sound. This makes them more sensitive than other types of mics, but also means they need power where others do not.

In Windows XP you can use the special pre-amp software to work around this, but I imagine the USB power issue remains simply masked.

It appears that not all USB power is created equal. Now the mic sounds great.

Welcome Windows 7 – See you at PDC09

Pete.Brown — Thu, 22 Oct 2009 17:13:19 GMT

I couldn’t have picked a more exciting time to join Microsoft. .NET 4 Beta 2 and the first version of Visual Studio to use WPF were both just released, MSDN has been relaunched with a better theme and content, and today, Windows 7 officially hit the stores.

Windows 7 is, to me, the most exciting release of Windows since Windows 95. While I’m one of those folks who never ran into any real issues on Vista, I can’t help but appreciate all the speed and usability enhancements, as well as the general crispness of our new OS. It’s products like these that make me proud to work at Microsoft.

Congratulations to the teams that made Windows 7 and .NET 4 possible.

Upcoming Videos and Tutorials

On the run up to PDC, I’ll be putting out some blog posts on new fun and useful things for developers on Windows 7 and .NET 4. Blog posts will be here, and videos will be on WindowsClient.net. Stay tuned and subscribe to my blog here and follow me on twitter for the announcements.

Free Windows 7 Developer Bootcamp at PDC

One way to get really jumpstart your Windows 7 development is to attend the free developer bootcamp at this year’s PDC. The bootcamp is the day before the PDC and is free. Space is limited, so be sure to sign up. I’m especially excited about the shell integration and the sensor and location API.

You can find more details on the bootcamp in both Tim Sneath’s post and Jaime Rodriguez’s post. That’s a serious amount of free there. If you’re going to the PDC or are just in the area, it would be crazy to pass it up.

Speaking of PDC, if you’re attending, check out the track of Windows 7 sessions. There’s a ton of great content in there, and since it’s the PDC, you know it’s going to be both high quality and technically deep.

Show me your App at PDC

I’ll be at the PDC this year with an HD video camera. I’m interesting in interviewing you and seeing your Windows applications (WPF, Windows forms, C++) in action. It doesn’t need to use the latest or greatest version of our tools, it just needs to be an app you’re proud of.

If you have something to show that you or your team wrote, bring it with you and email me at Pete.Brown /AT\ Microsoft.com so I can meet up and talk to you about it. Nothing super fancy, just 10-15 minutes of you and me talking about something you think is cool. Email me sooner rather than later to make sure we reserve a slot.

Kindle App for Windows

If you’re a fan of ebooks, but haven’t yet sprung for a Kindle, be sure to sign up for the Kindle for PC beta. This will allow you to read Kindle books on your Windows PC. Of course, with touch, font rendering enhancements, and all the other improvements in 7, the PC finally becomes a viable ebook reading platform that both looks and feels natural.

Feed Me

Oh, and if you’re in Japan, be sure to snag one of the Windows 7 Whoppers (preferably follows by 777 minutes on a treadmill <g>)

And while you’re on that treadmill, revisit Tim Sneath’s Windows 7 Secrets blog post from January to bone up on shortcuts and lots of hidden gems in Win7. Keep in mind it was written on an early rev of Win7, but many/most still apply.

My new netbook er.. notebook er.. computer

Pete.Brown — Tue, 06 Oct 2009 04:42:33 GMT

My old laptop had to be returned to my employee when I left my job at the end of September. That left me with no computer to carry around, and with my Microsoft NEO coming up the week of the 12th, that just wasn’t going to do.

I needed something decent, but cheap; Something I could lug around the airport without any trouble, and open on the cramped plane. I’m a big guy, so big laptops on tray tables end up sitting on my chest like a bib – not very useful. I also wanted something that would still have utility or novelty once I got my new work notebook.

My budget was $500 or under. The typical netbook (Intel Atom, 1gig RAM, 160gb drive, Windows XP) go for between $299 and $399 depend on features. They also have 1024x600 resolution.

The machine I ended up getting is the Acer Aspire 1410 in sapphire blue. Cost was $429 on sale at Micro Center up in Rockville, MD.

Acer classifies the machine as a notebook, but the store had it on display with all the netbooks. The size is only about 1” wider than typical netbooks, and much smaller than all the laptops in the room. It seems to occupy some fuzzy space between true netbooks and full service laptops.

Here’s a review I found: http://www.liliputing.com/2009/09/acer-aspire-1410-review.html

I’ll be trying this out over the next week, and posting any interesting findings on Twitter. My first task is to pave over vista with Win7, and install Office 2010. I can’t wait to try out the multi-touch trackpad with Win7.

Here’s a shot of it, on my (obviously dusty) desk, with my mouse and trusty seltzer water for comparison. (As an aside, interesting how the flash makes my primary display look pink)

Below are the specs. You tell me if you would consider this a netbook or a notebook, or neither.

CPU	Intel® Core™2 Solo Processor SU3500 (3MB L2 cache, 1.40GHz, 800MHz FSB)
Chipset	Mobile Intel® GS45 Express
VGA	Intel GMA 4500HHD up to 732 MB DVMT
LCD	11.6” HD LED LCD
Memory	2GB (2GB installed in one of two memory slots) DDR2 667 SDRAM User upgradeable up to 4GB (one 2GB memory card in each slot) subject to availability of 2GB cards
Storage	250GB HDD 5-in-1 card reader supports optional MultiMediaCard™, Secure Digital card, Memory Stick®, Memory Stick PRO™ or xD-Picture Card™ Optional external USB 1.44MB* floppy drive No optical drives
Bluetooth	yes
Ports	DC-in RJ-45 LAN VGA Headphones/speakers/line-out with SPDIF support Microphone HDMI™ (High-Definition Multimedia Interface™) with HDCP (high-bandwidth digital-content protection) Three USB 2.0
Audio	Integrated microphone Microsoft® DirectSound® compatibility Optimized second-generation Dolby® Sound Room audio enhancement Headphones/speaker/line-out with SPDIF support and microphone ports
OS	Windows Vista Home Premium (Micro Center offers free Win7 upgrade)
Video	Acer® CineCrystal 11.6" WXGA (1366 x 768) high-brightness (200-nit) TFT display with 16:9 aspect ratio and LED backlight Up to 16.7 million colors Integrated Intel® Graphics Media Accelerator 4500MHD Microsoft® DirectX® 10.0 support MPEG-2 DVD, WMV9/VC-1 (Windows® Media Video 9, VC-1 standard), H.264/AVC decoding VGA and HDMI™ (High-Definition Multimedia Interface™) with HDCP (high-bandwidth digital-content protection) support ports Support for simultaneous display on notebook LCD and external monitor
Communications	Intel® Wireless WiFi Link network connection supporting 802.11a/b/g/Draft-N wireless LAN, Acer® SignalUp technology for enhanced antenna efficiency, WI-FI CERTIFIED™ Gigabit LAN, Wake-on-LAN ready Acer® Video Conference with integrated Acer® Crystal Eye webcam supporting Acer® PrimaLite technology, which consists of a premium sensor, firmware and lenses to provide superior video performance under low-light conditions
UI	84-key full-size Acer® FineTip keyboard, inverted T cursor layout, embedded numeric keypad, hotkey controls, international language support 10 function, four cursor, two Microsoft® Windows® keys Multi-gesture touchpad supporting circular-motion scrolling, pinch-action zoom, page flip
Dimensions and Weight	11.2" (285.0mm) W x 8.0" (204.0mm) D x 0.9" – 1.2” (22.1mm – 30.0mm) H 3.1 lb. (1.4kg) Size and weight may vary depending on configuration
Power	30-watt AC adapter Six-cell lithium ion battery: up to 6.0 hours life depending on configuration and usage (may be reduced if Windows Vista® Aero is enabled)

Now with more forehead! (or, a happy shade of blue)

Pete.Brown — Sat, 19 Sep 2009 05:01:00 GMT

Over the past 13 1/2 years, I’ve had the pleasure of working with some really talented developers, architects and designers in what I and many others consider to be one of the very best .NET consulting companies on the east coast: Applied Information Sciences (AIS).

AIS hired me right out of college and moved me down to Maryland from New England back in 1996. During my interview, due to the thick central Massachusetts accent I had at the time, I was asked if I spoke any other languages besides Massachusetts :) The majority of my early projects were VB 4/5/6 applications that did the usual mix of forms over data combined with automating Word/Excel and the like. Way back, I architected a fairly large VB6 application that relied on Microsoft Transaction Server (later COM+) to handle middle tier components. Later on, I did more work in VB, and then in .NET with Windows Forms (VB and C#, several projects), a little ASP.NET and then several years of Silverlight. Prior to joining AIS, I was doing dBase/Foxpro, Borland C++, Delphi 1.0, PowerBuilder 3, and VB3 work for a medical billing company. (oh, and that company way back made me buy all my own (expensive) tools; they said programmers should be like carpenters. heh)

AIS has been great to me, and in return, I’ve done lots of things there that I am very proud of. I’ve managed projects with as many as 11 AIS direct reports (and twice that in client staff semi-reporting to me), architected solutions ranging from desktop apps to multi-headed client and web apps, and got my head firmly into the user experience space. My record is pretty good, and my experience is nicely varied between a huge number of problem domains and the gamut of Microsoft developer technologies and server products.

My main focus in the early to mid 2000s was in Windows Forms. I did enough Windows Forms development that I created my own website (www.irritatedVowel.com which I sorely need to redo) just so I could ensure I had some actual hands-on ASP.NET experience.

Now I get to apply that project and client app dev experience, and my community work, to a new area.

In September 2009, I was offered a dream position: Senior Program Manager on Scott Hanselman’s team, with focus on the Windows Client (WPF, C++/MFC, Windows Forms) properties on MSDN and windowsclient.net. The team I’d be working with would be second to none (Scott, Tim Heuer, Joe Stagner and Jesse Liberty). I’ve known those guys for a while, and I couldn’t possibly think of a team I’d rather work with, or a domain I’d rather work in. So, of course, I accepted it. I start at Microsoft in the middle of October.

Windows Client? I thought you were a Silverlight guy?

Back in 2007, I got into Silverlight because of my love for .NET client solutions and providing the best possible user experience for business applications. The rest of my company was going to web development (with a serious amount of SharePoint work as well). I saw Silverlight as a great way to bring my windows client skills to the web, and create better web apps faster, without forcing sub-par user experience on my customers. My going-in position with new clients, though, was always to recommend WPF for internal apps unless they proved to me they needed something only available in Silverlight, or it was a choice between Silverlight or HTML – nothing else. I’ve produced a bunch of great Silverlight applications over the past couple years, mentored others on how to write for it, and helped a number of companies get off the ground with new SL projects. I’m really proud of what I accomplished.

I still think Silverlight is an absolutely amazing technology. It always had the feel of a new and unexplored frontier. I saw it born and saw it (quickly!) grow up into a real app dev platform. It has brought and continues to bring new people to Microsoft development – people whose only past experience was with html/js and adobe products. I plan to stay engaged in the Silverlight community in the same hobbyist capacity I was before I decided to join Microsoft. Happily, WPF, being a superset, will make it easier for me to keep SL as a hobby without letting skills in either go stale.

Uh huh. But I thought you were a Silverlight guy?

I was, for a bit over two years, but I’ve been doing this for almost 18 years now. I tend to change focus fairly often. What stays consistent though is I am into the technologies that make it possible to create the best user experience with the least effort and most flexibility. Silverlight definitely fits that category – as does WPF and for many applications, Windows Forms. In fact, when I got a glimpse of Silverlight 2 and what it could do, I wrote an article where I mentioned that one of the great side effects of Silverlight 2 will be increased adoption of WPF.

There’s another thing that attracted me to this, though. Silverlight is getting TONs of attention right now. Most user groups get multiple Silverlight talks in a given year (I know, I’ve given a number of them); that’s saying something given the number of potential topics in the windows development space. There are lots of examples for Silverlight online. There are some of the best community folks I know (Tim, Jesse, and now John) who are dedicated 100% to Silverlight.

Windows client, on the other hand, has been a little neglected. Not for lack of love or lack of developers (it’s a huge percentage of all .NET development), but just lack of attention and visibility. There’s a ton of good work being done by windows client developers around the world, and not enough attention being brought to it, and not enough support being given to it and the community around it. I will make an impact in both of those areas.

What about the Silverlight book?

I am absolutely committed to completing what I expect to be the best Silverlight book on the market. My new management knows about the book and there is nothing but encouragement there. Back in July we (my publisher, editor, and I) made some content changes that we’ll announce in the fall, but they are great changes and will result in a world-class Silverlight book. I’m not scaling anything back, and I’m not compromising. Stay tuned.

Keep up with the updates here: http://manning.com/pbrown

So what’s in store?

With the release of Windows 7 and .NET 4, I can’t think of a better time to get back into the Windows Client space. Windows 7 is the most exciting OS in some time. I remember my friend and I going down to the store on our lunch break on release day to get Windows 95, and then barely able to contain ourselves from trying out the install on our work PCs (running Windows for Workgroups 3.11).

My goal over the next year is to show just how exciting Windows client development really is. Unlike web tech, client technology tends to be hidden behind firewalls, and inaccessible to the public. I want to change that, and provide ways for you all to showcase the the awesome apps you are creating every day. If you are creating something cool/useful/fun/interesting, tell me.

I’m also looking into doing some interesting web/desktop hybrid samples using the newer MS releases combined with client tech.

Oh, and when WPF was still known as Avalon, I started a kitchen PC project. I set it aside, and despite seeing some commercial implementations of the same, it may be good to reopen and open source that project.

That’s just the start. Once I get in there and start working with the rest of the teams, who knows what’s in store :)

And, of course, I’m here for you all. Tell me what interests you and then tell me what excites you.

What developer tweeps are using for their app dev

Pete.Brown — Tue, 15 Sep 2009 02:57:15 GMT

Last week, I opened a very unscientific poll on Twitter asking what MS technologies developers were using to build their current in-progress applications. It was retweeted about within the Silverlight community, but also with broader reach folks like Scott Hanselman, Brad Abrams, and Phil Haack, as well as a few people in the Windows Forms community.

(Please note that I allowed for multiple choices, to account for hybrid or multi-faced applications and simultaneous multi-project development).

Considering the community of people who saw the RTs numbers somewhere in the 20k range, the sample size here is a bit small. However, you can still glean some interesting information from it.

One interesting little stati is compiled client code (WPF, Windows Forms, C++, Silverlight) vs. browser-based HTML/JavaScript (ignoring “other”):

Code-on-Client: 386 votes
HTML/JS: 404 votes - no, I didn’t make that up :)

That’s a pretty close split considering that Twitter leans more heavily towards people working in web development. I can almost guarantee that Windows Forms and WPF are underrepresented in those numbers, but even at almost 50% it shows that code-on-the-client is still a big force in business application development. Keep in mind as well that I didn’t ask about XNA. While a business app in XNA could be pretty cool, I figured those were few and far-between :)

I fully expect widespread adoption of Windows 7 (which is a very cool platform to develop for), as well as .NET 4 and the next version of Silverlight to make this an even more compelling story.

Divine Vision, black helicopters, or sleep deprivation?

Pete.Brown — Mon, 17 Aug 2009 03:58:29 GMT

Today, while sitting at the kitchen table at my sister in law’s house in PA, waiting for my nephew’s 9th birthday party to kick into gear, I had a vision. By vision, I mean something along the lines of the Cheesus, chipotle Mary, chipped Jesus on toast, or Virgin Mary grilled cheese sandwich kinds of revelations -- but perhaps closer to the Dvorak toast.

Was it a freak trick of lighting, a divine revelation, or was a Microsoft satellite using lasers to beam the image into the house, to the wall, to convince my 9yo cousin to lay off the Wii and get a real computer and waste countless hours in InPrivate mode instead of pretending to exercise in front of the TV?

Is it a message to me to go door-to-door and inform people of the irresponsibility of staying on IE6? A blessed endorsement of IE8? Was I just seeing things because I’ve been up too late working on Silverlight projects?

Nerd Pareidolia. You decide.

(All in good fun - no offense intended to anyone, except maybe someone who thinks revelations come from frito-lay. Please pipe all complaints to /dev/null.)

Expression Blend 3 + SketchFlow RTW

Pete.Brown — Thu, 23 Jul 2009 21:56:33 GMT

Congratulations to the Microsoft Expression teams for another great release!

If you are an MSDN Premium subscriber, you’ll probably want to wait a week or so until Expression Studio 3 show up on MSDN. That will take about a week or so. The exciting news buried in that sentence is that MSDN Premium Subscribers will get all of Expression Studio 3 (including SketchFlow) as part of their subscription.

You can download and install the trial now if you wish, but you’ll need to uninstall once you get the MSDN version.