Ogy's log

[Inside TeamCompanion 2.2] Customizing the Work Item Preview

noreply@blogger.com (Ognjen Bajic) — Mon, 26 Oct 2009 01:53:00 +0000

One of the new features introduced in the TeamCompanion 2.2 is the ability to customize the new work item preview.

There are three ways to influence the content of the work item preview:

a) declarative – the list of the fields to be included or excluded form the preview is saved in the registry

b) programmatic – you override the xsl file used for formatting the xml generated by the TeamCompanion. You can do anything you like there.

c) mixed - above options combined.

Included/Excluded lists

Included lists are used to specify all the fields you want included in the Work Item Preview. Excluded lists specify all the fields you want excluded from the Work Item Preview. Included or excluded lists are semicolon separated lists of work item fields Reference Names. For example: „System.State;System.CreatedDate;System.CreatedBy;System.IterationPath;“.

It is an error to use both Included and Excluded lists at the same level/priority in registry. In that case TeamCompanion will use Excluded list.

The order of work item fields in the list is important.

Saving Included/Excluded lists in the registry

There are different locations where the Included/Excluded lists may be saved in the registry.

These locations define the scope of the setting, whereby the scope may be:

a) one particular server (global setting that would span multiple servers is currently not supported) – applies to all projects and all work item types in that server;

b) one particular project – applies to all work item types in that project;

c) one particular work item type in one particular project and server.

