If you’re using the November release, I strongly recommend that you upgrade – we’ve worked hard to ensure that we’re making positive incremental improvements, and you will find a lot of nice functionality in this release. There are not any new controls in this release.

The CodePlex site is the place to go to request new features, vote on suggestions that others have, and view additional information. We also run a forum and are diligent about following up on your questions.

Controls

The following controls are in the "Stable" quality band, you should be able to use these and enjoy the experience for many releases to come:

• AutoCompleteBox (promoted!)
• DockPanel
• HeaderedContentControl
• HeaderedItemsControl
• Label
• NumericUpDown (promoted)
• TreeView
• WrapPanel

These controls are in "Preview" quality band:

• Charting
• Expander
• ImplicitStyleManager
• Viewbox

Don’t let the "Preview" designation scare you off – I am using the charting and data visualization controls on several of my projects today and enjoying ever minute. It was really easy to pick up and learn.

Themes

There are new themes, similar to those you might find in Office and various Windows operating systems. You can view them here.

New sample explorer

We’ve combined the two sample projects into a single:

The new sample application also supports deep linking, so if you’re interested in a specific component, click away!

The links below go directly to the individual control pages and scenarios in the sample app:

Controls

• AutoCompleteBox
• DockPanel
• Expander
• TreeView
• ViewBox
• WrapPanel

DataVisualization

• Column
• Bar
• Pie
• Line
• Bubble
• Scatter

Input

• ButtonSpinner
• NumericUpDown
• UpDownBase

Theming

• Theme Browser
• ImplicitStyleManager

I’ll be following up with a few posts over the coming week covering new features, applications, scenarios, and of course the list of changes in the AutoCompleteBox control.

Hope you love it. At this price point (free), I hope that you’re able to share this with all of your developer friends this holiday season. Let me know what you think of the progress we’ve made, and the overall Silverlight Toolkit experience.

Check it out on the MSDN Code site:
Download the source code

I use Flickr’s web services and for most of the more advanced operations, you need to ‘sign’ the request using an MD5 shared secret – so this is a great improvement on what I had previously blogged about at MIX. I’ve been using this code for a few weeks now and love it.

I won’t get into a discussion on the pros or cons of MD5, other than to say, this is freaking awesome! Congratulations Reid.

Maurice de Beijer has blogged about his solution for creating a testable Flickr web service API. He’s created TestableWebClient and TestableOpenReadCompletedEventArgs types to assist with this, and kept the abstraction simple and to-the-point.

I agree with Maurice’s comments: it isn’t perfect, it isn’t awful; it isn’t pretty; but hey, it does get the job done, and he’s found a good solution for this today.

Maurice also previously posted his own introduction guide to Silverlight unit testing.

Just wanted to pass along, definitely check this out!

If you were intrigued by it, you’ll be happy to know that the source code is published and part of the Silverlight unit test framework’s source code, part of the ‘Quality’ section of the Silverlight Toolkit’s source enlistment.

Download the source here
Original post: Client-side HTML controls for Silverlight 2

Enjoy!

Since my blog’s filled with some fairly technical resources, I should point out that the book is not the right reference for anyone that has an extensive knowledge of WPF or that has been an early adopter of Silverlight 2.

Laurent’s book instead targets everyone else: the millions of web developers that are new to .NET, looking to expand their working knowledge, or just wanting to learn something about the new exciting Silverlight platform. Much like Adam Nathan’s WPF Unleashed book, the full color examples and screen captures really add life and will help you connect to the tools and examples.

The book is organized into many vignettes almost, each covering a concept, walkthrough of a task, and showing screen captures, code, and helpful tips along the way. As a former client- server- Flash- everything- guy, I’m confident in saying that this is a great overview of what you’d expect if you were wanting to get all the key, above-the-fold info on this new platform.

In Chapter 1, the book begins covering where Silverlight has come from, other plug-ins, and demos. Chapter 2 moves on to XAML, and then the book moves on to basic transforms, colors, paths, JavaScript basics, and finally, chapter 9, an intro to .NET.

The middle of the book moves to C# programming, isolated storage, and animations. There’s then coverage on Expression, videos, and events. It then progresses to details on the rich Microsoft presentation platform basics, and will be familiar to WPF developers. This includes layout basics, the built-in controls, simple interaction and interoperability features.

