Development

Multi-touch in WPF4.0 Beta2

Szymon Kobalczyk — Wed, 28 Oct 2009 08:02:44 GMT

Now that .NET Framework 4.0 Beta 2 is out let’s look again what is available for building multi-touch application in WPF. In Beta 1 we got only a preview of manipulation and inertia components. With Beta 2 we finally get access to whole touch input system, and it looks very close to what was shown on PDC last year. Here is an overview from MSDN:

Elements in WPF now accept touch input. The UIElement, and UIElement3D, and ContentElement classes expose events that occur when a user touches an element on a touch-enabled screen. The following events are defined on UIElement and respond to touch input. Note that these events are also defined on UIElement3D and ContentElement.

PreviewTouchDown

TouchDown

PreviewTouchMove

TouchMove

PreviewTouchUp

TouchUp

GotTouchCapture

LostTouchCapture

TouchEnter

TouchLeave

In addition to the touch events, the UIElement supports manipulation. A manipulation is interpreted to scale, rotate, or translate the UIElement. For example, a photo viewing application might allow users to move, zoom, resize, and rotate a photo by touching the computer screen over the photo. The following events have been added to UIElement:

ManipulationStarted

ManipulationDelta

ManipulationInertiaStarting

ManipulationCompleted

ManipulationBoundaryFeedback

To enable manipulation, set the IsManipulationEnabled to true.

This is exactly what we were waiting for. I started playing with this new API and I will try to share some samples soon. But here is one problem I run into already. When I tried to use touch in ordinary WPF application, I noticed that all Buttons have a weird behavior, so that when I touched the Button it didn’t go into a pressed state immediately (I’m testing this on HP TouchSmart). Instead it only fires the Click event when I lift the finger. Testing it more I noticed that on any UIElement it won’t fire the MouseDown event until I lift the finger or slide it quite a bit.

To help me diagnose this issue I created a simple test application shown here:

From left to right I have gray rectangles that react to input events from mouse, stylus and touch. Each rectangle will change color to orange when mouse or stylus is over, and to green when is pressed. In addition, on press I capture the appropriate device and during capture the border changes color to red.

This test confirms that when I use touch panel then the xxxDown events don’t arrive immediately regardless of the device used. I spent quite a while trying to figure it out and trying various settings in both the Touch and Pen Control Panel and the NextWindow’s USB Config utility.

Finally I noticed that somehow this works perfectly fine when I use manipulations. From this I quickly found that this problem goes away when you set IsManipulationEnabled property on the element. Turns out that the side effect of setting this property to true is also changing the stylus properties to disable PressAndHold and Flicks gestures on the element. This explains this problem because stylus engine has to postpone these events trying to interpret the gestures. You can see the difference by selecting the appropriate checkbox on the window.

However although now we get the xxxDown events immediately (which will be very useful for manipulations) this doesn’t fix the problem with Button pressed state. You will notice that MouseDown event is still deferred regardless of the IsManipulationEnabled settings. I believe that in this case this might be caused by input logic in Windows itself. In fact the only way I could affect this was to force the touch panel to report input as mouse events (using NextWindow’s USB Config tool).

In the end I believe the proper fix for this would require extending all WPF built-in controls so that they understand the touch events and react accordingly. At the same time some controls might get some multi-touch specific behaviors as well. For example it was already announced that ScrollViewer will be enhanced to support multi-touch panning. In case of Button it was mentioned several times, that when simultaneous touches occur the correct behavior should be to fire the Click event only after the last touch is lifted. I hope that we get some of these enhancements in the RTM timeframe.

You can download the sample code here.

More fun with robots

Szymon Kobalczyk — Mon, 06 Jul 2009 09:27:46 GMT

Last Friday I’ve received new Futaba S3001 servos. Turns out they are more easier to modify to Hitec’s, and at the same seem more reliable. I’ve simply followed this Instructable, and you can also find some additional photos in my gallery. What most important the servos are also easier to calibrate, so now my SERB will actually stop in place when I want it.

Below is a short video of the completed SERB robot where it just runs in random directions:

This weekend I’ve also started looking at Microsoft Robotics Development Studio 2008. This environment promises easy entry level to robotics. However this is true only when you have a compatible robotics platform (like Lego Mindstorms NXT, fishertechnik, iRobot and few others). There are pretty good tutorials on how to control these robots both from C# and from VPL. However before I can apply them to my SERB robot, first I need to implement the hardware interface and generic services to control the robot. Not much information on this and closest what I found so for is the Robotics Tutorial 6 – Remotely Connected Robots. It would be cool to get more detailed example on writing such services, but fortunately source code of services for other robots is included. In particular I’m trying to understand the code for iRobot and this additional service for VEX Robotics. If you know of any other good examples or tutorials please let me know.