Registry root folder ( path : „HKEY_CURRENT_USER\Software\Ekobit\TeamCompanion.Outlook“
    <server_name>
        [IncludedPreviewFields] or [ExcludedPreviewFields] – the option a
            <project_name>
                [IncludedPreviewFields] or [ExcludedPreviewFields] – the option b
                    <work_item_type_name>
                        [IncludedPreviewFields] or [ExcludedPreviewFields] – the option c

<server_name>, <project_name> and <work_item_type_name> represent Registry keys named after the server, project or work item type containing settings for a specific server_name, project_name or work_item_type_name respectively.

<server_name> is the name of the TFS server as it is displayed in the TeamCompanion’s UI (tree control): TFS_FQDN.PortNumber. e.g. tfs.test.com.8080 (notice that there is a DOT between the server name and the port number).

In the scheme shown above, "[IncludedPreviewFields] or [ExcludedPreviewFields]" are all valid places where „IncludedPreviewFields“ and „ExcludedPreviewFields“ lists can be put.

Each of these three places defines different validity scope. If for particular work item type, project and server there are settings defined on different levels, the setting on the lowest level will apply (work item level takes precedence over project level which takes precedence over server level). For some Work Item first will be used list specified in its key. If it isn't present, then the list in project key will be used. If that one also isn't present, the one in server key will be used. If there is no list that apply to that Work Item type, project and server, the default settings will be used.

We might provide proper UI for these settings in some future version.

Using your own XSL file

Full path to the alternative Xsl file must be saved in registry in

HKEY_CURRENT_USER\Software\Ekobit\TeamCompanion.Outlook\WorkItemPreviewXslFilePath.

For example, „D:\MyFolder\CustomXSL.xsl“. In case of any error while using that file, TeamCompanion will fall back to the default embedded XSL.

Attached you can find a sample xml (normally dynamically generated on the fly by the TeamCompanion) and sample xsl that is used to transform the xml in order to produce the work item preview.

There is one additional setting that influences the work item preview content: Removing Empty Fields in Work Item Preview

This setting can be edited from the TeamCompanion UI using the checkbox check box named „Remove empty fields from Work Item preview„ available in the Work Item Preview tab of the TeamCompanion options dialog.

If it is checked, empty fields will be removed (exception from this is if the field with the empty value is explicitly listed in the appropriate IncludedPreviewFields list, in which case they will not be removed).

[Update] Users having work item query folders where some work items already exist, need to remove and reload these work items for the new preview settings to become effective. This can be done by selecting all work items and deleting them by pressing Delete key on the keyboard. Don’t worry – your work items will remain intact. This will only delete cashed offline information about them. Execute the query once again (by executing Refresh command from the folder’s context menu) or, if you have scheduled execution of this query, wait for the schedule, and all work items will appear once again, this time with the preview formatted in accordance with your new settings.

Download File - Sample

TeamCompanion for Outlook v 2.2 released

noreply@blogger.com (Ognjen Bajic) — Thu, 08 Oct 2009 23:36:00 +0000

Earlier this week Ekobit released the TeamCompanion for Outlook v2.2. This is a minor .x version and as such it comes with some new features and many improvements of existing ones that complement and enhance existing functionality. In this version we address many usability obstacles in order to ensure smooth and efficient usage patterns throughout the application.

This release is a free update for all existing customers.

Following is the list of the most important new and improved features of TeamCompanion in v2.2:
• Better offline support and support for occasionally connected clients
• Improved Work item edit form
• Improved Work item preview (Support for history; preview is now fully customizable)
• Improved Work item from Mail action
• Improved Open related object action – for emails multiple related objects are offered; related work item for Outlook Appointments
• Improved Reports support (new conversion formats for Reports; support for Canceling )
• Improved Send Work Item as Mail action (‘with attachments’ option including attaching created mail back to the Work Item)
• Improved usability/ease of use
• TFS 2010 Beta support
• TeamCompanion v2.2 is compatible with Windows 7

Let's describe each of above points in more detail:
1. Better offline support and support for occasionally connected clients
Separate TeamCompanion’s offline mode doesn’t exit any more – we’ve merged it with Outlook’s offline mode switch (File\Work Offline menu option). Previously TeamCompanion’s offline mode was available in the Options dialog which wasn’t discoverable. We have heard the feedback and reorganized both internal logic and UI.
We deal with occasionally connected situations much better than before – using logic running in the background TeamCompanion detects if the Outlook is online or not and adapts itself. Actions that automatically connect to the server (like scheduled work item query execution) are executed only if Outlook is really online.

2. Improved Work item edit form
Work Item edit form is obviously one central piece of UI in TeamCompanion. There are some new actions in the form’s toolbar (new buttons in yellow):

Refresh/Undo actions are supported now.

There are different new ways to send work item as mail. Four alternatives are supported: send work item as mail with or without attachments and with or without subsequent attaching of the mail back to the work item after the mail is sent.

The default 'Send Work Item as Email' action type can be set in the appropriate options dialog.

Two new buttons in the upper right corner of the work item form make it very easy to find emails related to the work item – they search for mails containing either work item Id or Title. By default all mail folders are searched, but the search can be done in just some specific mail folders (configurable in Options dialog). The result of the search is the usual mail list UI in which we can execute all standard mail related actions.

3. Improved Work item preview (Support for history; preview is now fully customizable)
Workitem HTML preview is fully customizable. There are three ways to influence the content of the work item preview:
• declarative – the list of the fields to be included or excluded from the preview is saved in the registry
• programmatic – you override the xsl file used for formatting the xml generated by the TeamCompanion. You can do anything you like there.
• mixed - above options combined.
Details of preview customization are beyond the scope of this overview and will be covered in some future blog entry.

Second new feature of the HTML preview is the support for the work item history. This can be switched on and off in appropriate Options dialog tab. Additionally, for performance reasons, user can set the number of history entries that will be available in the preview.

Upgrade users having work item query folders where some work items already exist, need to remove and reload these work items for the History to become visible in the work item preview. This can be done by selecting all work items and deleting them by pressing Delete key on the keyboard. Don’t worry – your work items will remain intact. This will only delete cashed offline information about them. Execute the query once again (by executing Refresh command from the folder’s context menu) or, if you have scheduled execution of this query, wait for the schedule, and all work items will appear once again, this time with history in the preview.

4. Improved Work item from Mail action
In addition to mapping email fields and work item fields used when creating a work item based on an email, it is now possible to fill email fields with constant values. Internally, we call this feature “poor man’s work item templates”. It is especially usable to set the current iteration and (at least a part of) area information.
With this little feature, in many occasions, just one click is enough to create fully populated and valid work item from mail.

5. Improved Open related object action – for emails multiple related objects are offered; related work item for Outlook Appointments
Open related object action was introduced in TeamCompanion 2.1. This feature makes it easy to open TFS objects mentioned in an email (work item, changeset or build). In 2.1 we were able to offer just one most significant object and in v2.2 as long as there are multiple objects referred to in a mail, we will offer all of them. There are different methods we use to find object references (like parsing object urls, different patterns in the mail content etc.). If you believe we should be able to find a reference to an object in some mail of yours and we don’t, please contact me directly and hopefully we will support it in some future version.

6. Improved Reports support (new conversion formats for Reports; support for Canceling)
Two new conversion formats for reports are supported- embedded HTML and Web Archive. Embedded HTML is the new default. This way the text in the report description isn’t just a part of the image anymore and can be selected, copied etc.
Cancelling report execution is also supported.

7. Improved Send Work Item as Mail action (‘with attachments’ option including attaching created mail back to the Work Item)
There are four ways to send a work Item as Mail – with or without attaching Work Item attachments to the mail and with or without subsequent attaching the mail to the Work Item after the mail was sent. Wherever there are Work Items in the TeamCompanion’s UI they can be sent as mail.
The content of the mail is completely configurable (but that is not new in v2.2).

8. Improved usability/ease of use
There are many small usability enhancements
o Indicator during query execution – the text “(Working…)” is appended to the Query name during the query execution
o Ability to select server and project while creating wi from mail or attaching mail to existing work item

o Work Item form size and position remembered
o Better default work Item Query result grid column widths
o More responsive UI due to the asynchronous execution of following actions
- Scheduled query execution
- Opening a work item
- Creating new work item from Outlook items or attaching mail to work item
- Export to Excel and Project
o Reasign To combo supports auto complete – we filter the list of available people as you type which is especially helpful for large teams i.e. if there are hundreds or thousands of people in the list
o Work Item Field lists (e.g. in the Work Item Query Editor) support type ahead – similar as above

9. TFS 2010 Beta support
TeamCompanion v2.2 works with prerelease versions of TFS 2010 using the Team Explorer 2008 SP1 upward compatibility support. The restrictions imposed by the scope of compatibility support are described here.
In order to connect to the TFS 2010 server it is important to enter the whole url of the server including virtual folder and project collection like this:
http(s)://[serverName]:[port]/[vdir]/[collectionName]
Where the is an optional, server level argument.
Example connection Strings looks like: http://myserver:8080/tfs/Collection or http://server:8080/tfs.

If the server virtual folder is defined during the server installation it must be included in the server url. If you don't explicitly put project Collection name in the server url, you will be connected to the Default Collection.

With TFS 2010 server, most of the features work as expected. Some notable exceptions are listed here:
-Execution of hierarchical work item queries; work item query results are only flat lists
-Reports don't work (for this we need 2008 compatibility bits that should be available in the Beta 2 timeframe)
-New work item controls (Test steps etc.) are not displayed

Expect this compatibility issues to be solved in future TeamCompanion versions.

10. Compatibility with Microsoft CRM Outlook Addin
Microsoft CRM Outlook Addin seems to be relatively fragile and in some cases it refused to load if TeamCompanion was present. TeamCompanion v2.2 behaves the way CRM Addin expects, waits for it until it is initialized and only then it loads itself. This way these two Outlook Addins can coexist peacefully.

11. TeamCompanion v2.2 is compatible with Windows 7

TeamCompanion is tested for compatibility and reliability on Windows 7.

For this version, the UI has had considerable amount of improvements. We engaged SSW to do a Software Audit for UI usability and Adam Cogan was great as we went back over 4 iterations. We hope you notice the difference. If you are interested in learning more see SSW's User Interface rules or have an auditor performed on your own software.

There are many others that have helped shaping TeamCompanion v2.2, but I would personally like to thank Gregg Boer from the Team Foundation Server’s development team, who was willing to use various prerelease versions in his daily work and to test them thoroughly. Gregg suggested many features that in the end appeared in the above list.

Hopefully this rather long blog entry gives you a quick flavour of TeamCompanion 2.2 and where we are going with this release. As soon as you try it out, we would love to hear what you think of it.

Windows XP Mode RTMed

noreply@blogger.com (Ognjen Bajic) — Tue, 06 Oct 2009 10:50:00 +0000

Microsoft recently RTM’ed Windows XP mode – virtualization technology built into the Windows 7. Windows XP Mode provides what is called the “last mile” compatibility technology for those cases when a Windows XP productivity application isn’t compatible with Windows 7. This is important to convince those that still enjoy working on Windows XP that migration to Windows 7 doesn’t mean farewell to their possibly not compatible applications. I am really convinced that XP may play important role in securing success of Windows 7.

But this isn’t what excites me about Windows XP Mode.

Windows XP mode introduces an interesting way of UI integration with the host operating system where applications running in the virtual environment look as if they were native applications running in the host OS. At the first glance there is no difference between an application running in the host and another application running in virtualized environment. This opens lots of opportunities for everyday use of beta software which is for me as VSTS MVP especially interesting these days when different VSTS 2010 versions need to be tried out and played with.

And what really excites me is the ability to try TeamCompanion in Outlook 2007 and Outlook 2010 CTP side by side!

By running Outlook 2007 and 2010 side by side I get the opportunity to test drive both TeamCompanion in Outlook 2010 and with VSTS 2010 without having to explicitly use (and look after) multiple environments. Outlook 2010 accounts are configured so that they don’t remove mails from the server, so that for the time being I can still use Outlook 2007 as official mail client.

For more info about Windows XP Mode go here.

VS2010 Work item categories

noreply@blogger.com (Ognjen Bajic) — Thu, 27 Aug 2009 14:40:00 +0000

With VS2010 a new concept of work item categories is introduced. Out of the box there are four different categories defined: Requirements, Bugs, Shared test steps and Tests. They are used by the MTLM (Microsoft Test and Lab Manager – the new tool for manual testing) to filter the work items that will be shown in different parts of the MTLM’s UI.

Work items of the types belonging to the Requirement category are displayed in the window shown below:

Note: Images are taken from a VS 2010 Beta 1 build.

Categories are defined as a part of the process template. The only difference between categories defined in the two default process templates is that if you are using MSF Agile the Requirement is a User Story work item type, and in the MSF CMMI it is a Requirement work item type. It is easy to change these defaults – we can add different other work item types to a category, and they will appear in the MTLM’s UI as well.
Categories are defined as a xml file. The file is generated by the witadmin command line utility (available by default in the C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE). This is the new utility replacing several other command line tools like witexport, witimport etc…
The procedure is as follows: using witadmin with argument exportcategories to create the xml description, edit it and import back using witadmin importcategories.
The description for the Agile MSF looks like this:

<?xml version="1.0" encoding="utf-8" ?>
<cat:CATEGORIES xmlns:cat= "http://schemas.microsoft.com/VisualStudio/2008/workitemtracking/categories">

<CATEGORY refname="Microsoft.BugCategory" name="Bug Category">
<DEFAULTWORKITEMTYPE name="Bug" />
</CATEGORY>

<CATEGORY refname="Microsoft.RequirementCategory" name="Requirement Category">
<DEFAULTWORKITEMTYPE name="User Story" />
</CATEGORY>

<CATEGORY refname="Microsoft.SharedStepCategory" name="Shared Step Category">
<DEFAULTWORKITEMTYPE name="Shared Steps" />
</CATEGORY>

<CATEGORY refname="Microsoft.TestCaseCategory" name="Test Case Category">
<DEFAULTWORKITEMTYPE name="Test Case" />
</CATEGORY>
</cat:CATEGORIES>

Let’s expand the Requirement category and add the Bug type to it (we want to be able to define the tests testing the error causing the bug). The xml would look like this:

<CATEGORY refname="Microsoft.RequirementCategory" name="Requirement Category">
<DEFAULTWORKITEMTYPE name="User Story" />
<WORKITEMTYPE name="Bug" />
</CATEGORY>

And the MTLM would look like this - as requirements both user stories and bugs are listed:

Shared steps are another work item category. Out of the box the Shared steps work item type is the only one belonging to this category. This category is obviously used to show shared steps during the definition of the Test.

That’s it. Work item categories are just one additional level of indirection allowing for some flexibility in the MTLM.

TeamCompanion for Outlook v 2.1 released

noreply@blogger.com (Ognjen Bajic) — Thu, 16 Apr 2009 07:42:00 +0000

Earlier this week Ekobit released The TeamCompanion for Outlook v2.1. Although numbered as a minor .1 release this version brings not only bug fixes, improved performance and enhancements to existing features, but also some exciting new features. This way TeamCompanion fulfills its goal to provide the general purpose TFS client integrated in Outlook with rich feature set aimed at nontechnical users, but useful to anyone wanting to combine Outlook’s collaboration and communication features with the ability to access TFS artifacts.

This release is a free update for all existing customers.

Following is the list of new and improved features of TeamCompanion:
• Reports (including multiple saved parameter sets for each report)
Support for reports in TeamCompanion lets you use all standard TFS reports directly from Outlook including the ability to send the report as mail or create an Outlook task or an appointment with the report inside. This feature also lets you save the parameters with which you usually execute each report, so that you can access already configured report with just one click. For each report you can save multiple parameter sets. My favorite usage pattern is to add such preconfigured report to the favorite folder and have it there available for fast and easy access. Read more here.

• „Query by example“ Work Item Query editor (including full-text search support)
Query by Example (QBE) is a simplified Work Item Query editor that makes it easier to define usual everyday Work Item Queries. Queries are defined by entering values in already available placeholders for specific most frequently used Work Item Fields (like State, Priority, Iteration or Area Path etc.). QBE also supports full text search in any text or html work item field. There is full two way synchronization between QBE and standard grid based Query Editor so that you can edit search criteria in any of these two editors and freely switch between them. Read more here.

• Powerful online and offline work item search capabilities including desktop search integration
With Query by Example query editor for full text online search and desktop search integration for full text offline search in any work item field, TeamCompanion gives you all the tools you need to find the information you need.

• Attaching mails to work items using drag-n-drop
Just drag a mail to the work item’s attachment tab and drop it there. TeamCompanion will take care of the rest. You can also attach files with drag-n-drop or paste pictures easily too.

• Open related object (work item, changeset or build) action for notification mails
Whenever you receive a notification mail from the TFS that refers to some TFS object this feature will let you open that object with just one click. This works not only for work items, but also for changesets and builds. Opening a changeset from a notification mail is my personal favorite, since it gives you the ability to follow source code changes directly from Outlook – you receive a notification, open the changeset, in the list of changed files open the difference and there you have the view of the source code changes. All without leaving Outlook.

• Work Item Query management
Configuring "Group by" columns is now a part of the work item query editor. This setting doesn’t change the query itself of course. It rather defines the way the query result will be displayed in Outlook.

• Scheduled Work Item queries
With scheduled query feature introduced in TeamCompanion 2.0 end users can configure work item queries to be automatically executed periodically. With this release administrators get the ability to control how frequently queries may be executed to prevent too frequent execution that may cause heavy load on the Team Foundation Server.

For the complete list of features visit the TeamCompanion’s homepage.
TeamCompanion is available as a free 90-days fully functional trial.

[Inside TeamCompanion 2.1] Reports

noreply@blogger.com (Ognjen Bajic) — Sat, 11 Apr 2009 07:46:00 +0000

Reports are yet another feature introduced in the TeamCompanion v2.1. It integrates standard Team System reports with Outlook, thus making it not only easy to track and analyze the status of the project but also to send that further. In addition to that, support for reports in TeamCompanion simplifies the way you work with the same report used with different parameters by saving multiple parameter sets and making them available with just one click.
First of all there is a new Reports folder in the tree beneath the project folder containing all reports. If you open a report it will be shown embedded in the Outlook UI:

The report itself looks just the way you would expect it, but there’s a new toolbar at the top of the window. It lets you send the contents of the report as a mail, create an appointment or an Outlook task with the report contents attached.
In the popup menus for each of these options in the toolbar the default action, executed if you just click on the toolbar button, is displayed bolded (it can be configured in the Options dialog).

One of the most annoying things regarding reports is the necessity to enter the same report parameters each time you use the report: current iteration, area for the part of the project you are interested in, start and end dates and different other parameters over and over again. TeamCompanion with saved parameter sets comes to rescue: just click the Save as button in the reports toolbar and create a new parameter set. A new entry appears in the tree beneath the original report node and with just one click you can open the report with already populated parameters. And you can preset multiple different versions of the report with different parameter configurations (e.g. one for the current iteration, one for the previous iteration etc.).

And to make your preconfigured reports even more accessible, put them in the favorite folders. This way wherever you are in Outlook, with just one mouse click you will be able to open your favorite reports with parameters already set and start to analyze your project status straight away.

It can’t be easier than that.

[Inside TeamCompanion 2.1] Using Outlook 2007 Instant Search for offline work item search

noreply@blogger.com (Ognjen Bajic) — Tue, 31 Mar 2009 18:28:00 +0000

Instant Search is the way to perform precise and fast search within Outlook 2007 mails, tasks, contacts, etc. You can also use it to perform full text search within work items even if you are offline. Searching arbitrary text is easy. Just select query folder and type word or phrase you want to search. Searching for the text within specific work item fields is somewhat more involved, but is also very easy, as we will demonstrate shortly. Purpose of this text is to demonstrate both approaches.

To be able to search while offline, we first need to fetch the work item information from the server in online mode. In TeamCompanion, scheduled execution of work item queries is usualy used for that. Let's suppose we want to search within work items that were returned by some query called „Test Query“. On the right side the first few work items are visible:

If we want to search for text „process guidance“, we would simply type that text in the Instant Search text box. Note that phrase must be enclosed in quotes because we want to search fields that contain both the „process“ word and „guidance“ word. These are the results:

The result is as expected; search result consists of work items that contain the phrase „process guidance“.

Let's suppose that we want to restrict our search to some specific work item fields and not all of them. To accomplish that, search queries must be used. Generally, search queries have the following form: keyword:search criteria value. When searching within a single field, keyword is the name of the field and search criteria value is the phrase that field must contain for the item to appear in the search result. In the case of TeamCompanion, basic search query has the following form: [Tfs:work item field name]:search criteria value. Work item field name is the name of the column in query view and search criteria value is the phrase to search. Note that work item field must be added as column in order to be used for search (to add columns, right-click query folder and click „Customize View“). Square brackets are required because TeamCompanion prefixes work item field names with „Tfs:“. Since colon is used by the Instant Search as the separator between keyword and search criteria value, we must tell Instant Search that colon in Tfs:work item field name is not separator. To do this we enclose Tfs: work item field name with the square brackets.

Now, let's look at few examples. Assume we want to search for the phrase: „Set up“ in the Title field. Our search query must have the following form: [Tfs:Title]:“Set up“. This is the result:

Search results now consist of work items that have the phrase „Set up“ in their Title field.

Instant Search allows usage of the standard logical operators: AND, NOT, OR, <, >, =, etc. Next example will show how to use logical operators to create a bit more complicated search queries. Suppose we want to search work items that have word „task“ in their description but ID for that work items must be less than 200. Search query for the first condition is [Tfs:Description]:task, and search query for the second condition is [Tfs:ID]:<200. Since we want work items that satisfy both of these condition, we're going to use AND operator to combine previous search queries into the single search query: [Tfs:Description]:task AND [Tfs:ID]:<200. Search results are:

That's it! As you can see, searching work items is easy.
For more information about search queries, you may find these links helpful: Learn to narrow your search criteria for better searches in Outlook and Office Online on using Instant Search
[This blog entry was written by Dini Selimovic who implemented large parts of TeamCompanion.]

[Inside TeamCompanion 2.1] Query by Example (QBE)

noreply@blogger.com (Ognjen Bajic) — Tue, 24 Mar 2009 22:34:00 +0000

TeamCompanion features the standard grid based work item query editor (see Picture 1) since the version 2.0. This editor is powerful, very flexible and supports lots of options, which makes it overly complex for most standard everyday queries. Although there are only a handful of work item fields usually used in the queries, user needs to pick them from a long list of fields each time over and over again. From the names in the list it is not always even clear which is the right field for specific criteria. These are only some of the issues with the standard query editor that led us to the idea to make better querying experience possible.

Picture 1: Standard Work Item Query Editor

In order to enable easy and efficient work item query editing and work item search in general we have decided to implement a new kind of work item query editor in TeamCompanion v 2.1 - Query by Example (usually referred to just as QBE). In the QBE, the standard fields are already predefined and user only needs to fill in the values. Defining search criteria this way is easier, faster, and more straightforward – most of the queries can be defined with just few clicks.

In QBE, fields are grouped in 5 different groups and presented in as many tabbed dialogs:
• General (for general query filter fields like Project name, State, Work Item Type, Area and Iteration path, Id etc.),

• State transitions (for the fields related to the work item state transitions like Created on, Created by, Resolved on etc.),

• Text (for full text search over different text fields),

• Historical Queries (for the ASOF wiql operator)

• Additional criteria (for the fields that are not provided in previous dialogs; in the picture below we have arbitrarily added two fields: Discipline and Triage).

So, how would you define an ordinary Query like “give me all active bugs and tasks assigned to me in the current project”? Actually, all you would need are exactly six mouse clicks. Check the checkboxes for the work item types Bug and Task and select @Me from the list in the “Assigned to” control and Active from the “Status” control. It can’t be simpler than that.

Picture 7: A simple Work Item Query in QBE – criteria described above are highlighted

We could add some additional criteria from the State transitions tab (e.g. search for work items that “I have created in the last 30 days”). Another four clicks.

Picture 8: A simple Work Item Query in QBE contd. - State transitions

We can even have full text search criteria included in the query.

Picture 9: A simple Work Item Query in QBE contd. – Full text search

Now, you are in for a surprise. Just switch tabs from “Query by Example” to “Query Editor” and the same query we have just defined in QBE is available in the standard grid based editor and can be further refined there. We can change any of the criteria just defined in QBE or add some completely new criteria. In QBE there is a constrained set of fields available. In the grid there are no restrictions: you can choose any field you like and as long as you choose AND operator while adding new fields, you will be allowed to switch back to QBE and continue editing the query there.

If QBE were just a fancy way to define queries using hardcoded set of fields, it would clearly be of limited use. But if you add custom fields to the query in the Query Editor and switch back to QBE, these fields will be available there too. That is what Additional criteria tab is used for. If there are additional fields in the work item query, that are not provided by default in any other tab, as long as the query structure is such that the QBE can present it, the fields will be available in the Additional criteria tab.

Picture 10: A simple Work Item Query in QBE contd. – Query opened in the standard Query Editor

Picture 11: A simple Work Item Query in QBE contd. – Custom field added in the Query Editor

Picture 12: A simple Work Item Query in QBE contd. – Custom field editable in QBE

This way with QBE and grid based Query Editor you get the best of both worlds: efficiency and ease of use of QBE and flexibility of Query Editor.
Following are some best practices regarding QBE that will further improve your usage experience with QBE.

If you want to remove a clause regarding some field on the General tab that comes together with the combo for the operator (like State, ID or Priority etc.), instead of removing the value first and then the operator, clear the operator directly by choosing empty string from the combo – it will empty the value as well.
In the QBE’s State transitions tab, by default After/On (meaning greater than or equal) or Before/On operators are used. In order not to clutter the UI too much, these operators are read only and cannot be changed here. But, if you switch to the grid based Query Editor and replace ‘>=’ with ‘>’ or ‘=’ or replace ‘<=’ with ‘<’ or ‘=’ we will honor it. Switch back to QBE and the operator will be changed appropriately.

Picture 13 to 15 – Workflow when changing temporal operators

You may be wondering what kinds of queries QBE does support. There is one basic criterion a query needs to satisfy to be editable in QBE: each filter clause (at the root level) has to be connected using AND operator. Additionally there are some operators QBE doesn’t support. Usually you really don’t need to worry about it – if the query isn’t supported by (editable in) QBE, QBE tab will instantly be disabled. That is not needed all too often though; QBE supports all queries from both standard Microsoft process templates and from Conchango’s Scrum template.
One closing note: after you define the search filter in QBE and/or in the grid based Query Editor, you should go to the third tab and configure the column options for the query: columns displayed, sorting order and grouping. The first two are standard part of any work item query. The third one, grouping, is supported because in TeamCompanion we are leveraging Outlook grouping features.
That’s it, grab your copy of TeamCompanion and start playing with Query by Example.

Summary
Query by Example (QBE) is a simplified Work Item Query editor that makes it easier to define usual everyday Work Item Queries. Queries are defined by entering values in already available placeholders for specific most frequently used Work Item Fields (like State, Priority, Iteration or Area Path etc.). QBE also supports full text search in any text or html work item field. There is full two way synchronization between QBE and standard grid based Query Editor so that you can edit search criteria in any of these two editors and freely switch between them.

[Inside TeamCompanion 2.1] Open related object

noreply@blogger.com (Ognjen Bajic) — Sun, 22 Mar 2009 02:25:00 +0000

With the release of the TeamCompanion v 2.1 just a few days away it is high time to start a series of blog entries on the most interesting new features this version brings.
We will start with one of the small but useful productivity features that make everyday work with the Team System in TeamCompanion easier and more efficient.
Whenever you receive a notification mail from the TFS that refers to some TFS object this feature called “Open related object” will let you open that object with just one click. It is similar to the ability to configure the work item links in the notification mails introduced with the TFS 2008 SP1 that lets you open work items in the Team System Web Access. But, since we are in a desktop application – Outlook, it would be a shame to have to use web UI. We should be able to open the work item in a nice familiar desktop dialog. That is what “Open related object” is all about. In addition to work items it supports opening changesets and build reports too!
Let’s see what it looks like. We will start with a notification mail about work item change

After just one click on the “Open Work Item” button the work item edit form appears:

It works the same way for changesets:

and for the builds:

The same action is available from the context menu too:

Oracle support for Visual Studio Team Edition Database Edition announced!

noreply@blogger.com (Ognjen Bajic) — Wed, 25 Feb 2009 07:38:00 +0000

Quest Software announced yesterday (Feb 24, 2009) that it will offer Oracle support for Microsoft Visual Studio Team System (VSTS) 2010!
Quest will produce an Oracle Database Schema Provider (DSP) which will integrate Oracle with Visual Studio Database Edition and allow Oracle Developers using Visual Studio Team System to perform offline design, development and change management for Oracle databases, similarly to how Visual Studio Team System works with Microsoft® SQL Server™ databases.

See the screenshots or joint the beta.

Visit TeamFuze, new community for Oracle professionals working in VSTS.
Go to TeamFuze forums.
Visit TeamFuze blog.

Wahoo!

Oct'08 TFS Power Tools released

noreply@blogger.com (Ognjen Bajic) — Sat, 08 Nov 2008 21:40:00 +0000

I refrained from passing all the VSTS related news on the blog lately, since there are enough other places where one can plug in and be informed in real time of all important events.

But this is really important news: Microsoft has released a major piece of Team System functionality in an off the band release in its October 08 TFS Power Tools.
Oct ‘08 Power Tools come with many things lots of people have been asking for. Just read the list of the major new features:

Team Members
Adds a new node to under each Team Project to the Team Explorer called "Team Members" that identifies people and who work on the project. It serves as a "pivot point" for information and operations on people and teams. This is huge, because among supported operations we finally get IM, audio and video comm. integrated with TFS client. Right now Live Messenger 8.0 and later and Office Communicator 2005 and later are supported, but more are in the works.

Windows Shell Extension
Allows core version control operations directly within Windows Explorer (without using Team Explorer). You will need to use to use custom setup option in order to turn this feature on. And it works on 64 bit OS-es as well!

PowerShell Support
Provides a PowerShell pipeline and cmdlets for TFS. Initial support is for core version control operations.

Custom components
This feature brings support for automated distribution of client side custom components like custom work item controls, check in policies and similar. Up till now there was no good way to distribute them. Now there is. :-)

