Outlook 2000 Object Model

To help you develop COM add-ins as well as other applications, the Outlook Object Model in Outlook 2000 has been updated with over 100 new methods and properties and a bunch of new events that your applications can hook into. Figure 9-6 shows the hierarchy for the Outlook 2000 object model. In the rest of this chapter, we'll look at all the new objects, methods, properties, and events, and I'll give you hints for using them in your own applications. For more information on the Outlook 2000 object model, consult the help file named vbaoutl9.chm on the companion CD.

NOTE

---

The events discussed in this section are not available from VBScript behind your Outlook forms. You must either use VBA, Visual Basic, or Visual C++ to receive these events.

Figure 9-6 The Outlook 2000 object model hierarchy.

New Objects and Collections

Outlook 2000 contains new collections and objects that consist of new item types you can create, such as distribution lists, as well as new user interface enhancements, such as custom property pages.

DistListItem Object

The DistListItem object represents a distribution list in a Contacts folder, which allows your users to do away with personal address books. The DistListItem object can hold multiple recipients both from the address list in Microsoft Exchange Server as well as from one-off addresses.

You can use the CreateItem method on the Application object to create a new DistListItem object, or you can add the DistListItem object to a Contacts folder by using the Add method of the Items collection for the folder. The following code shows you how to use both methods to create a DistListItem object:

 Dim oApp As Outlook.Application Dim oNS As Outlook.NameSpace Dim oExplorer As Outlook.Explorer Dim oContact As Outlook.MAPIFolder Dim oItems As Outlook.Items Dim oDistList As Outlook.DistListItem Dim oDistList2 As Outlook.DistListItem Set oApp = CreateObject("Outlook.Application") Set oNS = oApp.GetNamespace("MAPI") Set oExplorer = oApp.ActiveExplorer Set oContact = oNS.GetDefaultFolder(olFolderContacts) Set oItems = oContact.Items Set oDistList = oItems.Add(olDistributionListItem) oDistList.DLName = "My new distribution list" oDistList.Save Set oDistList2 = oApp.CreateItem(olDistributionListItem) oDistList2.DLName = "My other new distribution list" oDistList2.Save 

The DistListItem object inherits many of the methods and properties that other Outlook items also inherit, but it also has some unique methods and properties, which are described in the following sections.

Adding new members to the distribution list To add new members to your DistListItem object, you use the AddMembers method. Before you call this method, however, you must create a new Recipients collection to hold the names you want to add to the distribution list. The easiest way to create the new Recipients collection is to create a new mail item and use the Recipients collection available on the mail item. Then you can populate the collection and create the new DistListItem object as shown here:

 Dim oDistList As Outlook.DistListItem Dim oTempMail As Outlook.MailItem Dim oTempRecips As Outlook.Recipients Set oDistList = oItems("My new distribution list") Set oTempMail = oApp.CreateItem(olMailItem) Set oTempRecips = oTempMail.Recipients oTempRecips.Add "Thomas Rizzo" oTempRecips.Add "Aaron Con" oDistList.AddMembers oTempRecips oDistList.Display 

Removing members from a distribution list To remove members from your DistListItem object, you use the RemoveMembers method. This method is similar to the AddMembers method in that you need to pass it to a valid Recipients object that contains the members you want to remove. The following code shows you how to use this method:

 Dim oDistList As Outlook.DistListItem Dim oTempMail As Outlook.MailItem Dim oTempRecips As Outlook.Recipients Set oDistList = oItems("My new distribution list") Set oTempMail = oApp.CreateItem(olMailItem) Set oTempRecips = oTempMail.Recipients oTempRecips.Add "Thomas Rizzo" oTempRecips.Add "Aaron Con" oDistList.RemoveMembers oTempRecips oDistList.Display 

