In most cases that makeweight does not matter at all since it is very small (about 100-200 bytes), but sometimes it may be excess. In order to get the exact size of the attached file, you need to use the PR_ATTACH_DATA_BIN binary property:

Private Function GetAttachSizeMAPI(ByVal oMAPIObject As Object) As Long

    If (oMAPIObject Is Nothing) Then Return 0

    Dim result As String = 0
    Dim pPropValue As IntPtr = IntPtr.Zero
    Dim IUnk As IntPtr = IntPtr.Zero
    Dim IProperty As IntPtr = IntPtr.Zero
    Try
        MAPI.MAPIInitialize(IntPtr.Zero)
        IUnk = Marshal.GetIUnknownForObject(oMAPIObject)
        ' Outlook 2003 and 2007 ( IMAPIProp )
        Dim res = Marshal.QueryInterface(IUnk, MAPI.guidMAPIProp, IProperty)
        If res = MAPI.S_OK Then
            Dim oMapiProp As Object = Marshal.GetObjectForIUnknown(IProperty)
            Dim iMapiProp As IMAPIProp = TryCast(oMapiProp, IMAPIProp)
            If iMapiProp IsNot Nothing Then
                Try
                    Dim stream As ComTypes.IStream
                    Dim IStream As IntPtr = IntPtr.Zero
                    iMapiProp.OpenProperty( _
                        MAPI.PR_ATTACH_DATA_BIN, _
                        MAPI.guidIStream, 0, 0, _
                        IStream)
                    If IStream <> IntPtr.Zero Then
                        Try
                            stream = TryCast( _
                                Marshal.GetObjectForIUnknown(IStream), _
                                ComTypes.IStream)
                            If stream IsNot Nothing Then
                                Try
                                    Dim stat As ComTypes.STATSTG = Nothing
                                    stream.Stat(stat, STATFLAG.STATFLAG_NONAME)
                                    result = stat.cbSize
                                    Return result
                                Finally
                                    Marshal.ReleaseComObject(stream)
                                End Try
                            End If
                        Finally
                            Marshal.Release(IStream)
                        End Try
                    End If
                Finally
                    Marshal.ReleaseComObject(oMapiProp)
                End Try
            End If
        End If
        ' Outlook 2000 and XP ( IAttach )
        res = Marshal.QueryInterface(IUnk, MAPI.guidMAPIAttach, IProperty)
        If res = MAPI.S_OK Then
            Dim oMapiProp As Object = Marshal.GetObjectForIUnknown(IProperty)
            Dim iMapiProp As IAttach = TryCast(oMapiProp, IAttach)
            If iMapiProp IsNot Nothing Then
                Try
                    Dim stream As ComTypes.IStream
                    Dim IStream As IntPtr = IntPtr.Zero
                    iMapiProp.OpenProperty( _
                        MAPI.PR_ATTACH_DATA_BIN, _
                        MAPI.guidIStream, 0, 0, _
                        IStream)
                    If IStream <> IntPtr.Zero Then
                        Try
                            stream = TryCast( _
                                Marshal.GetObjectForIUnknown(IStream), _
                                ComTypes.IStream)
                            If stream IsNot Nothing Then
                                Try
                                    Dim stat As ComTypes.STATSTG = Nothing
                                    stream.Stat(stat, STATFLAG.STATFLAG_NONAME)
                                    result = stat.cbSize
                                    Return result
                                Finally
                                    Marshal.ReleaseComObject(stream)
                                End Try
                            End If
                        Finally
                            Marshal.Release(IStream)
                        End Try
                    End If
                Finally
                    Marshal.ReleaseComObject(oMapiProp)
                End Try
            End If
        End If
    Finally
        If (pPropValue <> IntPtr.Zero) Then
            MAPI.MAPIFreeBuffer(pPropValue)
        End If
        If (IProperty <> IntPtr.Zero) Then
            Marshal.Release(IProperty)
        End If
        If (IUnk <> IntPtr.Zero) Then
            Marshal.Release(IUnk)
        End If
    End Try
    Return result
End Function

Personal thanks to François-Denis for his contribution to the PR_ATTACH_SIZE vs. PR_ATTACH_DATA_BIN properties discussion on our forum.

You may also be interested in:

How to program an Outlook COM add-in: ribbon tabs, command bars, task panes
Advanced features for Outlook plug-in development
How to develop custom Outlook forms

Available downloads:

This sample add-in was developed using Add-in Express 2009 for Microsoft Office and .net
C# sample Outlook add-in for VS 2005
VB.NET sample Outlook add-in for VS 2005

The first method is as follows: you store each attachment in a temporary file, then query the file size, and after that delete that temporary file. The other, and probably a smarter way, is getting the attachment size via the PR_ATTACH_SIZE Extended MAPI property. It is that second method that we are going to scrutinize today.

The DoGetAttachmentSize method is quite simple, the code below processes the Attachments collection:

Private Sub DoGetAttachmentSize(ByRef mail As Outlook._MailItem)
    Dim attachments As Outlook.Attachments = mail.Attachments
    If attachments IsNot Nothing Then
        Try
            If attachments.Count > 0 Then
                Dim Output As String = String.Empty
                For i As Integer = 1 To attachments.Count
                    Dim attach As Outlook.Attachment = attachments.Item(i)
                    If attach IsNot Nothing Then
                        Try
                            Dim size As Long = GetMAPIProp( _
                                attach.MAPIOBJECT, _
                                MAPI.PR_ATTACH_SIZE)
                            Output += "#" + i.ToString() + _
                             ": " + attach.FileName + _
                             " " + size.ToString() + _
                             Environment.NewLine
                        Finally
                            Marshal.ReleaseComObject(attach)
                        End Try
                    End If
                Next i
                If Output <> String.Empty Then MessageBox.Show(Output)
            End If
        Finally
            Marshal.ReleaseComObject(attachments)
        End Try
    End If
End Sub

In the GetMAPIProp method, you dig for the needed PR_ATTACH_SIZE property. Initialize Extended MAPI, query the right interface, get the SPropValue structure and receive the wanted value. Pay attention here to the two calls of QueryInterface. The point is that Outlook 2003 and Outlook 2007 return only the IMAPIProp interface, while Outlook 2000 and Outlook XP return the IAttach interface only. What kind of interface will be implemented in Outlook 2010 is unclear so far, that is why I am leaving the code as is,  with 2 QueryInterface calls:

Private Function GetMAPIProp( _
    ByVal oMAPIObject As Object, _
    ByVal uiPropertyTag As UInteger) As Long

    If (oMAPIObject Is Nothing) Then Return 0

    Dim result As String = 0
    Dim pPropValue As IntPtr = IntPtr.Zero
    Dim IUnk As IntPtr = IntPtr.Zero
    Dim IProperty As IntPtr = IntPtr.Zero
    Try
        MAPI.MAPIInitialize(IntPtr.Zero)
        IUnk = Marshal.GetIUnknownForObject(oMAPIObject)
        Dim guidMAPIProp As Guid = New Guid(MAPI.IID_IMAPIProp)
        Dim res = Marshal.QueryInterface(IUnk, guidMAPIProp, IProperty)
        If (res <> MAPI.S_OK) Then
            Dim guidMAPIAttach As Guid = New Guid(MAPI.IID_IAttachment)
            Marshal.QueryInterface(IUnk, guidMAPIAttach, IProperty)
            If (res <> MAPI.S_OK) Then Return 0
        End If
        Try
            MAPI.HrGetOneProp(IProperty, uiPropertyTag, pPropValue)
            If (pPropValue = IntPtr.Zero) Then Return 0
            Dim propValue As SPropValue
            propValue = _
                Marshal.PtrToStructure(pPropValue, propValue.GetType())
            result = propValue.Value And UInt32.MaxValue
        Catch ex As System.Exception
            Throw ex
        End Try
    Finally
        If (pPropValue <> IntPtr.Zero) Then
            MAPI.MAPIFreeBuffer(pPropValue)
        End If
        If (IProperty <> IntPtr.Zero) Then
            Marshal.Release(IProperty)
        End If
        If (IUnk <> IntPtr.Zero) Then
            Marshal.Release(IUnk)
        End If
    End Try
    Return result