Emulating multi-touch device for Windows 7

Szymon Kobalczyk — Wed, 11 Mar 2009 03:35:19 GMT

Short while after I wrote about resources for multi-touch on Windows 7 Daniel D left a comment that got me very excited:

MultiTouchVista now has a driver that emulates multitouch hardware for Windows 7

I got to try it out myself! Bit later I got everything up and running and I’m happy to report that it’s all true: you can now effectively emulate multi-touch devices under Windows 7. You can see it yourself on this video. In fact it works so well that I was able to demonstrate it last Saturday at 4Developers conference.

That being said, the process to get it running involves few steps so I thought it would help to have a walkthrough to follow for anyone who would like to try it. So here it goes.

Hardware

Of course you need a PC. Note that computer vision puts CPU to heavy use, and I was able to get barely 15 FPS on my laptop with 1.6Ghz, and thus the interaction wasn’t very smooth. In fact Windows 7 specification requires multi-touch devices to report at least 50hz per finger.

The software that we are going to use allows to work with number of protocols. One option is to simply connect multiple USB mice to emulate multi-touch. But it is much more fun to build your own surface-like table. For start you can built a MTmini table designed by Seth Sanders – it takes about 20 minutes to build and all you will need is:

Webcam – people try different kinds of webcams for this, but I think even something simple with decent video should work. I have great results using Logitech QuickCam Pro 9000 because it has excellent video quality in 640x480 and most important you can set the focus and other parameters manually.
Tracing paper – it’s purpose is to diffuse the light coming to the camera so only objects very close to the surface (i.e. your fingers) look sharp. Initially I used just ordinary printer paper, but tracing paper gives more even image.
Photo frame – no, I’m not talking about any fancy LCD frames. It’s just plain wood frame (word of advice: bad things will happen if you try to repurpose frame from your wedding photo). Frame I use has A4 paper format (210mm × 297mm) and fits nicely on top of the carton box from the packs of A4 office paper.
Cardboard box, duck tape, and scissors.

When you have all the materials here is what you do:

Put the camera at the bottom of the box facing up, and glue it with the duck tape. You might need to cut out the hole for the camera’s USB cord.
Remove the back board from the photo frame and put only the tracing paper on the glass.
Put the frame on top of the box.

You can also watch this video for step by step instructions.

Here is my completed setup:

Software

Obviously you need to have Windows 7 Beta installed. So hopefully you was able to download it while it lasted.

Next thing to download and configure is tBeta. Here is description of it from official website:

The Beta, tbeta for short, is a open source/cross-platform solution for computer vision and multi-touch sensing. It takes an video input stream and outputs tracking data (e.g. coordinates and blob size) and touch events (e.g. finger down, moved and released) that are used in building multi-touch applications. tbeta can interface with various web cameras and video devices as well as connect to various TUIO/OSC enabled applications and supports many multi-touch lighting techniques including: FTIR, DI, DSI, and LLP with expansion planned for the future (custom modules/filters).

Download the software from the above website and unzip to folder you choose. Before you run it you might want to change configuration to use higher resolution if your webcam supports it. Go to \tbeta\data folder and open config.xml file. Specify the correct values for WIDTH and HEIGHT in CAMERA_0 node.

One more thing I did to get more predictable results was to turn off all automatic adjustments in camera software. For Logitech QuickCam this includes switching to manual focus, and turning off Automatic settings for RightLight, exposure and gain. We are not going to move the camera around or dramatically change the lightning conditions so it will be best to make all settings constant.

When you run tbeta.exe you should see something like this:

The tricky part is calibration, which means adjusting the sliders for all filters at the bottom so that you get best recognition accuracy. Unfortunately I don’t know any rules that would help you with this. You would have to play with the settings a bit to get a feeling how it works. If you make it right you should see an outline and unique id associated with each of your fingers as seen on the above screenshot. When all works well you can minimize this window (press spacebar) so it won’t consume CPU for rendering.

The last piece of this puzzle is MultiTouchVista project that I mentioned in previous post as well. This framework, which actively developed by Daniel D himself (aka nesher), adds support of multi-touch to the current version of WPF. But for purpose of this article the important thing is the recently added Windows 7 multi-touch driver. It’s not even officially released yet, so you would need to go directly to Source Code tab and download latest bits (I run it on changeset 18685).

You can follow instruction in this video on how to install the driver and run the services. Here is a short summary of the same:

Compile all projects for MultiTouchVista. Follow instructions on this page.
From Windows Explorer go to MultiTouchVista\Main Source folder, and while holding down Shift right click on Multitouch.Diver folder and select “Open Command Window Here”.
In this window type: install driver.cmd, press Enter and ignore all warnings about not certified drivers.
Open Device Manager and confirm that new driver called “Universal Software HID device” is installed under “Human Interface Devices”. Video suggests to disable and then enable the driver to ensure it is working correctly.
To verify the driver is installed you can open “Pen and Touch” applet from Control Panel. It should now contain the Panning tab.
Back in Explorer go to MultiTouchVista\Main Source\Output folder and run Multitouch.Service.Consol.exe. By default it loads the MultipleMiceInputProvider so if you should see red dots indicating “virtual cursor” for each USB mouse you have attached. But to use your MTmini table you would need to change configuration so it connects to tBeta through TUIO interface.
From MultiTouchVista\Main Source\Output run Multitouch.Configuration.WPF.exe. From list of Available devices select Tuio and click the arrow button in middle to make it Active device. Then click “Restart service” button to apply the new configuration.
Finally go to MultiTouchVista\Main Source\Multitouch.Driver.Console\bin\debug and run Multitouch.Driver.Console.exe.
Now if you put finger on surface, you should see the input messages coming to the console window. And of course now you should be read to use it as input device for Windows.

Try it on several touch enable applications that I listed in my last post (XPS Viewer and Paint are great for quick demo). You can also find some C++/C# examples on MSDN Code Galery.

Great thanks for Daniel D for leaving this inspiring comment, and even bigger compliments for developing such great library. Please don’t hesitate to let me know if I can help with anything.

Resources for Multi-touch in Windows 7

Szymon Kobalczyk — Fri, 13 Feb 2009 14:19:14 GMT

Last couple of months I’ve been working on very cool project that utilizes new multi-touch features in Windows 7. Although I can’t talk yet about our product, I thought it would be good to start sharing my experience with multi-touch programming. I’ll begin with some general resources to get you started.

Prerequisites

Of course first thing you need is a multi-touch capable hardware. As far as I know currently there are only three devices available on the market. Those lucky to be at PDC could see that most demos were run on HP TouchSmart All-in-One PC, or Dell Letitude XT tablet. Later in December HP released TouchSmart tx2z tablet, and this week Dell announced specs on Letitude XT2. For my work I use HP TouchSmart IQ504 PC.

The good news is that we have already seen some announcements from other manufacturers, and can expect number of devices to increase closer to Windows 7 release date.

In terms of touch-screen technology both tablets use the same DuoSense capacitive digitizer from N-Trig, while HP All-in-one PC uses optical overlay developed by NextWindow. The main difference is that NextWindow device supports only two touch points, while N-Trig’s can recognize more contacts.

Unfortunately multi-touch works only with dedicated hardware, so you can’t use other digitizers (like Wacom’s), touchpads or TabletPCs. Also there is no way to emulate multi-touch on Windows 7, for example by attaching multiple mice, although this is supported on Surface SDK emulator as demonstrated by Scott Hanselman (see around 14:30).

Software

In terms of software you need two things: Windows 7 and proper multi-touch driver for your device. Currently I run on Windows 7 Beta 1 (build 7000 for x86), and when I did clean install today most of the drivers are now available through Windows Update. The only driver I had to install manually was for Ralink WLAN adapter. However the TouchSmart version I have doesn’t have TV tuner, so if yours does you might need to install some additional software. Fortunately Kurt Brockett published detailed guide how to setup Windows 7 on HP TouchSmart.

If by any chance the multi-touch drivers won’t install for you automatically, you can download them directly from NextWindow’s or N-trig’s websites:

NextWindow’s Multi-Touch Screen Driver (Current version is 1.0.3.8 – the same as on Windows Update)
N-trig’s Multi-Touch download for Win7

To verify all works fine open any page in IE8 and you should be able to use two fingers for zooming.

Here are some other areas in Windows 7 that were enhanced with multi-touch features:

Panning with inertia is enabled “everywhere” where scrollbars exist.
Paint
- Choose a brush from the “brush gallery” and you can then multi touch finger paint.
Games
- Hearts/Solitaire have been optimized for touch
Shell
- Windows Snapping (Aero Snap) with Touch
- Aero Peek with Touch
- Taskbar Jump Lists with Increased spacing
Windows Media Player
Windows Photo Viewer
- Zoom, Rotate, Panning and Flicks
XPS Viewer
- Gestures (Zoom, Two-Finger Tap, Panning)
Media Center
- Direct Panning in most Scrollable Views and Menus
Touch Keyboard / TIP
- Multi-touch touch keyboard
Internet Explorer 8
- Panning
- Drag Menu (Address Bar) with Increased Spacing
- Increased Spacing for Favorites with Touch
- Gesture (Zoom, Panning, Flicks back and forth)
Windows Live Photo Gallery
- Gesture support in the Viewer