Retrieving the name of the distribution list The DistListItem object contains a property called DLName. This property can be used to set or return the name of the distribution list. The following code finds all the distribution lists in your Contacts folder and returns their names in a message box:

 Dim oItem As Outlook.DistListItem RestrictString = "[Message Class] = 'IPM.DistList'" Set oRestrictedItems = oItems.Restrict(RestrictString) For Each oItem In oRestrictedItems     strDLs = strDLs & vbLf & oItem.DLName Next MsgBox "You have " & oRestrictedItems.Count & " DL(s) in your " _     & "contact folder.  Names: " & strDLs 

Counting the number of users in a distribution list Sometimes you'll want to know how many users are on a distribution list before you mail items to it. To retrieve the count for the number of users contained in a distribution list object, you must use the MemberCount property. Note that this count does not include the member count for nested distribution lists in your original list. For example, if you have a distribution list with 20 members, and one of those members is a distribution list with 50 members, the MemberCount property will return 20, not 70. The following code finds all the distribution lists in your Contacts folder and returns a sum of all the MemberCount properties:

 RestrictString = "[Message Class] = 'IPM.DistList'" Set oRestrictedItems = oItems.Restrict(RestrictString) For Each oItem In oRestrictedItems     intCount = intCount + oItem.MemberCount Next MsgBox "Member count for all DLs is: " & intCount 

SyncObject Object and SyncObjects Collection

Outlook 2000 allows users to set up quick synchronization folder groups. These synchronization groups, or profiles, allow users to configure different synchronization scenarios, such as which folders get synchronized offline and which filters apply to those folders. Users can then select the proper profile for their connection speed or synchronization preferences.

The Outlook SyncObjects collection contains all the synchronization profiles set up for the current user. Your program can start or stop any of these synchronization profiles using the methods of the SyncObject object. You can also monitor the progress of the synchronization by hooking into the events provided by the SyncObject object, named SyncStart, Progress, OnError, and SyncEnd. Let's look at how to use the SyncObjects collection and the SyncObject object.

Finding a SyncObject in the SyncObjects collection The SyncObjects collection contains one property, named the Count property, and one method, named the Item method, that you can use to find out more information about the SyncObject objects contained in the collection. The Item method allows you to identify an object in the collection by specifying a numeric or named index. By using the Item method, you can quickly retrieve a SyncObject object. The Count property returns the number of SyncObject objects contained in the collection.

The next code example shows you how to use both the Item method and the Count property. First, the code finds a SyncObject object named slow modem, and then it displays the number of synchronization profiles the user currently has set up. Note that you cannot create or delete SyncObject objects programmatically. Only the user can do this through the Outlook user interface.

 Dim oSyncObjects As Outlook.SyncObjects Dim oSyncObject As Outlook.SyncObject Set oSyncObjects = oNS.SyncObjects Set oSyncObject = oSyncObjects("slow modem") MsgBox "You have " & oSyncObjects.Count & " SyncObjects!" strNames = vbLf For Each oSyncObject In oSyncObjects     strNames = strNames & vbLf & oSyncObject.Name Next MsgBox "Names: " & strNames 

Starting and stopping synchronization Once you find a SyncObject object, you might want to start or stop the synchronization process. You can do this by using the Start and Stop methods of the SyncObject object, as shown here:

 Set oSyncObjects = oNS.SyncObjects Set oSyncObject = oSyncObjects("slow modem") oSyncObject.Start 

Monitoring the progress of synchronization The SyncObject object provides four events that your application can hook into to track the progress of a synchronization process: SyncStart, SyncEnd, Progress, and OnError. To implement these events, you must first declare a variable using the Dim statement in Visual Basic that corresponds to the SyncObject object and uses the keyword WithEvents. The SyncStart event is fired when Outlook starts synchronizing using a particular SyncObject. The SyncEnd event is fired immediately after Outlook finishes synchronizing. The OnError event is fired when Outlook encounters an error when synchronizing. The OnError event procedure is passed both the code for the error and the description of the error as a string.

