Wouter van Vugt

My blog has moved

2007-11-03T11:58:00Z

After having worked as a trainer for Info Support the past couple of years I have transitioned to the next phase of my career. I have started my own company Code Counsel through which I actively evangelize Microsoft .NET technology, with a focus on SharePoint and Office development. The time I have enjoyed at Info Support was one big learning opportunity and I couldn't have found a better company to work for so early in my career. It has been a wonderful time and a part of me is sad to be leaving. Thanks to all my great collegues who made it so much better. You guys are the one thing I'll be missing most. Now I have no one to tell me I am wrong when I go shooting my mouth of about something... :) (We already thought of a highly distributed SOA enterprise architecture with design patterns for auto delivering mails containing stuff like 'yes, but look at the other side of the ball Wouter', or 'Is that really so Wouter?', we only need to rent out the required rack space somewhere...)

So, if you want to continue checking up on my state of mind or you have some tech questions, head over to my currently un-branded and slightly, ehrm, really ugly blog. After TechEd I'll be fixing it up though. I will no longer be maintaining this place.

http://blogs.code-counsel.net/wouter

Open XML @ TechEd Europe 2007

2007-10-31T18:30:00Z

In a few days one of the biggest IT events in Europe is starting: TechEd Developers and the TechEd IT Forum. Come join many professionals and learn about new and current technologies. I will be attending TechEd Developers, together with a few collegues. You will find me available for discussing the Open XML technology, OBAs, SharePoint or just random talk like the reason why zebras and tigers have stripes, or why my keyboard has a CapsLock key....

Besides visiting great sessions I also plan to deliver three great sessions on Open XML. The first session on Tuesday afternoon is an Open XML introductionary talk. The intention for the first session is to provide you with an overview of the Open XML technology stack, as well as providing some insight into the business capabilities of Open XML like comprehensive digital signature support or the ways to embed business data from a document. On Wednesday the second session is in the morning, the last in the afternoon. The second will be on current implementations of Open XML and applications in the wild. The last session is a discussion on Open XML which I hope you'll join to discuss the merits of Open XML, the relation with ODF, or UOF, or even CDF...

Hope to see you there!

Откройте XML в России

2007-10-26T05:23:00Z

Я весьма горд объявить российский выпуск Открытого XML Объясненная книга. Есть другие переводы в создании и немногих доступный уже. Очень прохладный! Я надеюсь, что Вы любите читать маленькую книгу и что это обеспечивает немного ценных пониманий в мир Открытого XML, и развивающийся Office базировал заявления.

And yes, Boyrep that's me.

Ps. Did I mention we are trying to get a few (English) copies to TechEd which is in two weeks. I will be delivering three sessions on Open XML, one introduction, a real-world session and you get a chance to discuss the ECMA standard with us.

Hope to see you at TechEd!

Open XML in Healthcare

2007-10-24T05:53:00Z

Just learned from Microsoft that the white-paper on Open XML in healthcare is available on MSDN. The goal of the whitepaper is to show how Open XML can increase the portability of health records and empower the end-user in the tooling that they are familiar with (can you guess the tooling?)

"Using the Office Open XML Formats to Support Electronic Health Records Portability and Health Industry Standards"

Thanks to Ted Pattison and Chris Predeek for allowing me to collaborate on this whitepaper with them. Worked out quite well I feel. Also my first MSDN article which is a nice victory of the week :) Soon there will be a second on SharePoint field development, I'll let you guys know when it arrives.

Hope it helps

Updated extraction XSLT

2007-10-16T10:14:00Z

I updated the XSLT of the previous post. Mapped XML inside a table wasn't working properly, and now it is.

Extracting data from a xml-mapped document

2007-10-11T18:14:00Z

I have just returned from an MSDN InTrack session over here in the Microsoft Technology Center about Office Open XML and I wanted to share one of the demos I created for this event with you. The demo app extracts XML data from an XML-mapped WordprocessingML document. Note that this is not the Custom XML technology introduced in Open XML, but the earlier model already present in Office 2003. The one that looks like this:

Now the old model provides one great benefit. If you add new rows to the order-item table, the new rows are automatically mapped according to the XML schema that is attached to the document. One of the downsides is that the data is embedded in the rest of the main document markup which makes it harder to extract compared to the separate storage of Custom XML.