Above are only the most exciting features. For the complete list with more detailed description see Brian Harry’s blogs here and here.

Get the Oct’08 TFS Power Tools here.

VSTS Dev and DB Editions joined together!

noreply@blogger.com (Ognjen Bajic) — Tue, 30 Sep 2008 06:10:00 +0000

After a longer hiatus, this blog continues with exciting news about Microsoft yesterday’s announcement:
not only will VSTS Development Edition and Database Edition be merged in the next version of the VS, but as of October 1, 2008 if you have one (and valid SA – software assurance agreement) you are entitled to use the other even for the current 2008 version.

This also applies to Microsoft partners that until now only received Developer Edition licenses as a part of the partner benefits! They get the Database Edition as well now.

This is part of larger Visual Studio 2010 announcement. Read more in Brian Harry's blog (including the hint on when we can expect to get it).

TeamCompanion for Excel and Project support for TFS 2008 released

noreply@blogger.com (Ognjen Bajic) — Sat, 28 Jun 2008 01:29:00 +0000

Together with the new version of the TeamCompanion for Outlook, Ekobit released the TFS 2008 versions of TeamCompanion for Excel and Project. Find more about these two addins here.

TeamCompanion for Outlook v2.0 released

noreply@blogger.com (Ognjen Bajic) — Sat, 28 Jun 2008 01:19:00 +0000