The final event, Progress, is fired periodically by Outlook to report on the progress of synchronization. Four parameters are passed to the Progress event procedure: State, Description, Value, and Max:

• State is a Long data type that indicates the status of the synchronization. State can have the value olSyncStopped (0) or olSyncStarted (1).
• Description is a string that describes the current state of synchronization.
• Value is a Long data type that indicates the current value in the synchronization process. Value can be the number of items synchronized in the folder.
• Max is a long parameter that indicates the maximum value for the third parameter. The ratio of the third parameter (the value) to the fourth parameter (the max) represents the percent of the synchronization process that is complete.

The following code shows you how to use these events in your application. These events are not available from VBScript behind an Outlook form.

 Private Sub oSyncObject_Progress(ByVal State As Outlook.OlSyncState, _ ByVal Description As String, ByVal Value As Long, _ ByVal Max As Long)     strPercent = Description & Str(State / Max * 100) & "% "     MsgBox strPercent & vbLf & "State: " & State & vbLf & _         "Max: " & Max End Sub 

Outlook Bar Object Model

One of the most significant enhancements to the Outlook 2000 object model is the Outlook Bar objects, which allow you to manipulate the Outlook Bar shortcuts as well as the user interface. With Outlook 2000, Outlook Bar shortcuts hold not only file and folder shortcuts but also URL shortcuts to web pages, and you can customize it to meet the needs of your applications. Let's take a look at the new objects and collections for the Outlook Bar object model. Figure 9-7 shows how the objects in the Outlook Bar object model work together.

Figure 9-7 The relationship between the objects and collections in the Outlook Bar object model.

Panes Collection

The Panes collection enables developers to access the available Outlook application window panes. Although Outlook supports three panes—the OutlookBar, the FolderList, and the Preview panes—only the OutlookBar pane is accessible as an object in the Panes collection. If you try to access either of the other two panes, you will receive an error.

The Panes collection is retrieved from an Explorer object by using the new Panes property on that object. Once you retrieve the Panes collection, you can use the Item method of the Panes object and pass in either the numeric index or the name of the desired Pane object. To retrieve the OutlookBarPane object, you should pass in the text OutlookBar to the Item method.

The Panes collection also supports the Count property. Use this property to retrieve the number of Pane objects in the collection.

OutlookBarPane Object

After passing the text OutlookBar to the Item method of the Panes collection, Outlook returns an OutlookBarPane object. The OutlookBarPane object contains events and properties that let you control and monitor the Outlook Bar. These are the four properties you will use on the OutlookBarPane object:

• Contents. This read-only property returns the OutlookBarStorage object for the current OutlookBarPane object. From the returned object, you can retrieve the shortcuts and groups for the Outlook Bar.
• CurrentGroup. This property returns or sets the current group displayed in the Outlook Bar. You must pass a valid OutlookBarGroup object as the value for this property.
• Name. This read-only property returns a string that indicates the name of the current OutlookBarPane object.
• Visible. This property returns or sets the visibility of the OutlookBarPane object. This property takes a Boolean value that specifies whether you want to show the Outlook Bar in the user interface.

The following code shows you how to use the OutlookBarPane object in your applications:

 Dim oPanes As Outlook.Panes Dim oOutlookBarPane As Outlook.OutlookBarPane Set oPanes = oExplorer.Panes Set oOutlookBarPane = oPanes("OutlookBar") 'Flip whether the pane is visible or not oOutlookBarPane.Visible = Not (oOutlookBarPane.Visible) 

