Development

How I won the Lab49 WPF in Finance Innovation Contest?

Szymon Kobalczyk — Mon, 17 Mar 2008 20: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 06: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 — Wed, 30 Jan 2008 21: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!

Avoid common globalization errors in .NET

Szymon Kobalczyk — Sun, 16 Sep 2007 18:50:57 GMT

Last week I've been looking for a better RSS Reader (err... Aggregator). You see after certain number of feeds MS Outlook no longer works for me and I needed a better alternative. In my search I came a cross a product called RikReader and decided to give it a try. Why? I've read some good opinions about it, it's free, it uses Windows RSS Platform, and is close to my heart because it is done entirely in WPF.

I promptly downloaded and installed the package. But instead of the expected welcome screen here is what I get every time I try to run it:

(The error message is in Polish but it says: The input string has incorrect format)

As you can see the application includes a very nice error reporting window (every modern application should have one!) so Douglas Stockwell, its author is probably already aware of the problem and hopefully working on the solution. But I think he wouldn't mind to give him a hand.

So what exactly is this problem here? From the stack trace above we can see that it all start in a custom binding converter called MultiplyConverter. My guess is that when this converter expects a decimal number, but encounters a String argument it first tries to convert it to a Double value by calling System.Convert.ToDouble. In the end this method rises exception to indicate that the given text doesn't seem to represent a valid decimal number.

Looks like a pretty obvious bug, so you may wonder why the author didn't fixed it already? You say he can't reproduce it? So what is so special about my system that I always get the same error? The answer is this: it uses different language settings! Should it matter?

Not all of my English-speaking fellow developers might realize this (and those who do sometimes "forget" about it) but not all cultures use the same format to write numbers or dates. You see in certain languages, like French (or in my case in Polish), we write decimal number where the decimal separator is not a dot as in English but a coma. So instead of 123.456 we would write 123,456. A subtle difference but with huge implications (at least for the dumb computer).

Here is a simple example to demonstrate this. The .NET library provides several ways to convert a number to a string:

double number = 123.456;
string convertToString = Convert.ToString(number);
string numberToString = number.ToString();
string stringFormat = String.Format("{0}", number);

What do you think would be the value of each of these strings after running this code? The correct answer is it depends. For some systems this might be "123.456", but for others this could as well be "123,456". This is because by default, each of these methods uses the current culture settings to produce the text representation of the numerical value.

Similar there are several ways in .NET to parse the text to produce a decimal value:

string text = "123.456"; 
double convertToDouble = Convert.ToDouble(text); 
double doubleParse = Double.Parse(text); 
double doubleTryParse; 
if (Double.TryParse(text, out doubleTryParse) == false) 
    Console.WriteLine("Can't parse string.");

Is this code correct? It also depends in which culture you run it. In some the code executes fine and each double variable gets the correct number. In others the first two methods would throw exceptions and the last one will return false to indicate the string is invalid.

What this all means for you? If your application depends on storing decimal values in certain formats — for example attempts to read some settings from a text file — it can never depend on these methods alone. But not all is lost, and of course .NET provides means to handle such problem.

Each of these methods has overrides that can take IFormatProvider as an argument. How do we find one?. It could be hard to guess at first but in this case you should use appropriate instance of CultureInfo class. So if you expect that the input value you need to parse will be formated in Polish use CultureInfo("pl-pl"). The same applies to output. Of course sometimes it might be hard to determine what culture you should use. But if you are in a lucky position that your application controls both input and output format then you can just pick any culture and use for both. Actually .NET already provides a nice shortcut for this via CultureInfo.InvariantCulture.

I hope that by now you already know how to fix the above examples. Here is the corrected version that uses InvariantCulture:

string convertToString = Convert.ToString(number, CultureInfo.InvariantCulture); 
string numberToString = number.ToString(CultureInfo.InvariantCulture); 
string stringFormat = String.Format(CultureInfo.InvariantCulture, "{0}", number);

double convertToDouble = Convert.ToDouble(text, CultureInfo.InvariantCulture); 
double doubleParse = Double.Parse(text, CultureInfo.InvariantCulture); 
double doubleTryParse; 
if (Double.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out doubleTryParse) == false) 
    Console.WriteLine("Can't parse string.");

As you see this change is fairly simple so I strongly encourage you to review your code and always consider what would be the proper format of the input or output value. The same rules apply to other decimal data types (Float and Decimal), but also to formating dates (DateTime).