You can also download IdentityMine’s Air Hockey game from: www.identitymine.com/airhockey

Tip: If you are using touch on regular basis touch it is a good idea to increase the size of Windows UI (fonts, icons, etc.) by changing your display settings to Medium (125%). This will make Windows much more “touchable”.

Multi-touch Programming

Most of what we know so far about multi-touch API’s introduced in Windows 7 and WPF 4.0 comes from PDC session by Reed Townsend and Anson Tsao.

There are also two later sessions from WinHEC 2008: Multi-Touch in Windows 7 Overview covers some basics and repeats information from PDC, while Multi-Touch Driver Development and Logo Compliance is more toward hardware developers.

Recently published Windows 7 SDK Beta includes header files for WM_TOUCH, WM_GESTURE messages, and related functions and structures. It also includes some documentation and samples on this (also available on MSDN).

When you have all of above installed, you can try some code samples from hands on labs from PDC available on MSDN Code Gallery. These samples are both in C++ and C#. But to get it working in WPF you will need some more advanced framework in place, and I suggest you first take a look at the Multi-touch Vista project on CodePlex. You can take a look at MIRIA SDK that adds multi-touch support to Silverlight apps. Finally, for those of you that already work with TUIO libraries (like Touchlib) here is an applet to translate WM_TOUCH to TUIO messages.

More information in multi-touch and related technology can be found in the great NUI Group Forum. You can also find all information how to build multi-touch device yourself.

I hope that this information will get you started, and I will try to publish more information on multi-touch programming in C# in next few days. If you have any questions or suggestions please leave a comment.

What to do if your MS SQL Server 2005 eats 100% CPU at idle

Szymon Kobalczyk — Wed, 17 Sep 2008 01:21:36 GMT

Some time ago I got very strange situation on my development SQL Server 2005. Immediately after starting the process it went up to 100% CPU and stayed there for hours. There were no external connections, and I couldn't figure out what was causing this so I asked for help our best SQL geek Paweł Potasiński. With his help we were able to figure out that this was caused by service broker running on one of the databases although we didn't find the root cause for this.

Fast forward few months, and last week I got into the same trouble after upgrading the database. Of course I didn't recall how exactly we fixed it last time. So today I had to gave up and ask for Paweł's help again. I wrote this post mostly because I don't want to bother him again on this.

So first you use this to see which databases have service broker enabled:

SELECT * FROM sys.databases WHERE is_broker_enabled = 1

Then you can use ALTER TABLE ... SET DISABLE_BROKER but this would only work

when database is not locked. Therefore the best way to do this is like this:

ALTER DATABASE ... SET SINGLE_USER WITH ROLLLBACK IMMEDIATE
GO
ALTER DATABASE ... SET DISABLE_BROKER
GO
ALTER DATABASE ... SET MULTI_USER
GO

Note that this will kick off all users connected to this database.

Thanks for help Paweł - I owe you one more time :-)

Getting started with Managed Extensibility Framework

Szymon Kobalczyk — Mon, 08 Sep 2008 18:38:46 GMT

Last Friday Managed Extensibility Framework Preview 2 (MEF) was published on CodePlex. MEF is a new library in .NET that will simplify adding extension points to your applications. It enables discovery, loading and composition of the extensible components. You can now download the source code, samples and find more information on the project site: http://www.codeplex.com/MEF

I was playing with the bits over the weekend and chatted with Glenn Block (Program Manager on the .NET FX team that does MEF), who explained to me what MEF can do for us. I thought it would be beneficial to share this information, so I created a sample to demonstrate how MEF can be hosted in your application. Please note that this covers only a single scenario where I found MEF might be useful, but MEF probably can do much more for you.

Before we go any further you might want to download the sample project, so you can browse the source code while I walk through it:

Download MefNavigationWindow project

Sample scenario

So here is my sample scenario: Let's say you are building a Windows Forms application where you want to add browser like navigation capabilities. This means that your window contains a placeholder where you can load other "pages" be specifying only the page name. Sounds familiar? Yes, WPF supports this out of the box with then NavigationWindow and Pages. So in short we would like to build a NavigationWindow for Windows Forms.

Let's assume that our pages would be simply UserControls. Actually it is quite easy to load user control dynamically - you simply instantiate the control's type and add it to parent's Controls collection. The real problem here is how to map page name (string) to it's type.

For example we could create a section in app.config file that lists all available views and map their names to the corresponding types. This could look similar to this:

<pageMappings>
  <page name="Page1" type="MefNavigationWindow.Page1" />
  <page name="Page2" type="MefNavigationWindow.Page2" />
  <page name="Page3" type="MefNavigationWindow.Page3" />
</pageMappings>

Then our NavigationWindow would load these mappings and construct the pages using reflection. But I can see two potential problems here.

In case of a client applications the configuration file is easily available to users to mess with, and doing so it would likely break the application.
Because the definition of class and mapping are kept in two separate places developers can easily forget to update the mappings when adding new pages to our solutions.

Therefore a better solution could be to create a custom attribute that is used to assign page name to a given user control:

[PageMetadata(PageName = "Page1")]
public partial class Page1 : UserControl
{
    //...
}

Then we can scan the current assembly for all types that have this attribute (using reflection), construct a dictionary of all pages, and when requested create instances of a specified page (with reflection again).

But guess what... MEF already does all this for us with much less code. Let me show you how.

Exports

First let's look at the PageMetadataAttribute:

[MetadataAttribute]
public class PageMetadataAttribute : Attribute
{
    public string PageName { get; set; }
}

Very simple. Only odd thing is that this attribute itself need to be tagged with MetadataAttribute so MEF knows to expose it as metadata in the parts catalog (and we will use it in just a moment). Now we can use it on any UserControl to assign the page name, but we need to use it together with the Export attribute. Type discovery in MEF is based on attributes and Export indicates that the attributed class should be exported as ComposablePart and specifies the contract it implements (it is Page in our case):

[Export("Page")]
[PageMetadata(PageName = "Page1")]
public partial class Page1 : UserControl
{
    // ...
}

Notice that in MEF contract is specified as string. There is additional overload on the Export attribute that consumes a Type, but internally it would be converted to a fully qualified name of that tape. On the side note, even when you use a typed contract the attributed class doesn't really need to implement it - the contract type is used only as a key in the container.

CompositionContainer and Catalogs

Now we can start implementing our NavigationWindow and first thing to do is to configure the CompositionContainer:

private void InitializeCompositionContainer()
{
    var catalog = new AttributedAssemblyPartCatalog(typeof (NavigationWindow).Assembly);
    var container = new CompositionContainer(catalog.CreateResolver());

    container.AddPart(this);
    container.Compose();

    _container = container;
}