The OutlookBarPane object also provides two events that you can capture when users work with the Outlook Bar: BeforeGroupSwitch and BeforeNavigate. The BeforeGroupSwitch event is fired whenever the user or object model attempts to switch to a new visible group. The BeforeGroupSwitch event procedure takes two parameters, Group and Cancel. If you set the Cancel parameter to True, the switch is canceled. The Group parameter is an OutlookBarGroup object containing the Outlook group that the user is trying to navigate to. The following code shows you how to use BeforeGroupSwitch and cancel it when a user tries to navigate to a specific Outlook group:

 Dim WithEvents oOutlookBarPane As Outlook.OutlookBarPane Private Sub oOutlookBarPane_BeforeGroupSwitch( _ ByVal ToGroup As Outlook.OutlookBarGroup, Cancel As Boolean)     If ToGroup.Name = "My Shortcuts" Then         MsgBox "You cannot switch to the My Shortcuts group!"         Cancel = True     Else         MsgBox "Now switching to the " & ToGroup.Name & " group."     End If End Sub 

The BeforeNavigate event fires when the user attempts to click on an Outlook Bar shortcut. The BeforeNavigate event procedure takes two parameters, Shortcut and Cancel. Shortcut is an OutlookBarShortcut object, the Outlook Bar shortcut the user is trying to navigate to, and Cancel is a Boolean, which you can set to True to cancel the navigation. The following code example shows you how to use BeforeNavigate:

 Dim WithEvents oOutlookBarPane As Outlook.OutlookBarPane Private Sub oOutlookBarPane_BeforeNavigate( _ ByVal Shortcut As Outlook.OutlookBarShortcut, Cancel As Boolean) On Error Resume Next 'Need to watch out for File shortcuts! Err.Clear Set oTempFolder = Shortcut.Target strName = oTempFolder.Name If Err.Number = 0 Then     If strName = "Inbox" Then         MsgBox "Sorry, you can't switch to your inbox."         Cancel = True     Else         MsgBox "Now switching to the " & Shortcut.Name & " shortcut."     End If End If End S 

OutlookBarStorage Object

The OutlookBarStorage object is a container for the objects in an OutlookBarPane object. This object contains only one property—the Groups property—which you will use in your applications. The Groups property returns an OutlookBarGroups collection, which enables you to scroll through the groups on the Outlook Bar. The following code shows you how to use the Groups property to retrieve the OutlookBarGroups collection and then scroll through each group in the collection:

 Dim oOutlookBarStorage As Outlook.OutlookBarStorage Dim oOutlookBarGroups As Outlook.OutlookBarGroups Dim oOutlookBarGroup As Outlook.OutlookBarGroup Set oPanes = oExplorer.Panes Set oOutlookBarPane = oPanes("OutlookBar") Set oOutlookBarStorage = oOutlookBarPane.Contents Set oOutlookBarGroups = oOutlookBarStorage.Groups strGroups = vbLf For Each oOutlookBarGroup In oOutlookBarGroups     strGroups = strGroups & vbLf & oOutlookBarGroup.Name Next MsgBox "The names of the groups on your Outlook Bar: " _     & strGroups 

OutlookBarGroups Collection

The OutlookBarGroups collection contains OutlookBarGroup objects that represent all the Outlook groups on your Outlook Bar. Use this collection to count and add new groups to the Outlook Bar. This collection supports one property, Count, which you can use to retrieve the number of groups in the collection, as shown in the following code:

 Set oPanes = oExplorer.Panes Set oOutlookBarPane = oPanes("OutlookBar") Set oOutlookBarStorage = oOutlookBarPane.Contents Set oOutlookBarGroups = oOutlookBarStorage.Groups MsgBox "The number of Outlook groups on your Outlook Bar is: " _     & oOutlookBarGroups.Count 

This collection also supports three methods—Add, Item, and Remove. The Add method adds a new, empty OutlookBarGroup object to the collection and returns a reference to the new OutlookBarGroup object. The Add method takes two parameters: one is a string that specifies the name of the group to add; the other is optional and specifies a number indicating the insertion position for the new Outlook group. The top of the bar is at position 1.

The Item method allows you to retrieve an OutlookBarGroup object by name or by index. The Remove method allows you to delete an OutlookBarGroup object by specifying the index of the object you want to remove.