Earlier this week Ekobit released The TeamCompanion for Outlook v2.0. This second major version of the TeamCompanion brings a lot of new features. Actually, there are as many new features as there were features altogether earlier. The new TeamCompanion version sets standards in integration between Outlook and the Team Foundation Server. Scheduled queries will automatically refresh WI folders enabling you to stay up-to-date, while ad-hoc queries allow the execution of WI queries on the fly. With the ability to drag and drop queries in the favorite folders you will have that up-to-date information about the work progress always visible.

Some of the cool new features:

Work Item query management support
Editing areas and iterations support
Scheduled Work Item queries
Subscriptions to TFS alert notifications support
Integration with Excel and Project
Work Item reminders and To-Do list integration
Outlook Tasks support (Work item from Task, Task from Work item, Open associated Work Item)
Outlook RSS feeds support
Ad-hoc queries including all standard services (Work Item to Mail, task or appointment conversion)
Add related work item action support
Send Work Item Query result as mail
Additional simplified toolbar
Trial period extended to 90 days
... and a lot more available for download now.

Visit videos and the blog demonstrating and describing the most interesting usage scenarios.
TeamCompanion supports Outlook 2003 and 2007 and TFS 2005 and 2008 and is available in English and German.
Product homepage: http://www.teamcompanion.com/
Download the trial from: http://www.ekobit.com/ProductsDetailView.aspx?id=29

