Create a Category Toolbar in Outlook 2007

I met Nathan Elson for the first time yesterday when I responded to one of his tweets. In his tweet Nathan asked if some twitterverse resident knew of a way to modify Outlook and “create a toolbar button that assigns a category”. He explained that he would rather add or remove categories from his emails by clicking a single toolbar button rather than having to click Outlook’s Categories button and select from the resulting pull down menu. Two clicks versus one unless of course the category Nathan wants doesn’t appear on the pull down list. When that happens he’ll have to click All Categories from the pull down menu and then choose a category from the Color Categories dialog-box. That drives the click count to three and introduces the possibility of scrolling the list in order to find the category he’s looking for. While I might debate the logic of building a new toolbar to save a single click the toolbar could actually save two clicks and possibly prevent the need to scroll too. The discussion wouldn’t be complete without mentioning that Nathan could eliminate all clicks and the need for a toolbar by assigning a shortcut key to each category. Of course he’d have to remember the shortcut key and Outlook allows a limited set of shortcut keys, enough for just 11 categories. If he has more than that, then he’s out of luck.

Fortunately for Nathan it’s very simple to add a toolbar to Outlook. Toolbars can be added manually or via a script. In Nathan’s case the solution is to use a script. Why a script? There are a couple of reasons. First, Outlook doesn’t have a built-in toolbar button for adding/removing categories. It does offer the same Categories toolbar button that appears on Outlook’s built-in menu which is exactly what Nathan wants to move away from. Second, even if it were possible to add a toolbar button for a specific category, then Nathan would have to edit the toolbar each time he adds/removes a category since toolbars do not have an autoupdate capability. The ideal solution is one that would detect when categories have been added/deleted and update the toolbar on its own. Unfortunately that’s not possible because Outlook’s Categories object has no events. A script can’t react to a change if the change isn’t detectable. The script is still a better solution though because Nathan won’t have to add/remove buttons manually. All he’ll have to do is restart Outlook.

At less than 100 lines of code the script for this is surprisingly simple when you consider what it has to do. The script starts by building the toolbar. To do that it creates a toolbar, populates it with a button for each of Nathan’s categories, then displays the toolbar on screen. When Nathan clicks one of the buttons on the toolbar the script checks to see if the category associated with that button is already assigned to the currently selected item. If that category is not assigned to the item, then it adds it. If instead it finds that the category is already assigned, then it removes it. In other words the button is a toggle. The script works with all Outlook item types.

Before I present the code there are a couple of caveats I need to mention.

1. This solution only works with Outlook 2007. It will not work with any other version of Outlook. Outlook 2003 and earlier used a completely different approach to categories and is therefore incompatible. Outlook 2010 uses the same categories system as Outlook 2007 but it has eliminated toolbars in favor of the ribbon system used by the other Microsoft Office products. The ribbon is inaccessible by scripts.
2. The toolbar buttons this script creates are not color coded to match the color of the category each button is associated with. Toolbar buttons support a picture, a caption, or both. They do not support simply coloring the button.

On to the script. It comes in three parts. The first two are class modules, one to implement the toolbar and the other to implement the buttons that go on the toolbar. The third bit of code gets the process started by creating an instance of the toolbar class each Outlook is launched and destroying it each time Outlook closes.

Toolbar Button Class.

Private WithEvents objButton As Office.CommandBarButton
Private strThisCat As String

Private Sub Class_Terminate()
    Set objButton = Nothing
End Sub

Private Sub objButton_Click(ByVal Ctrl As Office.CommandBarButton, CancelDefault As Boolean)
    Dim olkItm As Object, arrCats As Variant, varCat As Variant, bolFound As Boolean, intCnt As Integer, strNewCat As String
    Select Case TypeName(Outlook.Application.ActiveWindow)
        Case "Explorer"
            Set olkItm = Outlook.Application.ActiveExplorer.Selection(1)
        Case "Inspector"
            Set olkItm = Outlook.Application.ActiveInspector.CurrentItem
    End Select
    arrCats = Split(olkItm.Categories, ", ")
    For Each varCat In arrCats
        If varCat = strThisCat Then
            bolFound = True
        Else
            strNewCat = strNewCat & ", " & varCat
        End If
    Next
    If Not bolFound Then
        strNewCat = strNewCat & ", " & strThisCat
    End If
    olkItm.Categories = strNewCat
    olkItm.Save
    Set olkItm = Nothing
End Sub

Public Sub Init(ByRef ofcParentBar As Office.CommandBar, ByVal strCatNum As String, strTipText As String)
    Set objButton = ofcParentBar.Controls.Add(msoControlButton)
    With objButton
        .Caption = strCatNum
        .Style = msoButtonCaption
        .TooltipText = strTipText
    End With
    strThisCat = strTipText
End Sub

Instructions. Follow these instructions to add the code to Outlook.

1. Start Outlook
2. Click Tools > Macro > Visual Basic Editor
3. If not already expanded, expand Microsoft Office Outlook Objects
4. Right-click on Class Modules, select Insert > Class Module
5. In the Properties panel click on Name and enter CatBtn
6. Copy the code and paste it into the right-hand pane of Outlook’s VB Editor window
7. Click the diskette icon on the toolbar to save the changes
8. Close the VB Editor

Toolbar Class.

'--- On the next line change True to False if you do not want the categories sorted ---'
Private Const SORT_CATS = True
Enum intSortType
    dicSortKey = 1
    dicSortItem = 2
End Enum

Private ofcBar As Office.CommandBar
Private colBtns As Collection

Private Sub Class_Initialize()
    Set colBtns = New Collection
    CreateCATBar Outlook.Application.ActiveExplorer
End Sub