End Function

Have a nice weekend. I hope the weather will finally get better here and I will go fishing to enjoy peace and tranquility, at last!

You may also be interested in:

How to develop an Outlook COM add-in step-by-step
Advanced features for Outlook toolbars, menus and ribbons

Available downloads:

This sample add-in was developed using Add-in Express 2009 for Microsoft Office and .net
C# sample Outlook add-in for VS 2005
VB.NET sample Outlook add-in for VS 2005

Starting from version 5.1, a new event is available in Add-in Express – ADXDragOverMinimized. Using this event you can access a dragged item and expand the form. The code of the sample is very plain indeed, and I am not going to publish it here. You can download the samples using the links at the end of this post.

You may also be interested in:

Advanced Outlook Regions for Outlook forms and views
Advanced Outlook Regions for Explorer and Inspector windows
Advanced Outlook Regions: read and compose mode
Advanced Outlook Regions: minimized, expanded, hidden

Available downloads:

C# sample Outlook and Word add-in for VS 2005
VB.NET sample Outlook and Word add-in for VS 2005
Delphi 7 sample Outlook and Word add-in

Ok, so here we go now. In the IEModule class of your IE add-on, you need the following declarations:

Private ADDON_TO_MYAPP_MessageId As IntPtr
Private MSG_ADDON_TO_MYAPP As String = "ADDON_TO_MYAPP"
 _
Public Shared Function RegisterWindowMessage( _
    ByVal lpString As [String]) As IntPtr
End Function
 _
Public Shared Function FindWindow( _
    ByVal lpClassName As String, _
    ByVal lpWindowName As String) As IntPtr
End Function
 _
Public Shared Function PostMessage( _
    ByVal hwnd As IntPtr, _
    ByVal wMsg As IntPtr, ByVal wParam As Int32, _
    ByVal lParam As Int32) As IntPtr
End Function

Then the OnConnect, OnDisconnect, DocumentComplete event handlers:

Private Sub IEModule_OnConnect( _
    ByVal sender As System.Object, _
    ByVal threadId As System.Int32) _
    Handles MyBase.OnConnect

    Me.ADDON_TO_MYAPP_MessageId = _
        RegisterWindowMessage(MSG_ADDON_TO_MYAPP)
    SendMessageToMyApp(0)
End Sub

Private Sub IEModule_OnDisconnect( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) _
    Handles MyBase.OnDisconnect

    SendMessageToMyApp(1000)
End Sub

Private Sub IEModule_DocumentComplete( _
    ByVal pDisp As System.Object, _
    ByVal url As System.String) _
    Handles MyBase.DocumentComplete

    SendMessageToMyApp(0)
End Sub

And three methods: SendMessageToMyApp is used to notify your standalone application about events, such as opening/closing a tab and web-page loading. The other two are called from the application:

Private Sub SendMessageToMyApp(ByVal delay As Integer)
    Dim hwnd As IntPtr = FindWindow(Nothing, "My Application")
    If hwnd <> IntPtr.Zero Then
        PostMessage(hwnd, Me.ADDON_TO_MYAPP_MessageId, delay, 0)
    End If
End Sub

Public Function GetCurrentTitle() As String
    Try
        Dim text As String = Me.HTMLDocument.title
        If [String].IsNullOrEmpty(text) Then
            text = "Blank Page"
        End If
        Return text
    Catch
    End Try
    Return [String].Empty
End Function

Public Sub NavigateTo(ByVal url As String)
    Try
        Dim dummy As Object = Type.Missing
        Me.IEApp.Navigate(url, dummy, dummy, dummy, dummy)
    Catch err As Exception
        MessageBox.Show(err.Message, Me.ModuleName, _
            MessageBoxButtons.OK, MessageBoxIcon.[Error])
    End Try
End Sub

And now the key piece of the application. Using the GetModulesByTypeName method, you can get a list of instances of your IEModule classes and use their methods and properties:

Private Sub RefreshItems()
    Dim [module] As ADX_IE_Addon_And_WinApp_VB.IEModule
    comboBox1.BeginUpdate()
    Try
        remoteModules.Clear()
        comboBox1.Items.Clear()
        Dim modules As ArrayList = _
            AddinExpress.IE.ADXIEModule.GetModulesByTypeName( _
                "ADX_IE_Addon_And_WinApp_VB.IEModule")
        If modules.Count > 0 Then
            For i As Integer = 0 To modules.Count - 1
                [module] = TryCast(modules(i), _
                    ADX_IE_Addon_And_WinApp_VB.IEModule)
                If [module] IsNot Nothing Then
                    remoteModules.Add([module])
                    comboBox1.Items.Add( _
                        [module].GetCurrentTitle())
                End If
            Next
        End If
        If comboBox1.Items.Count > 0 Then
            comboBox1.SelectedIndex = 0
        Else
            Application.[Exit]()
        End If
    Catch err As Exception
        MessageBox.Show(err.Message, Me.Text, _
            MessageBoxButtons.OK, MessageBoxIcon.[Error])
    Finally
        comboBox1.EndUpdate()
    End Try
End Sub

That’s all with it.

You may also be interested in:

Understanding and Working in Protected Mode Internet Explorer
How to develop an add-on for IE6, IE7 and IE8
How to add a custom button to IE toolbar
How to create an Explorer bar and context menu

Available downloads:

This sample add-in was developed using Add-in Express 2009 for Internet Explorer and .net

C# sample IE add-on for VS 2005
VB.NET sample IE add-on for VS 2005

Well, here goes! Let’s create a new IE plug-in project using the “ADX IE Bar” wizard, populate our IEBarModule with a group box that has 3 radio buttons, add a couple of checkboxes, a combo box and text box. Ergo, we need to store and synchronize 5 values, Integer as index for RadioButtons, two Boolean values as CheckBox states, another Integer as index for ComboBox and String for TextBox. Now, add to the project your own class, a descendent of ADXIESharedMemory, by using “ADX IE Shared Data” wizard and modify the GlobalData class, which is present in every IE plug-in project.

Here is a list of private variables needed:

Private lastOutputPath As String
Private optionPageData As MySharedData

Private Const FILE_LOCKED As Integer = 0
Private Const RADIO_OPTION As Integer = 1
Private Const CHECK_OPTION_1 As Integer = 2
Private Const CHECK_OPTION_2 As Integer = 3
Private Const LIST_OPTION As Integer = 4
Private Const STRING_OPTION As Integer = 5

Modified constructor:

Public Sub New()
    MyBase.New()
    'System.Diagnostics.Debugger.Break()
    Dim outputPath As String = _
        Path.Combine(Environment.GetFolderPath( _
        Environment.SpecialFolder.InternetCache), "Low")
    outputPath = Path.Combine(outputPath, "MyIEOptionPage")
    If Not Directory.Exists(outputPath) Then
        Directory.CreateDirectory(outputPath)
    End If
    Me.lastOutputPath = outputPath
    Me.optionPageData = New MySharedData( _
        "MyIEOptionPage", 512, 10)

    Me.optionPageData(FILE_LOCKED) = 0
    Me.optionPageData(RADIO_OPTION) = 0
    Me.optionPageData(CHECK_OPTION_1) = False
    Me.optionPageData(CHECK_OPTION_2) = False
    Me.optionPageData(LIST_OPTION) = 0
    Me.optionPageData(STRING_OPTION) = "Default"
End Sub

Added methods:

Public Sub LoadOptions()
    If CInt(Me.optionPageData(FILE_LOCKED)) = 0 Then
        Me.optionPageData(FILE_LOCKED) = 1
        Try
            Dim outputFile As String = _
                Path.Combine(lastOutputPath, "myoptions.cfg")
            If File.Exists(outputFile) Then
                Using sr As New StreamReader(outputFile)
                    Dim line As String
                    line = sr.ReadLine()
                    Me.optionPageData(RADIO_OPTION) = _
                      Convert.ToInt32(line.Trim())
                    line = sr.ReadLine()
                    Me.optionPageData(CHECK_OPTION_1) = _
                      Convert.ToBoolean(line.Trim())
                    line = sr.ReadLine()
                    Me.optionPageData(CHECK_OPTION_2) = _
                      Convert.ToBoolean(line.Trim())
                    line = sr.ReadLine()
                    Me.optionPageData(LIST_OPTION) = _
                      Convert.ToInt32(line.Trim())
                    line = sr.ReadLine()
                    Me.optionPageData(STRING_OPTION) = _
                      line.Trim()
                End Using
            End If
        Finally
            Me.optionPageData(FILE_LOCKED) = 0
        End Try
    End If
End Sub

Private Sub SaveOptions()
    If CInt(Me.optionPageData(FILE_LOCKED)) = 0 Then
        Me.optionPageData(FILE_LOCKED) = 1
        Try
            Dim outputFile As String = _
                Path.Combine(lastOutputPath, "myoptions.cfg")
            Using sw As New StreamWriter(outputFile, False)
                sw.Write(Me.optionPageData(RADIO_OPTION))
                sw.Write(sw.NewLine)
                sw.Write(Me.optionPageData(CHECK_OPTION_1))
                sw.Write(sw.NewLine)
                sw.Write(Me.optionPageData(CHECK_OPTION_2))
                sw.Write(sw.NewLine)
                sw.Write(Me.optionPageData(LIST_OPTION))
                sw.Write(sw.NewLine)
                sw.Write(Me.optionPageData(STRING_OPTION))
            End Using
        Finally
            Me.optionPageData(FILE_LOCKED) = 0
        End Try
    End If
End Sub

Public Sub UpdateOptions(ByVal [module] As IEBarModule)
    SyncLock Instance
        Me.optionPageData(RADIO_OPTION) = [module].RadioOptions
        Me.optionPageData(CHECK_OPTION_1) = [module].CheckOption1
        Me.optionPageData(CHECK_OPTION_2) = [module].CheckOption2
        Me.optionPageData(LIST_OPTION) = [module].ListOption
        Me.optionPageData(STRING_OPTION) = [module].StringOption
        SaveOptions()
    End SyncLock
End Sub

Public Sub RefreshOptions(ByVal [module] As IEBarModule)
    SyncLock Instance
        [module].RadioOptions = _
          CInt(Me.optionPageData(RADIO_OPTION))
        [module].CheckOption1 = _
          CBool(Me.optionPageData(CHECK_OPTION_1))
        [module].CheckOption2 = _
          CBool(Me.optionPageData(CHECK_OPTION_2))
        [module].ListOption = _
          CInt(Me.optionPageData(LIST_OPTION))
        [module].StringOption = _
          DirectCast(Me.optionPageData(STRING_OPTION), String)
    End SyncLock
End Sub

Public Sub CloseOptions()
    SyncLock Instance
        If Me.optionPageData IsNot Nothing Then
            Try
                SaveOptions()
            Finally
                Me.optionPageData.Dispose()
                Me.optionPageData = Nothing
            End Try
        End If
    End SyncLock
End Sub

Now let’s go back to IEBarModule and add Load, OnConnect, OnDisconnect, OnSendMessage and two button Click event handlers (one to apply settings, and another to cancel them):

Private startMode As Boolean = True
Private Const WM_UPDATE_OPTIONS As Integer = (&H400 + 3000)

Private Sub IEBarModule_Load( _
    ByVal sender As System.Object, ByVal e As System.EventArgs) _
    Handles MyBase.Load

    Try
        GlobalData.Instance.LoadOptions()
    Catch err As Exception
        MessageBox.Show(err.Message, Me.Title, _
          MessageBoxButtons.OK, MessageBoxIcon.[Error])
    End Try
End Sub

Private Sub IEBarModule_OnConnect( _
    ByVal sender As System.Object, _
    ByVal threadId As System.Int32) Handles MyBase.OnConnect

    comboBox1.SelectedIndex = 0
    SendMessageToAll(WM_UPDATE_OPTIONS, IntPtr.Zero, IntPtr.Zero)
    startMode = False
End Sub