[VSTS] Problem with Bissubscribe and keyword 'NOT'

noreply@blogger.com (Ognjen Bajic) — Tue, 26 Feb 2008 23:54:00 +0000

[Update: Problem described in this blog entry has been solved in TFS 2008 SP1.]
When called twice with the same arguments bissubscribe doesn’t do anything on the second call i.e. there is no additional second event subscription added. Normally it is safe to call bissubscribe with the same arguments as many times as you like – you will get only one subscription.

But, there is a know bug that causes problems if the filter expression contains the keyword 'NOT'.

If the filter contains ‘NOT’, if called multiple times with the same arguments, bissubscribe will not detect that the arguments are the same and will create a new subscription every time you call it.

Here is a generic sample to repro the problem:

If called twice following line will create two subscriptions
BisSubscribe.exe /eventType WorkItemChangedEvent /address http://tfs2k8/Notifications/EventHandler.asmx /server http://tfs2k8:8080 /filter "NOT \"PortfolioProject\" = 'a'"
whereby if we remove NOT from the filter expression only one subscription is created.

Suggested workaround is to use the operator ‘<>’ instead of the keyword ‘NOT’.

Following call works fine i.e. can be called multiple times and will result in one subscription only:
BisSubscribe.exe /eventType WorkItemChangedEvent /address http://tfs2k8/Notifications/EventHandler.asmx /server http://tfs2k8:8080 /filter " \"PortfolioProject\" <> 'a'"

[Inside TeamCompanion]: Desktop work item search - Part 2: Vista instant search hints

noreply@blogger.com (Ognjen Bajic) — Mon, 18 Feb 2008 14:59:00 +0000

In the previous blog entry I've presented desktop search integration for the work items implemented by the TeamCompanion. In this one, I will give you some hints how to best use it to get the right search results quickly and easily. The hints apply to Vista instant search.

The idea is to give the search engine some metadata in addition to the search term itself, so that it can best locate your work items.
Internally work items are presented to the indexing engine as mail items, so you should use „store:mapi“ in your work items searches. That is not too restrictive but will help.

In the following examples I will use the team foundation server name “TFS.ekobit.com” and the project name “SearchDemoProject”.

To search for work items from a specific server tell the search engine to look in specific folder only. Use „Folder:TFSServerName “. You don’t need to use the full server name. A part of the name unique among all of the servers used in the TeamCompanion will be enough.
Example: enter “store:mapi Folder:TFS TeamCompanion” in instant search to look for the word TeamCompanion in all retrieved work items of all projects in the server TFS.ekobit.com (as long as there are no other servers with names starting with letters TFS).

To search for work items in a specific team project make the query more restrictive. Use „Folder:TFSServerName/TeamProjectName“. Here you must use the complete server name (as shown in the TeamCompanion Mail folder tree) and any unique part of the team project name
Example: enter “store:mapi Folder:TFS.ekobit.com/SearchDemoProject TeamCompanion” in instant search to look for the word TeamCompanion in all retrieved work items in the project SearchDemoProject in the server TFS.ekobit.com.