If you have a large, existing application reviewing it quickly can be bit cumbersome, but thankfully FxCop contains set of rules that can help find such spots. Here is the code analysis report obtained by running FxCop on the first version of the above examples:

As you can see, it properly lists all lines with calls to methods that have overrides that take IFormatProvider (apart from Double.TryParse). With the corrected version of code all these warnings disappear.

Also worth noting is that all methods used in the first example are actually shortcuts for passing the CultureInfo.CurrentCulture value that (if you haven't changed it in your code) holds the culture of your operating system. For most purposes, like displaying the value to the user, this works fine and you could leave it as it is. But when reading files or any external data-source you should always use exactly the same culture that was used to write it.

Hopefully this information would help you avoid very common globalization errors that are quite annoying to many people living in this part of the world. If you need help ensuring that your application runs with no problems on non-English systems just e-mail me and we can test it together.

You can download the sample project here

Getting started with ADO.NET Entity Framework. Part I: Mapping entities

Szymon Kobalczyk — Wed, 29 Aug 2007 18:30:22 GMT

Two months ago, after listening to .NET Rocks! show with Daniel Simmons, I was really curious to learn more about ADO.NET Entity Framework (EF). As part of my learning I was ready to write a tutorial on how to get started with this framework. However there were no tools available at the time and with instructions on how to manually edit XML files the article turned very long, and quite frankly looked very boring. Hence I decided to postpone publishing it and wait for the tools to came out.

This week Microsoft released ADO.NET Entity Framework Beta 2. You can find the complete release notes on the ADO.NET Team Blog so I won’t repeat it here. What’s more important we finally get the first CTP of Entity Framework Tools. So now I have all the pieces to attempt to write my tutorial again.

• • •

Microsoft went a long road to get into the ORM space starting with ObjectSpaces, then WinFS and now LINQ and Entity Framework. For those interested in the full story here is nice article from one of the authors. Even though I'm by no means an ORM expert, I've worked before with number of both commercial and open source systems falling into this category.

According to ADO.NET team Entity Framework is much more then just another ORM tool. The aim here is to solve a more generic problem of mapping conceptual model to application logic which is prevalent not only in storing programming objects but also in such areas as data replication, remoting and reporting. Which EF you maintain a single conceptual model of your domain objects (called entities here) that can be later mapped and reused with other representation.

To learn new technology I usually develop a sample project so I have some well defined goal to achieve. This time again I choose to work with the PetShop 4.0 sample application. I prefer this sample for several reasons:

It contains existing entity model, so nice thing to try would if the whole data access code can be replaced with EF.
The application uses four databases in total, so it would test how to map the entity model to multiple data sources.
It is relatively simple and I worked with it before when learning CAB.

Besides Northwind and Adventure Works are already mapped as EF samples so it would be no fun in using them.

Step 1. Generating entity model from database

Working with Entity Framework involves creating three schemas for your data:

1. Conceptual Schema (CSDL) — represents the conceptual model of your data, that is entities and their relationships (in current version this maps 1:1 to the generated object model).

2. Storage Metadata Schema (SSDL) — describes the representation of your data when its stored in the database (or other storage media).

3. Mapping Specification (MSL) — as you can already guess this one describes how to map data from one of the above schemas to the another.

All three are now defined as part of single XML document that will be part of your project (edmx).

The normal workflow for Entity Framework should start with first creating the concept model of entities and then work the storage and mapping schemas from there. However in many cases you will be working with existing applications, so it would be more convenient to start from the database schema instead. This release of EF targets this "data first" scenario with the EDM Wizard built in Visual Studio.

As I said before PetShop uses four databases: product inventory, orders, and two for ASP.NET users and profiles. For now I will concentrate on the first one. So to begin with let's see how this database looks like:

As you see this database is extremely simple: each category has multiple products, that in turn hold multiple items. Each product item points to its supplier and there is additional table that holds current inventory count.

Okay, I'm ready to create the entity model. First I've created a new C# class library project, and then from the Add New Item dialog selected the ADO.NET Entity Data Model template. This starts the Entity Data Model Wizard where in first step we select either to generate model from database or to create empty one:

After selecting the first option we go to the next step when we need to specify the connection string to our database:

Note that the connection string used by the EF besides the typical settings for ADO.NET also contains paths to all three schema files.

In the last step we can select which tables, views and stored procedures should be included in the generated model (in this case I want to include all tables besides the AspNet_SqlCacheTablesForChangeNotification). We can also specify the namespace for the generated classes:

After pressing the Finish button the wizard generates the entity model (the PetShopModel.edmx file) and adds all required references to the project. In the previous version the wizard didn't worked very well and you'd had to use the command line tool called EDM Generator (edmgen.exe) to get these files. This time things changed for good so lets look at what was generated.

When we open this file from the Solution Explorer we can finally see our enities inside the EDM Designer (click on image to enlarge):

Notice that although this model looks very similar to the database model shown earlier it actually shows entities not tables. So besides the scalar properties that are mapped to the table columns we also have the navigational properties mapped to table relationships. There is also a new tab next to the Solution Explorer called Entity Model Browser that displays the structure of the model. We can see here that this model includes both the conceptual (entity) and storage schema. Finally at the bottom we see new window titled Entity Mapping Details that displays how the two schemas are mapped.

In the second part I will look at how we can modify the generated model to align it with our concept model and at the same time learn how to use this designer. Stay tuned!

UMPC + WPF = Audi Keyboard

Szymon Kobalczyk — Wed, 11 Apr 2007 21:21:00 GMT

As time goes by I keep finding more and more great WPF applications, but this one really got my attention. The Audi Keyboard is a WPF application that was designed for UMPCs that was used during the Melbourne Motorshow to input customer data. I actually found it on the Hugo Ortega's Uber Tablet blog (which I'm huge fan by now) so it might have been missed by pure .NET geeks. Hugo published video with overview of this project where you can learn more details.