Because we want MEF to discover all the pages in the current assembly we use the AttributedAssemblyPartCatalog that will search for all types that were attributed as exports. Catalogs are responsible for creating a Resolver that is then passed to the CompositionContainer so it can query for available ComposableParts (you can learn about the other two types of catalogs from the programming guide). Next we also register the NavigationWindow itself as a ComposablePart in the container. After doing so we need to call the Compose method to resolve dependencies (note that you don't need to call Compose to user parts exposed from catalogs). But for this to work properly we need to add Export attribute on NavigationWindow too:

[Export("NavigationWindow")]
public partial class NavigationWindow : UserControl

Imports

Ok, it's about time to talk about the dependencies, aka imports. For the NavigationWindow this will be the list of all available page types and we can get this by declaring following collection:

[Import("Page")]
private ExportCollection<UserControl, IPageMetadata> _pages;

The Import attribute indicates that container should resolve this dependency for us by assigning a collection of all exports with Page contract (this happens when you call container's Compose method). It will also expose the PageMetadataAttribute through IPageMetada interface:

public interface IPageMetadata
{
    string PageName { get; set; }
}

Notice that we didn't implement this interface earlier on the attribute itself. At runtime MEF will be able to create dynamic proxy to it with a magic thing called duck typing. Isn't that cool!

The _pages field is private and normally it wouldn't be resolved, but we can ask MEF to handle it by adding the assembly level AllowNonPublicComposition attribute (add it to AssemblyInfo).

Now we are ready to implement the GoTo method that will do the navigation:

public void GoTo(string pageName)
{
    var newPage = _pages.SingleOrDefault(e => e.MetadataView.PageName == pageName);

    Controls.Clear();

    if (newPage != null)
    {
        var control = newPage.GetExportedObject();
        control.Dock = DockStyle.Fill;
        Controls.Add(control);
    }
}

In the first line it will search the _pages collection for one with specified page name (MetadataView property implements our IPageMetada interface). Later when the page was found we request the instance of UserControl with call to GetExportedObject(). I told you this would be easy!

Now we can put the NavigationWindow on any Form and call navigationWindow1.GoTo("Page1") to get this:

I assume that we would like to navigate from one page to another by clicking the link. Therefore the page needs to know the NavigationWindow it is hosted in – in other words it has a dependency on the NavigationWindow.

[Import("NavigationWindow")]
public NavigationWindow NavigationWindow { get; set; }

private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
    NavigationWindow.GoTo("Page2");
}

This is why earlier we registered the NavigationWindow itself as a ComposablePart, so now we can import it from any other part. This would get us to the second window:

Object lifetime

To make this exercise more interesting here we have a TextBox and we want to pass its value to the third window. But first let's talk briefly about part's lifetime. By default all the exported parts are treated as singletons. For us this means that there would be only a single instance ever created of each page (as soon as you call Export.GetExportedObject method). Of course this is not always the desired scenario, and you can change this behavior using the CreationPolicy property of the CompositionOptions attribute. Here is Page1 revisited:

[CompositionOptions(CreationPolicy = CreationPolicy.Factory)]
[Export("Page")]
[PageMetadata(PageName = "Page1")]
public partial class Page1 : UserControl

The CreationPolicy enumeration has only two values: Singleton (default), and Factory.

Looking back to our scenario we want to make the second page a singleton so it can be accessed from the third page. To access it would also need to get a reference to the Container – and again we do this by adding another dependency in Page3:

[Import("Container")]
public CompositionContainer Container { get; set; }

Now, this dependency won't be available just yet. As we've seen before the container was created by the NavigationWindow. We could register it manually as we did with the NavigationWindow, but I would like to show you one more capability that MEF has – you can declare Exports not only on types but also on the class members:

[Export("Container")]
private CompositionContainer _container;

So when we add this field to NavigationWindow we now not only export the NavigationWindow itself but also the value in the it's _container field. I can imagine that this capability would be handy if you need to export one of the built-in system types or type from a third-party library when you can't add the Export attribute directly on the given type.

Finally here is the code from Page3 to get the reference to previous page and read the value entered in the TextBox:

private void PageLoaded(object sender, EventArgs e)
{
    var page = Container.GetExports<IAskNamePage>(p => p.ContractName == "Page" && string.Equals(p.Metadata["PageName"], "Page2")).Single();
    nameLabel.Text = "Helo " + page.GetExportedObject().FullName;
}

This time we used one of container's GetExports methods to query for a page (ComposablePart with contract "Page") and with page name of "Page2" (through Metadata dictionary). The query capability on metadata is one of the big things in MEF and it allows you to get detailed information about available parts even before you instantiate them. I've also added IAskNamePage interface so we can get the text entered on Page2:

public interface IAskNamePage
{
    string FullName { get;  }
}

It simply returns the text from TextBox:

public string FullName
{
    get { return textBox1.Text; }
}

Here is the last page:

Summary

I hope that this example gives you some idea where MEF fits and will help you get started. Let me know if you have any questions about this. For more advanced scenario check out the three samples that shipped with the current drop on CodePlex:

MEFlook - Outlook like client

MEFTris - Tetris like game with shapes as plug-ins

Extensible File Explorer - File explorer with extensible views, favorite file viewers and shell services

Two cool Microsoft Surface apps from InterKnowlogy

Szymon Kobalczyk — Fri, 29 Aug 2008 13:41:02 GMT

InterKnowlogy is always on the cutting edge of the Microsoft Platform so its not surprise that we were among first to build applications in WPF, Silverlight and now on Microsoft Surface (a touch screen computer embedded in a coffee table). I'm excited to show you two applications that we released recently.

VitruView

VirtuView is a collaborative environment for viewing and annotating patient's examination results on anatomic 3D models. This application is evolution of our earlier Angiographer that we build for InterMountain Healthcare together with our partner Zygote (world's leader in 3D human anatomy models and textures). VirtuView lets users zoom and rotate the 3D heart models with your hands. You can use your fingers to draw arteries, place Stents and add annotations. And because this is multitouch you can use more than one finger or many people can work at once. This application is done in WPF and uses Microsoft HealthVault to securely store patient's data.

Check out this video demonstration from Tim Huckaby and Kevin Kennedy:

Update: Here you can watch another video with Tim and Dr. Peter Kuhn from Health User Group Conference.

History at your fingertips

This amazing application was built in conjunction with Microsoft and the Library of Congress. It chronicles the history of the republican and democratic national conventions in interactive Surface experience. The application is featured LIVE on Surface units at both upcoming conventions, and it was shown on the ABC National News this week and you can watch it on the ABCnews.com website (move forward to approximately 01:18).

Here is a more technical demonstration from Rodney Guzman:

What about me?

Meanwhile I've been working with great team at Colonial Life & Accident Insurance Company that built the Harmony solution. We helped them built a WPF offline version of the Web based Harmony self-enrollment system that will be used by insurance agents. You can find more details in this Microsoft case study.

How I won the Lab49 WPF in Finance Innovation Contest?

