Jeff Wilcox » Silverlight Toolkit

Exploring the August 2011 Silverlight for Windows Phone Toolkit for ‘Mango’

Jeff Wilcox — Wed, 17 Aug 2011 18:00:36 +0000

We’ve now shipped the August 2011 release of the Silverlight for Windows Phone Toolkit, a key ingredient in preparing a great ‘Mango’ app. There are new controls, many bug fixes, great new localization features, and more in this pack of components.

You can download the new release straight from the CodePlex site at http://silverlight.codeplex.com/ – it requires the latest ‘Mango’ developer tools as well.

The release is also available on NuGet as the SilverlightToolkitWP package

Check out the sample app

One of the best ways to learn about the controls is to use the sample app on your Windows Phone. We haven’t published it to the marketplace yet, so in the meantime, just deploy this .XAP to your developer-unlocked Windows Phone (or the Windows Phone Emulator). It should work with the latest Windows Phone ‘Mango’ developer tools.

We’ve posted the sample XAP here.

The app includes a nice list of the controls, touch one to go into a sub-page. The full open source code to the sample is on the CodePlex site at http://silverlight.codeplex.com/

What’s in the new release?

LongListSelector has been rebuilt and redesigned to take advantage of the new smooth scrolling and off-thread touch input support in ‘Mango’. This is a buttery-smooth control for showing lists, including grouping and jump list support.

MultiselectList control enables multiple selection for easily working with lists of data, similar to the Mail app’s capability.

LockablePivot adds a special mode to the Pivot control where only the current item is shown (often used with multiple selection).

ExpanderView is a primitive items control that can be used for expanding and collapsing items (like the threaded views in the Mail app).

HubTile lets you add beautiful, informative, animated tiles to your application, similar to the new People groups in ‘Mango’.

ContextMenu control has been reworked: performance improvements and visual consistency fixes.

ListPicker now supports multiple selection.

RecurringDaysPicker lets your users select a day of the week.

Date & Time Converters localized to 22 languages. The converters let developers easily display date and time in the user interface in one of the many styles found throughout the phone’s UI, from a short date like ‘7/19’ to relative times like ‘about a month ago’.

Page Transitions have improved performance for a more responsive feel.

PhoneTextBox is an early look at an enhanced text box with action icon support, watermarking, etc.

All error messages and interface elements have been localized to all of the supported languages, making for a great experience for users around the world.

Other great components

If you’re new to the Silverlight for Windows Phone Toolkit, you’re in for a treat as an app developer: the simple developer library also contains these great components designed specifically for the Windows Phone:

AutoCompleteBox is a text box control that allows for simple auto-completion based on a filter.

DatePicker lets a user select a date, similar to that found in the Alarms app on the Windows Phone.

PerformanceProgressBar can be used to show indeterminate progress inside an app (though you should also consider the new ProgressIndicator support in ‘Mango’, too).

TiltEffect attached property that gives buttons, list items, and other components that nice ‘tilt’ touch experience.

TimePicker for choosing a time.

WrapPanel is a non-virtualized wrapping panel often used for displaying photo thumbnails.

Helper code for Gestures (touch input manipulations).

Are there plans for a 7.0 toolkit refresh?

Yes. We don’t have it prepared yet, but we have integrated many of these new features into the 7.0 Windows Phone branch that we have, and eventually (no timeline yet) we’ll get that out to developers.

Using the localized Date and Time Converters

The date/time converters help simplify displaying date information. We’ve done all the hard work of preparing relative date logic, localizing strings and information, and making sure it’s all good code, so you can just use these in your app.

To get started, you add the converters as resources, either app-wide (in your App.xaml), or in a specific page.

Here’s all of the new converters:

You can use the sample app to experiment with the various views, but they mimic many of the views found throughout the Windows Phone for showing this information.

Now, to show the formatted and localized time or date, just use the converter in binding syntax, like this:

Here’s German (on the left) and French (right) with the nice RelativeTimeConverter in use:

The new HubTile control

The HubTile control lets you add your own tiles to your app, just like the People hub in ‘Mango’ does for groups of people. It looks sharp. Similar to how the phone does it, there’s a central coordination system so that tiles animate in a defined but random way; you can also freeze/unfreeze the tiles to improve performance in pivot scenarios, etc.

The control is simple to use, here’s some of the code from the sample project:

The tiles can be arranged to offer links to sub pages easily, etc. These look really slick at runtime.

Using the Page Transitions

The page transitions are a nice, easy way to improve the visual experience of your app, and now they are much more responsive, immediately reacting to new navigations.

It’s a two-step process to use the transitions in your project once you’ve included the toolkit.

First, open App.xaml.cs, open up the region at the bottom of the file with the phone initialization work, and replace the standard phone frame with our TransitionFrame (about line 108 in the standard project):

RootFrame = new TransitionFrame();

Next, on every page, you can define the transitions you would like for in and out navigations; often we see developers creating a style in App.xaml and just applying that to pages.

Other resources

From one of the earlier releases, you can find out about ListPicker, LongListSelector, TransitionFrame, AutoCompleteBox, etc. in David Anson’s blog post on these components.

Special thanks

The toolkit is made possible by a number of people throughout Microsoft who are passionate about great user experiences and the Windows Phone – too many people to list here but definitely Dave, Dustin, Aaron, Phillip, Richard, Tom, Peter, and more! But with this release, we’ve also had the pleasure of working with a number of great students from around the world who interned this summer at Microsoft.

With their permission, I wanted to share their names here to thank them for their contributions – and this way you know who to bug on Twitter or online when you’re filing bugs!

Badr Zrari (Software Engineering, Polytechnic Montreal) worked on the new buttery-smooth LongListSelector (now based on ListBox)
José H. Arriaga (Computer and Robotics Engineering, Monterrey Institute of Technology and Higher Education) worked on the HubTile, date and time converters, multiselect list, expander item
Andrew Munsell worked on PhoneTextBox

Hope you enjoy the new release.

Updated Silverlight Unit Test Framework binaries–compatible with the Mango phone tools beta

Jeff Wilcox — Thu, 09 Jun 2011 20:38:07 +0000

I took a few minutes today to build and share this updated set of assemblies that are Mango beta-compatible for phone developers. These can also be used with the RTM of phone, SL3, etc. There were some XAML syntax errors in code that was previously not exercised, oops.

[ZIP, 518K] Silverlight Unit Test Framework Assemblies compatible with Mango Beta Tools

I’ve enclosed the license file, too. Sorry it took so long to get out, Jon.