Private Sub Class_Terminate()
    Set colBtns = Nothing
    Set ofcBar = Nothing
End Sub

Private Sub CreateCATBar(olkWindow As Object)
    Dim objCatBtn As CatBtn, olkCat As Outlook.Category, objDict As Object, intCnt As Integer, arrKeys As Variant, varKey As Variant
    On Error Resume Next
    Set ofcBar = Outlook.Application.ActiveExplorer.CommandBars("CAT")
    On Error GoTo 0
    If TypeName(ofcBar) = "Nothing" Then
        'Create the toolbar
        Set ofcBar = olkWindow.CommandBars.Add("CAT", msoBarTop, False, True)
    
        'Create the buttons
        Set ofcButton = ofcBar.Controls.Add(msoControlButton)
        With ofcButton
            .Caption = "CAT"
            .Enabled = False
            .Style = msoButtonCaption
        End With
        
        'Create the category buttons
        Set objDict = CreateObject("Scripting.Dictionary")
        For Each olkCat In Outlook.Application.Session.Categories
            objDict.Add olkCat.Name, olkCat.Name
        Next
        If SORT_CATS Then
            Set objDict = SortDictionary(objDict, dicSortKey)
        End If
        arrKeys = objDict.keys
        intCnt = 1
        For Each varKey In arrKeys
            Set olkCat = Outlook.Application.Session.Categories.Item(varKey)
            Set objCatBtn = New CatBtn
            objCatBtn.Init ofcBar, intCnt, olkCat.Name
            colBtns.Add objCatBtn
            Set olkCat = Nothing
            intCnt = intCnt + 1
        Next
        
        ofcBar.Visible = True
    End If
End Sub

Private Function SortDictionary(ByVal objDict, ByVal intSort As intSortType) As Object
'--- This function is from the Microsoft KB article: http://support.microsoft.com/kb/246067 ---'

  ' declare constants
  Const dictKey = 1
  Const dictItem = 2

  ' declare our variables
  Dim strDict()
  Dim objKey
  Dim strKey, strItem
  Dim x, y, z

  ' get the dictionary count
  z = objDict.count

  ' we need more than one item to warrant sorting
  If z > 1 Then
    ' create an array to store dictionary information
    ReDim strDict(z, 2)
    x = 0
    ' populate the string array
    For Each objKey In objDict
        strDict(x, dictKey) = CStr(objKey)
        strDict(x, dictItem) = CStr(objDict(objKey))
        x = x + 1
    Next

    ' perform a a shell sort of the string array
    For x = 0 To (z - 2)
      For y = x To (z - 1)
        If StrComp(strDict(x, intSort), strDict(y, intSort), vbTextCompare) > 0 Then
            strKey = strDict(x, dictKey)
            strItem = strDict(x, dictItem)
            strDict(x, dictKey) = strDict(y, dictKey)
            strDict(x, dictItem) = strDict(y, dictItem)
            strDict(y, dictKey) = strKey
            strDict(y, dictItem) = strItem
        End If
      Next
    Next

    ' erase the contents of the dictionary object
    objDict.RemoveAll

    ' repopulate the dictionary with the sorted information
    For x = 0 To (z - 1)
      objDict.Add strDict(x, dictKey), strDict(x, dictItem)
    Next

  End If

  Set SortDictionary = objDict
End Function

Instructions. Follow these instructions to add the code to Outlook.

1. Start Outlook
2. Click Tools > Macro > Visual Basic Editor
3. If not already expanded, expand Microsoft Office Outlook Objects
4. Right-click on Class Modules, select Insert> Class Module
5. In the Properties panel click on Name and enter CatBar
6. Copy the code and paste it into the right-hand pane of Outlook’s VB Editor window
7. Click the diskette icon on the toolbar to save the changes
8. Close the VB Editor

Startup/Shutdown Code.

Dim objCatBar As CatBar

Private Sub Application_Quit()
    Set objCatBar = Nothing
End Sub

Private Sub Application_Startup()
    Set objCatBar = New CatBar
End Sub

Instructions.

1. Start Outlook
2. Click Tools > Macro > Visual Basic Editor
3. If not already expanded, expand Microsoft Office Outlook Objects and click on ThisOutlookSession
4. Copy the code and paste it into the right-hand pane of Outlook’s VB Editor window
5. Click the diskette icon on the toolbar to save the changes
6. Close the VB Editor
7. Click Tools > Trust Center
8. Click Macro Security
9. Set Macro Security to “Warnings for all macros“
10. Click OK
11. Close Outlook
12. Start Outlook. Outlook will display a dialog-box warning that ThisOutlookSession contains macros and asking if you want to allow them to run. Say yes.

Putting it All Together.
Once Nathan has added this code and restarted Outlook he should see a new toolbar that looks something like this.

Categories Toolbar

Is I noted earlier, toolbar buttons can have a picture, a caption, or both. I’ve used the caption in this solution. The caption on each button is a number representing the button’s position on the toolbar. When Nathan moves the mouse pointer over a button the category associated with that button will appear as a tool tip.

Categories Toolbar with Tooltip Showing

When Nathan wants to add/remove a category to/from an item all he as to do is select the item and click the toolbar button for the desired category.

Enhancements.
Here are two enhancements Nathan may want to consider.

1. Colored icons. Nathan could make a set of icons matching Outlook’s category colors. He could then change the button style (line 36 of the Toolbar Button Class code) to use an icon instead of a caption.
2. Show Item Categories. Perhaps Nathan would like to see the categories already applied to the currently selected item. To do that he’d have to write code that is triggered each time he selects an item. That code would check the item’s categories and depress the corresponding toolbar button(s).

It’s time to send Nathan a link to this post. I hope he finds the code useful. Here’s hoping that you do too.