The rest of Silverlight 2 Unleashed book covers a few neat topics that people may not be as familiar with: loading media metadata, quick WCF basics, cross-domain requests, exception handling, and then a bunch of odds-and-ends that will whet your appetite for learning more about working in a Silverlight world, working with binding converters, unit testing, and resources for finding controls and resources.

And, yes, you read that right: a Silverlight unit testing walkthrough is on pages 541-549. For full disclosure, I should note that I did work with Laurent to review that part of Chapter 24.

Anyway, if you’re looking to move to the Microsoft web platform, expand your skills, and see what Silverlight is all about – do check it out! Oh, and if you’re looking for even more controls resources, do check out the Silverlight Toolkit.

This was originally one of the more complex samples that we included in the toolkit sample project, and Tim has done a great job boiling it down to the essentials, complete with step-by-step code.

Definitely check it out at http://timheuer.com/blog/archive/2008/11/05/silverlight-editable-combobox-using-styles.aspx.

This really cuts down on the moving parts from the previous 1.0 templates that had dependencies on so many loose JavaScript files.

I wanted to blog about my experience in case others ran into this: if you have your Xap files on a domain different than your pages, you might find that the Silverlight plugin is blank and the media player never loads. This is a by-design feature per the Silverlight HTML DOM bridge security model – but you can actually do a few things to get this to work.

I host my Silverlight applications and media assets on a separate domain. This creates the situation where the bridge is disabled; if you would like to reference the .Xap files from different sites or enable others to embed your video player, it won’t work out of the box unless you modify the <object /> tag or modify and rebuild the managed media player to gracefully move on in this situation.

Here’s the breakdown that I have for my web pages vs. my Silverlight assets, including the apps:

The additional parameter within the object tag will be easiest for most folks, and is probably the way that the Expression team hopes that you’ll enable this scenario. I always forget things like modifying the object tags, since this isn’t in the default generated HTML file that Encoder outputs, so I’m going for a more involved solution.

Oh, and don’t get me wrong: SP1 rocks. I highly recommend that you install it; I’m getting so much more use out of Encoder 2 now. If you haven’t purchased Encoder… well, you really should try or buy it. With SP1 it not only adds the nice Silverlight 2 templates, but also H.264 mobile encoding. I was able encode my screencast in H.264, and it looks great on my iPhone!

The HTML DOM Bridge security model in Silverlight

Per the DOM bridge security model in Silverlight 2, the default behavior when the .Xap is hosted on a domain different than your web page, is that the HTML DOM bridge feature will be disabled for that Silverlight application in the .Xap. The DOM bridge is used by the managed media player to get the document URI property when trying to look up relative-path video assets.

This situation can also present itself on the same domain, when the web page author explicitly denies the HTML DOM bridge access to a plugin: if the <param name=”EnableHtmlAccess” value=”false” /> tag is present in the object tag, the DOM bridge will not work and the media player template will end up throwing an exception while trying to access the HtmlPage.Document.DocumentUri property.

The quick fix

Inside your Silverlight plugin object tag, add the EnableHtmlAccess parameter with a value of ‘true’. Here is a sample embedded object tag with the parameter added:

<object data=”data:application/x-silverlight-2,” type=”application/x-silverlight-2″ width=”685″ height=”448″>
     <param name=”source” value=”http://media.cdn.com/Xaps/MediaPlayerTemplate.xap” />
     <param name=”initparams” value=”expression encoder generated parameters go here” />
     <param name=”enableHtmlAccess” value=”true” />
</object>

The source fix

I decided to just update the media player to not be dependent on the HTML DOM bridge feature.

This fix assumes that you always provide the absolute URI for video assets in the playlist. Effectively it won’t try any relative URI lookups when HTML DOM bridge access is not permitted.

Thanks to the Expression team, they did a good thing and shipped the source to the media player template with the product. You will find it in %programfiles%\Microsoft Expression\Encoder 2\Templates\en\SL2Standard\Source. It opens with Visual Studio 2008 SP1 + the Silverlight 2 Developer Tools.

I went ahead and rebuilt the template: whenever the C# code would try and use the HtmlPage.Document.DocumentUri getter, I would encase the code in an HtmlPage.IsEnabled check. I had to do this in just a few spots.

One nice side effect was that I was able to chop the .Xap size down about 50K by removing the Adaptive Streaming support built into the template, since I just host my media assets over simple HTTP and do not do streaming.

