As you may know, Mindscape offers one of the best suites of Windows Phone 7 controls including some amazing charts. We’d love to see you build applications with what you learn in this article. To make it even easier we’ve got a fantastic offer for our readers – get 40% off Windows Phone 7 in Action with the following discount code:

mscape40

This article is based on Windows Phone 7 in Action. It is being reproduced here by permission from Manning Publications . Manning early access books and ebooks are sold exclusively through Manning. Visit the book’s page for more information.

All Windows Phones have at least one built-in camera. Microsoft’s minimum hardware specification requires a camera with a flash. Some phones have a second front-facing camera. The Windows Phone class library contains two chooser tasks that provide limited access to the camera, or more specifically, to pictures taken by the camera or pictures that exist in the media library.

Note: Only photographs are accessible via the chooser tasks. The chooser classes do not allow you to access videos from the camera.

The chooser tasks are the PhotoChooserTask and CameraCaptureTask. Let’s look at choosing from the media library with the PhotoChooserTask first.

Choosing a photo with PhotoChooserTask

All phone users are familiar with how to take a picture with their mobile device since taking picture is a part of their daily phone usage. But, as programmers, knowing how to take a photo with the phone is not enough. The PhotoChooserTask allows an application to launch the built-in Photo Chooser application.

You need to know how to use the camera from your code and how to integrate the camera with your custom application. This is what you’re going to learn in this article.

PhotoChooserTask allows users to select the photo from phone memory with the built-in Photo Chooser. The Photo Chooser has a navigation button that can take you to the camera application. The PhotoChooserTask is handy for those applications that allow a user to choose a photograph and use it somewhere in the application. One example is adding a picture to a user’s profile.

If you are coming from a .NET background then you might be wondering about the differences between OpenFileDialog and PhotoChooserTask when they both select files. The Windows Phone APIs do not give you a generic file picker so you will have to use PhotoChooserTask in order to allow the user to select a photo in your application. Table 1 describes the members of PhotoChooserTask.

PhotoChooserTask Members

PhotoChooserTask’s Show method launches the built-in Photo Chooser application. When the Show method executes, your application is moved to the background as the operating system switches to Photo Chooser application. The Photo Chooser application is shown in figure 1. The Photo Chooser opens to a list of albums that the user has created in the phone. There are only two default albums in the emulator, named “Camera Roll” and “Simple Picture,” but the user might have more in a real phone device. Note that “Camera Roll” is the default album that stores all photos taken by the phone camera.

A screenshot of the built-in Photo Chooser application with camera button

The ShowCamera property can be set to true if the user should see the camera icon in the application bar. When the camera icon is shown, the user has the option to take a new picture. It is always a best practice to set the ShowCamera property to true because the user may want to take a new photo right away instead of selecting one from the photo albums.

Let’s add an ApplicationBar menu item to show the PhotoChooserTask in our PhotoEditor application.

<phone:PhoneApplicationPage.ApplicationBar>
    <shell:ApplicationBar IsVisible=“True” IsMenuEnabled=“True”>
        <shell:ApplicationBar.MenuItems>
            <shell:ApplicationBarMenuItem Text=“choose photo” 
                Click=“Choose_Click” />
        </shell:ApplicationBar.MenuItems>
    </shell:ApplicationBar>
</phone:PhoneApplicationPage.ApplicationBar>

The ApplicationBarMenuItem displays the text “choose photo.” The click event hander for the menu item constructs a PhotoChooserTask and sets the ShowCamera property to true.

private void Choose_Click(object sender, EventArgs e)
{
    var task = new PhotoChooserTask();
    task.ShowCamera = true;  #1
    task.Completed += chooserTask_Completed;
    task.Show();
}

The Completed event is wired up to the chooserTask_Completed event handler. When the Show method is called, your application is paused and placed in the Task Switcher’s back stack. When the user completes the chooser operation, the operating system navigates back to your application. The Completed event handler is called when the application resumes operation in the foreground.

Note: The media library is locked when a device is connected to a computer and the Zune software is running. When the media library is locked, you will encounter errors when testing the PhotoChooserTask.

The Completed event will be raised when user selects a photo from a photo library, takes a new photo, or uses the back button to navigate back to the application. Listing 1 shows how to handle the Completed event and display the selected photo in the image control.

Displaying the selected photograph

private WriteableBitmap currentImage; #1
 