Private Sub IEBarModule_OnDisconnect( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles MyBase.OnDisconnect

    Try
        GlobalData.Instance.CloseOptions()
    Catch err As Exception
        MessageBox.Show(err.Message, Me.Title, _
          MessageBoxButtons.OK, MessageBoxIcon.[Error])
    End Try
End Sub

Private Sub IEBarModule_OnSendMessage( _
    ByVal e As AddinExpress.IE.ADXIESendMessageEventArgs) _
    Handles MyBase.OnSendMessage

    Select Case e.Message
        Case WM_UPDATE_OPTIONS
            If True Then
                startMode = True
                Try
                    GlobalData.Instance.RefreshOptions(Me)
                Finally
                    startMode = False
                End Try
            End If
            Exit Select
    End Select
End Sub

Private Sub buttonApply_Click( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles buttonApply.Click

    Try
        GlobalData.Instance.UpdateOptions(Me)
        SendMessageToAll(WM_UPDATE_OPTIONS, IntPtr.Zero, _
            IntPtr.Zero)
    Finally
        buttonApply.Enabled = False
        buttonCancel.Enabled = False
    End Try
End Sub

Private Sub buttonCancel_Click( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles buttonCancel.Click

    Try
        GlobalData.Instance.RefreshOptions(Me)
    Finally
        buttonApply.Enabled = False
        buttonCancel.Enabled = False
    End Try
End Sub

So, now we have all the settings stored in the myoptions.cfg file. Once the settings are changed, all active instances of the IE plug-in in all running Internet Explorer processes learn the fact and get to know their new values.

That’s all for today.

You may also be interested in:

How to develop an add-on for IE6, IE7 and IE8
How to create a custom button for IE toolbar
How to build an Explorer bar and context menu

Available downloads:

This sample add-in was developed using Add-in Express 2009 for Internet Explorer and .net

C# sample IE plug-in for VS 2005
VB.NET sample IE plug-in for VS 2005

All API functions are implemented in the Add-in Express for Internet Explorer and .net product and today we are going to look into their capabilities.

You can create an instance of the AddinExpress.IE.ADXIEProtectedModeAPI class and check out the Protection Mode state using the OnCreate event handler:

Private Sub IEToolBarModule_OnConnect( _
    ByVal sender As System.Object, _
    ByVal threadId As System.Int32) _
    Handles MyBase.OnConnect

    Try
        Me.pAPI = New AddinExpress.IE.ADXIEProtectedModeAPI()
        If Me.pAPI.IsProtectedModeOn() Then
            Me.label1.Text = "Protected Mode: On"
        Else
            Me.label1.Text = "Protected Mode: Off"
        End If
    Catch err As Exception
        MessageBox.Show(err.Message, Me.MenuText, _
          MessageBoxButtons.OK, MessageBoxIcon.[Error])
    End Try
End Sub

Then you can use the ADXIEProtectedModeAPI methods in your code. In the code below, the ShowSaveFileDialog, GetWriteableFolderPath and SaveFile methods are used for saving a file into a location specified by the end-user:

Private Sub buttonSave_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles buttonSave.Click

    Dim tmpFilePath As String = String.Empty
    Try
        If Me.pAPI IsNot Nothing Then
            Dim state As Integer = 0
            Dim fileName As String
            fileName = Me.pAPI.ShowSaveFileDialog( _
                Me.TabWindowHandle, _
                "Log.txt", _
                Nothing, _
                "Text files|*.txt|All files|*.*|", "txt", _
                1, _
                ADXIEOpenFileNameFlags.ofnEnableSizing Or _
                ADXIEOpenFileNameFlags.ofnHideReadOnly Or _
                ADXIEOpenFileNameFlags.ofnPathMustExist Or _
                ADXIEOpenFileNameFlags.ofnOverWritePrompt, _
                state)
            If state = 0 Then Exit Sub
            Try
                tmpFilePath = Me.pAPI.GetWriteableFolderPath()
                tmpFilePath = Path.Combine(tmpFilePath, _
                  "IEProtectedModeAPI")
                If Not Directory.Exists(tmpFilePath) Then
                    Directory.CreateDirectory(tmpFilePath)
                End If
                tmpFilePath = Path.Combine(tmpFilePath, "log.txt")

                Using sw As New StreamWriter(tmpFilePath, False)
                    sw.WriteLine("IEProtectedModeAPI Example")
                    sw.WriteLine("--------------------------")
                    sw.WriteLine("This is just a test.")
                End Using

                If Not File.Exists(tmpFilePath) Then
                    Throw New FileNotFoundException( _
                      "The log file doesn't exist.")
                End If

                Me.pAPI.SaveFile(state, tmpFilePath)
                MessageBox.Show(Me, _
                  "The file has been successfully saved.", _
                  Me.MenuText, MessageBoxButtons.OK, _
                  MessageBoxIcon.Information)
            Catch
                Me.pAPI.CancelSaveFile(state)
                Throw
            End Try
        End If
    Catch err As Exception
        MessageBox.Show(Me, err.Message, Me.MenuText, _
            MessageBoxButtons.OK, MessageBoxIcon.[Error])
    Finally
        If tmpFilePath <> String.Empty Then
            If File.Exists(tmpFilePath) Then
                File.Delete(tmpFilePath)
            End If
        End If
    End Try
End Sub

Now you can save your data not only to a special pre-determined location that you can obtain by using the GetWritableFolderPath function, but to any location specified by the end-user. That’s all for today.

You may also be interested in:

How to create an add-on for IE6, IE7 and IE8
How to develop an IE toolbar with custom buttons
Building IE browser helper objects

Available downloads:

This sample add-in was developed using Add-in Express 2009 for Internet Explorer and .net

C# sample IE plug-in for VS 2005
VB.NET sample IE plug-in for VS 2005

Using the code bellow, we can promptly and easily get a list of synonyms for a given word, i.e. a word on which the cursor is placed:

Private Sub AdxCommandBarButton1_Click( _
    ByVal sender As System.Object) _
    Handles AdxCommandBarButton1.Click, ShortcutSynonym.Action

    Dim frm As New Form1()
    frm.ListBox1.Items.Clear()
    frm.Text = "Synonym list"
    frm.Label1.Text = "Select synonym:"

    Dim selection As Word.Selection = WordApp().Selection
    If selection IsNot Nothing Then
        Try
            Dim wordText As String = selection.Words.Last.Text
            Dim objLanguage As Object = Word.WdLanguageID.wdEnglishUS
            Dim info As Word.SynonymInfo
            info = WordApp().SynonymInfo(wordText, objLanguage)
            If info IsNot Nothing Then
                Try
                    If info.MeaningCount > 0 Then
                        Dim duplicate As Boolean
                        For Each meaning As String In _
                            DirectCast(info.MeaningList, System.Array)

                            Dim objMeaning As Object = meaning
                            Dim synonyms As System.Array
                            synonyms = DirectCast( _
                                info.SynonymList(objMeaning), _
                                System.Array)
                            For Each synonym As String In synonyms
                                duplicate = False
                                Dim list As String
                                For Each list In frm.ListBox1.Items
                                    If list = synonym Then
                                        duplicate = True
                                        Exit For
                                    End If
                                Next
                                If Not duplicate Then
                                    frm.ListBox1.Items.Add(synonym)
                                End If
                            Next
                        Next
                        frm.ListBox1.SelectedIndex = 0
                        If frm.ShowDialog() = DialogResult.OK Then
                            ReplaceWord( _
                                selection, _
                                wordText.Trim().Length, _
                                frm.ListBox1.Text)
                        End If
                    Else
                        MessageBox.Show( _
                            "There are no synonyms for this word.")
                    End If
                Finally
                    Marshal.ReleaseComObject(info)
                End Try
            End If
        Finally
            Marshal.ReleaseComObject(selection)
        End Try
    End If
    frm.Dispose()
End Sub

The code that allows getting the antonyms list is more compact and easier. You can get it by downloading the VB.NET and C# samples below.
Please keep in mind that you can get the synonym and antonym lists not only via a COM add-in but from a standalone application as well by using the MS Word Object Model capabilities.

You may also be interested in:

How to develop a COM add-in for Microsoft Word step-by-step

Available downloads:

This sample add-in was developed using
Add-in Express 2008 for Microsoft Office and .net

C# sample Word add-in for VS 2005
VB.NET sample Word add-in for VS 2005

Our tests show that in Outlook 2000, 2002 and 2003 this event is not fired if more than 16 elements are dragged. Imagine, only 16! Outlook 2007 with SP2 is more stable in this regard, the ItemAdd event stops firing when more than 512 elements are dragged simultaneously. How can you get all the moved items? You need to use the Extended MAPI IMsgStore::Advise method and implement the IMAPIAdviseSink::OnNotify method.

All this has already been implemented in our MAPI Store Accessor and works just fine (BTW, it is a free tool and you can download it right now). In this particular case, it is the OnObjectMoved event that interests us most:

Private Sub adxmapiStoreAccessor_OnObjectMoved( _
    ByVal sender As System.Object, _
    ByVal e As AddinExpress.MAPI.ADXMAPIObjectNotificationEventArgs) _
    Handles adxmapiStoreAccessor.OnObjectMoved

    Dim folder As AddinExpress.MAPI.Folder = _
        adxmapiStoreAccessor.GetMapiFolder(itemsEvents.FolderObj)
    If folder IsNot Nothing Then
        Dim folderId As Object
        folderId = folder.GetProperty( _
            AddinExpress.MAPI.ADXMAPIPropertyTag._PR_ENTRYID)
        folder.Dispose()
        If e.ParentId.ToString() = _
            AddinExpress.MAPI.EntryId.ConvertToString( _
            CType(folderId, Byte())) Then
            Dim ns As Outlook._NameSpace
            ns = OutlookApp.GetNamespace("MAPI")
            If ns IsNot Nothing Then
                Try
                    Dim mail As Outlook.MailItem
                    mail = TryCast( _
                        ns.GetItemFromID(e.EntryId.ToString(), _
                        Type.Missing), Outlook.MailItem)
                    If mail IsNot Nothing Then
                        Try
                            AddEventToLog( _
                                " Object moved. Subject = " + _
                                mail.Subject)
                        Finally
                            Marshal.ReleaseComObject(mail)
                        End Try
                    End If
                Finally
                    Marshal.ReleaseComObject(ns)
                End Try
            End If
        End If
    End If
End Sub

MAPI store events have 2 specificities related to MS Exchange-based stores:

• Events are raised asynchronously, which means that it could be a significant time interval since the items were dragged before the event was triggered.
• The Public Folders store doesn’t support events at all.

Well, thanks for reading. Hope somebody finds it useful.

Available downloads:

This sample add-in was developed using Add-in Express 2008 for Microsoft Office and .net

C# sample Outlook add-in for VS 2005
VB.NET sample Outlook add-in for VS 2005

So, Microsoft Exchange Server can operate with email address types such as Exchange, SMTP, X.400, Microsoft Mail, etc. By default, the Address property of the Mail.Recipient object returns just an Exchange type address, for example this one:

/O=ORGANIZATION_NAME /OU=EXCHANGE_GROUP /CN=RECIPIENTS /CN=USER_NAME

To get other address types, we need to find the recipient in the Outlook address book by using the IAddrBook.ResolveName method, then reach the IMailUser interface with the IAddrBook.OpenEntry method and get the PR_EMS_AB_PROXY_ADDRESSES property. The code below gets the Address property from NameSpace.CurrentUser.AddressEntry, checks the address type and obtains the SMTP address if it is of the Exchange type:

Private Sub CommandBarButton1_Click(ByVal sender As System.Object) _
    Handles CommandBarButton1.Click

    ' Outlook Explorer button
    Dim ns As Outlook._NameSpace = OutlookApp.Session
    If ns IsNot Nothing Then
        Try
            Dim currentUser As Outlook.Recipient = ns.CurrentUser
            If currentUser IsNot Nothing Then
                Try
                    Dim entry As Outlook.AddressEntry = _
                        currentUser.AddressEntry
                    If entry IsNot Nothing Then
                        Try
                            Dim smtpAddress As String = String.Empty
                            ' Exchange address
                            If (entry.Type = "EX") Then
                                smtpAddress = GetSMTPAddress( _
                                    entry.Address)
                            Else
                                smtpAddress = entry.Address
                            End If
                            MessageBox.Show("SMTP Address:" + _
                                Environment.NewLine + _
                                smtpAddress)
                        Finally
                            Marshal.ReleaseComObject(entry)
                        End Try
                    End If
                Finally
                    Marshal.ReleaseComObject(currentUser)
                End Try
            End If
        Finally
            Marshal.ReleaseComObject(ns)
        End Try
    End If
End Sub

I will not publish the whole code of the GetSMTPAddress method right here, because it is rather huge. You can download VB.NET and C# samples with source code, including the declaration of Extended MAPI interfaces, types, tags and properties via the links below.

That’s all for now, have a nice weekend!

Available downloads:

The sample add-ins below were developed on Add-in Express 2009 for Office and .net

C# sample Outlook add-in for VS 2005
VB.NET sample Outlook add-in for VS 2005

Add-in Express has all needed stuff except for the color to fill the background. Firstly, we’ll need the OfficeColorSchemeChanged event handler in which we forcibly change the background of all our custom forms:

Private Sub AddinModule_OfficeColorSchemeChanged( _
    ByVal sender As System.Object, _
    ByVal theme As AddinExpress.MSO.OfficeColorScheme) _
    Handles MyBase.OfficeColorSchemeChanged

    ' Excel task pane
    If Me.HostType = AddinExpress.MSO.ADXOfficeHostApp.ohaExcel Then
        Dim ExcelPane As ADXExcelTaskPane1
        ExcelPane = CType( _
            ExcelTaskPanesCollectionItem.TaskPaneInstance, _
            ADXExcelTaskPane1)
        ExcelPane.DoPaint(theme)
    End If
    ' Outlook forms
    If Me.HostType = AddinExpress.MSO.ADXOfficeHostApp.ohaOutlook Then
        Dim OutlookForm As ADXOlForm1
        Dim I As Integer
        For I = 0 To OlFormsCollectionItem.FormInstanceCount - 1
            OutlookForm = CType( _
                OlFormsCollectionItem.FormInstances(I), _
                ADXOlForm1)
            OutlookForm.DoPaint(theme)
        Next
    End If
End Sub

Secondly, your custom form, or a task pane, needs to be able to paint its background before it shows up:

Private Sub ADXExcelTaskPane1_ADXBeforeTaskPaneShow( _
    ByVal sender As System.Object, _
    ByVal e As AddinExpress.XL.ADXBeforeTaskPaneShowEventArgs) _
    Handles MyBase.ADXBeforeTaskPaneShow

    DoPaint(CType (AddinModule, AddinModule).OfficeColorScheme)
End Sub

Private Sub ADXOlForm1_ADXBeforeFormShow() Handles _
    MyBase.ADXBeforeFormShow

    DoPaint(CType(AddinModule, AddinModule).OfficeColorScheme)
End Sub

And here is the key point – colors:

• Black – &HEBEBEB (0xEBEBEB)
• Blue – &HD5E4F2 (0xD5E4F2)
• Silver – &HEEEEF4 (0xEEEEF4)

Public Sub DoPaint(ByVal theme As _
    AddinExpress.MSO.OfficeColorScheme)

    Select Case theme
        Case AddinExpress.MSO.OfficeColorScheme.Black
            Me.BackColor = Color.FromArgb(&HEB, &HEB, &HEB)
        Case AddinExpress.MSO.OfficeColorScheme.Blue
            Me.BackColor = Color.FromArgb(&HD5, &HE4, &HF2)
        Case AddinExpress.MSO.OfficeColorScheme.Silver
            Me.BackColor = Color.FromArgb(&HEE, &HEE, &HF4)
        Case AddinExpress.MSO.OfficeColorScheme.Unknown
            Me.BackColor = SystemColors.Control
    End Select
End Sub

And that seems to be all! If you have any questions or comments, you are most welcome!

You may also be interested in:

Advanced Outlook form and view regions
Customization of Reading pane, Outlook bar and To-Do bar
Zero visibility for Outlook forms
Outlook forms: minimized, expanded, hidden 

Available downloads:

The sample add-ins below were written using Add-in Express for Office and .net

C# sample Outlook and Excel add-in for VS 2005
VB.NET sample Outlook and Excel add-in for VS 2005

Why does Office Live Add-in replace my menu on Word 2003?

My add-in creates a new item in the main menu of Word 2003. Here’s how it looks like – see My Menu Item in the picture below:

After the first start of the add-in all was fine. The second start of Word, however, made me strain myself, rub my eyes and open them again – just have a look at My Menu Item in this picture:

It took me some time to understand what’s going on before I gathered wits to switch off the Office Live Add-in. We found out that the framework on which the add-in is written doesn’t matter at all, whether it be an Add-in Express based add-in or a “plain shared add-in” (I need to remember this phrase) or a VSTO-based add-in.

Workaround

For the moment, the only solution is to disable the Office Live Add-in.

Applies to

The problem occurs only on Word 2003 (all service packs and updates installed) with Office Live Add-in Update 1.3 installed (OLConnector.dll version is 2.0.2313.0).

What about Add-in Express?

We are yet to find a decent workaround.

“Microsoft Office Excel has stopped working” or how to crash Excel 2007 with the Office Live Add-in step-by-step

• Check out if you have Office Live Add-in Update 1.3. installed.
• Load Visual Studio 2008, create a Windows Forms application.
• Add a reference to Microsoft Excel 12.0 Object Library to your project.
• Add a button to the form and handle it with the following code: 

    Private Sub Button1_Click(ByVal sender As System.Object,_
        ByVal e As System.EventArgs) Handles Button1.Click

        Dim app As Excel.Application = New Excel.Application()
        app.Visible = True
        app.Quit()

    End Sub

• Important! Disable all network connections.
• Important! Unload all Office applications.
• Run the project, click the button.
• And voilà: Microsoft Office Excel has stopped working:

• Click Close program, close the project.
• Start Excel manually and here’s what we get: Excel experienced serious problems with the microsoft office live add-in:

Workaround

It all lies in a nutshell! Just give your processor some time to cool down :)

Private Sub Button1_Click(ByVal sender As System.Object,_
ByVal e As System.EventArgs) Handles Button1.Click

Dim app As Excel.Application = New Excel.Application()
app.Visible = True

System.Threading.Thread.Sleep(1000) ' <=== Workaround!!!

app.Quit()

End Sub

You need to disable the Office Live Add-in if…

Righto, if Dr. Watson reports make you feel giddy, you need to disable the Office Live Add-in :)

Applies to

The problem occurs only on Excel 2007 (without SP, with SP1, with SP2) with Office Live Add-in Update 1.3 installed (OLConnector.dll version is 2.0.2313.0). Well then, no Windows update will help, even despite the fact that Office Live Add-in, Update 1.3 comes as part of Microsoft Optional software update.

What about Add-in Express?

At first sight, the code sample above is of no use at all – it opens and closes Excel straight away. However, this is at first glance only. In fact, a great deal of useful code can be put between New Excel.Application() and app.Quit(). For example, Add-in Express acts exactly according to this model when cleaning up all traces of the add-in when it is being unregistered. And it was unregistration of add-ins when we ran into the problem of Excel 2007 + Office Live Add-in. But that’s not the half of the Office Live Add-in. To be continued…

You may also be interested in:

Creating Excel COM add-in step-by-step
Developing Excel Automation add-in in .net
Building Excel Automation add-ins in Delphi

Earlier, prior to version 2009, I had to unregister my add-in, delete a couple or a few more keys from the registry, and after that register the add-in anew. But by the time of version 2009, my patience had given out and our developers had to strain their efforts to provide an easy and accessible way of resetting the state of all Outlook regions. Note, this works on Add-in Express 2009 only!

Add-in Express 2009 for Office and .net (and VSTO too)

For Add-in Express for .net and Add-in Express for VSTO, to reset all Outlook view and form regions, right click on the Outlook Forms Manager component and select Reset Regions:

Add-in Express 2009 for Office and CodeGear VCL

For Add-in Express for VCL, to reset all Outlook view and form regions, right click on the Outlook Forms Manager component and select Reset Regions:

The RestoreFromMinimizedState property

In version 2009, there appears a new property – RestoreFromMinimizedState. Now I will show you its behavior. Let’s say, we have a minimized by default region, see the picture below:

By default (when RestoreFromMinimizedState = False), when clicking the icon of one of the region’s forms, this form is expanded over the content of the parent window, you can see the form overlaying the content of the Explorer window in the picture below:

As a matter of fact, the minimized Navigation Pane behaves in the same way (though, it allows resizing… hmm… we ought to do this as well :)

If you set RestoreFromMinimizedState to True, then upon clicking an icon of one of the region’s forms, this form is completely restored:

By the way, our task panes have the same property. And this is particularly crucial, for example, for Excel. Say, we have a table like this:

A click on the form’s icon, the form is expanded and overlays not only the active cell and the mouse pointer, but practically the entire table as well. You can see it in this picture:

To avoid this, you simply set the RestoreFromMinimizedState property to True.

Normally, you may need this, for example, to update data only in visible forms / task panes. So, here goes! In our sample add-in, we are going to embed custom forms into the Outlook Explorer and Outlook Inspector windows, two forms into each. In this example, we need to know which of the window types, explorer or inspector, a given form belongs to and somehow identify this form, say, by its caption. All this can be done in the ADXBeforeShow event handler:

Private isExplorer As Boolean = False

Private Sub ADXOlForm1_ADXBeforeFormShow() _
    Handles MyBase.ADXBeforeFormShow

    If Me.Text = "ADXOlForm1" Then
        If Me.ExplorerObj IsNot Nothing Then
            Me.isExplorer = True
            Me.Text = "Explorer Form " + _
             (Me.Item.Collection.IndexOf(Me.Item) - 1).ToString()
        End If
        If Me.InspectorObj IsNot Nothing Then
            Me.isExplorer = False
            Me.Text = "Inspector Form " + _
             (Me.Item.Collection.IndexOf(Me.Item) + 1).ToString()
        End If
    End If
End Sub

We can identify the Outlook region in which your form appears at this very moment using the following code:

Public Function GetFormRegion(ByVal Instance As ADXOlForm) As Object
    If DirectCast(Instance, ADXOlForm1).isExplorer Then
        Return Instance.Item.ExplorerLayout
    End If
    Return Instance.Item.InspectorLayout
End Function

The next question is the form state. To identify the state, I suggest using the following type:

Public Enum FormState
    Focused
    Visible
    InRegion
    InCache
End Enum

And here’s what the terms above mean:

• Focused – Outlook form is visible, active, the focus is on the form.
• Visible – Outlook form is visible.
• InRegion – Outlook form is in the region, but is not visible. It may, e.g. be overlaid with another form, or be in the Minimized or Hidden state.
• InCache – Outlook form is in Cache. A form instance is created by default for each Outlook folder which was opened.

The code below will return us the form state:

Public Function GetFormState(ByVal Instance As ADXOlForm) As FormState
    If Instance.Visible AndAlso _
        Instance.Active AndAlso _
        CheckFocused(Instance) Then
        Return FormState.Focused
    End If
    If Instance.Visible AndAlso Instance.Active Then
        Return FormState.Visible
    End If
    If Instance.Visible Then
        Return FormState.InRegion
    End If
    Return FormState.InCache
End Function

Public Function CheckFocused(ByVal Instance As ADXOlForm) As Boolean
    For I As Integer = 0 To Instance.Controls.Count - 1
        If Instance.Controls(I).Focused Then
            Return True
        End If
    Next I
    Return False
End Function

Now we need to iterate the ADXOlFormsManager.Items collection, get all form instances by using the FormInstances method, then get the form state and the region in which the form is located, and output the result:

Private Sub ButtonCheckForms_Click(ByVal sender As _
    System.Object, ByVal e As System.EventArgs) _
    Handles ButtonCheckForms.Click

    Dim text As String = String.Empty
    Dim I, J As Integer
    For I = 0 To Me.FormsManager.Items.Count - 1
        For J = 0 To Me.FormsManager.Items(I).FormInstanceCount - 1
            Dim form As ADXOlForm = _
                Me.FormsManager.Items(I).FormInstances(J)
            If form IsNot Nothing AndAlso form IsNot Me Then
                text = text + _
                    form.Text + Environment.NewLine + _
                    "State: " + GetFormState(form).ToString() + _
                    Environment.NewLine + _
                    "Region: " + GetFormRegion(form).ToString() + _
                    Environment.NewLine + Environment.NewLine
                DirectCast(form, ADXOlForm1).TextBoxDetails.Clear()
            End If
        Next J
    Next I

    TextBoxDetails.Text = _
        "--- THIS FORM: ---" + Environment.NewLine + _
        Me.Text + Environment.NewLine + _
        "State: " + GetFormState(Me).ToString() + _
        Environment.NewLine + _
        "Region: " + GetFormRegion(Me).ToString() + _
        Environment.NewLine + Environment.NewLine + _
        "--- OTHER FORMS: ---" + Environment.NewLine + _
        text
End Sub

If you have any questions or comments, you are most welcome!

For more information about Advanced Outlook Regions see:
Complete review: Advanced Outlook Regions basics
Complete review: Outlook Explorer and Inspector regions
Complete review: Outlook Regions – cached instancing, exposing events, read and compose

Available downloads:

Note! The samples below are built using generation 2009 of Add-in Express.

C# sample Outlook add-in for VS 2005
VB.NET sample Outlook add-in for VS 2005

Cached instancing

Oh yes, there turned out to be room for the word that has a smell of something lower-level than forms embedded into Outlook. I am speaking about the Cached property of the Outlook Forms Manager component and about creating instances of your forms.

This property and its “mechanics” are described best on the Cached Outlook forms page. I’ll just point out that setting OneInstanceForAllFolders considerably speeds up the work of the add-in and Outlook itself. So, it would be unwise to shrug off this fact.

Outlook events exposed by the Add-in Express Outlook Forms Manager

Besides a number of Outlook events that are quite frequently used in add-in development, e.g. SelectionChange, FolderSwitch and NewInspector, the Add-in Express Outlook Forms Manager component (which is the heart of the Advanced Outlook Regions) exposes several other events inaccessible through the Outlook object model. Here they are:

• NavigationPaneHide, NavigatioPaneShow, NavigationPaneMinimize – these names speak for themselves, don’t they?
• TodoBarHide, TodoBarShow, TodoBarMinimize – names of these events are rather expressive as well.
• ReadingPaneHide, ReadingPaneShow, ReadingPaneMove – hide and show events are easy-to-understand, as to the Move event, I will note that it fires when the Outlook Reading Pane is moved from the bottom to the right and vice versa.

Inspector mode – read and compose

In addition to the earlier existing methods of binding Outlook regions to context (see Context is a brilliant in Advanced Outlook Form and View Regions, part 1), version 2009 allows showing regions separately for read or compose inspector mode. For instance, you can show your regions only when the end-user is editing an e-mail message or reading a received meeting request. However, you should clearly understand which of Outlook items can be opened in this or that mode, and how a given mode is determined. I tried to put all information together in a table, and here’s what I have come up with:

In our today’s VB.NET example (a C# sample is available for download at the bottom of the page), we are going to fill in the DataGridView component, which is located in the Outlook Explorer window, with data by using a background thread. Here’s the code that runs the thread and adds a hundred lines to the DataGridView.Rows collection:

Private Sub startButton_Click(ByVal sender As System.Object, _
  ByVal e As System.EventArgs) Handles startButton.Click
    startButton.Enabled = False
    myThread = New Thread(AddressOf StartThread)
    myThread.Start()
End Sub

Private Sub StartThread()
    SyncLock ThreadRunningObj
        FlagThreadRunning = True
    End SyncLock
    Try
        Dim nameColumn As String
        Dim timeStamp As String
        Dim boolColumn As Boolean = True
        For i As Integer = 1 To 100
            nameColumn = "Record " & i.ToString()
            timeStamp = DateTime.Now.ToString()
            boolColumn = Not boolColumn
            AddRow(nameColumn, timeStamp, boolColumn)
            Thread.Sleep(1000)
            If Not FlagThreadRunning Then
                Exit Try
            End If
        Next
        SetEnabled(True)
    Finally
        SyncLock ThreadRunningObj
            FlagThreadRunning = False
        End SyncLock
    End Try
End Sub

Naturally, besides launching we need to stop the thread. Let’s do it with some stop button:

Private Sub stopButton_Click(ByVal sender As System.Object, _
  ByVal e As System.EventArgs) Handles stopButton.Click
    StopThread()
    startButton.Enabled = True
End Sub

Private Sub StopThread()
    SyncLock ThreadRunningObj
        FlagThreadRunning = False
    End SyncLock
    myThread.Join()
End Sub

One more note. You have to stop the additional thread not only upon clicking the Stop button, but also when closing the host application. In our sample, it should be done in the Dispose method:

Protected Overloads Overrides Sub Dispose( _
  ByVal disposing As Boolean)
    If disposing Then
        If myThread IsNot Nothing Then
            StopThread()
        End If
        If Not (components Is Nothing) Then
            components.Dispose()
        End If
    End If
    MyBase.Dispose(disposing)
End Sub

That’s all for today. If you have any questions or comments, don’t hesitate to post them!

You may also be interested in:

How to create Office COM addin in .net
Build COM add-in for Office 2000 – 2007 in Delphi

Available downloads:

C# sample Outlook add-in for VS 2005
VB.NET sample Outlook add-in for VS 2005
Delphi sample Outlook add-in for Delphi 7

At the very beginning of their history, the Advanced Outlook Regions were totally based on the Microsoft Office 2003 terminology, that is why you may find some discrepancies in the names of the regions supported at that time and in the more recent regions’ names. The point is that in those, in fact, not very old days nobody could fancy that Microsoft would release their version of regions and would call them Outlook form regions. Then two nouns were used in the description of the Outlook windows elements – panes and subpanes. For this reason, beside the pictures I will give the specific name of the region, which is used in the ExplorerLayout and InspectorLayout properties of the Add-in Express Outlook Forms Manager component.

Outlook Explorer regions and Outlook view regions

To denote regions that can be created in the Outlook Explorer window, we use two interchangeable phrases – “Outlook Explorer regions” and “Outlook view regions”, even despite the fact that the View pane (an area containing, for example, a grid with e-mails in mail folders) is just a part of the Outlook Explorer window.

Outlook Inspector regions and Outlook form regions

For regions in the Outlook Inspector window, we employ the same approach and use two interchangeable phrases – “Outlook Inspector regions” and “Outlook form regions”.

Outlook view regions

All regions that you can use in Outlook Explorer windows are grouped together under this common name. However, there is always an opportunity to specify the region more precisely by using the following more accurate names:

• Folder view regions
• Reading pane regions
• To-Do Bar region
• Navigation Pane region
• Outlook bar region
• WebView pane region

You will find more details about each of them below.

Folder view regions

Let’s start with four regions located around the View pane. Here are their names according to the ExplorerLayout property: LeftSubpane, TopSubpane, BottomSubpane, RightSubpane. In these names, you can notice an evident terminology of the Office 2003 times.

In the screenshot above I deliberately hid the Outlook To-Do bar and the Reading pane. Here is what we get if to turn them on:

Don’t you agree that it looks too variegated? I hope nobody is going to use all the four regions in such parrot-like coloring :) And here’s how the most frequently used pattern looks like – in this case the top region includes a folder-specific toolbar:

Reading Pane regions

Regions around the Reading pane are complete analogues of the previously shown regions, they embed forms like this:

These are their names for the ExplorerLayout property: LeftReadingPane, TopReadingPane, BottomReadingPane, RightReadingPane.

To-Do Bar, Navigation Pane and Outlook Bar region

Practically all panes of the Outlook Explorer windows can include regions. Besides the above mentioned regions there are two more: BottomNavigationPane and BottomTodoBar in the ExplorerLayout property (for Outlook 2000 and 2002 there is yet another one – BottomOutlookBar region). You can see these two regions in the following picture:

Both the Outlook Navigation Pane and To-Do Bar (oh yes, and Outlook Bar in Office 2002) can be hidden or minimized. In this case the regions that they contain will be hidden.

WebViewPane region

WebViewPane is the name of one more region from the ExplorerLayout property. The WebViewPane region totally replaces the content of the View pane (the region is based on the folder home pages). The most frequent use of the region is to replace some folder’s view with its form. In principle, when using this solution nothing prevents you from hosting any application into Outlook, allocating its interface into the folders created for this occasion. The best examples of such applications are Outlook Business Contact Manager and Outlook Client for Microsoft CRM.

Outlook form regions

For Outlook Inspector window, you can use any of the four regions available in the InspectorLayout property: LeftSubpane, TopSubpane, BottomSubpane, RightSubpane (their names sprout up from the Outlook 2003 terminology):

Regions and “zero-visibility”

Finally, there are three quite specific regions, which are described separately in Add-in Express 2009, beta 1 - Zero-visibility for Outlook regions, part 2. You will find a couple of interesting pictures there as well :)