For your reference:

Download ModifiedTemplate.zip (69 K, solution in a Zip)
Download MediaPlayerTemplate.xap (114 K, Xap)
Note: Does not contain adaptive streaming support.

HtmlPage.IsEnabled lesson

You should always make sure to check the HtmlPage.IsEnabled property before attempting to access any of the HTML DOM bridge resources. This is good practice whether thinking about scenarios where the bridge is disabled, or designer tools like Cider and Blend.

Disclaimer: I am not a member of the Expression team, this is not my area of expertise, other than being a member of the original HTML DOM bridge feature crew for Silverlight. I do not know if this was a known issue before, an expected, by-design feature, will be fixed, or anything like that.

Live, embeddable player: Shawn Burke’s PDC talk

Oh, and here’s Shawn Burke’s excellent PDC talk. If you haven’t checked out everything that was released in the Silverlight Toolkit, or heard about the release model, you should watch this. It is using my updated Xap player, so you can even embed Shawn’s talk in your own blog.

Hope this helps.

If you’ve ever had to do the "rename .Xap to .Zip" routine while doing Silverlight development, then you’ll enjoy this fix. The entry also sets the MIME type of .Xaps to "application/x-silverlight-app", so it relates to my earlier post about the MIME type, too.

I’ve been using this on my Windows Vista and Windows Server 2008 workstation, but have not tried it on XP.

XNA users: Jeff Klawiter pointed out in the comments that part of the XNA Framework uses .xap for its project file extension. So, beware. Sucks that there is overlap.

Disclaimer: Use this registry file at your own risk. I am not responsible in any way for the results. As developers like to say, "it works great on my machine!"

Download and run this registry patch: Xap.reg

Here’s the contents of the registry patch:

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\.xap]
"PerceivedType"="compressed"
"Content Type"="application/x-silverlight-app"
@="CompressedFolder"

[HKEY_CLASSES_ROOT\.xap\CompressedFolder]

[HKEY_CLASSES_ROOT\.xap\OpenWithProgids]
"CompressedFolder"=""

[HKEY_CLASSES_ROOT\.xap\PersistentHandler]
@="{098f2470-bae0-11cd-b579-08002b30bfeb}"

The experience before the patch:

And after:

Hope this helps!

When you do not need to configure the MIME type:

• If your .Xap files and web pages are on the same domain and do not need to be embedded elsewhere
• If you use a service like Silverlight Streaming and just embed <iframe /> tags in your web site

But, if you want to share or enable embedding for others, you need to add the “application/x-silverlight-app” MIME type for your .Xap files.

This will allow:

• You to host your application binaries with a CDN
• Others to embed your applications in their pages and sites
• Bloggers to embed Silverlight <object /> tags right in their content and let syndication services and news readers embed the content

Equally important, if you don’t want others to directly link to and reference your .Xap from their domains, then make sure to not send this mime type.

Apache
For global configuration, in your central mime.types file, add:

# Enable Silverlight support for our apps to be embedded anywhere
application/x-silverlight-app        xap

Then restart Apache:

$ sudo ./apachectl restart

If you’re just configuring at the directory level, edit or add the .htaccess file in the directory you want to serve anywhere, and add the line:

AddType application/x-silverlight-app xap

IIS 6 & 7
Here’s a nice step-by-step guide to adding the MIME type on Windows web servers.

Amazon S3
Maybe not a true CDN, I do use Amazon’s Simple Storage Service (S3) for most of my Silverlight application hosting.

Amazon S3 records the MIME type that your S3 client sends with each file upload. This means that you must configure your system with the appropriate “application/x-silverlight-app” MIME type when you upload, or when clients download your .Xap, they will get an unknown MIME type and be greeted with blank space where you’d expect your app to be working.

Your CDN
I do not know the current Limelight or Akamai stories, sorry! Feel free to post a comment if you know.

Use Fiddler to check

I’d highly recommend that you download and use Fiddler2 on your Windows system. Using it, you can make sure and see what the content type is when it comes back in an HTTP response.

Note: This post contains live Silverlight content that your news reader may not be able to display.

The auto complete pattern is well-known, useful, time-tested. There’s been one in IE for ages. You expect that your e-mail client auto completes. Auto complete functionality can be found in controls in Winforms, WPF, AJAX, Flex. And now, Silverlight.