Hope this helps.

4th & Mayor: the ultimate foursquare app for your Windows Phone

Jeff Wilcox — Sun, 20 Mar 2011 22:43:05 +0000

I’m pleased to announce that my app is called 4th & Mayor. It is a foursquare client for Windows Phone 7 and it is now available for free on the Windows Phone Marketplace. I previously hinted at the app with this other post.

This app brings all of the great new foursquare features that your iPhone and Android friends have been using: adding and experiencing photos at places, photos with tips, commenting on check-ins, and an early look at the cool new “explore” features that recommendations places and things to do. (fsq3 info on the foursquare blog)

It’s been a lot of fun building the client over the past few months, and I am excited to share a lot of my development experiences on this blog. Expect great things. Foursquare has a very solid and open API for developers to use (REST + JSON), and it’s a great, fun way to explore any city and stay in touch with your friends. Also, given all the recent news about Twitter, I’m super happy that I didn’t decide to make a Twitter client

On top of being a fully functional, free foursquare app, I’ve also made sure to address key complaints that I heard from people regarding the official foursquare app for WP7: general touch responsiveness, feature completeness, and the ability to check-in to international locations (with accents and other special characters in their name).

Follow the product

You can find out more about 4th & Mayor on the web at http://www.4thandmayor.com/ – as well as on Twitter @4thandmayor and on Facebook. If you are interested in the app, its features and updates, please subscribe to the app’s blog at http://blog.4thandmayor.com/. I don’t want to inundate my technical subscribers with news about app updates and new features, so I want to keep that separate for the most part.

Do expect a great series of blog posts to come out of this learning experience, all the development-related information will be posted here. From the Windows Phone design system to development tips and tricks, this is the place to find that.

“4th & Mayor”

So my app is called 4th & Mayor. Instead of focusing on just raw performance from a development standpoint, I wanted to show how I would envision a great Windows Phone app. I believe that for a v1.0 release, I have delivered a great initial app experience. I decided to try and demonstrate a happy compromise, hoping to yield a wonderful experience that doesn’t take short-cuts.

An emphasis on design
Aiming for complete client functionality
Keeping the app responsive to user input no matter what
A beautiful experience, yet differentiated enough

This all started because one of the things I use my smart phone the most is foursquare, followed by email and Twitter. I just really wanted a better foursquare experience on the Windows Phone, and figured this would be the best way to gain excellent app development experience.