BTW, the next post will not have such colorful pictures, enjoy them now :)

So far this technology, which is included in all the three editions of Add-in Express for Office (.net, VCL and VSTO), was presented in the specially dedicated section – Customization of Outlook forms and views, and it is this section that contains the least actual information about our Outlook regions. In addition, you can find something on the pages devoted to a particular edition of Add-in Express for Office:

• Advanced Outlook view and forms regions in Add-in Express for Office and .net
• Outlook-specific features in Add-in Express for Office and VSTO
• Outlook view and form regions in Add-in Express for Office and VCL

Besides that, Andrei depicted the programming side of these regions in corresponding Developer’s Guides. However, all the above mentioned does not give a complete overview of the technology. In fact, a familiarization tour of our Outlook regions should be started with…

What is the Advanced Outlook View and Form Regions?

Formally, I would define them in this way: The Advanced Outlook View and Form Regions is a technology included in all editions of Add-in Express for Office that allows a developer to embed their forms into the Outlook GUI. Informally, I would put it like this: this is what can overthrow your views on building the user interface of your Outlook add-ins. The key point here is to remember that a form is not necessarily something big and “multicontrol”, like Outlook Explorer or the main Outlook Options dialog box. I’m giving a hint! A toolbar is also a form. And a single button with a vivid icon is a toolbar as well… :)