With the Silverlight Toolkit, we’ve decided to go beyond text-only suggestions. With basics in mind, we designed a flexible & extensible control that lets modern app developers use data binding, styling, data templates, and more.

Auto complete features you expect

• Bind to a list
• Override population
• Set a minimum length required to get results
• Set a delay before fetching suggestions

Silverlight AutoCompleteBox features

• Style and retemplate: style the control, the text box, the container; set a DataTemplate for items in the drop down; retemplate the control to look like a combo box; you name it.
• Built-in search modes. Provide your own custom text and item filter lambdas.
• Replace the ListBox with your own custom selection adapter

Using AutoComplete

To get started, just set the ItemsSource property to an IEnumerable. You’re then hooked up to the default filtering and are ready to go.

I’m going to walk you through some simple scenarios now using the control assemblies that we shipped in the toolkit. To follow along, you’ll need Visual Studio 2008 (SP1) with the Silverlight 2 Tools installed, plus the free Silverlight Toolkit.

First, create a new Silverlight application project: open Visual Studio, go to the File | New | Project menu option, and create a new C# ‘Silverlight Application’ project.

In the ‘Add Silverlight Application’ dialog, select the 2nd option to ‘Automatically generate a test page’, and click Ok.

To add a reference to the main toolkit control library, right-click on the project in the Solution Explorer and select ‘Add Reference’.

Now, click on the ‘Browse’ tab, locate the extracted toolkit folders, and move into the ‘Binaries’ directory. Select the ‘Microsoft.Windows.Controls.dll’ file and click Ok.

If you create a new Silverlight Application project and add a reference to the Microsoft.Windows.Controls.dll assembly that we shipped in the toolkit, you can follow along and learn about the control.

Inside Microsoft.Windows.Controls we included ObjectCollection. It makes it easy to create collections in SIlverlight XAML.

Inside Page.xaml:

• Add the XML namespace for the Silverlight Toolkit controls. I’m using the prefix "controls" here.
• Add mscorlib as a namespace, for strings.
• Add an ObjectCollection of months in the resources.
• Create an AutoCompleteBox control, setting the ItemsSource.

Here’s the Page.xaml file:

<UserControl x:Class="SilverlightApplication6.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:clr="clr-namespace:System;assembly=mscorlib"
    xmlns:controls="clr-namespace:Microsoft.Windows.Controls;assembly=Microsoft.Windows.Controls"
    Width="400" Height="300">
    <UserControl.Resources>
        <controls:ObjectCollection x:Key="Months">
            <clr:String>January</clr:String>
            <clr:String>February</clr:String>
            <clr:String>March</clr:String>
            <clr:String>April</clr:String>
            <clr:String>May</clr:String>
            <clr:String>June</clr:String>
            <clr:String>July</clr:String>
            <clr:String>August</clr:String>
            <clr:String>September</clr:String>
            <clr:String>October</clr:String>
            <clr:String>November</clr:String>
            <clr:String>December</clr:String>
        </controls:ObjectCollection>
    </UserControl.Resources>
    <StackPanel VerticalAlignment="Top" Margin="5">
        <controls:AutoCompleteBox ItemsSource="{StaticResource Months}" />
    </StackPanel>
</UserControl>

If you press F5 to run the project, you’ll get a text box that lets you type in a month.

Here is the application:

Do know that in the current release, this control does not respect the INotifyCollectionChanged interface. If you’re changing the underlying data, please reset the ItemsSource to a new list. We’ll address this in a future release.

Key AutoCompleteBox properties, methods and events

ItemsSource

Set your data here.

Text

Contains the current text that the user has entered or selected.

The TextChanged event is fired whenever the text is updated. Most classic auto complete applications function like text boxes, so those apps can use the Text and TextChanged events as they are.

You can also replace most simple TextBox instances in your applications with AutoCompleteBox.

IsTextCompletionEnabled

This property is true by default. It will perform a search on your items and look for the best match; if one is found, the text box is updated with the item’s string value, and the rest of the text will be highlighted.

SelectedItem

Is null if no item is currently selected.

If the user navigates through the drop down, selecting items, or clicks on an item, this will be updated to that item.

The SelectedItemChanged event fires when the item changes.

