Detecting and Deploying Prerequisites

This is the 2nd of a multi-part series on deploying VSTO Applications using NSIS. Part 1 of the series can be found here.

Step 4: Ensuring MSI 3.1 is available

Before proceeding you need to make sure the client computer has MSI 3.1 installed. Click here to find out how.

Step 5: Checking whether Excel is Installed

Being an Excel Worksheet-Level Customization, it makes no sense for this app to be deployed on a computer that doesn't have MSO Excel 2003 Professional installed. Lets see how we can achieve this. If you do a bit of research you can find out that with VS Deployment Projects, this is achieved by doing a Windows Installer search for the component ID {A2B280D4-20FB-4720-99F7-40C09FBCE10A}.

Since performing a Windows Installer Search is a common and desirable feature, I came up with the following macro:

When invoked, this macro will generate a function, with the give name that will search for the specified Component ID. So the code to detect Excel 2003 becomes:

So, why did I make this a macro that generates a function, and not just a function that accepts the component ID as a parameter? Well, parameter passing is not that straight forward with NSIS, and I believe this leads to much cleaner code at the end.

Step 6: Ensuring .NET 2.0 Runtime is Present

You can find plenty of ways to do this on NSIS web site. Here's one of them.

Step 7: Ensuring VSTO is Present

We now have the scripts in place to deploy the application components as well as the to determine all prerequisites are available. All that is left is to add the boiler place Update Manifest and Set Security code. Easiest way to do this is to bring the code over a new .NET EXE project and pass the installation-dependant (e.g. Installation Path etc.) parameters as command line arguments. You can then execute the EXE as the last step of the installation.

For a little over a year, we’ve been working on a very sophisticated Microsoft Excel 2003 Document Level Customization project. We have nothing but pride towards the ingenuity of this application. But, there was one aspect that consistently overshadowed its success: Deployment.

Visual Studio Deployment Projects help you generate a setup app quickly and easily. It has the ability to look up source projects and determine all the components that need to be deployed. This makes things remarkably easy when you want a rudimentary installation. But, for anything out of the ordinary,  you will find that this offers you very limited help. To workaround these limitations you have to pick up a tool called Orca. Now, here’s where things get really dirty.

To use Orca, you have to have some semblance of the MSI database format. That isn’t actually so bad. A simple search on the Internet will fetch you loads of information regarding the subject. But, figuring out the format is just the beginning. You then have to weed your way using some ugly hacks. That's not all; you have to reapply those hacks with each build. If you are willing to live with the inconveniences, there's still a lot you can achieve using Orca. Musical Nerdery has a neat example on the subject.

Anyway, the point is we got sick and tired of working within these constraints and started looking for alternatives. After some serious considerations we opt to go with NSIS (Nullsoft Scriptable Installer Suite). We were mostly excited about its low footprint and its powerful scripting language.

This post is the first of a series in which I'm going to guide you through the steps involved in migrating your existing VSTO deployment package to NSIS. Before we begin, I should point out a few of the downsides to using NSIS.

1. NSIS doesn't understand VS Projects. It cannot scan through your projects and determine which components are relevant. You have to figure out all the files/dependencies you must deploy on to the client PC. Easiest way to do this is by creating a VS Deployment Project and let it tell you which files you need.
2. It cannot perform automatic rollbacks. If you want the user to be able to cancel the installation midway (after some files have already been deployed), you have to roll back the installation yourself using scripts. I'd argue that this is only a minor concern.

Since basic tutorials on NSIS scripting are widely available, I'm going to skip over the basics. You can learn about them here if you need to.

Step 1: Add a Visual Studio Deployment Project to your VSTO Solution

For the purpose of this tutorial I'll be using a really simple Excel 2003 Document Level Customization project called NsisDemo. All it does is display a message box saying "NSIS Rocks!!!" You can download it here or use your own VSTO project and include a VS Deployment Project as I have done.

Step 2: Begin your NSIS Script

Now, fire up your favorite text editor. I tend to prefer Notepad++ which offers syntax highlighting for NSIS scripts. Create the basic skeleton of a NSIS script in a sub folder of your main solution folder. If you need help getting started check out HM Nis Edit to generate a script for you, or use this one: Sample NSIS Start Script (2.4KB).

Step 3: Include Files that will be Copied to Client Machine