This project is great example of how WPF brings together designers and developers enabling them to work together on the same project. There is also very interesting video interview up on ScreenEdit.com with Richard Bassett (the designer) and Dr. Neil (the programmer). As they point out the most important lesson they learned is that with WPF each of them can work in the environment they are comfortable with (designer = Expression Blend, developer = Visual Studio), but this would be still part of the same project (remember that Blend reads and creates .csproj files). Also worth noting are the first impressions of seasoned designer coming to the Expression suite, and comparing it to competitive technologies like Flash and Adobe Illustrator.

After working with WPF for a while I can 100% agree with what they say.

WPF TabItems With Close Button

Szymon Kobalczyk — Sun, 08 Apr 2007 14:48:00 GMT

One of the most common questions I've seen regarding the TabControl in Windows Forms was how to add a close button to each tab (similar to seen on tabs in Internet Explorer 7).

Although there were some solutions available the results weren't quite satisfactory and often requiring to rewrite the whole control from scratch. Recently I faced the same challenge working on the TSRI project. It turned out that in WPF this pretty straightforward task and in this article I'm going to show all the steps required to complete it.

To follow the discussion you can download the demo code first:

Download the source code

We start by creating a new custom control deriving from TabItem that implements this behavior. I'll name it CloseableTabItem.

public class CloseableTabItem : TabItem
{
    static CloseableTabItem()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(CloseableTabItem),
            new FrameworkPropertyMetadata(typeof(CloseableTabItem)));
    }
}

The instruction in static constructor informs the system that this element wants to use different style than it's parent. Since we are creating the default theme for the custom control it would be defined in generic\themes.xaml.

Before we add more code let's create the control template first. With the aid of Expression Blend we can easily create a copy of the default template for TabItem control and start from there. The default template consists only of Grid and Border that wrap the ContentPresenter. We need to place additional DockPanel inside this Border to host both the Content and our close Button. Because we will reference this button from code later it's named PART_Close following the WPF naming convention. The button contains the "x" icon defined as Path element. You can see final hierarchy of elements on the image below:

The close button should only show it's border when mouse is over and it shouldn't accept keyboard focus, hence there is additional style called CloseableTabItemButtonStyle. This template consist of Border and ContentPresenter inside of a Grid. The Border is hidden by default and shows only when mouse is over the button. To be consistent with IE7 behavior I've also added triggers to change the "x" icon fill color to red when mouse is over the button or when it's pressed.

