Automating Microsoft Outlook Using Visual Basic Scripting Edition or Visual Basic for Applications

Microsoft Corporation

May 5, 1997

Contents

Introduction
Choosing Between VBScript and Visual Basic for Your Outlook Solution
Differences Between VBScript and VBA
Using VBScript to Program Outlook Objects from Outlook
Using Visual Basic to Automate Outlook from Other Applications
Automating Other Applications from Outlook

Introduction

The first part of this article describes the differences between using Microsoft® Visual Basic® Scripting Edition (VBScript) code to automate Microsoft Outlook™ objects from within Outlook, and using Microsoft Visual Basic for Applications (VBA) to automate Outlook from another Microsoft Office 97 application. The second part of the article describes how to automate other Office 97 applications from within Outlook.

Choosing Between VBScript and VBA for Your Outlook Solution

Both VBScript and VBA are members of the Visual Basic language family. VBScript is a subset of VBA that you can use within Outlook. VBA is the programming language that you can use within the other Office 97 applications. All VBScript code will run in VBA, but all VBA code will not run in VBScript.

You can use either VBScript or VBA to program Outlook objects, but keep the following points in mind when you are choosing where to write your code:

• Event procedures that respond to events on either Outlook items or controls on Outlook items must be written in VBScript in Outlook.
  
  
• If you are writing a cross-application solution involving one primary application and one or more secondary ones, you probably want to write and run your code from the primary application.

  For example, if your solution is primarily a Microsoft Excel solution that uses some of the functionality of Outlook, write VBA code in Microsoft Excel to automate Excel and Outlook. If your solution is primarily an Outlook solution that uses some of the functionality of Microsoft Excel, write VBScript code in Outlook to automate Outlook and Excel.

• If you write VBA code that automates Outlook from another Office 97 application, you can take advantage of the richer programming environment in the controller application.

Differences between VBScript and VBA

The following table summarizes the differences between writing code to control Outlook in VBScript and writing code to control Outlook in Visual Basic for Applications. For more information, see "Microsoft Outlook Objects" (MSDN Library, Microsoft Office Development), or read "Microsoft Visual Basic Scripting Edition: Frequently Asked Questions."

Using VBScript to Program Outlook Objects from Outlook

To automate Outlook objects using VBScript code that runs from Outlook itself, you add event procedures and standard procedures to your custom forms. An event procedure can be triggered by events on either the item created from the form or on controls on the item.

Note   In Outlook, code runs only in response to events. Therefore, you can write Sub and Function procedures that don't respond to events, but there is no way to call these procedures directly. The only way to run a procedure that isn't associated with an event is to call it from a valid event procedure.

Creating an Item Event Procedure

In form event procedures, you use Item to refer to the item or form where the event occurred. This means that all form event procedure names are composed of the word "Item" followed by an underscore character (_) and the name of the event (for example, Item_Open). In addition, within the event procedure, you use Item to refer to the object that represents the Outlook item where the event occurred.

The following example adds the date and time that the Outlook item was opened to the end of the item's subject line.

Function Item_Open()
    Item.Subject = Item.Subject & " [opened " & Now & "]"
End Function

To add an empty form event procedure to your script in the Script Editor, on the Script menu click Event, then click an event name in the list, and then click Add. The appropriate Sub . . . End Sub or Function . . . End Function statement is inserted with its arguments (if any) specified.

Creating a Control Event Procedure

To create a Click event procedure for a control on an item, add a procedure whose name is composed of the name of the control followed by an underscore character (_) and the word "Click" to your code in the Script Editor. You must type the complete Sub . . . End Sub statement.

The following procedure disables the ReplyAll function for an item when the button named cmdNoReplyAll is clicked.

Sub cmdNoReplyAll_Open()
    Item.Actions("Reply to All").Enabled = False
End Function

Using Numeric Values Instead of Built-in Outlook Constants in VBScript

Unlike Visual Basic, VBScript does not support the built-in constants supplied by the Outlook type library. Therefore, when you automate Outlook by using VBScript, you must use the numeric values that the built-in constants represent.

If you write your Outlook code in one of the other Office 97 applications to take advantage of the development environment, be sure to replace the constants that are automatically supplied for you with their numeric equivalents when you paste the code into the Script Editor. You can look up the numeric values of built-in Outlook constants using the Object browser, or you can consult the following tables. These tables can also be found under "Microsoft Outlook Constants" in Microsoft Outlook Visual Basic Help.

OlActionCopyLike

OlActionReplyStyle

OlActionResponseStyle

OlActionShowOn

OlAttachmentType