If you enter text into the control, such as "Steve Ballmer," the SelectedItem may not be updated to an item unless the list box item is selected or if you have text completion enabled.

SearchMode

Selects the built-in search filter to use. The default is "StartsWith," and checks that each item’s string value starts with the user’s search string. "Contains" is another very useful value, as is "None".

If you connect AutoCompleteBox to a web server that performs its own filtering, you’ll probably want to set the SearchMode to ‘None’.

MinimumPopulateDelay

This is an amount of time that elapses after the user types and the population event is fired.

The default value of 0 is very quick, so every time the user enters new character, the Populating event is fired. If you’re connected to a web service, you’ll want to step back and place a reasonable value in here so that not every keypress goes straight to the server.

MinimumPrefixLength

This is the minimum number of characters that must be entered before the control looks for suggestions. The default value is 1, but a lot of classic AJAX auto complete controls use 3 as the default value, so this is a common customization property.

Advanced scenarios might make use of:

TextFilter

Provide a lambda/delegate that takes two parameters: the search string, and the string that represents an item. The function needs to return bool true or false, indicating whether the item should be shown as a suggestion in the drop down list.

ItemFilter

The more fun version of TextFilter, this takes a lambda expression that has two inputs: the search string, and the item as an object. You are then free to use your own filtering logic with your rich data types to return true or false.

Populating event

Called whenever the control is ready to search for suggestions, this is your opportunity to intercept the standard filtering and manage the items source first.

If you have the data available immediately, before your handler returns, you can simply change the ItemsSource property of the AutoCompleteBox control right here, no other changes necessary.

But if you’re going to perform an asynchronous operation (background thread calculations; call a web service), you need to set the Cancel property of the event arguments to True. This will cancel the built-in AutoComplete filtering and effectively tell the control to hold off until you are ready.

To continue the suggestion process, you need to then call the PopulateComplete method. In your web service completion event, you’ll want to place this call.

Populated event

This is called once suggestions are found and ready to be displayed. The Data property of the event arguments gives you read-only access to the view that will be provided to the selection control.

DropDownOpening, DropDownOpened, DropDownClosing, DropDownClosed

A nice set of drop down events. The Opening and Closing events can be canceled.

AutoComplete items in the real world

Setting the ItemsSource in XAML is not a real scenario. Enter web services, business object collections, XML files.

The ItemsSource property will take any IEnumerable. Linq fans rejoice. If you don’t have the data ahead of time, you can subscribe to the Populating event of AutoCompleteBox and update the ItemsSource with the appropriate results, synchronously or asynchronously.

Using ItemsSource with a collection

If your application already has a set of data available (list of names, parsed XML, set of static city and state names), you can just set the items source in code to your enumerable collection.

Here’s another quick app. The XAML is:

<UserControl x:Class="SilverlightApplication7.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:controls="clr-namespace:Microsoft.Windows.Controls;assembly=Microsoft.Windows.Controls"
    Width="400" Height="100">
    <StackPanel VerticalAlignment="Top" Margin="5">
        <controls:AutoCompleteBox x:Name="AutoComplete1" />
    </StackPanel>
</UserControl>

And the code behind file:

using System.Windows;
using System.Windows.Controls;

namespace SilverlightApplication7
{
    public partial class Page : UserControl
    {
        public Page()
        {
            InitializeComponent();
            Loaded += OnLoaded;
        }

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            AutoComplete1.ItemsSource = new string[]
            {
                "Steve Ballmer",
                "Bill Gates",
            };
        }
    }
}

Connecting to a JSON web service

Most AJAX auto complete controls today use JSON. The transmit format is lightweight, able to transfer rich object data, and supported by just about everything out there. The System.Json assembly in Silverlight makes it easy to parse in VB and C#.

Here is a minimalistic example. I have this PHP page deployed:

<?php
header("Content-type: application/json");

$var = "prefix";
if (isset($_GET[$var]) and $_GET[$var] != "")
{
        // Shorten
        $prefix = substr($_GET[$var], 0, 40);

        // Strip
        $s = strip_tags($prefix);

        // Create suggestions
        $suggestions = array();

        for ($i = 0; $i < 11; $i++)
        {
                $suggestions[] = $s . $i;
        }

        print json_encode($suggestions);
}
?>

I’m using the same Page.xaml from before. To get ready to use JSON, I need to:

• Add a reference to the System.Json Silverlight assembly
• Add a using statement to the top of my file for ‘System.Json’, ‘Microsoft.Windows.Controls’, ‘System.Linq’, and ‘System.Windows.Browser’

The code behind file doesn’t need many changes to deal with a web service.

The basic idea is to intercept the Populating event, cancel it, and kick off a web client. In the completion event for the web client, we update the items source of the AutoCompleteBox and call the PopulateComplete method to display the suggestions.

In my app, I first subscribe to Population. I set some basic properties too:

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            AutoComplete1.IsTextCompletionEnabled = false;

            // Server does the filtering
            AutoComplete1.SearchMode = AutoCompleteSearchMode.None;

            AutoComplete1.Populating += (s, args) =>
                {
                    args.Cancel = true;
                    WebClient wc = new WebClient();
                    string prefix = HttpUtility.UrlEncode(args.Parameter);
                    Uri service = new Uri("http://www.jwpc.com/services/suggest/?prefix=" + prefix);
                    wc.DownloadStringCompleted += DownloadStringCompleted;
                    wc.DownloadStringAsync(service, s);
                };
        }

Then, in the DownloadStringCompleted handler, I parse the JSON response:

        private void DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            AutoCompleteBox acb = e.UserState as AutoCompleteBox;
            if (acb != null && e.Error == null && !e.Cancelled && !string.IsNullOrEmpty(e.Result))
            {
                List<string> suggestions = new List<string>();
                JsonArray ja = JsonArray.Parse(e.Result) as JsonArray;
                foreach (JsonPrimitive suggestion in ja)
                {
                    suggestions.Add(suggestion.ToString());
                }
                if (suggestions.Count > 0)
                {
                    acb.ItemsSource = suggestions;
                    acb.PopulateComplete();
                }
            }
        }

That’s all there is to it!

Real world AutoComplete example

Inside the Silverlight Toolkit samples project, I’ve included a similar example of connecting to a JSON web service. It uses the excellent Live search suggestions. In this sample, the MinimumPopulateDelay is set to 150 milliseconds.

Here’s the Live.com sample:

How we determine what text to display in the text box

For performance reasons, we haven’t exposed the ability for you to creating a binding expression linking your items and the text that should be used in comparisons.

When you bind to a list of objects, the string representation is evaluated in the following order:

• Attempting to use an IValueConverter instance (this is the Converter property, along with ConverterParameter and ConverterCulture)
• Calling ToString() on the item

So, if you own the data classes in your application, you’ll want to expose the most meaningful name (such as a person’s full name, or employee ID), since the default ToString operator is going to return the type name of your item instead.

You can also provide a value converter in all situations.

AutoCompleteBox data templates, styling, and templating

You can use the ItemTemplate property to provide a DataTemplate that is used for rendering items.

These dependency properties can be used for styling:

• ItemContainerStyle
• TextBoxStyle

In the Live search example, the text box style was:

    <UserControl.Resources>
        <Style x:Key="SearchTextBoxStyle" TargetType="TextBox">
            <Setter Property="Background" Value="#AAFFFFFF" />
            <Setter Property="FontFamily" Value="Verdana" />
            <Setter Property="FontSize" Value="18" />
            <Setter Property="Padding" Value="2" />
        </Style>
    </UserControl.Resources>

And the AutoCompleteBox XAML:

<controls:AutoCompleteBox
    SearchMode="None"
    x:Name="Search"
    TextBoxStyle="{StaticResource SearchTextBoxStyle}"
    IsTextCompletionEnabled="False"
    IsEnabled="False" />

The control defines four template parts, similar to ComboBox; however, the default control template only provides 3 of those parts, since it does not expose a toggle button. All 4 are:

• The text box; named ‘Text’
• The popup; named ‘Popup’
• The selection adapter (ListBox is the default); control type or wrapper implements the ISelectionAdapter interface; named ‘SelectionAdapter’
• The drop down toggle button; named ‘DropDownToggle’ and of type ToggleButton

What’s next?

I hope this gives you what you need to get started using AutoCompleteBox in your own applications. In the coming days I’ll be posting some details and fun examples of how you can really make your apps shine with this control.

If you’re looking for other posts about the control, I’d recommend checking out Jonas Follesø’s AutoCompleteBox post too. He’s a blogging machine!

Hope this helps.