Szymon Kobalczyk — Tue, 18 Mar 2008 02:39:06 GMT

Honestly, I still don't know how I did it. The LAB49 WPF in Finance Innovation Contest was announced back in December and I think I first read about it on Tim Sneath blog. With all the cool prizes I was very inclined to participate, but it quickly turned out that its available only to US citizens. However that changed in the first week of February, so I started considering it again, but still didn't had any clue what to do. You see the goal of this contest was to create a WPF application that visualizes a set of provided financial data in some interesting way. While the first part was easy (writing the app in WPF) the hardest part was to figure out what to do with the data. Only after "last call to action" email from Daniel Chait I decided its about time to start coding.

Because I started working late on this project, initially I wanted to create only a charting control capable of displaying the line and candlestick plot of stock prices. But after the contest deadline was extended I started thinking of a better way to visualize the stock prices for a given day – something that goes beyond a simple listbox or a datagrid. The next option I considered was to create a heatmap – i.e. use color gradients to denote the change in stock prices relative to the previous day. But in all samples I’ve seen these symbols were placed on a regular grid and the placement didn’t correspond in any particular way with the data. I started thinking about how to sort the symbols so that those that experienced similar data change would be close to each other, and those with different data change remain further apart. This finally led me to the idea of applying Craig Reynolds’ flocking algorithm to perform this clustering.

Here is a screenshot from my final entry called Stock Information Boids:

Also you can already download the source code for this application from my resource page at MSDN Code Gallery. Make sure to read the user guide that describes how the algorithm works and how to use the application.

Turns out that for some reason the judges liked my solution, because last week at the closing keynote of 2008 Microsoft Financial Services Developer Conference in New York, Daniel Chait announced that I won the grand prize in the contest!

The two finalist were Jacob Carpenter and Jobi K Joy, while the honorable mention went to Paul Hounshell. Congratulations guys, great work! You can download their very cool applications from here:

In following weeks I will try to share some details on my implementations (in particular about the Timeline and Flock controls). I was already told that Jobi K Joy and Jacob Carpenter plan to do the same, so make sure to subscribe to their blogs too.

I would like to thank the judges for selecting my entry. And last but not least, big kisses for my wife Joanna for letting me work on the project all nights and weekends considering her present condition (L)

Moving my code samples to MSDN Code Gallery

Szymon Kobalczyk — Tue, 19 Feb 2008 13:14:13 GMT

When I started blogging here on GeeksWithBlogs it turned out that if want to publish any code samples I have to find yet another place to host the source code. I didn't own any web servers that I could use for this, so I started looking how other bloggers do this, and came across ProjectDistributor.net. It did exactly what I was looking for:

ProjectDistributor is a web application for distributing small pieces of software - such as tools, components, widgets and controls. Users create groups to store projects against and visitors can login to download those projects or to leave feedback about bugs or to request new features.

Although it's quite simple and didn't offer many features it did a decent job hosting my samples. The projects can be grouped by author and category.

However recently I got several comments that the download links don't work, and the site was down for some time (now it's up again). To fix this I decided to move my files to Windows Live SkyDrive. It's a generic service for hosting any files on internet. When you sign up you get 1GB of free space. The UI is very simple: you can create folders, setup the permissions (private, shared or public) and you then quickly upload your files.

The nice addition is that when you publish a file on SkyDrive, it creates a nicely formatted HTML snippets that you can embed in your page (there is even a Windows Live Writer plugin that helps you with this):

These nice emblems is the only thing I really miss abut SkyDrive. They were just easier to find on the page then a simple download link.

But as I said, SkyDrive is a generic service not really targeted to host programming samples. You don't get any ways to categorize, tag or search the projects. You don't even get the number of downloads or any other statistics. In addition some of my friends reported that they get redirected to Sign In page for Windows Live whenever they open my blog.

That's why when I heard about CodePlex's younger brother – MSDN Code Gallery on recent .NET Rocks! interview with Matthew Manela I decided to give it a try and this weekend I moved all my samples there:

Here is the link to my resources page: http://code.msdn.microsoft.com/KobushCode

My experience so far was very positive. It's basically a CodePlex (even shares the same codebase from what I heard) but without the TFS integration - so you don't get version control or project management features. But when you create a resource page you still get:

Home page that you can edit with wiki syntax and supports comments. You can also create subpages to publish your articles or documentation. You can also tag your project so it would be easier to find for others.
Rleases tab where you publish your source code, binaries or stand alone documentation (and it has a downloads counter).
Discussions forum that your readers can use to publish questions or comments.
You can even run an Issue Tracker to record bugs or feature requests if you need to (it's optional and you can turn it on in the Resource Page Settings).
If you find someone to help you out with the project you can manage your team on the People tab.
License tab shows the terms and conditions the user needs to agree when downloading your code. Note that currently it's the Microsoft Public License (Ms-PL) and you cannot change it (you can do this on CodePlex though). It's a basic "use it how you want - no guarantee" type of license, and personally I don't have any objections to it but you need to judge it for yourself.

Also note that while I decided to publish all my samples on a single resources page, nothing prevents you from creating more than one. You can then link them together using Related Resource Pages sections.

For me the site offers all I really need to host my code samples. But if your project eventually grows and you need more features you can move it to CodePlex (I wonder if there will be any migration path for doing this). Also note that in many aspects it replaces now retired GotDotNet site and some popular samples were migrated from it.

Probably most bloggers that write about programming face the same problem that I had, and MSDN Code Gallery does a good job solving it. So if you are looking for a place to put your samples I strongly recommend to give it a try.

Introducing WikiSpider

Szymon Kobalczyk — Thu, 31 Jan 2008 04:22:47 GMT

About two weeks ago Daniel Biesiada (who is ISV DE here in Poland) announced on his blog a little programming contest. The goal was to build a .NET application that would check if the the theory of Six Degrees of separation applies to two given topics in Wikipedia. In order words to find a path from the source page to destination with no more then six links. At the time I had not much else to do (apart from setting up website for the C2C Conference, helping out with the European Silverlight Challenge, and preparing for the WPF Beta Exam) so I decided to give it a try.

Fast forward two weeks and I present you my WikiSpider:

As usual building this took me much more time than I initially anticipated (including few sleepless nights). And still I didn't make it before the deadline, so this even didn't count as a contest entry anymore (sigh!). However this was mainly because my personal goal was to throw in there every new piece of .NET 3.5 I could find fit - and most of them I never used before.

Here are some key technologies I managed to put into this:

The UI is done in WPF (and this was the only thing here I knew a bit about). However I borrowed the graph control from the excellent Kevin's WPF Bag-o-Tricks.
The caching is done using SQL Server Express. Initially I wanted to do this using SQL Compact but I run into performance issues and had to switch to full SQL in order to run the queries in profiler. But since this was fixed (with big help from Paweł Potasiński) I could try with SQL Compact again.
Of course data-access is done using LINQ to SQL. And of course this was the main source of my problems, as it was first time I've done anything in it, and so far I only read the Scott Gu's tutorials. Still, I'm already in love with it.
Speaking of LINQ. Initially we were screen scrapping the HTML pages to get all the links. But turns out that Wikipedia has a little known about Query API that enables to get the page content in XML. So the obvious move was to rewrite this part with LINQ to XML.
The path-finding algorithm was borrowed from Eric Lippert. The nice thing about it is that it uses lots of C# 3.0 language features, so it is a great resource to learn from. The new C# syntax is so addictive that I already miss it in my other project.
Finally, I wanted to publish the app with ClickOnce but run out of time. So maybe later.

I learned many interesting things and tried out some new stuff that I wanted to check out anyway. I will try to share my discoveries in the next few days, but in the meantime feel free to download and take a look at may code (I know it's not prettiest piece of code you've seen but I was in a rush to finish this on time):

Download the source code

Here you can also download the entries from other participants: Łukasz Sowa, Maciej Rutkowski, and Arkadiusz Benedykt. Congratulations to all of you!

Installation

Download the code from the above link and extract it.
The application uses local SQL database for caching and unfortunately you need to create it yourself (now you know why I wanted to use SQL Compact). Simply launch SSMS and create empty database called WikiCache.
Run the Create_WikiCacheDB.sql script from the data folder to create the database schema.
By default the app is configured to look for the WikiCache database on the local SQLEXPRESS instance. If you installed it somewhere else update the connection string in app.config accordingly.
Run the build.bat or open solution in Visual Studio 2008 and run from there.

Usage

Enter the name of the Wikipedia page in the address bar at the top and press the Go! button. The entered topic and the pages it links to will be displayed as graph.
Clicking on any topic will make it currently selected (put it in the center of the graph).
Right-click on any topic to open the context menu. Select "Open in browser" to.... load the page in browser.
Select "Set as source" or "Set as destination" to put the topic name in appropriate field on the sidebar
[Note: Currently it's the only way to show the sidebar]
You can also enter the source/destination topics manually.
When both are set click on the Start button to begin searching for the path. Few statistics are displayed on the bottom of the sidebar.
During the search you can still use the graph or navigate to other pages (thanks to the BackgroundWorker magic).
When path is found it is displayed on the sidebar, and you can click on each topic to center it on graph.

Have fun!