The Advanced Outlook Regions work on Outlook 2000 – 2007

You have just read the most essential note in the heading. This is true – you can use the Advanced Outlook Regions on all Outlook versions starting from Outlook 2000.

Context is a brilliant

One more note before we proceed to pictures. Using the regions, you not only embed your forms into the Outlook GUI, but also bind them to a context. For example, you can bind your forms to one or several folders by their names or type (you can show your form for folders with tasks only). You can also bind your forms to your custom Outlook forms (you are still using custom Outlook forms, aren’t you?) through the message classes on which they are based (see PR_MESSAGE_CLASS in MAPI). In addition, by using the corresponding events this context-sensitivity can be programmed a little (or much) to make binding your forms to context utmost flexible. That’s all, let’s move to the pictures…

Regions as they are

The picture below shows the main Outlook window with one region between the folder view pane and To-Do bar (the latter is minimized).

The region contains an embedded form (I colored it in green) and the region header with several controls. Instead of the green background you can, naturally, place any controls from your collection and even fill them with some data ;-) Well, I am not going to linger round this subject now. As for the header, it is worth dwelling on. The first two buttons with right and left arrows allow quick switching between previous-next forms embedded into the region. A click on the form’s icon (in my case, it is a green-roofed home), on the form’s caption or a down arrow will open a list of all forms contained in the region. To the right of the cross button that customarily closes the current form, there is a button with two right arrows (>>) that allows minimizing the region. I’d also like to draw your attention to the splitter to the left of the region. A double click on it hides the region. In the picture above you see the region in its normal state (there is a special property – DefaultRegionState).