(The name? It’s a little odd yet creative, is clearly not an official client, and it’s all about working to become the mayor while having fun, right? The intersection of foursquare (4th) and the fun of the game – working to establish a mayorship (Mayor).

An emphasis on design and rich visuals

The design system for Windows Phone, code-named “Metro”, really is cool. Others have written about the experience before, but it really is a very developer-friendly design system that is crisp, clean, and once you understand the core principles and rules, it’s easy to build jaw-dropping apps. I’m just a geek, but feel I’ve come away with a pretty good first release when it comes to visual consistency and trying to adhere to the basics of “Metro”.

This comes through in a few ways. If you look to the screenshots below, on the left, you see the nice visuals in the “places” listing: no rounded corners, crisp and clean, etc. On the right, the “photos” pivot item for a page shows a few large, rich photos from the venue – and clicking them brings up the full-screen photo experience.

Both are very easy scenarios to polish thanks to XAML, but it takes an understanding of how to translate “Metro” ideas into XAML. A lot of off-by-12-pixel polishing goes into shipping a solid Windows Phone app.

A fun experience

There’s great incentive in the new foursquare 3 features to check-in and have fun doing it: a completely revamped points system. Get points for being a VIP (checking in with the mayor), being the first of your friends to check out a new place, and so on. This, combined with the new leaderboards and an ever-growing catalog of badges is just modern-day fun.

The rush to the marketplace

When I heard about the problems that people were having with the foursquare app for Windows Phone, I decided to try and move into “ship mode” immediately instead of completing all of the features I had planned. I forked my source and started polishing and fixing bugs last weekend. As a result, I apologize if there’s something missing or a few bugs in the first release.

My app does 2 things that people have been having issues with the foursquare WP7 app:

Sign in works
You’re able to check into a place that has special characters or accents in the name (international friends, enjoy!)

An update with specials is coming soon

Now that the app is out there, an update coming soon will add specials support, and I’ll also work to address any large buckets of customer-reported bugs. Thanks to getting the build out earlier in the week for people with developer unlocked phones, I’ve been able to start identifying a few small bugs and issues that I hope to correct soon (thanks everyone).

From a blank Visual Studio project to shipping… < 120 days

I created a new Visual Studio project a few weeks after purchasing my first Windows Phone (a Samsung Focus, I’m pretty happy with it), and registered for the domain name 4thandmayor.com in early December 2010. Hoping to learn about the process of building a large, feature-complete Windows Phone app from the ground up, I had no idea how much time it would take, but it’s been a fun use of many a night and weekend over the past few months.

Most development happened in spurts as I found a free Sunday afternoon or a clear night or two. I’m really glad that I was able to the have the opportunity to build a feature-complete WP7 app and that Microsoft is open to this kind of project as appropriate.

A brief, approximate timeline of my development process:

Early Dec. 2010: App concept, goals, and new Visual Studio project created. Targeting v1 of the foursquare API.
Mid-December: Domain name registration, setup a source control system at home, etc. Oh no! Foursquare v2 API launched, v1 to be deprecated.
Christmas vacation Dec. 2010: Lots of coding and completing the application, foursquare launched photos & comments support for iPhone and Android. I was able to add these features in a few days over the break.
Late January: spent a few weekends polishing, fixing bugs, and focusing on the “Metro” design
February: moved to a much more rich data loading system
3/8/2011: foursquare announced fsq3, with even more new features, at SXSW. Around this time, there were login issues with the official foursquare app for WP7, and I decided it was time to launch the app.
3/16/2011: submitted to the Windows Phone Marketplace

Not knowing that fsq3 was coming out at SXSW, it’s a testament to the Windows Phone app platform that it only took a few hours to add these new views, models, and features into my app (exploring, enhanced leaderboards, etc.), allowing me to deliver a little more than a week and a half later a feature-complete implementation.

I will be covering a lot of the experiences and sharing a decent amount of code and samples over the next many blog posts, covering:

Application architecture
Data loading strategies
Designing for Windows Phone… for developers.
Building out controls and components for a strong and polished “Metro” experience
Establishing a web experience for your WP7 app
Compromising between raw performance and beautiful design
Analytics and apps
Keeping the user interface responsive
OAuth2 and the Windows Phone
Pivot loading techniques and user interface virtualization tips
Debugging, collecting feedback and beta testing
Gold plating: making a fun out-of-box, first-time-run experience
Polishing a Windows Phone app
Marketplace ingestion and the last mile

Please let me know if there are any things I’ve missed, or you’d like to know about, and I will add them to the list! I’ve learned a wealth of information along the way but I think this will be a long-term blogging project, there’s just so many different things here.

Technical building blocks

The app was a pretty big technical undertaking, the goal of building a feature-complete app for such a large service is a big challenge. Along the way I had to build out a number of components, and of course make use of many great things others have shared as well.

Silverlight for Windows Phone Toolkit: powering page transitions, the tilt effect, and toggle switches.
AgFx: a Windows Phone and Silverlight application framework by Shawn Burke (more info here and here too)
Various image control and loading concepts by David Anson
JSON.NET by James Newton-King
Andy Pennell’s LittleWatson
SLaB by David Poll (used for tombstoning stuff)
Advice and code by Peter Torr & also Gilles Khouzam
Bing Maps Mobile Platform
And last but most important, the foursquare developer API

And I also built out a ton of specialized components, talk about fun:

Watermarked text box
Visual components resembling the OS’s text messaging experience
An awesome scroll viewer that can do delayed image loading in an efficient and smart manner
Smart image controls for fading, replacing “Metro”-style blocks of color, and efficiently downloading bits.
A grouping items control with an emphasis on smooth scrolling
A text visualizer for showing licensing information in the About screen
A Static Bing Map control for high-performant, beautiful maps
A WebXamlBlock for displaying updatable information
Orientation-aware layout containers
An analytics component
“Live tiles” for use inside an app
A fun Ken Burns-style effect
Enhanced message box and dialog overlays
A very lightweight app settings provider
Tombstoning stream and text functionality

Initial reception

“My Saturday night was great, thx to 4th & Mayor” – toowicked

“Been using 4th & Mayor foursquare app, gotta say it’s the best one I’ve used on any OS. Get it when it’s available in WP7 marketplace!” – Jonnie

“4th & Mayor you are beautiful and fill my heart with hope for #WP7 future.” – Sergey

“Wow, 4th & Mayor is incredible. Infinitely better than the official foursquare app for Windows Phone.” – Brian

“Inspired by the @4thandmayor application. I guess I will be doing some #wp7 coding this weekend.” – Laci

“Wish we could get you to make a Twitter app that looks as good as 4th & Mayor ” – Josh

Special thanks

This project could not have happened without the help and support of many good friends and engineers.

A big shout out to Naveen and all the folks at foursquare: thanks for building a beautiful product, great service, and having a solid, open API for developers to take advantage of!

As called out in the “About” page of my app, thanks:

Shawn Burke
David Anson
Gilles Khouzam
David Poll
Peter Torr
Andy Pennell

Also, thanks to my excellent beta testers who have been checking in all over the world. Notably, Shawn, Eric, Gilles, Nimesh, Shoko, Sam, Johan, David, and Nic. You all rock!

There is a list of known issues up on the site. The app is designed to offer a rich, compelling and fun experience for people with up to 50 foursquare active friends, with slight performance degradation for people with more friends.

So, check out the site and download the app if you’re into foursquare.

Hope you enjoy the app!

Foursquare™ is a trademark of Foursquare Labs, Inc.
This application uses the foursquare™ application programming interface but is not endorsed or certified by Foursquare Labs, Inc.

Using AutoCompleteBox in a Windows Phone Panorama or Pivot item

Jeff Wilcox — Wed, 09 Mar 2011 22:28:20 +0000

With some quick re-templating action, you can use AutoCompleteBox from the toolkit in a Panorama or Pivot control page for Windows Phone. This is one of the key customer asks from folks developing WP7 apps that I hear often.

The good news is that this can be accomplished with simple re-templating of the AutoCompleteBox control, and a little visual trickery.

The bad news is that I’m not sure that we will be able to address the CodePlex work item to officially support this, work item 7574 with 21 votes so far (a popular issue!), because of the technical limitations at play here: the control itself uses a child Popup in the template to display the results, showing them on top of your page and content. When used in a Panorama or Pivot, there are issues here where the Popup doesn’t properly align on the page, or work at all.

There are three steps to doing this:

Making sure that you have a Visibility converter available in your app (most already have this)
Designing the visuals with grids to include a placeholder and a spanning content area on top of your pivot/panorama items’ content
Retemplating your AutoCompleteBox when used

For this example, I’m starting with the standard Windows Phone Pivot Application template so that you can follow along. This is best described as “hack quality” so proceed at your own risk. I want to unblock people that believe this is not possible, so here it is.

Also, with this workaround, the Visual Studio design surface is unable to continue working due to an issue resolving RelativeSource at runtime. You’ll want to comment out some of it while working on your design.

Visual trickery, illustrated

The trick to this re-template is to remove the popup from the template. Instead, we need to “fake” the popup experience by overlaying the results of the AutoCompleteBox (when searching) on top of the visuals in the PivotItem or PanoramaItem.

As always, I believe re-templating is a core Silverlight development technique. Though often a last resort before modifying the code of controls or building your own, it is a super important concept to master.

To do this, start with a standard Pivot control or Panorama item template and make these changes to the item that will contain your search box.

The root element of the item must be a Grid, not a StackPanel
It must define at a minimum 2 rows: the first row has a hard-coded height of 72 that will represent the search/text box of the AutoCompleteBox, effectively a “placeholder”
The last visual needs to be another Grid, with Grid.Row set to 0, and the RowSpan to span the entire number of rows defined in the child of the pivot/panorama item. This is to fake the effect of a “popup” by allowing visuals to be on top.

I understand this concept can be a little confusing, which is yet another reason we can’t really just change the template for all AutoCompleteBox examples. I might add this template to the sample project in the future, however!

The reason the last item needs to be the “overlay” grid is that XAML at the bottom of an item has a higher z-order than the rest, acting similar to a popup.

So visually, we define first a basic grid in the item.

The XAML might look like this now – you can follow along in the default pivot app project to see what’s different.

This defines a placeholder (Row 0) and the content of the item (Row 1). Row 0 is where the text box visually should be overlaid. Visually, this is sort of what this is about enabling from a spacing perspective:

Now, we add the “overlay” grid. For this purpose, I temporarily colored it Red to show that it overlays the earlier items:

In the actual world, this is where you want to put in the overlay grid and eventually the AutoCompleteBox.

So the updated code is similar to this:

Ok. We’re closer now that the basics are there. If you run the project, you’ll still see simply your content, with space at the top where the AutoCompleteBox (text box part) will go.

A required visibility converter

Since we replaced the pivot, we need to instead toggle the visibility of the list box for showing results only when the IsDropDownOpen dependency property is set to true. This is easy enough using a relative source binding (similar to a template binding) plus adding a Visibility converter to the project, and using it in the template.

Here’s a super simple visibility converter to get started. Add it as a class file to your project.

using System;
using System.Windows;
using System.Windows.Data;

namespace Microsoft.Phone.Controls
{
    public class VisibilityConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            bool visible = true;

            if (value is bool)
            {
                visible = (bool)value;
            }
            else if (value is int || value is short || value is long)
            {
                visible = 0 != (int)value;
            }
            else if (value is float || value is double)
            {
                visible = 0.0 != (double)value;
            }
            else if (value == null)
            {
                visible = false;
            }

            if ((string)parameter == "!")
            {
                visible = !visible;
            }

            return visible ? Visibility.Visible : Visibility.Collapsed;
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}

And then to the page, add it as a resource, plus the XMLNS for “localControls” pointing to the Microsoft.Phone.Controls namespace. I use the key name Vis.

Now we’ll use it in the template.

The new template

Now we want to re-template the AutoCompleteBox. You could define the template once in App.xaml, but for simplicity I just did this inline. The most important parts are:

Removing the Popup template part
Adding a Visibility relative source binding to show/hide the results at the appropriate time
The listbox and textbox in the template are moved into a grid-row structure visually

This takes advantage of the idea that template parts in controls are usually “optional”, so without the Popup in there, it still functions just fine in the app.

So this now adds to the overlay grid…

AutoCompleteBox instance
Sets the item template, filter parameters, etc., as an example
Sets the ControlTemplate

Here is the ControlTemplate if you are just copying and pasting into your own app:

The Visibility binding on the ListBox is important, as it is what keeps the ListBox from being displayed over your existing page content at runtime. It uses the resource we defined for the visibility converter, Vis. Relative source binding is used to make it very similar to a template binding with a converter.

And so the final XAML for the PivotItem looks like this expanded:

So, taking a few of the coloring concepts from earlier, you see we end up with this idea at runtime when entering text (coloring added to show separation, it won’t look like that in your app)

Download the completed project

I’ve zipped up the sample including the template. Make sure you have the Silverlight for Windows Phone Toolkit installed as well, you might have to re-add that reference to the sample.

[ZIP] 31 KB – AutoCompletePivot.zip

Other notes

Selecting an item may require a few touches by default

When you select an item in the AutoCompleteBox, it will fire SelectionChanged, etc., but you may find that the list shrinks (requiring another press), or that the software keyboard is still up. These need to be worked around today at the app level to match the experience you want to offer your users.

Consider hooking up to the selection event in the control, then calling Focus() on a visual element elsewhere to remove the software keyboard
Consider a code fix where if a single item is selected currently, to assume that was the final selection by the user and dismiss the selection system – requires a code workaround since not all app authors may want this.

Enables Landscape page use as well

This also enables using AutoCompleteBox on landscape pages, although it’s very difficult to control the software keyboard (SIP), so you may find that you can hardly see a single item while in landscape mode with the software keyboard up.

You may notice that the native Windows Phone experience rarely offers auto completion in landscape, and as always, Panorama pages should not be Landscape.

IE NOTE

The Internet Explorer browser has an auto complete box in Portrait mode only. In Landscape, it is hidden – and although I don’t have the official word, I believe it is because the software keyboard takes up most of the screen, leaving no space to select items.

So I think the UX guidance is to NOT show auto completes in landscape, but you’re welcome to try. You could add special app logic similar to this to try and fix the problem, but it isn’t pretty:

Attach to the GotFocus and LostFocus events of the text box in the template (requires some visual tree logic code)
In your GotFocus handler, if the page is in one of the Landscape modes… you’ll want to open up additional visual space above your page content.
Temporarily collapse the page title and perhaps its header (very involved if it is a pivot control!)
When the focus is lost, you want to restore that content. The platform should handle “scrolling” around the viewport in this mode to maximize screen real estate.

Items source size warning

One thing to callout is that the implementation of AutoCompleteBox was originally designed for use on powerful desktops, so the key code path for filtering is designed to be run on the user interface thread. On the Windows Phone, with a single core and mobile ARM hardware, this can be a bottleneck for apps.

Please consider keeping the number of items under 100 if possible, and if you need more, you may need to consider ways to use the “Populating” method to spin up your own filtering work on a background thread (not covered in this post).

Hope this helps.

Introducing the February 2011 Silverlight for Windows Phone Toolkit

Jeff Wilcox — Thu, 17 Feb 2011 02:48:58 +0000

Today we pushed the button on the February 2011 release of the Silverlight for Windows Phone Toolkit. We’ve added a few new controls that previously app developers had to pick up separately while working on polishing their apps, including the tilt effect and performance progress bar. VB samples, too!

Please download the new Silverlight for Windows Phone Toolkit release here. This is a great download to pair with your updated January 2011 Windows Phone Developer Tools installation.

What’s new?

Tilt effect

We have integrated the TiltEffect attached property, allowing developers to really easily turn on the “tilt effect” in this apps, automatically giving buttons, hyperlinks and check boxes the desired tilt effect that is found in many parts of the Windows Phone experience.

MSDN documents are available for this feature:

This is the same control that was once presented on Peter Torr’s blog and became a sample, now much easier to use.

PerformanceProgressBar

There have been several PerformanceProgressBar iterations, and finally there is one available built-in to the Silverlight for Windows Phone Toolkit.

This version is very easy to use, you can just drop it on a page, without needing to specify styles like earlier workarounds. Also, it smoothly animates out in an improved way, improving the visual attractiveness of apps.

Simply bind to or set the IsIndeterminate property to get the visual effect. There is no need to visually collapse this implementation.

For some history and other information,

Bug fixes and feature improvements

We’ve addressed customer-requested issues and improvements, most in the LongListSelector and transitions space.

VB.NET Samples

Now that Visual Basic support is available for Windows Phone, we are pleased to now offer the same sample project we ship with the toolkit, now in VB.NET.

To use VB.NET with Windows Phone apps, you also need this easy download.

A 1 minute click-through of new features in the sample app

Here’s a quick video of the emulator running the samples project included with the source download.

In the video, you see:

The tilt effect in use on the main page
The LongListSelector, which has received a number of improvements and bug fixes
The performance progress bar, including a quick demonstration where the blue progress bar (the PerformanceProgressBar in the toolkit) competes against the red standard ProgressBar with the user interface thread blocked. Also, the blue performance progress bar automatically fades out, yielding a smooth UX polish for your apps.
The tilt effect page, where you see a button, checkbox, and hyperlinkbutton being touched, responding with the tilt effect underneath.

Earlier phone toolkit features

As always, there are other useful features for app developers built into the toolkit, including:

AutoCompleteBox
ContextMenu
DatePicker & TimePicker
Gestures
ListPicker
LongListSelector
ToggleSwitch
Transitions
WrapPanel

Addressing touch responsiveness and list scrolling

One thing that we’re still trying to find the best solution to is list scrolling. The LongListSelector (LLS) control was designed to help address some of these issues, but we know that we aren’t there yet.

I’ve had conversations with a number of developers both at Microsoft, within the product teams, and with the community out there, to try and compile a list of issues, asks and possible solutions.

We know, for instance, that there are issues with the use of the TouchPanel component that the gesture service is built on, and we want to find a good solution for that.

At this time, LongListScroller is the best recommendation for most apps that need to do grouping, where the standard virtualizing ListBox is not enough.

A more active CodePlex site

Another administrative note, we’re trying to keep the CodePlex site at http://silverlight.codeplex.com/ a little more up-to-date than in the past. You’ll notice that work items should be responded too, and we’re going to keep porting bugs between our Microsoft systems and the external site.

One experiment that we’re doing with the phone toolkit is that we are offering many bug fixes as they happen as opposed to at release time; in fact, since the November 2010 Silverlight for Windows Phone Toolkit release, we’ve checked in multiple updates to the source to address customer feedback, marketplace ingestion issues, and transition bugs.

You can view the latest source code and related check-ins at http://silverlight.codeplex.com/SourceControl/list/changesets

Let us know what you think of this more transparent way of working. Hope this helps. (Download link)

Notes on Silverlight and Phone Toolkits, Testing and Other Phone Stuff

Jeff Wilcox — Sun, 06 Feb 2011 21:59:25 +0000

Hello readers, and happy 2011. It’s been a very busy January, and just now I am preparing a number of exciting new posts to get things going again. Until then, here are some small notes and previews on the Windows Phone tools, the Silverlight for Windows Phone Toolkit, the Silverlight Toolkit, and the Silverlight Unit Test Framework.

Windows Phone Developer Tools January 2011 update

The long-rumored Windows Phone 7 update is even closer, a new developer release download is now available. Please do update to the tools now! You can continue to use the tools to build apps for the marketplace today. (Release notes)

New functionality: Copy and paste support for apps. It just works in your apps, too, so that’s nice – no special action required to enable it for controls. Text boxes, password boxes, and the browser control “just work”.

This is yet another set of patches on top of the original tools download, so it’s not a pretty update, but it is worth the multiple downloads.

Rebuilding your applications that use Panorama, Pivot, and Maps

You might want to rebuild your application and resubmit it to the marketplace if you meet a few conditions:

Were using the Bing Maps control without the October 2010 patch. There were a number of key bugs fixed in that release. It is now build into the 1/2011 tools.
Were using text boxes inside of a Panorama or Pivot control. Copy and paste doesn’t work so hot due to some manipulation bugs in the Pano+Pivot libraries.
Were wanting to use a Bing Map inside of a Panorama or Pivot.

The reason that you have to rebuild is because these are “client libraries” that are built into your actual .Xap that goes to end users, so to get the goodness of these changes, you have to resubmit a new Xap with these updated client library bits in them.

Looking at Copy and Paste in action

So if you have an app that uses text box, you’re ready to go. Here’s what it looks like when you use the newest tools build, that contains the ROM image with copy & paste built into the framework.

Select some text in the text box

Click the copy indicator button near the selection

In the SIP (software keyboard), click the paste icon to insert it!

There is no programmatic API to access the clipboard at this time.

Silverlight for Windows Phone Toolkit February 2011 release is brewing

We’ve been addressing customer-reported bugs and issues with the previous Silverlight for Windows Phone Toolkit release, and are getting close to having something ready. As we’ve always been a small, agile, dedicated team, we’re trying to fix up a few last-minute issues before pushing the button.

We will also be adding Visual Basic samples this time around.

Some of the fixes you can look forward to:

Improved transitions experience including a timing fix and new easing functions to better match the phone UX. Oftentimes the transitions would not appear on the device when complex pages were being navigated to.
Large set of LongListSelector (LLS) control improvements and bug fixes.
An AutoCompleteBox crash fix.
Other minor customer bug fixes (as indicated in the work items tracker)
The November updates addressing marketplace ingestion issues

About bleeding-edge phone toolkit source

Something we are trying with the phone toolkit now is offering important fixes and other changes directly in the source control, ahead of the next official binary release. This allows us to better serve folks by offering a preview of what’s coming.

Here’s where you go to list all the changesets we’ve submitted for the toolkit source: http://silverlight.codeplex.com/SourceControl/list/changesets

If you build the source for the toolkit in your project, then you can easily get these new changes. And, you’re an honorary member of the Silverlight Toolkit testing team since you can help us uncover issues and send feedback ahead of the larger release.

This kind of input is super important. We’ll try not to push bugs to the source control, but it can happen!

Open source notes on the Silverlight Toolkit

It’s very exciting being a part of the Silverlight Toolkit and its sister release, the Silverlight for Windows Phone Toolkit. The large source tree is a great learning resource for Silverlight developers everywhere w.r.t. custom control development. But it is also true that we don’t accept external contributions to the toolkit at this time, it is a pull-only repository. You’re free to fork it into your projects and enjoy it as you like, but if you submit patches to the site, we unfortunately cannot use them. Recently we updated the homepage of the Silverlight Toolkit to note this, since we don’t want to waste anyone’s time creating patches that cannot be used (sorry!).

Here are a few notes specific to the toolkit for Microsofties, however…

If you are a Microsoft dev

If you are a full-time Microsoft employee and using the Silverlight (or phone) Toolkit, we’re happy for that, and are definitely interested in accepting any bug fixes or improvements to the existing controls. Just send me an e-mail to talk about this, since we do have a set of guidelines and process for this sort of thing.

We recently had a number of great unit test fixes come in this way, and appreciate the help, since we often can only focus on one release of technology at a time.

If you are a Microsoft team

Microsoft teams looking to use the Silverlight Toolkit can find more information at this internal link.

If you want to be a Microsoft developer

We’re always hiring – find out more at the http://careers.microsoft.com/.

Silverlight Unit Testing Updates coming soon

There have been a flurry of bug fixes checked into our source control system for the unit test framework, powered by customer-reported issues and a few generous developers inside Microsoft who have contributed improvements that their teams have been using.

Some of the fixes and changes include:

Phone unit test framework interface fixes
Automated test service fixes (restores command-line test execution)
Browser automation fixes
Targets file fixes
Additional metadata for test methods

When I have new builds ready and blogged, I’ll also be updating the source on the public CodePlex site. No timeline for this yet, though; sorry.

Yup, I’m building an app…

If you follow my Twitter stream (@jeffwilcox), you know that I often spend my evenings and weekends coding. I’ve been building a social app for Windows Phone and it has been a really fun (and challenging) process building an app from the ground-up.

Once the app is finished, I will be covering in detail the challenges and issues I encountered, and strategies for dealing with many of the issues large apps are hitting. I’m also trying to get the best guidance on improving scrolling performance in lists, and have spoken with a number of devs about this recently.

Great 2010

I also wanted to take this time to thank everyone that I’ve had the pleasure of interacting with in the past year. It’s been exciting, bringing our new platform to light, leveraging years of hard work we have done on the Silverlight team.

This was nice for me as I was able to meet other folks at Microsoft worldwide, developers in so many places, and sit with smart engineers from other companies for a change. Well worth the price paid sitting in the back of planes. I swear I could walk through SEA-TAC airport with my eyes closed now.

Thanks, happy new year, and enjoy the Super Bowl if you’re in the states and into American football.

A quick look at the types of Windows Phone page transition animations

Jeff Wilcox — Wed, 17 Nov 2010 00:42:14 +0000

Today Will Faught from the Silverlight Toolkit team blogged about the transitions built into the latest release of the Silverlight for Windows Phone Toolkit. Good stuff (Will was the developer for this feature).

In case you haven’t opened up the sample app that came with the phone kit, and just want to see at a basic level what these different transition animations are, I built this quick Silverlight app to show them to you. Click on the name of the animation type to see what it looks like as the out/forward transition.

And yes, in case you’re wondering about the beauty of Silverlight code consistency, this app is built by just starting a new Silverlight project and pulling in some of the open source phone toolkit files. Enjoy the transition animations on your pages!

Early Windows Phone media with the Silverlight Mobile team

Jeff Wilcox — Wed, 22 Sep 2010 20:44:47 +0000

Several of us from the Silverlight Mobile and Silverlight Toolkit team have been featured on podcasts, video segments and written great articles in the weeks leading up to the release of the Windows Phone developer tools.

I wanted to share some links to some of this media to specifically highlight members of the Silverlight team who have been helping to make this launch a success:

Silverlight for Windows Phone Toolkit:

David Anson and Dave Relyea (Channel 9)

Panorama and Pivot Controls Introduction:

Jeff Wilcox (Channel 9)

Silverlight Performance:

Enjoy.

Windows Phone Developers: Enjoy the new controls, toolkit, and final tools!

Jeff Wilcox — Thu, 16 Sep 2010 17:16:14 +0000

Today the Windows Phone developer tools have been released (Scott’s post here, Windows Phone post here). Everything you need is easy to get started with (download here), from the free Visual Studio express to the free Expression Blend designer tools, emulator, and plenty of controls and tools to help you along the way.

There isn’t much I have to add as it’s a fun-filled day of tweeting, blogging, downloading, installin’ and building apps.

Make sure to see the official documentation of What’s New in the Final Release.

Official Panorama and Pivot Controls

Personally, the biggest news of the day is that the Microsoft official Panorama and Pivot controls are now in the tools (we missed getting them in the beta, that’s water under the bridge now though, right?).

Taking some credit here for the Silverlight implementations, Jeff Wilcox developed the Pivot control, Dave Relyea created the Panorama control, and David Anson was instrumental in working on both. (Now you know who you can complain to). I also want to point out that there have been many other teams at Microsoft, especially those who work with the mobile operators, who did a lot of the early heavy lifting in defining the model and working to explore this area, having done very similar work. I think together we’ve all learned a lot and built some impressive controls for this new platform – let us know!

The controls are built right into the tools that you can download here.

My introductory post on the controls is still valid: http://www.jeff.wilcox.name/2010/08/looking-ahead-at-panorama-and-pivot/

You’ll also find MSDN documentation on Panorama and the Pivot control.

Introducing the Silverlight for Windows Phone Toolkit

It’s pretty hard to imagine a Silverlight platform without an awesome side dish a.k.a. the Silverlight Toolkit. The Windows Phone platform is no different, and we’re pleased to announce that the Silverlight Toolkit site now includes a new SKU, the Silverlight for Windows Phone Toolkit.

Goodness in the bits include:

ContextMenu
DatePicker
GestureService
TimePicker
ToggleSwitch
WrapPanel

David Anson has a really nice overview of all the new controls in the phone toolkit, including XAML samples and APIs. John Papa also covers some of the new controls here.

Progress Bar performance note

And yet another reminder: if you are using the indeterminate ProgressBar built into the Windows Phone platform, please follow my instructions to make sure you have a smooth, fluid user interface experience. You need to use a special workaround to offload the animations to the compositor thread and remember to toggle IsIndeterminate back to false when you no longer need it.

This is super important because so many applications are doing potentially heavy processing when they are showing a progress bar like this. The performance issue is not evident in the emulator as much as on actual Windows Phone 7 devices by the way.

Applications Applications Applications

I’ve been able to travel around the world meeting with developers to check out their apps. There are some amazing and fun apps being built using these tools, and we have been learning a lot about best practices, caveats, tips and tricks.

Over the coming weeks, we’ll be working to provide more app development guidance, so let us know how things go.

I’d highly recommend that you take the time to subscribe at least initially to these blogs to keep on top of these tips & tricks:

Hope you have fun exploring the RTM release of the platform!

Updated Silverlight Unit Test Framework bits for Windows Phone and Silverlight 3

Jeff Wilcox — Thu, 27 May 2010 21:02:52 +0000

Here are updated quasi-official unit test framework bits for Silverlight 3 and Windows Phone developers. These are not intended for Silverlight 4 developers, since the same framework built for SL4 is included in the April 2010 Silverlight Toolkit.

This brings the new features from the Silverlight 4 version to developers who have a business reason to continue with Silverlight 3 development for the time being:

Updated user interface
Integrated “tag expression” support for selecting subsets of tests to run
Performance improvements
Removal of dependencies on XLinq and System.Windows.Browser assemblies

These are also the bits you want for Windows Phone testing.

Why wasn’t there one for Silverlight 3 already?

Since the April 2010 toolkit release was targeted for Silverlight 4 developers only, these bits were not released for version 3 (though were built from the same source).

Why doesn’t the April 2010 toolkit work for Windows Phone development & testing?

The Windows Phone development environment is based on a version of Silverlight 3 today, and so that means that you need to use Silverlight 3 binaries and class libraries when re-using Silverlight apps and code – not Silverlight 4.

These bits work well for phone developers and replace the older bits I had posted to my MIX talk site.

Download the binaries

[Silverlight 3 binaries for the Silverlight Unit Test Framework, Zip 452KB]
You may need to ‘unlock’ the binaries for security reasons once downloading and extracting the assemblies from the .Zip. To do this, right-click on the file and select the ‘Unlock’ button.

These binaries are strong named as before, but are not Authenticode signed, so they are not official. This helps work around some Windows Phone signing issues I’ve heard reports of.

Hope this helps,
Jeff

How about a Zune-style ChildWindow?

Jeff Wilcox — Fri, 21 May 2010 21:25:39 +0000

Today I’m sharing my new ChildWindow style. It is a differentiated child window designed in that it doesn’t have a close button, has a completely different animation in and out, and I thought I was worth sharing. I’ve included a runtime app so you can run it and see for yourself.

My ChildWindow style

Click on the window above to open a simple Silverlight 4 application that demonstrates the transitions and interactivity. Project download.

Some things to call out:

I don’t include a Close button in the window chrome.
I hook up to the OnKeyDown event in my sample implementation. I always try and do this with my ChildWindows so that the escape (ESC) key can be treated as a cancelation of the dialog. Personal preference but a usability win I believe.
I like a light overlay color instead of a darkening experience, and went for that look.
My actual implementation uses a value converter to capitalize the title. I’ve removed this from my template for the time being.

The story on my evolving, unnamed theme, and how it relates to “Cosmopolitan”

There’s an excellent “Cosmopolitan” Silverlight project template + theme available that makes building good-looking interfaces a snap, and I’d highly recommend it if you’re looking to modernize the look of a new Silverlight project. I believe it pulls from “codename Metro” design ideas. It just works and as a VS template it rocks!

I’ve built an alternative, but similar theme, over time that I use on many of my projects, and it also pulls from the inspiration of the clean, consistent Zune software design principals.

Now that the “Cosmopolitan” theme is out there, I’ve been taking the time to compare and contrast my similar theme with this, and see where I can make changes. Yeah, the things I do in my free time are baffling…

This is a good exercise because design is a two-way street, comparing and contrasting design decisions and implementations: I’ve learned that I should have been including validation templates in my theme (oops, haven’t used that feature enough). And I’ve shared some minor feedback on parts of the “Cosmopolitan” theme’s implementation details with its designers.

In the future I’ll present the complete theme for many controls, but until that develops, I’m going to continue to share small styles and templates, along with my comments along the way. Previously I blogged my context menu style.

If you’re wondering “why should I use ChildWindow?” – I used to wonder the same thing. But I’m using ChildWindow more now than ever. I’ve discovered the importance of the nice integration with Visual Studio (there’s an item template for child windows), and out-of-browser applications have many uses for a rich modal-style window for sharing information at runtime.

I’ve completely replaced the MessageBox in my out-of-browser applications to instead use a child window designed to replace the message box functionality, offering a consistent visual design even when a message box-like experience is needed. I even use extension methods to add methods to MessageBox to instead use my styled child window.

Other ChildWindow styles

Here’s the standard ChildWindow style and control template that is built into the Silverlight SDK. I’m displaying a password entry form adapted from an app I was experimenting with:

Here is the same window with the “Cosmopolitan” theme’s style applied:

Note: There’s a bug in ChildWindow implicit styling support

While working on creating themes, I did discover that there’s an unfortunate bug in Silverlight 4 where the implicit styles for ChildWindow are not picked up in certain XAML scenarios. Namely, if you use the handy item template in Visual Studio, the implicit style won’t be picked up.

Oddly, at times Visual Studio will show the proper implicit style, but at runtime it will revert to the standard control default style. Here’s a small screenshot – this is out-of-the-box “Cosmopolitan” theme with a ChildWindow item template.

At design time it looks fine:

At runtime:

It appears that this item template format, where the XAML file of the child window’s root is the child window, doesn’t allow the style that was implicitly defined to be picked up.

No worries. To workaround this, add a Style attribute to the root of the file and a static resource to ChildWindow name. If you’re working with “Cosmopolitan”, then here are the steps:

Open the Assets/SDKStyles.xaml file
Navigate to the implicit style for ChildWindow around line 2,440
Add an x:Key to make the style explicit instead of implicit. x:Key=”ChildWindowStyle”
Add this line after the (now explicit) style:

Here’s how you reference it:

And now let’s make that into an implicit style for Silverlight 4. Just remove the x:Key:

And here’s how you reference that style – you don’t – it’s implicit:

Small caveat, fyi: there is a bug with implicit styles not necessarily being applied within data templates. To work around this, I had to move to explicit styles (adding an x:Key to the style, then setting the Style property in the DataTemplate’s XAML to the static resource’s key).

Local fonts

I also used a feature of Silverlight 4 that lets me pick up and use local fonts on the machine. I’m using the ‘Segoe UI’ font, a key part of the Windows 7 user experience and visual identity.

However I also define fallback fonts, just like you would in HTML:

My Zune-like context menu

Here are the templates I ended up creating using Expression Blend.

To achieve the fade-in effect, I faked a little and used a Loaded event trigger, so the first time any particular context menu is shown, it will quickly fade – but subsequent presentations of the same instance will not fade, for a faster, more performant feel.

ContextMenu Style

Separator Style

MenuItem Style

ZuneLikeContextMenuImplicitStyles.xaml.txt: XAML. Download all three in one file. The file contains both implicit styles plus defined style names.

Here’s a comparison, a screenshot of the Zune menu on the left, and my Silverlight 4 context menu on the right:

Hope this helps you create some nice modern-looking Silverlight apps!

Silverlight Unit Test Framework: New version in the April 2010 Silverlight Toolkit

Jeff Wilcox — Mon, 03 May 2010 22:26:06 +0000

In April we released a new version of the Silverlight Toolkit for targeting Microsoft Silverlight 4. This release contains a new version of the Silverlight Unit Test Framework. Key improvements come in user interface, Silverlight 4 support, and performance.

Rich, modern user interface

The user interface no longer uses the antiquated HTML DOM bridge for displaying results, but now is a data bound, rich Silverlight application itself.

Rich results information is available, and a tree view control allows you to select results to be included in a test report that can be copied to the clipboard. Failures are automatically selected.

The results pane includes information about the tests that ran, as well as detailed information for failures.

Descriptive text helps identify negative tests, known test issues and bugs, and other important metadata that was not always exposed in the previous test framework.

Integrated tag expression support

The startup experience now allows you to enter a tag expression to select which tests to run, or not to run. You can add the Tag(“”) attribute to any test methods or classes to define your own tags. Also, the full and short names of tests and classes implicitly become test tags, as well as priorities.

This means that you can define tags such as:

!MyTest1	Run all tests except for the method named MyTest1
MyTest1+MyTest2	Run the MyTest1 and MyTest2 test methods

Out of Browser support

The framework now supports running out-of-browser. Paired with the new Silverlight 4 Tools for Visual Studio 2010, you can press F5 to run a test project you have marked as an out-of-browser.

This also opens up an opportunity to do testing of elevated apps that make use of AutomationFactory and other advanced features on Windows.

Simplified dependencies

The test framework removed dependencies on System.Windows.Browser (from the platform) and System.Xml.Linq (XLinq, from the SDK).

Building blocks for Windows Phone testing support

This version also contains the full source to the phone testing interface, which is significantly different in visual design and experience to coincide with the Windows Phone device size.

However, the story for phone testing is still developing: in the meantime binaries designed for phone use can be found at http://jeffatmix.com/

New location for binaries

Since the new rich user interface contains a number of controls, the traditional design-time integration system conflicts and presents some issues.

As a result, we had to move the binaries from the Bin directory of the toolkit installation folder into a new Testing directory.

So the two test framework assemblies (Microsoft.Silverlight.Testing and Microsoft.VisualStudio.QualityTools.UnitTesting.Silverlight) have moved.

This location change could cause existing applications that reference the test assemblies to fail to compile due to the "missing" references.

If that happens, please delete the two broken references and create references to these assemblies in their new location. Everything else should continue to work as expected.

Simplified test project template

In alignment with the test project changes in Visual Studio 2010, which are more simplified, the unit test project template for Silverlight no longer includes a README.TXT file.

Known issues

Test service

I’ve received reports from a number of people about issues with the test service automation support. Some of the NDA/preview users of the framework reported issues that were corrected, but there may still be some bugs out there. I’m working to investigate and post a fix if and when I know more.

In the meantime I know that StatLight, a third party system, has been updated for the April release and is working well for automation.

Test panel and visuals

Please beware that some of your tests may need to be updated to use the new framework if your application, utility functions, or tests ever used the Application.Current.RootVisual (against the recommended pattern for interface testing).

The root visual is now the test framework application runner itself, and the tests run within the same TestPanel as before. Controls added to the test panel will not be located at the 0, 0 screen position, but likely near the bottom of the screen instead.

Hope this helps. To get started, download and install the April toolkit!

No March 2010 release of the Silverlight Toolkit

Jeff Wilcox — Fri, 26 Mar 2010 00:08:04 +0000

I’ve received a number of emails and questions from developers about the next release of the Silverlight Toolkit and wanted to take a moment to address the lack of a March release.

Although we had previously talked about a March 2010 release to coincide with the Silverlight 4 RC at MIX, we have decided not to ship an interim release for the RC, since the final release of Silverlight 4 is coming next month.

This is a good thing for developers, the time we save by not releasing goes toward a better release overall when Silverlight 4 is final.

In the meantime, the release of the toolkit in November, for Silverlight 3, still works great on Silverlight 4 RC.

Silverlight Toolkit and the Windows Phone: WrapPanel, and a few others

Jeff Wilcox — Sun, 21 Mar 2010 20:27:34 +0000

Are you looking for WrapPanel for your Windows Phone application? Look no further. The Silverlight Toolkit has several controls that work pretty well on the Windows Phone.

I wanted to provide my own informal look at how it’s working with Silverlight for Windows Phone today.

Note that this information is only current as of today, 3/21, when used with the MIX-related CTP of the tools and emulator, and the November 2009 Silverlight Toolkit. A lot could change, and this is not exhaustive.

I’m also including some controls that are found in the Silverlight SDK today. I present these in order of how much I have used the components while building apps.

WrapPanel and DockPanel

Found in the Silverlight Toolkit, System.Windows.Controls.Toolkit.dll (SWC.Toolkit).

Work great.

If you just need the WrapPanel, and don’t want to include the entire toolkit assembly, you can just paste these source files into your application project instead (license: Ms-PL):

Charting and Data Visualization

There is a known issue with LINQ that prevents the controls today from working perfectly. A small, targeted fix has been made in the charting codebase and a future release will work well on the device.

Re-templating and styling the control is very important, and required, for working on the phone in an acceptable manner. I hope to share any decent templates I can come up with.

HeaderedItemsControl, HeaderedContentControl

Work great. Split between System.Windows.Controls (SWC) and SWC.Toolkit.

TreeView

SWC. Functional; requires massive re-templating and styling. Font sizes are much too small, and the theme and visuals do not appear code-name “Metro” compatible.

AutoCompleteBox

Found in the System.Windows.Controls.Input SDK library of the Silverlight 3 SDK.

Works OK, not ready for general development use.

Drop-down appears well. Major features all work. However, touching an entry in the drop down only performs selection. A second touch is required to verify the choice, effectively requiring a double-tap in use.

Calendar, DatePicker

SWC. Limited functionality, too small visually. Not designed for touch – not enough space to reliably click on a date. Require massive re-templating. Do not resemble the same experience as the date picker built into the Windows Phone operating system.

GridSplitter

Works, but may pose difficult to use on a device: requires much larger padding and custom templates to make the touch area visible and useful.

Not yet checked

DataGrid, DataPager, ChildWindow, Label, NumericUpDown, DomainUpDown, DataForm, Rating, TimePicker, TimeUpDown, GlobalCalendar, TransitioningContentControl, TreeMap, BusyIndicator, Viewbox, Expander, Accordion, drag and drop features, and many more.

We’re also still developing a story for the toolkit’s phone story moving forward. As there is a lot of momentum around the phone in the company, it’s very likely that some set of phone tools, samples, and toolkits come out.

Hope this helps.