The following example uses all three of these methods together. It creates a new OutlookBarGroup object, finds the object by using the Item method, and deletes the object by using the Remove method.

 'Create the new group at the top of the bar Set oNewOLBarGroup = oOutlookBarGroups.Add("My New Group", 1) MsgBox "Added Group" Set oTempOLBarGroup = oOutlookBarGroups("My New Group") MsgBox "Got Group Named: " & oTempOLBarGroup.Name 'Since you have to remove a group by numeric index, we can loop  'through the collection, find the OutlookBarGroup by name, and  'get the corresponding index intCounter = 0 boolFound = 0 For Each oOutlookBarGroup In oOutlookBarGroups     intCounter = intCounter + 1     If oOutlookBarGroup.Name = "My New Group" Then         boolFound = intCounter     End If Next If boolFound <> 0 Then     oOutlookBarGroups.Remove boolFound     MsgBox "Deleted Group" End If 

The OutlookBarGroups collection is interesting because it supports three events that you can hook into: BeforeGroupAdd, BeforeGroupRemove, and GroupAdd. These three events enable you to trace when users try to add or remove certain Outlook groups and, if desired, cancel the user from removing or adding an Outlook group.

The BeforeGroupAdd event is fired before a new group is added to the Outlook Bar through either the user interface or code. The BeforeGroupAdd event procedure is passed a Boolean named Cancel which, if set to True, will not be added to the new group by Outlook. The next code snippet shows you how to use the BeforeGroupAdd event to cancel a user's attempt to add an Outlook group. Note that because the group hasn't been created yet, a reference to the new group is not passed the BeforeGroupAdd event procedure, so you have no way of knowing which group the user is trying to add. However, since the GroupAdd event passes you the group the user added, you can write code in that event procedure to remove the group if the user is not allowed to add it.

 Dim WithEvents oOutlookBarGroups As Outlook.OutlookBarGroups Private Sub oOutlookBarGroups_BeforeGroupAdd(Cancel As Boolean) MsgBox "You are not allowed to add groups to your Outlook Bar!" Cancel = True End Sub 

The BeforeGroupRemove event is fired before a group is removed from an Outlook Bar. You can hook into this event with your custom applications to prevent users from deleting Outlook groups you created programmatically. The BeforeGroupRemove event procedure is passed two parameters. The first is an OutlookBarGroup object, which corresponds to the Outlook group that a program or user is trying to remove. The second is the Cancel Boolean, which you can set to True to cancel the removal of the Outlook group. The following code checks to see whether the user is trying to remove her Outlook Shortcuts group, and when it finds out that she is, the code cancels the action:

 Private Sub oOutlookBarGroups_BeforeGroupRemove( _ ByVal Group As Outlook.OutlookBarGroup, Cancel As Boolean)     If Group.Name = "Outlook Shortcuts" Then         MsgBox "You cannot remove this group!"         Cancel = True     End If End Sub 

The GroupAdd event fires when a new group has been added successfully to the Outlook Bar. The GroupAdd event procedure is passed an OutlookBarGroup object, so you know which group has been added. If the user adds the new group using the Outlook user interface, the group will be named New Group because this is the default name for newly created Outlook groups. The following code displays a message box that shows the name of the Outlook group you added:

 Private Sub oOutlookBarGroups_GroupAdd( _ ByVal NewGroup As Outlook.OutlookBarGroup)     MsgBox "You added the " & NewGroup.Name & " group!" End Sub 

OutlookBarGroup Object

The OutlookBarGroup object represents an Outlook group on your Outlook Bar. The OutlookBarGroup object supports three properties and no methods. Use these three properties to access information about the Outlook group as well as shortcuts inside the Outlook group:

• Name. This property returns or sets the name of the OutlookBarGroup using a string.
• Shortcuts. This property returns the set of Outlook shortcuts contained in the group as an OutlookBarShortcuts collection.
• ViewType. This property returns or sets the way icons are displayed in the Outlook Bar. This property can be two values, either olLargeIcon (1) or olSmallIcon (2).