void chooserTask_Completed(object sender, PhotoResult e)
{
    if (e.TaskResult == TaskResult.OK) 
    {
        currentImage = PictureDecoder.DecodeJpeg(e.ChosenPhoto); #2
 
        photoContainer.Fill = new                     #3
            ImageBrush{ ImageSource = currentImage }; #3
 
        imageDetails.Text = string.Format(“Image from {0}\n”, 
            sender.GetType().Name);
        imageDetails.Text += string.Format(“Original filename:\n{0}”, 
            e.OriginalFileName);    
    }
    else
    {
        photoContainer.Fill = new SolidColorBrush(Colors.Gray);
        imageDetails.Text = e.TaskResult.ToString();
    }
}

#1 Field to hold the chosen photo
#2 Photo stream is in e.ChosenPhoto
#3 Displays the image with a brush

First, we need a new WriteableBitmap field named currentImage (#1) in which we store the photograph shown in the photoContainer Rectangle control. It is a best practice to check the TaskResult property to determine if the chooser task completed OK or if the task was canceled. The PhotoResult class defines two properties named ChosenPhoto and OriginalFileName. ChosenPhoto contains the selected picture’s data in a Stream. We pass the image stream to the DecodeJpeg method of the helper class named PictureDecoder (#2).

The PictureDecoder class is found in the Microsoft.Phone namespace. The DecodeJpeg method builds a WriteableBitmap. We use the WriteableBitmap as the source for an ImageBrush, and the brush is used as the Fill for the photoContainer (#3). Finally, we build a message informing the user that the picture came from the PhotoChooserTask and had the filename specified in the OriginalFileName property.

When the TaskResult is not OK, we clear the photoContainer by setting the Fill property to a SolidColorBrush and display the TaskResult value in the imageDetails TextBlock.

Run the application, select the choose photo menu item, and pick a photo. The photo you choose should be shown in the application when the PhotoChooserTask completes. Next, we look at how to use the CameraCaptureTask.

Taking photos with CameraCaptureTask

CameraCaptureTask is another useful task that allows developers to launch the built-in camera application. Unlike PhotoChooserTask, it allows you to open the camera directly from an application without requiring the user to perform additional clicks. Shown in figure 2, the camera application in the emulator shows a placeholder white screen with a moving black block. You can take a photo in the emulator by clicking the round widget located at the right top corner. We recommend you to use a physical device to test this task.

Figure 2 The camera application in the emulator

The CameraCaptureTask does not have any properties and only implements the Show method. Let’s show the camera application by calling the Show method from the click event of a new menu item we add to MainPage.xaml.

<shell:ApplicationBarMenuItem Text=“capture photo” Click=“Capture_Click” />

The snippet below shows how to use CameraCaptureTask.

private void Capture_Click(object sender, EventArgs e)
{
    var task = new CameraCaptureTask();
    task.Completed += chooserTask_Completed;
    task.Show();
}

We subscribe to the Completed event to receive the photo stream from the camera and we call the Show method to launch the camera. For Completed event, we can use the same event handler method that we used in PhotoChooserTask sample.

Deploy the updated application to your phone, run the application and choose the capture photo menu option. Hold the phone in the landscape orientation, snap a picture and press the accept button. When the task completes, you should see your new photo displayed in the photoContainer. Select the capture photo menu option again, but, this time, hold your phone in the portrait orientation when you snap the picture. When the task returns this time, the new picture is displayed sideways. The important thing to note is that the image stream that returns from Camera will not respect the orientation of your application. We show you how to handle the orientation of a picture in the next part.

Handling picture orientation in CameraCaptureTask

Please take a look at figure 3. Do you notice that there is something wrong? The orientation of the photograph does not match the orientation of the application.

Figure 3 Orientation problems with CameraCaptureTask

The photo stream that returns from the camera does not know or care about the orientation of your application. The picture’s orientation will be based on how the user holds the phone while taking the picture. We cannot ask our user to hold the photo in specific position and they will hold the phone however they like. All we can do is to adjust the orientation of photo before showing it in our application.

Tip: The image rotation techniques shown in this section were inspired by Microsoft blogger Tim Heuer, who wrote very good post about orientation mismatch in his blog. You can read his blog post here.

The CameraCaptureTask writes metadata about the picture to the stream along with the image data. The image data and metadata are in the Exchange Image File Format (EXIF). The EXIF format has an attribute that we can read to determine the orientation of the photo. The PhotoResult’s ChosenPhoto property is a Stream and we need a way to extract the EXIF data from the stream. In our sample, we are going to use ExifLib, an open source EXIF library that can be downloaded here. We have included the ExifLib assembly in the sample project. Feel free to use an EXIF library of your choice or you can even roll your own library.

Before we think about how to modify the orientation, we need to figure out the default orientation of the photo that we get from the camera and how the orientation is different from the application’s orientation. Figure 4 shows the possible combinations of application and camera orientation.

Figure 4 Different ways of holding camera, photo outputs, and degrees that the picture needs to be rotated

This figure shows four different ways of holding the camera and the output in very clear manner. The first column of this diagram illustrates that our sample application is always in a portrait orientation. The second column shows the different ways of holding the camera. The third column displays the output photo from the camera. As you can see, the default orientation of photo will be different based on the way that the user holds the camera. The last column shows how many degrees we need to rotate the photo in order to get an orientation that matches the application.

The code that performs the desired modifications shown in figure 4 is implemented in two steps. The first step calculates the angle to rotate the image, and the second step performs the rotation. Listing 2 demonstrates how to calculate the degree of rotation in the GetAngleFromExif method.

Calculate how many degrees to rotate a photo

using ExifLib; #A
using System.IO; 
 
int GetAngleFromExif(Stream imageStream)
{
    var position = imageStream.Position;
    imageStream.Position = 0;
    ExifOrientation orientation = ExifReader.ReadJpeg(  #1
        imageStream, String.Empty).Orientation;         #1
    imageStream.Position = position;
 
    switch (orientation) #2
    {
        case ExifOrientation.TopRight:
            return 90;
        case ExifOrientation.BottomRight:
            return 180;
        case ExifOrientation.BottomLeft:
            return 270;
        case ExifOrientation.TopLeft:
        case ExifOrientation.Undefined:
        default:
            return 0;
    }
}

#A Uses the EXIF library
#1 Reads the orientation
#2 Determines the rotation angle

First, we read the orientation from the EXIF formatted stream. The ExifReader.ReadJpeg method accepts an image stream and returns a JpegInfo instance. The JpegInfo object contains information stored in the EXIF header in the image stream, including its orientation. We extract the orientation, in the form of an ExifOrientation instance, from the Orientation property (#1). Based on that, we will define how many degrees we need to rotate (#2). We suggest that you compare the implementation and the diagram in figure 4 to understand more details.

Once we know how many degrees we need to rotate the original photo, it’s very easy to create a new photo with the correct orientation based on the original photo. The WriteableBitmap class provides direct access to the pixel level information of bitmaps. The image data is accessed through the Pixels property, a one-dimensional array of pixels laid out in a row first pattern. The PixelWidth and PixelHeight properties are used to determine how many rows and columns of pixels exist in a two-dimensional image. The first row of pixels resides in the Pixels array from index 0 to PixelWidth – 1. The second row of images resides in the Pixels array from index PixelWidth to 2 * PixelWidth – 1. Listing 3 shows how to read the pixels from original photo and copy them to the right position in the new bitmap image.

Listing 3 Copy the pixels from original bitmap to new bitmap

private WriteableBitmap RotateBitmap(WriteableBitmap source, 
    int width, int height, int angle)
{
    var target = new WriteableBitmap(width, height);  #1
    int sourceIndex = 0;
    int targetIndex = 0;
    for (int x = 0; x < source.PixelWidth; x++)
    {
        for (int y = 0; y < source.PixelHeight; y++)
        {
            sourceIndex = x + y * source.PixelWidth;
            switch (angle) #2
            {
                case 90:
                    targetIndex = (source.PixelHeight - y - 1) 
                        + x * target.PixelWidth;
                    break;
                case 180:  
                    targetIndex = (source.PixelWidth - x - 1) 
                        + (source.PixelHeight - y - 1) * source.PixelWidth;
                    break;
                case 270:  
                    targetIndex = y + (source.PixelWidth - x - 1) 
                        * target.PixelWidth;
                    break;
            }
            target.Pixels[targetIndex] = source.Pixels[sourceIndex]; #3
        }
    }
    return target;
}

#1 Creates an empty bitmap
#2 Determines target location
#3 Copies pixels

The RotateBitmap method accepts four parameters which are the source bitmap, the width and height of the new bitmap and the angle the bitmap should be rotated. The method starts off creating a new WriteableBitmap with the specified width and height (#1). We loop through each pixel in the source bitmap, calculating the index of the source pixel and the index in the target bitmap where we will copy the pixel. Depending on the rotation angle (#2), we calculate the target index using one of three different expressions. Finally, we copy the pixel (#3) from the source bitmap to the target bitmap.

Note: If you would like more information about WriteableBitmap, please read the MSDN documentation for Silverlight’s version of WriteableBitmap.

RotateBitmap accepts a WriteableBitmap. The CameraOperationCompletedEventArgs passed to the camera_CaptureCompleted method provides a Stream. Currently, the camera_CaptureCompleted method uses DecodeJpeg to convert the stream to a WriteableBitmap. Let’s wrap the call to the DecodeJpeg and RotateBitmap methods in a new DecodeImage method. The code for the new method is shown in listing 4.

Listing 4 Decoding the image stream

private WriteableBitmap DecodeImage(Stream imageStream, int angle)
{
    WriteableBitmap source = PictureDecoder.DecodeJpeg(imageStream); 
 
    switch(angle)
    {
        case 90: 
        case 270: 
            return RotateBitmap(source, source.PixelHeight, #1
                source.PixelWidth, angle);                  #1
        case 180: 
            return RotateBitmap(source, source.PixelWidth, 
                source.PixelHeight, angle);
        default:
            return source;  #2
    }
}

#1 Swaps width and height
#2 Skips RotateBitmap

The new DecodeImage class accepts an image stream and the rotation angle. The first step is to convert the image stream into a WriteableBitmap using the PictureDecoder helper class. Next we examine the degree of rotation, calling RotateBitmap if necessary. When we are rotating the image by 90 or 270 degrees, we are swapping the width and height (#1). When the angle is 0, we do not call RotateBitmap (#1).

With the new GetAngleFromExif and DecodeImage methods in place, we can update the chooserTask_Completed method to rotate the captured photos. In the completed event handler, replace the call to PictureDecoder.DecodeJpeg with the following snippet.

int angle = GetAngleFromExif(e.ChosenPhoto);
currentImage = DecodeImage(e.ChosenPhoto, angle);

Summary

You now have a good understanding of how PhotoChooserTask and CameraCaptureTask work. You have also learned how to handle the picture orientation. These chooser tasks are useful when choosing a picture is a secondary feature of your application.

WPF Elements

• Stock and candlestick charts
• Fixed a bug with StackedAreaSeries containing a large number of data points
• Fixed a bug in automatic LabelStep calculation
• Fixed some issues with the DualSlider generic style

Silverlight Elements

• Added control over data sampling for very large charts

LightSpeed

• Fix for unbinding nullables

Phone Elements

• Added SelectedLoopingListBoxItem and ItemContainerStyle properties to the LoopingListBox control

NHibernate Designer

• You can now drag views on from Server Explorer

Web Workbench

In addition to the major changes discussed in the release announcement, there are a few smaller fixes and enhancements:

• Fix for error on !default directive
• Support for @page directive
• For Chirpy users we now provide guidance on how to configure Chirpy to allow Web Workbench to work with Less files

As always the free editions are available on the downloads page and you can get the full editions from the store.

Make building better software your New Year’s resolution by taking advantage of our 30% sale on the Mega Pack.

For a limited time, pay only $699 and you’ll receive:

• LightSpeed O/R Mapper (normally $349)
• WPF Elements (normally $699)
• WPF Diagrams (normally $699)
• Silverlight Elements (normally $699)
• Phone Elements for WP7 (normally $299)
• NHibernate Designer (normally $99)
• SimpleDB Management Tools (normally $29)
• Web Workbench (normally $29)
• Visual Tools for SharePoint (normally $349)

Plus, you also get:

• 12 months of new releases, nightly builds and new products!
• The best support in the business!

Imagine that – a full range of developer tools across WPF, Silverlight, Windows Phone, Data Access, Web Development and Domain Modeling for just $699!

So, save thousands of dollars by getting all your tools at once with our 30% off Mega Pack Special now.

Hurry, promotion ends 1 Feb 2012!

LightSpeed

• Some fixes around ordering across associations
• Added support for calculation/aggregation operators over subqueries
• Improvements to the LINQ Count() operator over projection subqueries
• The designer defaults policy can now override the defaults for generating DataMember attributes on associations
• Fix for associations not respecting DependentAttribute if the foreign key was a string
• Fix for value objects in derived entities not being materialised if using FindBySql or a stored procedure, and the inheritance model was class table inheritance, and the query was through the base class

WPF Diagrams

• Added hooks for customising marquee selection behaviour

WPF Elements

• Automatic label step calculation for Y axes

Phone Elements

• Landscape support for the palette colour picker

NHibernate Designer

• Option to suppress association properties in generated code

Nightly builds of free products are available on the Downloads page; for retail editions you can get them from the store.

WPF Diagrams

• DiagramToolBox support for scroll bar visibility attached properties
• Node tool drag sizing is now cancelled if the user doesn’t click on the diagram surface
• You can now control the heuristic function used by the A* pathfinder
• New sample: custom shapes
• Added an IsDragResizeEnabled property for enabling or disabling drag-sizing when using a charged cursor to create new node

LightSpeed

• Fix for a spurious discriminator warning if a STI root class derived from another class using concrete table inheritance
• We’ve relaxed the warnings for discriminators on abstract classes
• Improved error if you set an entity to be its own direct parent. “Doctor, it hurts when I do this.”
• If you drag from Server Explorer and you haven’t saved your password, we’ll now try to detect this and remind you
• Fix for error in certain grouping queries with joins
• Email validator now accepts the ‘+’ character in addresses
• Improvements to find by identifier in DistributedUnitOfWork

Phone Elements

• Support for styling alternate Y axes

WPF Elements

• Fixed a property grid bug with keyboard navigation on expanded nodes

Web Workbench

• Fixed a couple more cases where we were indicating syntax errors on correct CSS

Free editions of the nightly builds are on the downloads page, and full editions are in the store.

LightSpeed

• Compiled queries! Yay!
• Fix for an error when projecting only base class fields while filtering only on derived class fields in class table inheritance
• Fix for a class table inheritance cascade delete issue
• Fixed a column mapping issue with unversioned partial updates
• Fix for BeginEdit on a distributed entity

WPF Diagrams

• Performance and functionality improvements to the A* pathfinder
• Added an option for marquee selection to select when the marquee intersects a node rather than only when it wholly contains a node

WPF Elements

• Fixed an error when typing non-Latin characters into a numeric text box
• Fixed an issue where the minimum and maximum values of an alternate Y axis could not be set automatically

Phone Elements

• Fixed an issue where the minimum and maximum values of an alternate Y axis could not be set automatically
• Fixed a font sizing issue with the picker controls

Silverlight Elements

• Fixed an issue where the minimum and maximum values of an alternate Y axis could not be set automatically. Coincidentally enough

All these features and fixes are in the current nightly builds. Free editions are available from the downloads page, and full editions from the store.

This point release occurs at the same time as it represents primarily the addition of new charting types across the product line and the sharing of performance improvements across them all. There is also a roll up of individual product improvements in each product as well.

What’s new in all three products?

• Polar charts including rose charts, radar charts and polar scatter/bubble charts
• Additional events for interactive chart usage (e.g. DataSeries.SelectedDataPointChanged)
• Added ChartAxis.MinimumRange, TitleVisibility and LabelStep properties
• DataSeries.Visibility can be used to collapse a series on the chart
• Additional performance improvements

We have also rolled up a number of general enhancements – for example basic image support in the Silverlight Rich Text Editor, improved keyboard navigation in the Book and Coverflow controls and new colour palettes for WPF and Silverlight.

This brings the number of overall controls to 45+ for WPF Elements, 40+ for Silverlight Elements and 30+ for Phone Elements. If you haven’t tried these products before but want to create amazing user experiences you can download the trials free from the download page. Customers already have the latest builds available on their account pages.

To whet your appetite, here’s an example application built using WPF Elements charting:

 

 

We would, as always, love to hear your feedback on what’s new and what you’d like to see in the future.

Happy coding!

Now that Microsoft have unveiled the latest ‘Mango’ version of Windows Phone 7, we’ve been asked if Phone Elements will work with Mango. The answer is yes. We’ve tested our controls with the Mango pre-release, and all the controls work happily as you would expect. You won’t need to make any changes or download any updates.

Just to remind you, here’s a taste of all the cool stuff in Phone Elements.

Get your Mango on — download the trial today!

Using the radial gauge control in your applications is very simple. It extends from the RangeBase class so you just need to set the Minimum and Maximum values to specify the range, and use a binding to set the Value property from your business model. Additionally, the StartAngle and SweepAngle properties can be used to customize how the labels get displayed. The StartAngle defines where the first label gets rendered. A value of 0 will display the first label at the top of the gauge. Larger values move around the gauge in a clockwise direction. The SweepAngle is the total angle of an arc that the labels will be positioned against. A value of 180 for example will display the labels around half a circle. Here is an example of setting up a radial gauge in XAML.

<ms:RadialGauge Maximum="100" StartAngle="200" SweepAngle="270" />

Custom styling

Like all controls in Phone Elements, the radial gauge can be styled in all sorts of different ways to make your applications sparkle. From nice looking styles that follow the Metro guidelines, to shiny styles with smooth gradient paints. Here is some example code used to create the style seen above.

<LinearGradientBrush x:Key="RadialGaugeBackground" StartPoint="0,0" EndPoint="0,1">
    <GradientStop Offset="0" Color="Black" />
    <GradientStop Offset="0.6" Color="Black" />
    <GradientStop Offset="1" Color="#3A3A3A" />
</LinearGradientBrush>
 
<LinearGradientBrush x:Key="ShineBackground" StartPoint="0,0" EndPoint="0,1">
    <GradientStop Offset="0" Color="#77FFFFFF" />
    <GradientStop Offset="1" Color="#11EEEEEE" />
</LinearGradientBrush>
 
<LinearGradientBrush x:Key="RadialGaugeBorder" StartPoint="0,0" EndPoint="0,1">
    <GradientStop Offset="0" Color="#FBFBFB" />
    <GradientStop Offset="1" Color="#363636" />
</LinearGradientBrush>
 
<LinearGradientBrush x:Key="RadialGaugeInnerBorder" StartPoint="0,0" EndPoint="0,1">
    <GradientStop Offset="0" Color="#363636" /> 
    <GradientStop Offset="1" Color="#FBFBFB" />
</LinearGradientBrush>
 
<Style x:Key="RadialGaugeStyle" TargetType="ms:RadialGauge">
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="ms:AnimatedValueDisplay">
                <Grid>
                    <Ellipse Fill="{StaticResource RadialGaugeBorder}" />
                    <Ellipse Fill="{StaticResource RadialGaugeInnerBorder}" Margin="5" />
                    <Ellipse Fill="{StaticResource RadialGaugeBackground}" Margin="10" />
                    <Grid>
                        <Path Name="PART_Arc" Stroke="White" StrokeThickness="8" />
                        <ItemsControl Name="PART_LabelsHost">
                            <ItemsControl.ItemsPanel>
                                <ItemsPanelTemplate>
                                    <Grid />
                                </ItemsPanelTemplate>
                            </ItemsControl.ItemsPanel>
                        </ItemsControl>
                        <Grid Margin="20">
                            <Grid.RowDefinitions>
                                <RowDefinition Height="*" />
                                <RowDefinition Height="*" />
                            </Grid.RowDefinitions>
                            <Path Name="PART_Needle" Data="M 0.5 0 L 1 1 L 0 1 Z" Fill="#C21218" Width="6" Stretch="Fill" />
                            <Ellipse Margin="40,-8,40,-20" Fill="{StaticResource ShineBackground}" />
                        </Grid>
                        <Ellipse Width="20" Height="20" Fill="#C21218" />
                    </Grid>
                </Grid>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

If you need any help with creating custom styles for any of the controls in Phone Elements, then let us know by leaving a comment on this blog post, or come visit the forum and we’ll help you out. You can also let us know of any features you would like to see in the gauge control and we’ll see what we can do.

LightSpeed

• Fix for nulling a foreign key not removing the entity from the parent’s children collection
• Fix for changes not being tracked when nulling a one-to-one association
• Fix for order by’s not being aliased correctly when there is a sequence numbering alias applied because a parent instance of a table is in scope.
• Fix for association change tracking not being reset during SaveChanges
• Added option flag for removing deleted entities from the unit of work after the delete has been committed
• You can now specify the same grouping key multiple times with different functions applied to it

WPF Elements

• Fix for a possible negative width error in rose charts

Silverlight Elements

• Fix for a possible negative width error in rose charts

Phone Elements

• Fix for a possible negative width error in rose charts. (Did you guess?)

WPF Diagrams

• SelectedElementsChanged was not always being raised when using marquee select
• Fix for XML serialisation in cultures that use a different numeric format from the invariant culture