OlBusyStatus

OlDaysOfWeek

OlDefaultFolders

OlFlagStatus

OlFolderDisplayMode

OlFormRegistry

OlGender

OlImportance

OlInspectorClose

OlItems

OlJournalRecipientType

OlMailingAddress

OlMailRecipientType

OlMeetingRecipientType

OlMeetingResponse

OlMeetingStatus

OlNoteColor

OlRecurrenceType

OlRemoteStatus

OlResponseStatus

OlSaveAsType

OlSensitivity

OlTaskDelegationState

OlTaskOwnership

OlTaskRecipientType

OlTaskResponse

OlTaskStatus

OlTrackingStatus

OlUserPropertyType

Using Visual Basic to Automate Outlook from Other Applications

To control Outlook objects from outside Outlook, you must establish a reference to the Outlook object library from the project in which you are writing your code. To do this, use the References dialog box on the Tools menu in the Visual Basic Editor. Then write code that returns a reference to the Outlook Application object. Through this reference, your code has access to all the objects, properties, methods, and constants defined in the Outlook type library.

There are several ways to return a reference to the Outlook Application object.

You can use the CreateObject function to start a new session of Outlook and return a reference to the Application object that represents the new session.

You can use the GetObject function to return a reference to the Application object that represents a session that's already running.

You can use the New keyword in several types of statements to implicitly create a new instance of the Outlook Application object. You can use the New keyword with the Set statement to set an object variable to the new instance of the Application object. You can also use the New keyword with the Dim, Private, Public, or Static statement to declare an object variable. (The new instance of the Application object is created on the first reference to the variable.)

The following example, run from Microsoft Excel, sets the myOlApp object variable to a new instance of the Outlook Application object using the Set statement and CreateObject function. The code then uses the CreateItem method of the Application object within a For Each . . . Next loop to create one ContactItem object for each row in the specified range on the Contacts worksheet and to set properties for the item, using values from cells in the row.

Sub WriteContactInfo()
    Dim myOlApp As Outlook.Application
    Dim w As Workbook
    Dim s As Worksheet
    Dim c As Range

    Set s = Worksheets("Contacts")
    Set myOlApp = CreateObject("Outlook.Application")
    For i = 1 To s.Range("a1").CurrentRegion.Rows.Count
        Set c = s.Cells(i, 1)
        Set myItem = myOlApp.CreateItem(olContactItem)
        With myItem
            .FullName = c.Value
            .Birthday = c.Offset(0, 1).Value
            .Children = c.Offset(0, 2).Value
            .Spouse = c.Offset(0, 4).Value
            .Save
        End With
    Next
End Sub

The following example, run from Microsoft Access, sets the myOlApp object variable to an instance of the Outlook Application object using the Set statement and the New keyword. The rest of the code goes to the Contacts folder, adds a new item, and sets the item's properties to values in a Microsoft Access form.

Sub AddNewContact
    Set myOlApp = New Outlook.Application
    Set myOlNameSpace = myOlApp.GetNamespace("MAPI")
    Set objFolder = myOlNameSpace.GetDefaultFolder(olFolderContacts)
    Set objForm = Forms!Customers
    Set objNewContact  = objFolder.Items.Add
    With objNewContact
        Set prpUserProp = .UserProperties.Add("Priority", olText)
        prpUserProp.Value = objForm!Priority
        .FirstName = Left(objForm!ContactName, InStr(objForm!ContactName, " ") - 1)
        .LastName = Mid(objForm!ContactName, InStr(objForm!ContactName, " ") + 1)
        .CompanyName = Nz(objForm!CompanyName, "")
        .JobTitle = Nz(objForm!ContactTitle, "")
        .Save
    End With
End Sub

Automating Other Applications from Outlook

To automate other applications using Outlook VBScript code, use the CreateObject method of the Application object. The following VBScript example, which is run by clicking the cmdToXL button on an item, reads information about the current item and writes it to a Microsoft Excel worksheet. The form from which the current item was created must be based on the Contact item form.

Sub cmdToXL_click()
    Set myXLApp = Item.Application.CreateObject("Excel.Application")
    myXLApp .Visible = True
    Set c = myXLApp.Workbooks.Add.Worksheets(1).Range("a1")
    c.Value = Item.FullName
    c.Offset(0, 1).Value = Item.HomeAddressStreet
    c.Offset(0, 2).Value = Item.HomeAddressCity
    c.Offset(0, 3).Value = Item.HomeAddressState
    c.Offset(0, 4).Value = Item.HomeAddressPostalCode
End Sub

This document is for informational purposes only.