The following example shows you how to use all these properties. It loops through the OutlookBarGroups collection, and then retrieves each OutlookBarGroup object and displays information about it.

 For Each oOutlookBarGroup In oOutlookBarGroups     strName = oOutlookBarGroup.Name     Set oOutlookBarShortcuts = oOutlookBarGroup.Shortcuts     intShortcutCount = oOutlookBarShortcuts.Count     strNames = vbLf     For Each oOutlookBarShortcut In oOutlookBarShortcuts         strNames = strNames & vbLf & oOutlookBarShortcut.Name     Next     Select Case oOutlookBarGroup.ViewType         Case olLargeIcon:             strViewType = "Large Icons"         Case olSmallIcon:             strViewType = "Small Icons"     End Select     MsgBox "The following information is for the " & strName _         & " group." & vbLf & "The ViewType is: " & strViewType _         & vbLf & "The number of shortcuts in the group" _         & " is: " & intShortcutCount & vbLf & _         & "The shortcuts are named:" & strNames & vbLf Next 

OutlookBarShortcuts Collection

The OutlookBarShortcuts collection contains a set of OutlookBarShortcut objects and represents the shortcuts in an OutlookBarGroup object. This collection supports the Count property, which returns the number of OutlookBarShortcut objects in the collection.

This collection also supports three methods so that you can manipulate it: Add, Item, and Remove. The first method, Add, allows you to create a new shortcut in your Outlook group. The return value for Add is the new OutlookShortcut object you created. This method takes three parameters. The first parameter is a Variant that is the target for the shortcut. The target can be either a MAPIFolder object or a string that specifies a URL. Outlook 2000 supports placing URL shortcuts on your Outlook Bar. The second parameter is a string that specifies the name of the shortcut you are creating. The final parameter is an optional parameter that specifies the insertion position of the new shortcut. A value of 0 specifies to insert the shortcut at the top of the Outlook group. The following code example adds both a folder and a URL shortcut to a newly created Outlook group using the Add method:

 'Create the new group at the top of the bar Set oNewOLBarGroup = oOutlookBarGroups.Add("My New Group", 1) 'Get the shortcuts in the new group Set oOutlookBarShortcuts = oNewOLBarGroup.Shortcuts 'Now add a shortcut that points to a Folder Set oFolder = oNS.GetDefaultFolder(olFolderInbox) 'Optionally, we can set a variable to retrieve the 'new shortcut.  0 at the end means add it to the 'top of the group. Set oNewShortcut = oOutlookBarShortcuts.Add(oFolder, "My Inbox", 0) 'Now let's create a new shortcut to a web page strEXHTTP = "http://www.microsoft.com/exchange" oOutlookBarShortcuts.Add strEXHTTP, "Exchange web site" 

The second method, Item, allows you to specify the index number or the name of the shortcut you want to retrieve from the collection. The third method, Remove, takes the index of the OutlookBarShortcut object you want to remove from the collection. The following code shows you how to find and remove all shortcuts that point to the Inbox:

 On Error Resume Next For Each oOutlookBarGroup In oOutlookBarGroups     Set oOutlookShortcuts = oOutlookBarGroup.Shortcuts     intCounter = 1     For Each oOutlookShortcut In oOutlookShortcuts         'Watch out for File System shortcuts         Err.Clear       If oOutlookShortcut.Target.Name = "Inbox" Then           If Err.Number = 0 Then              oOutlookShortcuts.Remove intCounter             End If         End If        intCounter = intCounter + 1     Next Next 