Note! Regions can contain any number of embedded forms, however only one form can be active. For switching between forms you use the following buttons: Previous form, Next form, Show form list.

The next picture shows the same region after clicking on the Minimize button (the Minimized state).

Finally, a double click on the left splitter collapses the region to a few pixels (the Hidden state).

And the final note. You can hide the headers for your regions (we are often asked about that). Though, your end-users will not be able to move your forms between regions.

In my next post I will show you almost all types of regions. Stay tuned!

See also

• Outlook regions zero-visibility, part 1
• Outlook regions zero-visibility, part 2
• Outlook regions and drag-and-drop
• HowTo: Customize Navigation Pane in Outlook 2003 and 2007
• HowTo: Get properties of an Outlook email item drag-and-dropped onto a .NET form

Well, in Outlook 2003 the only thing that the developer can do is to switch the Navigation Pane on and off. Agree, it’s barely sufficient, but that’s the whole of the Outlook 2003 Object model capabilities available for the developer:

Private Sub ButtonVisible_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles ButtonVisible.Click
    If TryCast(ExplorerObj, Outlook._Explorer). _
    IsPaneVisible(Outlook.OlPane.olNavigationPane) Then
        TryCast(ExplorerObj, Outlook._Explorer).ShowPane( _
        Outlook.OlPane.olNavigationPane, False)
        ButtonVisible.Text = "Navigation Pane On"
    Else
        TryCast(ExplorerObj, Outlook._Explorer).ShowPane( _
        Outlook.OlPane.olNavigationPane, True)
        ButtonVisible.Text = "Navigation Pane Off"
    End If
End Sub

In this respect, the Outlook Object Model 2007 offers far more features. Besides the ability to minimize the Navigation pane programmatically, we can switch between navigation modules using the CurrentModule property, manage the folder list in Favorite Folders, create your own groups in all navigation modules except for MailModule module, populate custom NavigationGroup using the NavigationFolders collection.

I am not going to publish the whole code right here, you can download the C# sample and VB.NET sample using the links below. As to the notorious question “How to add a custom button to the bottom of the Navigation Pane?”, the answer is the same as before – there is no way to do it. Even the Outlook 2007 Object Model doesn’t allow this. Probably something will change in the next Microsoft Office version, let’s wait and hope :)

You may also be interested in:

Outlook customization: Reading pane, Outlook bar and To-Do bar
Special features for Outlook plug-in development

Available downloads:

C# sample Outlook add-in for VS 2005
VB.NET sample Outlook add-in for VS 2005