We are now ready to test these templates. To use our new control first the containing namespace must be mapped to a XML namespace. We don't need to reference the resource dictionary because it is declared as default theme for the control. Here is example markup for the main window of the application:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:CloseableTabItemDemo"
    x:Class="CloseableTabItemDemo.MainWindow"
    Title="CloseableTabItem Demo" Height="300" Width="500"
    >
    <Grid>
      <TabControl Margin="5">
        <local:CloseableTabItem Header="TabItem 1"/>
        <local:CloseableTabItem Header="TabItem 2" />
        <local:CloseableTabItem Header="TabItem 3" />
        <TabItem Header="TabItem 4" />
      </TabControl>
    </Grid>
</Window>

Note that we can freely mix the regular TabItems with our custom controls. Here is the result when we run this application:

Having all the visuals in place lets switch back to Visual Studio and finish the remining code. I choose to publish the Close button click event as the a routed event on the control. Of course I could handle it directly in the code of the control but this way I have more control on how to handle it in the application (for example I could display a confirmation dialog before closing the tab). Alternatively I could also create a custom Command and bind it directly to the close button. This would allow me to declare everything in XAML markup but I think event would be easier to use in this case. So below is the declaration for the CloseTab event:

public static readonly RoutedEvent CloseTabEvent =
    EventManager.RegisterRoutedEvent("CloseTab", RoutingStrategy.Bubble,
        typeof(RoutedEventHandler), typeof(CloseableTabItem));

public event RoutedEventHandler CloseTab
{
    add { AddHandler(CloseTabEvent, value); }
    remove { RemoveHandler(CloseTabEvent, value); }
}

To raise the event I need first to attach a handler to the Button's Click event. I can do it easily by overriding the ... method. This is where I use the PART_Close name mentioned earlier to find the button declared in template by using the GetTemplateChild method. The event handler simply raises the new event.

public override void OnApplyTemplate()
{
    base.OnApplyTemplate();

    Button closeButton = base.GetTemplateChild("PART_Close") as Button;
    if (closeButton != null)
        closeButton.Click += new System.Windows.RoutedEventHandler(closeButton_Click);
}

void closeButton_Click(object sender, System.Windows.RoutedEventArgs e)
{
    this.RaiseEvent(new RoutedEventArgs(CloseTabEvent, this));
}

So the only thing left is to actually handle this event. This will be done in the MainWindow's code behind. Normally I would have to attach handlers for this event to each tab I created but since this is a routed event (with bubble strategy) I can also attach it once on any of it's parents (up to the Window itself). Closing the tab is done by finding the parent TabControl removing the source tab from it's Items collection.

public partial class MainWindow : System.Windows.Window
{
    public MainWindow()
    {
        InitializeComponent();

        this.AddHandler(CloseableTabItem.CloseTabEvent, new RoutedEventHandler(this.CloseTab));
    }

    private void CloseTab(object source, RoutedEventArgs args)
    {
        TabItem tabItem = args.Source as TabItem;
        if (tabItem != null)
        {
            TabControl tabControl = tabItem.Parent as TabControl;
            if (tabControl != null)
                tabControl.Items.Remove(tabItem);
        }
    }
}

That's all we need to do. Now we have customized tab items with fully working tab control. And as you can see this is relatively easy to implement so nothing prevents adding more buttons or other elements on the tabs. For example in the TSRI project we have additional button that opens the tab contents as floating window.

Overriding default SystemColors in WPF

Szymon Kobalczyk — Sun, 25 Mar 2007 11:46:00 GMT

After working with WPF for a while I must say that it is wonderful platform for building complex user interfaces but sometimes it falls short in very simple scenarios. Or in other words, it's easy to do complex things with it's powerful tools but often it lacks simple tools to do simple things. At least from a perspective of Windows Forms developer who expects some familiar tools and quickly finds out that they are gone.

There are several examples of this, but one that I run across recently and find it very often in other forums is how to change default colors in more complex controls like ListBox or ComboBox. For example yesterday there was a question on the MSDN forum on how to change the highlight color in a popup of combobox.

All controls in WPF have only three properties to adjust their colors: Foreground, Background and BorderBrush (keep in mind that all of these properties accept brushes instead of solid colors). But you won't find such properties as HighlightedItemBrush on ComboBox or SelectedItemBrush on ListBox.

I read somewhere, that primary reason for this is that Controls encapsulate logical elements and shouldn't have properties that depend on their visual representation. Instead the appearance of each control is defined through it's ControlTemplate and with some alternative template these properties might make no sense at all.