See also:

AutoCompleteBox: The 5 things you need to know

AutoCompleteBox Video Introduction

We named this control the AutoCompleteBox, not AutoComplete. Its different. It is a rich control that provides a set of suggestions, but not so much the old AJAX version that required you to wire the control up to a web service.

So, if you heard AutoComplete and got worried… don’t. You can just bind it to simple data that you already have in your application.

<controls:AutoCompleteBox x:Name="State" ItemSource="{StaticResource StateCollection}" />

 
Have fun, give it some style.

As a composite control, AutoCompleteBox has a TextBox and usually a ListBox. The TextBoxStyle, ItemContainerStyle, and ItemTemplate properties are key to styling. And we expose the complete set of standard control visual states, plus PopupOpened and PopupClosed.

Changing the look of the text box part is easy:

<controls:AutoCompleteBox x:Name="Patient">
    <controls:AutoCompleteBox.TextBoxStyle>
        <Style TargetType="TextBox">
            <Setter Property="Background" Value="Red" />
            <Setter Property="FontSize" Value="24" />
        </Style>
    </controls:AutoCompleteBox.TextBoxStyle>
</controls:AutoCompleteBox>

 
You can use your own rich data objects.

If you shove a collection of Airport objects into the control, your business logic can work with the AutoCompleteBox’s "SelectedItem" value. Talk about easy.

 
AutoComplete with a text list is so 1999.

We’re opening the door for auto complete like you’ve never experienced it before. The drop down inside AutoCompleteBox ships with ListBox. But with a little effort building an adapter, you can easily throw in a media control, TreeView, DataGrid, you name it.

And don’t worry. We made sure to master the text list scenario, too. It just works.

 
This is a preview control. Talk to us.

The Preview quality band covers controls that are useful, should meet most applications’ needs, and is going to just keep getting better.

That is a good thing: we really want to hear your feedback. Your feedback is going to make a difference in the direction and the core scenarios that AutoCompleteBox covers. What sucks? What’s missing? What rocks?

Check out the Silverlight Toolkit today.

Experience the live toolkit sample page.

In all seriousness, Shawn Burke is the man behind open source in the developer division. And my boss. And we’ve been planning this major source release for a while now. He’s the person to thank for having the vision and the passion to challenge us to get this out there for you all.

All of our work is out there now with the Microsoft Public License (Ms-PL), an Open Source Initiative-approved license, so there’s a lot of opportunity for developers to reuse our hard work.

Delivering source code is easy. So we’re raising the bar, and shipping sample apps, sample source, plus the thousands of unit and functional tests that we used for testing these controls on all the supported platforms. Download the November ’08 release now!

We also deliver a complete data visualization stack, and David Anson has more details on that.

AutoCompleteBox

I was the developer for the AutoCompleteBox control and will be sharing a lot of the fun scenarios that the control enables on this blog in the coming days. This control is a lot like other AutoComplete AJAX controls that are out there, but shaken up and served with a twist of extensibility.

One small example for the true geeks out there: I love that we were able to deliver a searching/filtering story that lets you provide a lambda function to perform your own advanced filtering on the items.

Click to open the live sample project shown above. Then navigate to "AutoCompleteBox > Scenarios > Search Suggestions".

The "Search Suggestions" scenario sample inside the live control samples application actually connects to the Live Search web service, just like Live.com and IE8 do. The requests come back in JSON. And the sample features the AutoCompleteBox control for Silverlight. Clicking through the filenames at the top of the frame you’ll see that the whole thing was done in about a page of code.

The proverbial Microsoft blog storm is off to a good start. I’ll contribute my own wave of posts here soon enough. In the meantime, there’s already plenty of coverage out there.

Enjoy the source. Learn from it. Tell us what you would like us to focus on and do better and we continue to iterate on this toolkit.

Stay tuned.

Written by developers, and not expert technical writers, don’t expect anything too earth-shattering. The download has no conceptual content. Do know this: every single type & P.M.E. is commented, thanks to Source Analysis. The help file was generated using Sandcastle.

Download the test framework documentation

Download the documentation (Zip containing a Chm, 1881K)
Silverlight unit test framework site

Using the documentation

Before opening the content, you will most likely need to unlock the file since the file’s from the tubes. For first-time use:

• Extract the contents of the Zip download
• Right-click on the *.chm file and click ‘Properties’
• Click the ‘Unblock’ button
• Open the *.chm file as usual

Silverlight documentation

Looking for the offline Silverlight 2 SDK documentation download, or the online Silverlight resources? All of these are good bookmarks to have handy:

• Silverlight in the MSDN Library
• Silverlight class library reference in the MSDN Library
• Download the Silverlight 2 SDK docs

Hope this helps!

Download the templates

Direct download link to the templates (Zip, 46K)
Direct download link to the Silverlight Unit Test Framework binaries (Zip, 284k)

To install, just drop the templates and binaries in the right directories.

Project templates go here: %userprofile%\Documents\Visual Studio 2008\Templates\ProjectTemplates
Item templates: %userprofile%\Documents\Visual Studio 2008\Templates\ItemTemplates
And the unit test framework binaries: %programfiles%\Microsoft SDKs\Silverlight\v2.0\Libraries\Client

New to Silverlight unit testing?

• What’s new in the RTW release of the Silverlight Unit Test Framework (9/30/08)
• Visual Studio unit testing introduction (8/16/08)
• Unit Testing with Silverlight, Scott Guthrie (4/2/08)
• Unit Testing with Silverlight 2 (3/31/08)
• Original introduction post (3/7/08)

 
WrapPanel tests running in the Silverlight Unit Test Framework

Upgrade your Beta 2 test projects

There’s a breaking changes guide for the test framework, for anyone who was using the last version for Beta 1 and/or Beta 2 development.

Thanks to Marius Rochon for sending me one of these and challenging me to get them all updated for the final release of Silverlight 2. Hope this helps!

Last week I was really bunkered down with Silverlight. That and upgrading to the 64-bit Photoshop. That’s nice, but I’m always pressing Alt-Tab to use Expression Blend. You really can build expressive apps with Silverlight.

I know for a fact that there’s some neat work happening in the community, and do apologize for being silent on the blogging front. Here’s some of what’s going on.

Built-in controls

The controls that ship with the Silverlight 2 runtime and SDK are slick. They received crisp, refined styles this time around, and the experience for application and interface developers is feeling similar to WPF now. There’s also a progress bar and password box built-in now.

If you’re not using the DataGrid in your apps, you’re missing out: Scott Morrison has been busy updating all of the great DataGrid tutorials for the final release version. Key messages: Performance, customizable, and new features too, like multi-selection.

Silverlight Toolkit

With the final Silverlight 2 release a little over a week ago, Shawn Burke blogged about the progress that we’re making on the Silverlight Toolkit. There are neat controls in the pic that he posted: Expander, a TreeView, NumericUpDown, and an AutoComplete text box.

Oops. I hit the wrong button, and Windows Live Writer seems to have posted a screenshot of a sample that I had up on my desktop… hmm… It sort of looks like a text box. And a drop down. Yet it has a DataGrid, too. Interesting…

So, stay tuned. Reiterating the cool things Shawn’s talked about:

• MS-PL, open source from Microsoft
• Things you’ve been missing: WrapPanel. DockPanel.
• Accompanying unit & integration tests built with the Silverlight Unit Test Framework

Watermarked TextBox Control

Yesterday Tim Heuer posted some Watermarked TextBox goodness on his blog, in case you were looking for that one.

SilverlightContrib

A few days ago a friend pointed me to the SilverlightContrib project. I’ll admit I don’t know a lot about it, other than the bullet points I saw on the homepage. I’m not associated with this project in any way, but want to give it props. Just look at some of the things it has:

• Zip compression
• Utilities galore: byte utilities. string utilities. animation stuff
• Some selection controls and gauges.

Check it out! There is a live demo page out there, too.

Here comes PDC

If you’re looking for something to do next weekend, it sounds like all the Microsoft geeks will be converging on the Los Angeles Convention Center for PDC 2008. There is even a nice convincing letter you can send your boss. Let me know if that works for you.

Stay tuned!

I’ve been involved in Silverlight for a few years now, in one capacity or another – and the trip has been awesome.

I won’t reminisce much, other than to say that I do have vivid memories of the weeks that debugging didn’t work… the weeks that the wrong clicks in a sequence could cause problems… What was released last week is solid.

Major kudos to everyone that made the release happen, it has been a pleasure working with you all. Now we’re going to see just how fun this gets. There’s more to come.