The OutlookBarShortcuts collection supports the BeforeShortcutAdd, BeforeShorcutRemove, and ShortcutAdd events. The BeforeShortcutAdd event fires before a new shortcut is added to the Outlook Bar. The BeforeShortcutAdd event procedure is passed a parameter named Cancel, which you can set to True to cancel the attempted addition of the shortcut. The following code shows you how to hook into this event and cancel the action of a user trying to add a new shortcut to his Outlook Shortcuts group. Note that you are not passed the new Outlook shortcut object because the event is fired before the new shortcut is created.

 Dim WithEvents oOutlookShortcuts As OutlookBarShortcuts 'The oOutlookShortcuts var must be set before the event will fire Set oOutlookBarGroup = oOutlookBarGroups("Outlook Shortcuts") Set oOutlookShortcuts = oOutlookBarGroup.Shortcuts Private Sub oOutlookShortcuts_BeforeShortcutAdd(Cancel As Boolean)     On Error Resume Next     MsgBox "You are not allowed to add shortcuts!"     Cancel = True End Sub 

The second event supported by the OutlookBarShortcuts collection is the BeforeShortcutRemove event, which fires before a shortcut is removed from a group in the Outlook Bar. The BeforeShortcutRemove event procedure is passed two parameters: an OutlookBarShortcut object that corresponds to the shortcut the user or program is trying to remove; and Cancel, which is a Boolean that you can set to True to cancel the removal. The following code shows you how to use this event to prevent a user from removing his Calendar shortcut from the Outlook Shortcuts group:

 Dim WithEvents oOutlookShortcuts As OutlookBarShortcuts 'The oOutlookShortcuts var must be set before the event will fire Set oOutlookBarGroup = oOutlookBarGroups("Outlook Shortcuts") Set oOutlookShortcuts = oOutlookBarGroup.Shortcuts Private Sub oOutlookShortcuts_BeforeShortcutRemove( _ ByVal Shortcut As Outlook.OutlookBarShortcut, Cancel As Boolean)     On Error Resume Next     If Shortcut.Target.Name = "Calendar" Then         MsgBox "You can't remove the shortcut to your calendar!"         Cancel = True     End If End Sub 

The third event supported by the OutlookBarShortcuts collection is the ShortcutAdd event. This events fires after a new Outlook shortcut has been added to the Outlook bar. This event passes to you, as an OutlookBarShortcut object, the newly added shortcut. The following example shows you how to hook into this event:

 Dim WithEvents oOutlookShortcuts As OutlookBarShortcuts 'The oOutlookShortcuts var must be set before the event will fire Set oOutlookBarGroup = oOutlookBarGroups("Outlook Shortcuts") Set oOutlookShortcuts = oOutlookBarGroup.Shortcuts Private Sub oOutlookShortcuts_ShortcutAdd( _ ByVal NewShortcut As Outlook.OutlookBarShortcut)     MsgBox "You added the " & NewShortcut.Name & " shortcut!" End Sub 

OutlookBarShortcut Object

The OutlookBarShortcut object represents an Outlook shortcut on your Outlook Bar. Use this object to inquire about the target a shortcut points to. You make the inquiry by using the Target property. The Target property returns a Variant; the data type of this Variant is determined by the target for the shortcut. If the shortcut points to a folder, the data type is a MAPIFolder object. If the shortcut points to a file system folder, the data type is an Object. If the shortcut points to a URL or a file system path, the data type is a string. You can see how to use this object in the Account Tracking application we examine in Chapter 10.

Selection Collection Object

To provide your applications with the ability to identify what the user has selected in an Explorer window in Outlook, the Outlook object model has added a Selection collection object. The Selection object contains the set of items that a user has selected in the user interface. For example, you could use this collection to validate that the user has selected the proper item to enable your application to continue. You could also use it to dynamically add menu options and toolbar buttons when a user selects a certain item.

You must use the Item method to retrieve a specific object in the collection by using the object's index. The object is returned to you as an Object variable, so if you want to call a specific method or property on the object, you should coerce the object to a specific data type first.

This collection supports the Count property, which returns the number of items selected in a collection. You could use the Count property to determine the number of items the user has currently selected.

NOTE

---

To see the Selection collection in action, refer to the enhanced Account Tracking application in Chapter 10.