Open your VS Deployment Project. Go to the File System Editor and take a look at the file list under Application Folder.

Lets go ahead and add these files to our script. You'd need to modify the main installer section as well as the uninstaller section.

Note that all the non-user files (files other than NsisDemo.xls and NsisDemo.dll) are part of the Office 2003 PIAs. You might chose to deploy these files properly using the PIA installer. But, for now lets keep things simple and stick to copying them to the install directory.

At this point you may compile the script to generate an executable installer file. However, the VSTO application deployed through it will fail at run time as there are lot more missing pieces we need to stitch in to it.

Up next: Part 2

After weeks of inactivity, I finally managed to get a demo project in place for the BreadCrumbs controls. You can download it here. The code includes few updates I have made since the last version. For the sake of flexibility, I have kept the basic control as simple as possible. In the demo, I have added few additional helper classes to provide the full functionality desired.

Extending the control is pretty simple too. For instance, to display the menus for each of the sub items in a list item, you handle the SubItemClicked event. The SubItemClickedEventArgs passed to you along with this event provides you with the row index, column index and the bottom-left corner pixel coordinates of the sub item. In the demo app, this event handled as;

Here, the _entityMenu is a pre-constructed menu while as the "Template Menu" is reconstructed every time based on the selection.

Due to a life changing experience that I ran into 2 weeks ago, I've been unable to continue on with my regular R&D work. I've got a small breather that might last the rest of the week and so figured I should try to finish up some of my projects: 1st off, I managed some work on the Bread Crumbs list control.

Here's what the control looks right now:

Items support Hot-Tracking	Vista's Windows Explorer style item selection
Sub-item selection	Sub-item Menu Support

Also added support for item editing:

Design

The controls design is pretty basic and the code not overly elegant at this stage.

Each row on the List Box is an instance of the BreadCrumbsItem class. The BreadCrumbsItem holds an array of strings with each element corresponding to  an individual column. The list box requires that you insert only items with equal number of columns. Otherwise an exception will be thrown.

I had trouble getting the scrollbars inherent in UserControl/ContainerControl to function properly. The OnScroll method wasn't receiving the proper scroll value and was reverting to 0 all the time. So, I had to go with adding a vertical scroll bar manually. Anyway, check out the code (49.5 KB zipped folder).

Over the past few months, I've been working on a pretty high-end VSTO application. There had been some really ground breaking concepts thrown into that project which unfortunately, cannot be posted here for obvious reasons. What I can do is discuss a little widget I'm hoping to build that would eventually find it's way into that project.

Background

The application contains an Advanced Search feature where the user can build reusable search template (called a Saved Search) as well as a reusable results templates. A "Saved Search" is basically a collection of search criteria linked to a results template. The results template decides which fields from are displayed from the "results set".

We have 2 wizard UIs for configuring Saved Searches and Result Templates. The first page for each of the  wizards are almost identical in the fact that they asked the user to

1. Pick an Entity class and then,
2. Type in the name for a new saved search/result template to create or pick from a list of existing templates.

Since both the UI requirements were similar (and much similar UIs were required on few other places), this was implemented as a User Control that looked like:

All the text labels on the control were configurable and each time the selection changed in the Entity class drop down, it would fire an even asking for an array of existing items. On the wizard page this control was placed, the event was handled and the array filled with either the list of Results templates or saved searches for that particular Entity class.

Limitations of the Existing UI

The above interface was good enough initially. But it became quite cumbersome as the number of Entity classes grew (and it could potentially grow up to hundreds) and as more and more templates/searches were being saved. The user  was forced to go through all the Entity classes one by one if he wished to see all the saved items. I later added a Recent Items list but, the problem still required a better solution.

Adopting Vista Breadcrumbs Concept

One of the coolest new features in Vista is the breadcrumbs bar in Windows Explorer. The ease of which this allows you to navigate through folders is simply amazing.

And that got me thinking; can I adopt this to improve the user experience in the above case?  Here are my initial designs:

You would notice the peculiar menu items at the bottom indicating a character range (e.g. A-N). Well, I hope to make this work like Outook's Address book buttons; probably using the code found here.

In the coming weeks, I hope to get some code out based on this concept UI. Obviously, there's a lot of work required for a clean implementation. I can in the meantime get a quick and dirty , proof of concept control done using a auto scrolling Flow Panel and an array of Toolbar Strips. Well, stay tuned...