So it might seem that the only option to override these colors would be to recreate the ControlTemplate for particular control and adjust the colors. Thankfully you don't have to do it manually. With Microsoft Expression Blend you can very easily create copy of the default ControlTemplate by selecting the control and then from menu invoking Object > Edit Control Parts (Template) > Edit a Copy...

But this will only recreate the template for your current Windows Theme so if you have to preserve all other visual aspects of the control you need to put even more work to subclass your control and recreate all themes for the new control. This is quite a big effort to do such a small thing.

There is however much simpler solution if overriding the default colors is the only thing you want to change. Because these colors are defined as resources you can try to override these resource for your control.

For example, to change the color of selected item in a ListBox (or highlighted item in ComboBox ) override following resource:

<SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}" Color="Orange" />

And because I also wanted to have the same color when ListBox doesn't have focus I needed to override this resource as well:

<SolidColorBrush x:Key="{x:Static SystemColors.ControlBrushKey}" Color="Orange" />

As with all resources you can do it either only for this particular control (using Style.Resources), whole window or even for the whole application depending on which ResourceDictionary you would use. And because these resources are referenced as DynamicResource you can even adjust them at runtime.

So now the only problem is to find out what resources you need to override to get the desired control. Once again the Microsoft Expression Designer comes in handy and you can find this out by recreating the default templates but this time only to read what colors it uses and what what purpose.

I've started putting together a reference of which system colors are used in default templates for simple controls and will publish it shortly.

How to access SharePoint's Discussion Board using Web Services. Part 2.

Szymon Kobalczyk — Fri, 16 Mar 2007 09:01:00 GMT

In my previous post I wrote how you can access the contents of discussion boards using web services. For reading existing discussions threads the Lists web service was all that we needed. However there were problems when creating discussions using the same service. After whole day of trial and error I finally gave up this approach and decided to first try using SharePoint's object model instead.

I work on the Scripps project!

Szymon Kobalczyk — Tue, 13 Mar 2007 08:22:00 GMT

Usually I don't write about my current employer or work, but I think this time it deserves to make an exception. You read already it in the title: I work now on The Collective Molecular Environment (C-ME) for The Scripps Research Institute (TSRI).

If you are following the news on Windows Vista or WPF you have probably seen this application already (the screen on the right might remind it to you). The Scripps Research Institute is a biomedical research organization that is trying to find a cure for cancer and make cancer a managed disease. Scientist wanted a better way to organize and share the research information. To answer these needs InterKnowlogy developed application that uses .NET 3.0 Windows Presentation Foundation and Office 2007 SharePoint to visualize and annotate research results.

You can watch a short video about the project that Microsoft produced. This was also the only third-party application shown by Steve Ballmer during Windows Vista and Office 2007 lunch event (the demo it's just after 30 minutes in it). And for some technical details I recommend the video interview with Tim Huckaby and Dr. Peter Kuhn on Channel 9. There is much more on the project site.

In the beginning of February Stephen Forte posted a Call for Developers to participate in the Scripps project on his blog (big thanks for Tad for forwarding it to me):

"Do you believe that software can change the world? How about the opportunity to work on an application that promises to help accelerate a cure for cancer?"

(Later I've learned that this was a joined initiative of Stephen, Tim Huckaby, and Eileen Rumwell.)

After watching all this stuff and hearing all the buzz with this project I was really excited to join the team. I've sent my resume... and a week later I got response from Tim Huckaby that I was accepted. I just couldn't believe it!

Altogether four developers were selected from all around the world. I have the pleasure to work with Haaron (Mexico), Rania (Egypt) and Kandaiya G (India), as well as great people from InterKnowlogy (San Diego, California): Kevin, Russ, Dan and Tim.

So right now we are working on the next version of C-ME. The team is communicating remotely using IM, email and telephone (and we use TFS if anyone cares to ask). Each of us was assigned a specific task to build during this month. We are using cutting edge technologies like Windows Presentation Foundation and Microsoft Office SharePoint 2007. So it's a lot of new stuff to learn.

My first task is to add support for discussion annotations to the viewer application. The application already supports File, Note, Url and Screen Capture annotations and they are all stored in SharePoint site for given entity. The new type I'm adding will be using the Discussion Board lists in SharePoint but it renders the whole discussion desktop application using WPF (and bit of HTML).

Of course, I will keep you updated on our progress during this month.

(Actually you can read first post on accessing discussion lists from SharePoint already.)