If you want to search only in the results of one specific work item query, make the folder specification even more restrictive: “Folder:TFSServerName/Team Queries/TFSWorkItemQueryName”. Instead of “Team Queries”, obviously you can put “My Queries” as well.
Example: enter “store:mapi Folder:TFS.ekobit.com/SearchDemoProject/Team Queries/All Tasks TeamCompanion” in instant search to look for the work TeamCompanion in all retrieved active task work items in the project SearchDemoProject in the server TFS.ekobit.com.

[Inside TeamCompanion]: Full text desktop search and work items

noreply@blogger.com (Ognjen Bajic) — Mon, 18 Feb 2008 07:05:00 +0000

TeamCompanion integrates work item management with Outlook. As a part of this integration, every time a work item query is executed we save the complete content of all work items from the query result (of course we get only the new information or info that was changed since the last get). We do that in order to be able to support offline work, to offer work item information even if TeamCompanion is not connected to the TFS server.

At the same time, since this data is subject to Outlook indexing engine, the full text search of work items is supported. All work item fields, standard or custom, are subject to search. Search also includes some not so obvious parts of work item information: attachment names, links and even categories if you assign them to the work items (btw. categories are especially useful during the triage!). Outlook highlights all occurrences of the searched term. The only prerequisites are that you have retrieved the work item data by executing a query from TeamCompanion and that the indexing engine has already processed the query result (count with some delay). For performance reasons we (currently) don’t support the search through the work item history. We might consider it for some future version.

See the screenshot below:

This kind of search works wherever desktop search works -Windows XP and Vista.

But, there is more to it. Since the same index is used by the Windows Vista instant search, we are able to support searching for work items from the Vista Start menu “Start search” edit box. You enter the search term, get the list of results, choose one and as long as it is a work item, you will get it opened in the nice familiar work item edit form!
Usualy you will need to help search engine to find precisely what you want.More about that in following blog enties.
Click on the result link, and... Voilà - here's your work item:

That’s the beauty of joined powers of TeamCompanion, Outlook and Vista.

[VSTS] Adding work item query to Excel programatically

noreply@blogger.com (Ognjen Bajic) — Tue, 22 Jan 2008 02:10:00 +0000

Inspired by the forum question that asked whether it is possible to add work item query to Excel file programmatically and following the reasoning of the poster that since Project Creation Wizard (PCW) can do it we should be able to do that as well, I did a bit of research. I mean, I reflected a bit.:-)

The first problem was to find the PCW plug-ins. They all implement IProjectComponentCreator (see ppt by Marcel de Vries covering PCW plug-ins inner workings) which made it easy to find them. For instance, the WSS Portal Plugin is in the class Microsoft.VisualStudio.TeamFoundation.WssSiteCreator in Microsoft.VisualStudio.TeamFoundation.TeamExplorer.dll.

Second part was to find the way this Plug-in adds queries to Excel files –the DocumentELeadEnabler class. Just call its ELeadEnable method and query is added to the Excel file. The class is internal so you should be aware of possible future changes, but for now it works all right.

Attached zip file contains the source of the command line utility that takes several arguments (Path to the Excel file, Server name, Server url, Project name, Project uri and the work item query guid) and inserts the query in the file. Hint: The guids and urls for the project and queries can be found in the properties window in Team Explorer. Query guid is a part of the query uri.

Attached: AddWIQLToExcel.zip

TeamCompanion for Project and Excel released

noreply@blogger.com (Ognjen Bajic) — Thu, 25 Oct 2007 23:57:00 +0000

Last week we at Ekobit have released the TeamCompanion for Outlook, but that was not the only TeamSystem related release from the TeamCompanion family of tools that has seen the light on that day.

The TeamCompanion for MS Project and TeamCompanion for Excel were released as well. Old time readers of this blog may remember that a bit less than a year ago I have published an MS Project add-in that made opening the work items from inside MS Project possible. This scenario, not normally supported by the TFS add-in for Project coming with Visual Studio Team System, makes the life of a project manager much easier since they don’t need to switch contexts and leave MS Project every time they want to open a work item in order to see its details or to edit it.

TeamCompanion for Project is improved version of that add-in with some problems of the original version solved. TeamCompanion for Excel offers the same functionality but in Excel.

Both tools are free.