Of course using a little XSLT-trickery you can still obtain a data only copy (or use the Word UI for it, by saving as a 'Word 2003 XML document', which is a bit unfriendly to the users.

If you run the following XSLT against the main document body you can extract the data. Note that there are no data-type checks, and reviewing options in the document will mess things up (it's a demo…). Also line-breaks are not copied from the document, or other special non-printing characters such as tabs. Feel free to improve it and I'll update the XSLT here for the rest of the community.

<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0"
xmlns:xsl=http://www.w3.org/1999/XSL/Transform
xmlns:w=http://schemas.openxmlformats.org/wordprocessingml/2006/main
exclude-result-prefixes="w">

<xsl:template match="w:p | w:r | w:tbl | w:tr | w:tc">
   <xsl:apply-templates select="w:customXml | w:p | w:r | w:tbl | w:tr | w:tc"/>
</xsl:template>

<xsl:template match="w:customXml">
    <xsl:element name="{@w:element}" namespace="{@w:uri}">
      <xsl:choose>
        <xsl:when test="not(descendant::w:customXml)">
          <xsl:value-of select="descendant::text()" />
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="child::node()"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:element>
</xsl:template>

</xsl:stylesheet>

I'll post the demo-app later together with the rest of the demos.

Hope it helps!

OpenOffice developer strikes out at Sun

2007-10-06T08:20:00Z

Funny to see that Microsoft software is called 'closed', and they are always accused of overly protecting their markets. This is from one of the OO developers:

But I’d love to be proven wrong. I’d love to be proven that Sun still are willing to work with us, to make OO.o truly a wonderful product as well as a project attractive to prospective code contributors. But there is nothing I, as a single insignificant mere mortal can do to influence the behemoth that is Sun. It’s impossible to make an even slightest change in how the project is run, even after countless hours of coding and more than 10,000 lines of code generation (which I received no compensation for and involved quite a lot of personal sacrifice). In the end, I made no difference at all. Sad, truly sad.

This is a bit of a no-brainer. How open is your open source software if there is a large company investing highly in it? They need to meet customer demand just like any other, so probably that piece of open software is less open than you want it to be. If key positions are taken you can have a strong grip on the project and hence your company's future.

Personally I like the recent steps taken by Microsoft. They totally openend up their old and their new document format, and now they released the source of the .NET Framework. The software works and integrates extremely well. The value proposition of Microsoft Office together with SharePoint 2007 (for the most part free) for the team and collaboration stuff to me is very appealing. I wouldn't trade that for the eighties look of OpenOffice today.

[edit]A Tweakers thread actually had a sensible comment on this. I roughly translated:

If OO will fork the code you will have eight or nine versions in no time at all, who with a little luck will be 95% compatible with each other. Only a different 95% in each case of course. And then of course just when you want to send out your company folder the part that indicates how great your company actually just might not be to visible to customers using My-OO instead of the Your-OO.

Als OO dadelijk een paar keer gaat 'forken' heb je binnen de kortst mogelijke keren 8 of 9 verschillende versies die met een beetje geluk 95% compatible met elkaar zijn. Maar natuurlijk wel allemaal een andere 95%. En natuurlijk is het dan zo dat alle leuke dingen die jij in je bedrijfs reclame folder hebt staan die laten zien hoe goed jouw bedrijf is net niet helemaal overkomen bij jouw klanten die een toevallig andere versie hebebn.

(isn't this already the case?)

You've got the source Luke, You've got the source

2007-10-04T09:32:00Z

Notified by my collegue Bart, who is a bit slower on blogtyping than I am :)

http://weblogs.asp.net/scottgu/archive/2007/10/03/releasing-the-source-code-for-the-net-framework-libraries.aspx

Get a hard-copy of the Open XML - The Markup Explained book

2007-09-28T16:16:00Z

The fruits of my labor are finally getting there. I just learned from Doug that he'll be sending over a container ship with hard-copies of my first book on Open XML.

This means I can finally satisfy the overwhelming demand of people wanting to get a hard-copy here in the Netherlands and Belgium (this means you Maarten :)

So if you are interested in a copy of this book, let me know and I'll see what I can do about it. The PDF version is of course available as well, but I'll sign my copies to provide some extra value :)

I do have some further interesting developments which I'll blog about later. The next month is probably really busy, so expect the same amount of posts as last month (I also have a great MSDN article coming up on SharePoint custom fields with all the pooha that you would want in the near future)

The three-layered cake

2007-09-26T12:51:00Z

Besides funny IT stories:

http://worsethanfailure.com/Articles/The-Mythical-Business-Layer.aspx

Come jump in with me

2007-09-10T08:16:00Z

Thinking of leaping into .NET, Open XML, or SharePoint? Not sure where to start? Come jump in with me!

The Package Explorer splash screen: Multi-threaded application initialization

2007-08-25T16:14:00Z

Besides the nifty HTML start page that Package Explorer 3.0 will be using, there is another feature that I am quite happy about; the splash screen.

Now you have splash screens and splash screens, and mine of course needed to be a proper splash screen. To me this means the following:

Send status messages
Minimum display duration
Proper threading model

Especially that last item in the list is where I see many splash screens fail. There are many things that you can do with splash screens and threading, and if you do it wrong your splash will look ugly. The most basic implementations use the thread that you are handed on application start to show the splash and then init the application. By then switching the splash form with your real one you have done it. The difficulty is that while you are doing the init work on your UI thread, and you move another window over the splash, your splash UI will not update, leaving those familiar white gaps that Windows users have gotten accustomed to. Some sprinkle the Application.DoEvents call across their initialization code to have the messages appear correctly in the splash screen, not nice!

The second model is to have the application initialization run on a separate thread. That's of course a great solution to keep the splash screen responsive. The UI thread can update the splash screen and the messages which appear there and wait for the initialization thread to complete. Again, one of my demands is making things difficult. What I'd like to do is just create a WaitHandle that gets set from the initialization thread, and have the UI thread wait on this WaitHandle. This will satisfy my second demand, a minimum duration. But, in order to keep the UI responsive, you cannot do a WaitHandle.WaitOne, you might be able to do some polling on IsCompleted and do some Application.DoEvents in the mean time to update the UI, but again, not nice!

So my model then. It does it a bit differently. Both the UI thread and the initialization thread are created on application startup. So instead of the UI thread needing to wait for the application to start, the controller thread can do that. UI responsiveness galore!

In order to encapsulate the difficulties of working with multiple threads I borrowed an idea I found on the web. The Application.Run method can take an ApplicationContext as a parameter. This object holds a reference to the application's main form. When this form closes, the message pump is stopped. You can derive from the ApplicationContext in order to customize how this works. A good place to implement your splash screen logic.

Using the code

The end user scenario looks like the following block of code. This is typically how your main method would look.

static class Program
{
    static void Main(string[] args)
    {
        SplashScreenContext context = new SplashScreenContext();
        context.MinimumSplashDuration = 2000;
        try
        {
            context.Run(args,typeof(SplashForm),
                ApplicationInit, UIInit);
        }
        catch (Exception e)
        {
            MessageBox.Show(e.InnerException.Message);
        }
    }

    static void ApplicationInit(string[] args,
        SafeSendMessageCallback messageCallback)
    {
        messageCallback("Doing important application init work.");
        messageCallback("This method runs on a worker thread.");
        Thread.Sleep(500);
    }

    static Form UIInit(string[] args,
        SafeSendMessageCallback messageCallback)
    {
        messageCallback("Doing important UI init work.");
        messageCallback("This method runs on the UI thread.");
        Thread.Sleep(500);
        return new MainForm();
    }
}

You create an instance of SplashScreenContext, and before you call Run you are allowed to provide settings such as minimum duration of the splash display and maximum duration of the init method before an exception will be raised. Next you call Run to start your application. You pass in the command line arguments, the Type of the splashscreen form and two methods. The first will be called on a separate non-ui thread, the second will be called on the UI thread and needs to return the main form to switch to after the splash screen closes. Do be aware that the Main method runs on a different thread than the UIInt method. The UI thread is created by the SplashScreenContext to allow the wait for minimal splash duration to be non ui-blocking.

All exceptions flowing out of the initialization methods will be marshaled to the startup thread and throw there. This will allow you to catch all initialization errors inside your Main method. Both initialization methods are also provided with a callback for sending status messages to the splash screen in a thread-safe manner.

If you want to be able to send messages to the splash screen, just implement IDynamicSplashScreen on the Type passed in to the Run method. Your code will always be called on the UI thread so you have an easy time updating your status.

Here's a diagram.

The SplashScreenContext

Now the inner workings of the SplashScreenContext class are more complex than how you use it (as it should be).

The first interesting part is the Run method of which the signature is show here:

void Run(string[], Type, ApplicationInitCallback, UIInitCallback);

All parameters which have thread affinity are passed in the Run method, so the class doesn't contain any fields. This reduces the risk of me doing stupid coding resulting in contention somewhere.

The first task is setting up some basic stuff. The running Boolean is set to block changes to the properties of the class. The thread name is setup for better debugging, and some waithandles are created. The first WaitHandle is used to wait for the init thread to complete. The second for the UI thread to create the main form. While this second task is almost instantaneous, threading is always hard so I thought it was a good idea to wait for the UI thread to go live before going into the rest of the initialization work.

_running = true;
Thread.CurrentThread.Name = "Initial Thread";
// Create waithandle for minimum splash duration
_initReadyEvent = new AutoResetEvent(false);
_uiReadyEvent = new AutoResetEvent(false);

So the next thing that happens is the UI thread gets created, and the WaitHandle is used to hold further work until its live. (imagine the scenario where a status message gets sent to the UI thread while it isn't ready, waiting is probably good here). The SplashForm is also passed in as a Type instead of an instantiated class. The form cannot be instantiated yet, because that needs to happen on the UI thread which isn't created yet when the application starts.

Thread uiThread = new Thread(UIThreadMethod);
uiThread.Name = "UI Thread";
uiThread.SetApartmentState(_apartmentState);
uiThread.Start(splashFormType);
if (_uiReadyEvent.WaitOne(
    new TimeSpan(0, 1, 0), false) == false)
{
    ShutdownUIThread();
    throw new ApplicationException(
        "The UI did not initialize in a timely fashion.");
}

Next the initialization thread gets created. This is the one that will call your initialization method. When your initialization is done, the thread will signal the startup thread that it is finished.

// Create initialization data
ApplicationInitData initData = new ApplicationInitData();
initData.FinishedEvent = _initReadyEvent;
initData.InitCallback = applicationInitMethod;
initData.CommandlineArgs = (string[])args.Clone();
// Fire up initialization thread
Thread initializationThread = new Thread(ApplicationInitMethod);
initializationThread.Name = "Application Init Thread";
initializationThread.Start(initData);

Next is the easy part. The startup thread will wait on the initialization thread to complete, after it has waited for the minimum duration. You can specify how long the waits should be.

// now wait for minimum duration
if (_minimalSplashDuration > 0)
{
    Thread.Sleep(_minimalSplashDuration);
}
// now wait for init to complete
if (_initReadyEvent.WaitOne(
    new TimeSpan(0, _maxWaitForInitDuration, 0), false) == false)
{
    throw new ApplicationException(
        "The application did not initialize in a timely fashion.");
}

The Run method finishes with checking for errors, and switching to the application's main form. This of course needs to be done on the UI thread since controls like to be on the same thread always. First a check occurs to see if initializing the application resulted in an error.

if (_initException != null)
{
    ShutdownUIThread();
    throw _initException;
}
MainForm.Invoke(new ToggleToMainFormCallback(ToggleToMainForm),
uiInitMethod, args);
if (_initException != null)
{
    ShutdownUIThread();
    throw _initException;
}

UI Thread

The UI thread method that is used is rather simple. You find the same code as in the normal Main method from Visual Studio, plus some extra bits to fit it in the model.

void UIThreadMethod(object parameter)
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Form splashForm =
        (Form)Activator.CreateInstance((Type)parameter);
    MainForm = splashForm;
    _uiReadyEvent.Set();
    Application.Run(this);
}

Init Thread

The Initialization thread method is not more complex.

void ApplicationInitMethod(object parameter)
{
    ApplicationInitData initData = (ApplicationInitData)parameter;
    try
    {
        initData.InitCallback(initData.CommandlineArgs,
            new SafeSendMessageCallback(SafeSendMessage));
    }
    catch (Exception e)
    {
        _initException = new InitializationException(
            "An error occured during application initialization",
            e);
    }
    initData.FinishedEvent.Set();
}

That's it, and that's that. A handy class that can help you do a good splash screen keeping responsive and providing the feature set that I need. Download a demo here.

Hope it helps.

Package Explorer Start Page - How to use Win32 resources and the res:// protocol from .NET

2007-08-25T10:08:00Z

One of the cool new features that I am working on for RC2 of Package Explorer is a start page that is presented when the application starts. Because of the graphical nature of these startpages many applications like IDEs choose to use an HTML page that is displayed in a WebBrowser control of some sort. I of course wanted to do the same and bumped in to some interesting hurdles for which I didn't find a fix that I liked. So, here's my solution for doing this. (Did I mention that Package Explorer is starting to get really cool, and it's got some nifty pieces of code as well, like the Main routine)

First of all, a screenie (mind you, it is a work in progress, as it appears the transparency isn't quite transparent)

And yes, I have Maarten to thank for designing this. I really suck at it, so his designs are very welcome. Thanks Maarten!

Now the issue. Personally I don't like to have resource files loose on disk. I like to embed them in the DLL and only have one file to deploy. I at least like that for not frequently changing resources. For the startpage this would mean I need to embed the HTML (no problem) and the images (hmmm). To access the images inside the DLL I planned to use the res:// protocol. It can access resources in a DLL for just this purpose (and many others I would suspect). The downside, a .NET embedded resource is different from a Win32 embedded resource which the res:// protocol handler understands in IE. There are tools that you can use to embed resources manually after the build, but I am a programmer and I don't like to do things manually. I bet you don't either :)

My solution? I have a separate project for the start page HTML and images. The first task is to allow Win32 resources to appear in the .NET DLL. The CSC compiler has a switch to allow you to do just this. You can edit the CSPROJ project file to tell Visual Studio to use this switch and select the right resource file for the compilation. You can edit the project file using Notepad or something. Visual Studio will detect the change and ask you to reload the project.

<PropertyGroup>
<Win32Resource>StartPage.res</Win32Resource>
</PropertyGroup>

That's step 1, now to get a .RES file. This is rather easy and can be neatly integrated into the build. The RC.exe compiler can take a .RC file to compile into a .RES file. So it's just two easy steps to make it work. First you create a .RC file for the resource compiler:

Background.bmp Bitmap "Background.bmp"
FieldsetBackGround.bmp Bitmap "FieldsetBackGround.bmp"
FieldsetLabelBackGround.bmp Bitmap "FieldsetLabelBackGround.bmp"
Logo.bmp Bitmap "Logo.bmp"

Next you add a prebuild commandline to the poject using Visual Studio.

"C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\rc" /r "$(ProjectDir)StartPage.rc"

That's it. You can now just compile the project and it will first compile a .RES file from the resource definition and this .RES file will be embedded into the DLL automatically.

Now the cool thing is that you cannot only reference the embedded resources using the normal tags such as IMG

<img src="res://PackageExplorer.StartPage.dll/#2/LOGO.BMP" />

But you can also reference the resources from CSS (at least in IE that I am aware of)

fieldset
{
background-image: url(res://PackageExplorer.StartPage.dll/#2/FIELDSETBACKGROUND.BMP);
}

No more clutter on the harddrive and the possible deletion / change by Joe User.

Hope it helps.

75% approve in the States

2007-08-24T08:21:00Z

Just in:

http://ballot.itic.org/itic/tallyvote.taf?function=vote&committee=INCITS&ballot_id=2341&_UserReference=96EBDF227BF339D246CE4E20

It appears that the INCITS will move to vote Approve with Comments. The latest ballot resulted in 12 approves, 3 disapprove and 1 abstain. The disapprovers? IBM and Oracle most notably... :)

And I bet that those 12 approvers will expect their comments to be addressed!

A funny spin

2007-08-22T18:31:00Z

While checking up on my RSS feeds I came across this one which has a great quote.

"So we have language. And, although specialists may disagree, the English language allows us to express ourselves effectively. I propose to abolish all other languages and make the English language the only language. Or perhaps, better than that, I would like to go back to the original Neanderthal language as that was the first language in use and all other languages have no place trying to compete with Neanderthal."

Haha, indeed, I vote approve!

http://vacant.spaces.live.com/blog/cns!2526F2136E321C7E!287.entry