Download the TeamCompanion for Project from here (http://www.ekobit.com/ProductsDetailView.aspx?id=43).

Download the TeamCompanion for Excel from here (http://www.ekobit.com/ProductsDetailView.aspx?id=38).

TeamCompanion for Outlook 2007 released!

noreply@blogger.com (Ognjen Bajic) — Mon, 15 Oct 2007 11:58:00 +0000

A few days ago Ekobit has released the TeamCompanion for Outlook 2007, an Outlook Add-in that integrates Outlook and mails with the Team Foundation server and work items.

If you spend a large percentage of time in Outlook writing and reading mails and at the same time work in a Visual Studio Team System based environment, wouldn’t it be great to have everything you need at hand – all the work items, mails and the great integration of the two.

TeamCompanion offers great features that make work item management within Outlook enjoyable experience. Actually, for the last two months, I’ve been working with work items almost exclusively using TeamCompanion. Not only to dogfood the product, but also because it is easier and in some ways more elegant than with any other existing tool. Through ease of use, TeamCompanion enables efficient communication, better work item management and less friction between them for less effort.

TeamCompanion gives you the ability to execute all the usual work item queries, access every work item field, group, filter, categorize, search (over all textual fields, including even the names of the attachments) and create appointments for work items, send them as a mail or export to MS Office OneNote. To have them always at hand, add your most frequently used queries to the favorite folders window. TeamCompanion also gives you the ability to take work items with you offline, and still do all of the above things except executing the queries, of course!

When you are online once again, you will additionally be able to create, edit and quickly open work items, create work items from mail and do lot of other things.

If you feel friction between the ways you communicate using mails and the way the work is managed using work items, Team Companion for Outlook 2007 might be the solution.

TeamCompanion for Outlook 2007 homepage: www.teamcompanion.com
Download the fully functional 30 days free trial: http://www.ekobit.com/ProductsDetailView.aspx?id=29
Complete features overview: http://www.ekobit.com/ProductsDetailView.aspx?id=44
FAQ: http://www.ekobit.com/ProductsDetailView.aspx?id=25

Source code for the .Net library for the .Net 3.5 and VS 2008 will be released

noreply@blogger.com (Ognjen Bajic) — Thu, 04 Oct 2007 08:04:00 +0000

Scott Guthry blogs about very exciting news: Microsoft will release the source code for the .Net 3.5 library later this year. The source will be installable as a separate standalone setup and viewable in any text editor but VS will also include the debugger support in VS 2008. This is a huge leap forward in the way we'll program .Net applications!
For the list of the libraries that will be released in the first wave and for some screenshots of the debugging experience and other details go here.

Custom work item controls

noreply@blogger.com (Ognjen Bajic) — Sat, 22 Sep 2007 01:14:00 +0000

Introduction
Custom work item controls are used to implement the functionalities not offered by the set of standard controls used in the work item form (edit box, combo box, datetime, html control and the special ones like area/iteration). They are available in Team System as of SP1 for TFS 2005.
In this article we will describe what the custom controls are and how they can be implemented and used. We will develop a custom control, the Checkboxed options control, which will accept and show multiple values by showing a row of checkboxes.

Checkboxed options control
Related reading
There are no many sources of information on custom work item controls on the Internet. So, I might as well list all currently available relevant sources:
The official msdn documentation[1] is rather brief, so you might like to start with the first ever published article on custom controls [2] written by Naren Datha of Microsoft. It is not too long either but covers everything from the reasoning for the custom controls to the deployment. Recently, a colleague of mine, VSTS MVP Neno Loje published the Custom work item controls primer [3] on his blog, a description of the first steps needed to build and use a work item custom control. Last but not least, you should visit the semi-official place to find publicly available custom controls on Codeplex [4]

Why would you build a custom control?
There are many reasons why you would use custom controls. If you want to provide richer UI or provide some additional functionality in the work item form, custom controls are the way to go. One case of such better UI would be graphical representation of the severity level data in the form of traffic lights instead of just numbers from 1 to 3. Custom controls can enable more elegant way to insert screenshots as attachments [5] or to do some mathematical operation with the work item’s data, evaluate a formula e.g. sum the estimates, different parts of the team have given for a task, in order to get the total estimate. For some further ideas on possible uses of custom controls see [7].
Currently there is no way to put multiple data in one work item field other than to use a custom control. One such case is the Checkboxed options control we demonstrate in this article.
You can implement custom controls using Windows Form controls or even use ActiveX controls wrapped as Windows Form controls.
In which cases would it be wrong to use custom controls? You shouldn’t try to use them in order to implement additional work item rules [6], since Excel or MS Project don’t support custom controls. Your rules would not be evaluated in at least these two environments and it is thus better not to raise false expectations and to refrain from implementing rules through custom controls.

Restrictions of the custom controls
There are several restrictions you should have in mind before deciding to use the work item custom controls:
The binaries for the custom control must be locally installed on each client computer. Visual Studio assumes the binaries are already available and does nothing itself to provide for them. If the required files are missing you will simply get an empty box instead of the control. Hint: There is no requirement for Admin rights to install custom control binaries.
This is the major problem, since it hinders easy adoption. Until a good way to centrally manage and easily distribute the binaries is found, custom controls will have only limited importance.
· Only Visual Studio and other environments that use standard work item edit form support the custom controls. See the section “Custom controls and different client environments (TSWA, Excel, MS Project)” below.

Basic interfaces/basics of a custom controls
Custom controls must derive from
System.Windows.Forms.Control class, have a no-argument constructor and implement the IWorkItemControl interface.
The IWorkItemControl interface looks like this:

public interface IWorkItemControl
{
StringDictionary Properties { get; set; }
bool ReadOnly { get; set; }
object WorkItemDatasource { get; set; }
string WorkItemFieldName { get; set; }

event EventHandler AfterUpdateDatasource;
event EventHandler BeforeUpdateDatasource;

void Clear();
void FlushToDatasource();
void InvalidateDatasource();
void SetSite(IServiceProvider serviceProvider);
}

The Properties property gives access to all the attributes defined for the control in the work item type definition. Custom, control specific attributes are allowed here as well. This is the way to set the configuration data for your control.
The ReadOnly property is used to tell the control that it should be displayed as read/only. See also the section “Making a custom control read-only” below.
The WorkItemDataSource property is the reference to the work item object. Should be cast to WorkItem class. Using the Fields property of the work item you can access any field of the current work item.
The WorkItemFieldName property holds the name of the work item field this control is associated with. A control can be associated with 0 or 1 field.
The AfterUpdateDatasource and BeforeUpdateDatasource events should be raised when you update the fields in the work item so that other controls can refresh themselves if needed.
Clear should reset the content of the control.
FlushToDatasource can usually be safely ignored since you’ll directly change the work item object as soon as the control’s content is edited.
InvalidateDatasource – in this method the control should use the data from the work item object and other possible data sources to redraw itself.
SetSite makes IServiceProvider interface available that can be used to access VS services.
So, the life of a custom control in terms of properties and methods of the IWorkItemControl interface can be summarized like this:
A control edits a field named in WorkItemFieldName of the work item object whose reference is in WorkItemDataSource. In InvalidateDatasource the control redraws itself, using the dana from the work item and probably using one or more attributes from the Properties property bag. As soon as the user edits the control's content, events AfterUpdateDatasource and BeforeUpdateDatasource should be raised. If the ReadOnly is set, the control should make itself read only.
Once you've implemented this interface you're ready to use the control in the xml work item type definition.

Using custom controls in the work item type xml definitions
Once you've developed a custom control, it is time to use it in the work item definition. In order to do that, it needs to be included in the work item's layout. In the work item's xml definition, the design of the work item form is defined by the Layout element [8].

Each control on the work item form is defined by the Control element [9] below the Layout element.
The only required attribute of the Control element is the Type attribute. Originally, there was a fixed list of possible values this attribute can have: FieldControl (meaning: the standard control, edit box or the combo box, depending on the content), DateTimeControl, HtmlFieldControl, WorkItemClassificationControl (used for Areas and Iterations) and the three special “controls” that are in fact the whole tabs in the standard work item layouts - LinksControl, AttachmentControl and WorkItemLogControl.
With the introduction of custom controls the definition of the Type attribute was extended. If it contains something other than one of previously listed predefined values, this value is expected to be the name of a custom control class.
Usually you will set at least one optional attribute – FieldName. It defines the name of the work item field bound to the control; the value defined with this attribute will be given to the custom control in its WorkItemFieldName property.
Other optional attributes are Label, LabelPosition, ReadOnly, Dock, Padding and Margin.
As we will see later, whatever other attributes you set, they will be available to your control through IWorkItemControl.Properties property bag. Once the Type attribute is used to instantiate the custom control, it is the responsibility of the control (that means, your custom code) to interpret the meaning of all other attributes. Since it is the sole responsibility of your control to interpret the attributes, as long as the control understands them, custom attributes can be used as well. In our case we will use the attribute Options to define the names of the options the Checkboxed options control will display.

There is a bad news related to editing the xml definitions of the work item types – you will need to edit them by hand. Since the Team System Process Editor (PTE) [10] doesn't support custom controls, there is no other choise. If you really like PTE and would still like to work with custom controls, one possible workaround [11], would be to have two versions of the work item definition, the working one and the final one. The working copy contains a placeholder standard control for each instance of a custom control. This version can be edited and previewed in PTE. Once, when you are satisfied with this version, using find and replace and the text editor or some script you replace each placeholder with appropriate custom control Control tag, thus creating the final version. The final version is the one that should be uploaded (witimported) to the server and actually used.
That said, I prefer editing work item xml definitions by hand, since I am usually more efficient that way, but if you’re unsure what exactly needs to be done or just feel more secure doing it using a tool, with the above workaround, PTE can be of use.

Work Item Custom Control (.wicc) files and deployment
How does Visual Studio know where to find the implementation of the custom control?
It uses .wicc (Work Item Custom Control) files. These contain the fully qualified name of your control class and the name of the assembly containing the implementation. The name of the file is the name you should use as the control’s type name (Type attribute of the Control element) in the work item definition.
The file used for our Checkboxed options control looks like this:

But where should I put the .wicc file and the implementation of the custom control?
Visual Studio looks for them in the “Microsoft\Team Foundation\Work Item Tracking\Custom Controls“ folder under Environment.SpecialFolder.CommonApplicationData folder first, then under Environment.SpecialFolder.LocalApplicationData.

In order to enable side by side installation of custom controls compiled with VS 2005 and those compiled with VS 2008 libraries, in Orcas, the search path was extended, as described in [
12]. In Orcas, VS will first look in the subfolder 9.0 of the Custom controls folder in order to find Orcas specific versions. So the Orcas versions of the custom controls (these are the ones compiled with Orcas versions of the Work Item object model .dlls) should be put in “Microsoft\Team Foundation\Work Item Tracking\Custom Controls\9.0“.
You can xcopy deploy your files to above folders or make a .msi file that does that. Attached “Checkboxed options.zip” file contains the VS setup project that generates the appropriate .msi file. The .msi contains only two files – the .wicc file and the .dll containing the implementation of the custom control.

Checkboxed options control
The Checkboxed options control uses the CheckedListBox to show the list of checkboxes.
Let’s go through the control’s initialization code:
We check whether there is an Option attribute in the xml definition for the control, parse the content of the attribute and initialize the ListBox entries

//insert the list entries
if (!m_properties.ContainsKey("options"))
{
throw new InvalidFieldValueException(
"Entries for the Checkboxed options control in the work item not defined. " + Environment.NewLine +
"Add Options attribute to the appropriate element in the work item definition.", null);
}
string[] names = m_properties["Options"].Split(m_Separator);
this.m_listBox.Items.AddRange(names);
m_listBox.ColumnWidth = MeasureListItemWidth(names);

Then we ignore the standard control attributes while parsing all other custom attributes and use them to initialize the control:

//set other properties
foreach (string propName in m_properties.Keys)
{
switch (propName)
{
//ignore the non custom properties
case "fieldname":
case "label":
case "labelposition":
case "options":
case "type":
break;
default:
{
try
{
string propValue = m_properties[propName];
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(m_listBox);
//names of the properties are case insensitive
PropertyDescriptor pd = properties.Find(propName, true);
if (pd == null)
Trace.WriteLine("Property " + propName + " with value " + propValue + " not found.");
else
{
pd.SetValue(m_listBox, pd.Converter.ConvertFrom(propValue));
}
}
catch (Exception e)
{
Trace.WriteLine("Setting " + propName + " failed:\r\n" + e.Message);
}
}
break;
}

Members m_workItem, m_fieldName, m_properties are bound to the IWorkItemControl.WorkItemDatasource , IWorkItemControl.WorkItemFieldName and IWorkItemControl.Properties respectively.
When the user clicks on one of the checkboxes the new value for the complete “encoded” content of the control is calculated and saved directly into the work item:

void m_listBox_ItemCheck(object sender, System.Windows.Forms.ItemCheckEventArgs e)
{
...
StringBuilder sb = new StringBuilder();
for (int i = 0; i < m_listBox.Items.Count; i++)
{
if (i == e.Index)
{
if (e.NewValue == CheckState.Checked)
sb.AppendFormat("{0}{1}", GetInternalRep(m_listBox.Items[i].ToString()), m_Separator);
}
else
{
if (m_listBox.GetItemCheckState(i) == CheckState.Checked)
sb.AppendFormat("{0}{1}", GetInternalRep(m_listBox.Items[i].ToString()), m_Separator);
}
}
string value = sb.ToString();

OnBeforeUpdateDatasource(EventArgs.Empty);
m_workItem.Fields[m_fieldName].Value = value;
OnAfterUpdateDatasource(EventArgs.Empty);
}

The function GetInternalRep adds angle brackets around the value of a field. In the end, if the control looks as in the picture at the beginning of the article, the value "[WXP Pro SP2];[Vista];" is saved in the work item field.

Querying

Use "Contains" clause in the work item query tool to query for one specific option set. Following query returns all work items having "Vista" checkbox checked.

Debugging

The easiest way to debug the control is to use another instance of Visual Studio and to attach it’s debugger to the first VS instance where the work item form containing the custom control is displayed.

Making a custom control read-only

In order to make your custom control read only, check value of the work item field’s IsEditable property in InvalidateDatasource event and set your control’s edit state accordingly. This is how the native controls like FieldControl, DateTimeControl handle read-only state.

Custom controls and the different client environments (TSWA, Excel, MS Project)

MS Excel and MS Project don’t support custom controls. Excel and Project will show the textual representation of the data instead, which is ugly but sometimes still usable. Usually though, editing the custom control field data in Excel or Project directly, might damage the data consistency, so it should be avoided. Current version of the TSWA (Team System Web Access) doesn’t support the custom controls, at least not in a documented way. Good news is that the next version of the TSWA (the one coming with the Orcas wave) will support custom controls. That said, you need to have in mind that TSWA will not be able to reuse the WinForms implementation of a custom control; it will need a custom web forms based one.

Checkboxed options control: Source, Setup

References:
[1] Official MSDN documentation, http://msdn2.microsoft.com/en-us/library/bb286959(VS.80).aspx [2] Naren Datha’s blog entry on custom work item controls, http://blogs.msdn.com/narend/archive/2006/10/02/How-to-use-Custom-Controls-in-Work-Item-Form.aspx
[3] Neno Loje’s article: Getting started using Custom Work Item Controls, http://msmvps.com/blogs/vstsblog/archive/2007/07/07/starting-using-custom-work-item-controls.aspx
[4] Codeplex project TFS Work Item Tracking Custom Controls, http://www.codeplex.com/WitCustomControls
[5] TFS Work Item Screenshot Custom Control, http://olausson.net/blog/PermaLink,guid,8d7a24a9-b1b4-463c-a037-769c33aabfb9.aspx
[6] MSDN documentation: Available Field Rules, http://msdn2.microsoft.com/en-us/library/ms194953(VS.80).aspx
[7] Naren Datha's introduction to the custom controls, http://blogs.msdn.com/narend/archive/2006/09/27/773025.aspx
[8] Layout Element (Work Item Type Definition Schema), http://msdn2.microsoft.com/en-us/library/aa337635(VS.80).aspx
[9] Control Element (Work Item Type Definition Schema), http://msdn2.microsoft.com/en-us/library/aa337625(VS.80).aspx
[10] Team System Process Editor as one of the tools in the Microsoft Visual Studio 2005 Team Foundation Server Power Tool, http://www.microsoft.com/downloads/details.aspx?familyid=7324c3db-658d-441b-8522-689c557d0a79&displaylang=en
[11] Developer discussion on Codeplex: Problems with new Process template Editor and Custom Control, http://www.codeplex.com/WitCustomControls/Thread/View.aspx?ThreadId=7676
[12] How to port Whidbey custom controls to Orcas , http://blogs.msdn.com/narend/archive/2007/08/23/how-to-port-whidbey-custom-controls-to-orcas.aspx

CTP of the VSTS Web Access for TFS 2008 released

noreply@blogger.com (Ognjen Bajic) — Fri, 21 Sep 2007 22:45:00 +0000

Brian Harry just announced the availability of a CTP of the next version VSTS Web Access, the one that will be released together with VS Orcas. This version will work with both TFS 2005 and TFS 2008 (you will need to have Team Explorer 2008 installed locally in both cases).

This version of VSTS Web Access is exciting because it finally brings the support for the work item custom controls to the VSTS Web Access!

See the full announcement here.
Download the bits here.

Team System Web Access Power Tool Released!

noreply@blogger.com (Ognjen Bajic) — Tue, 31 Jul 2007 00:42:00 +0000

Microsoft just released the first Microsoft branded version of Team Plain - Team System Web Access Power Tool.
It brings much better performance, many bug fixes, and a lot of new features... Read more here.
Download the tool here.

Chat with the Visual Studio Team System product team

noreply@blogger.com (Ognjen Bajic) — Tue, 31 Jul 2007 00:40:00 +0000

Come chat with the Visual Studio Team System product team – This Wednesday

Join members of the Visual Studio Team System product group to discuss features available in Visual Studio Team Foundation Server, Architecture Edition, Development Edition, Database Edition, and Test Edition. In addition, discuss what's new in Beta 2.

We will be holding two sessions:

Join the chat on Wednesday, August 1st, 2007 from 10:00am - 11:00am Pacific Time. Add to Calendar Additional Time Zones
-or-
Join the chat on Wednesday, August 1st, 2007 from 4:00pm - 5:00pm Pacific Time. Add to Calendar Additional Time Zones