[转]Extending the User Interface in Outlook 2010

本文转自：https://msdn.microsoft.com/en-us/library/office/ee692172%28v=office.14%29.aspx#OfficeOLExtendingUI_ContextMenuforaMailItem

Office 2010

Summary: Learn how to programmatically extend the Microsoft Office Fluent user interface (UI) to customize the UI in Microsoft Outlook 2010. The Fluent UI in Microsoft Office 2010 includes the Office Fluent ribbon, menus, and Microsoft Office Backstage view. This article discusses how to customize the explorer and inspector ribbons, the menus and context menus, and Backstage view in the Outlook 2010 UI. It walks through a code sample that illustrates how to customize the ribbon, the context menus, and Backstage view, and examines specific issues that apply to the Outlook 2010 UI. (47 printed pages)

Last modified: January 30, 2013

Applies to: Office 2010 | Outlook 2010 | Visual Studio

In this article
Overview
Sample Add-In
Ribbon Identifiers
Explorer
Inspector
Folder Context Menu
Root Search Folder Context Menu
Store Context Menu
Context Menu for a Mail Item
Context Menu for Multiple Selected Items
Context Menu for an Appointment or Meeting Request
Context Menu for a Task Item
Context Menu for a Contact Item
Context Menu for a Journal Item
Context Menu for a Note Item
Shortcut Context Menu
Attachment Context Menu
Table View Context Menu
Calendar View Context Menu
Card View Context Menu
Timeline View Context Menu
Menu for the Arrange By Command
Context Menu for Time Bar
Context Menu for Free/Busy Bar
Context Menu for a Table View Column
Categories Context Menu
Context Menu for Quick Flags
Context Menu for Flagged Mail Item
Context Menu for Flagged Contact Item
New Items Menu for Mail Module
New Items Menu for Calendar Module
New Items Menu for Contacts Module
New Items Menu for Tasks Module
New Items Menu for Journal Module
New Items Menu for Notes Module
Persona Context Menu for a Sender or Recipient
Menu for Alternative Interactions
Contextual Tabs
Backstage View
Conclusion
Additional Resources

Published: November 2009 | Updated: April 2010

Provided by: Randy Byrne, Microsoft Corporation

Outlook 2010 Sample: Extending the User Interface

Contents

Overview

This article describes the many new ways that you can programmatically customize the following areas in the Outlook 2010 UI:

Explorer ribbons
Inspector ribbons
Context menus
New item menus
Contact Card context menus
Contextual tabs
Backstage view

Specifically, this article explains how to use Fluent UI extensibility to customize the components in each of those areas. To begin, you must supply XML markup to the GetCustomUI method of the IRibbonExtensibility interface. Use the ribbon ID for the component that you want to customize to determine the XML to pass as a returned value in the GetCustomUI method. Your XML typically supplies callbacks that you can use to respond to a button click, or to control the visibility of your ribbon controls.

This article lists the IRibbonControl.Context property that you should expect in Fluent UI extensibility callbacks in your code. In addition, it includes sample XML markup for each UI component, and a screenshot that illustrates the UI component to help you understand where the customization occurs in the Outlook 2010 UI.

Note
The ribbon IDs and components in this article might change in the final release of Outlook 2010. In some cases, the exact menu items on a menu or context menu depend on the suite of Microsoft Office 2010 installed and the type of Outlook item that is selected.

Before you read this article, you should already have a basic understanding of how to extend the Fluent UI by using an add-in. If you are not familiar with Fluent UI extensibility, see the technical articles listed in the Additional Resources section.

Sample Add-In

This article has an accompanying sample add-in named RibbonXOutlook14AddinCS. It uses Microsoft Visual C# and requires Microsoft Visual Studio 2008 Service Pack 1 and Outlook 2010.

Overview

The sample add-in demonstrates how to customize the ribbons, menus, context menus, and Backstage view in Outlook 2010. Developed in Visual Studio 2008 Tools for Office, the add-in adds ribbon controls, a custom menu, context menu items, and Backstage view controls, and then displays a message box when the user clicks the control or menu item. The add-in provides a visual element for every entry point in the Outlook 2010 UI that you can customize by using Fluent UI extensibility.

The sample add-in has some additional features that illustrate how to manage certain problem areas in the Outlook 2010 UI. For example, suppose that you want to show a custom group in the ribbon for received e-mail items only. The sample add-in displays the custom ribbon tab only when the selected item in the Outlook explorer is a received mail item or when the received mail item is displayed in an inspector. Although that might seem to be a trivial task at first, it is actually a complex problem because Outlook can display multiple explorer or inspector windows, and your code must be able to respond appropriately. For example, in two open explorer windows, you might have to hide the custom tab in the window that has a meeting selected, but display the custom tab in the window that has a received mail item selected. Once you understand how the sample add-in works, you can use the wrapper classes from the sample to build your own solution that can coordinate the display of your command UI in multiple Outlook windows.

Installation Instructions

To download the sample code installation package

Download the OL2010ExtendingtheUserInterface_CS.zip file from Outlook 2010: Extending the User Interface in the MSDN Samples Gallery.
Extract the .zip file into the folder of your choice. In Windows Vista, the default path for Visual Studio 2008 Tools for Office projects is C:\Users\user\Documents\Visual Studio 2008\Projects.

To run the Outlook Ribbon extensibility sample

Close Outlook 2010.
In the folder where you extracted the RibbonXOutlook14AddinCS.zip file, open the RibbonXOutlook14AddinCS solution.
On the Build menu, click Build RibbonXOutlook14AddinCS.
Start Outlook 2010 to start the add-in in run mode, or press F5 to start the add-in in debug mode. If Outlook does not start in debug mode, complete the following procedure.

To start Outlook in debug mode

In Solution Explorer, select RibbonXOutlook14AddinCS.
On the Project menu, select RibbonXOutlook14AddinCS Properties, and then click the Debug tab.
Under Start Action, select the Start External Program option, and then click Browse.
In the [Drive:]\Program Files\Microsoft Office\Office14 folder, select Outlook.exe.
Press F5 to start the add-in in debug mode.

Code Walkthrough

The Outlook14RibbonXAddinCS solution is built with Microsoft Visual Studio 2008 Service Pack 1. It uses manual authoring of XML markup files instead of the ribbon designer that is provided with Visual Studio Tools for Office. The most important architectural feature is the use of wrapper classes (OutlookExplorer.cs for explorers and OutlookInspector.cs for inspectors) to handle multiple Outlook windows. The wrapper classes are implemented by using a C# Generic List(T) class.

Note
If you are not writing managed code, you must write native C++ code that mimics the use of these wrapper classes.

First, the following class-level instance variables are declared in the standard ThisAddin class in Visual Studio 2008 with Visual Studio Tools for Office.

using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms;

using System.Diagnostics;

using Outlook = Microsoft.Office.Interop.Outlook;

using Office = Microsoft.Office.Core;

namespace RibbonXOutlook14AddinCS

{

    public partial class ThisAddIn

    {

        #region Instance Variables

        Outlook.Application m_Application;

        Outlook.Explorers m_Explorers;

        Outlook.Inspectors m_Inspectors;

        public stdole.IPictureDisp m_pictdisp = null;

        // List of tracked explorer windows.

        internal static List<OutlookExplorer> m_Windows;

        // List of traced inspector windows.

        internal static List<OutlookInspector> m_InspectorWindows;

        // Ribbon UI reference.

        internal static Office.IRibbonUI m_Ribbon;

        #endregion

        ...

    }

}

Once the instance variables have been declared, they are used in the Startup method of the ThisAddin class that is provided to all Visual Studio 2008 with Visual Studio Tools for Office add-ins. In the Startup method, which typically occurs when Outlook starts, the code first hooks up an event handler to respond to the NewExplorer event on the Outlook Explorers collection object. After the NewExplorer event has been handled, the active explorer window is added by using the following code.

private void ThisAddIn_Startup(object sender, System.EventArgs e)

{

    // Initialize variables.

    m_Application = this.Application;

    m_Explorers = m_Application.Explorers;

    m_Inspectors = m_Application.Inspectors;

    m_Windows = new List<OutlookExplorer>();

    m_InspectorWindows = new List<OutlookInspector>();

    // Wire up event handlers to handle multiple Explorer windows.

    m_Explorers.NewExplorer +=

        new Outlook.ExplorersEvents_NewExplorerEventHandler(

            m_Explorers_NewExplorer);

    // Wire up event handler to handle multiple Inspector windows.

    m_Inspectors.NewInspector +=

        new Outlook.InspectorsEvents_NewInspectorEventHandler(

            m_Inspectors_NewInspector);

    // Add the ActiveExplorer to m_Windows.

    Outlook.Explorer expl = m_Application.ActiveExplorer()

        as Outlook.Explorer;

    OutlookExplorer window = new OutlookExplorer(expl);

    m_Windows.Add(window);

    // Hook up event handlers for window.

    window.Close += new EventHandler(WrappedWindow_Close);

    window.InvalidateControl += new EventHandler<

        OutlookExplorer.InvalidateEventArgs>(

        WrappedWindow_InvalidateControl);

    // Get IPictureDisp for CurrentUser on startup.

    try

    {

        Outlook.AddressEntry addrEntry =

            Globals.ThisAddIn.Application.Session.CurrentUser.AddressEntry;

        if (addrEntry.Type == "EX")

        {

            Outlook.ExchangeUser exchUser =

                addrEntry.GetExchangeUser() as Outlook.ExchangeUser;

            m_pictdisp = exchUser.GetPicture() as stdole.IPictureDisp;

        }

    }

    catch (Exception ex)

    {

        // Write exception to debug window.

        Debug.WriteLine(ex.Message);

    }

}

Just after Outlook starts, Office calls GetCustomUI. GetCustomUI is the method of the IRibbonExtensibility interface that loads custom XML markup. In Outlook 2007, Office called GetCustomUI when the first instance of a given inspector type, such as a contact or appointment, was displayed. In Outlook 2010, Office calls GetCustomUI before the ThisAddin.Startup method to accommodate the loading of ribbon customizations for the Outlook explorer ribbon. Because Office calls GetCustomUI only once for the first Outlook explorer during startup and multiple times for the first instance of multiple inspector types, consider using a Switch statement to control loading of XML markup for different customized Ribbons. For each ribbon in Outlook, GetCustomUI is called and Office passes the ribbon ID string that identifies the ribbon that is being loaded in Outlook. For a complete listing of ribbon IDs, see the section Ribbon Identifiers.

In the sample code, there are three XML markup files:

ContactCard.xml
Explorer.xml
ReadMail.xml

ContactCard.xml contains XML markup for context menus on the Contact Card. Explorer.xml contains XML markup for the explorer ribbon, context menus, and Backstage view. Readmail.xml contains XML markup for a read mail inspector.

To get a better idea of how this technique works, examine the following code from the GetCustomUI method in the OutlookRibbonXclass.

public string GetCustomUI(string ribbonID)

{

    string customUI = string.Empty;

    Debug.WriteLine(ribbonID);

    // Return the appropriate XML markup for ribbonID.

    switch (ribbonID)

    {

        case "Microsoft.Outlook.Explorer":

            customUI = GetResourceText(

                "RibbonXOutlook14AddinCS.Explorer.xml");

            return customUI;

        case "Microsoft.Outlook.Mail.Read":

            customUI= GetResourceText(

                "RibbonXOutlook14AddinCS.ReadMail.xml");

            return customUI;

        case "Microsoft.Mso.IMLayerUI":

            customUI = GetResourceText(

                "RibbonXOutlook14AddinCS.ContactCard.xml");

            return customUI;

        default:

            return string.Empty;

    }

}

Take a look at the sample solution for a complete listing of ContactCard.xml, Explorer.xml, and ReadMail.xml. Once custom XML markup has been loaded for each add-in, it is time to write code in Fluent UI extensibility callbacks to hide and show the tab named MyTab, depending on whether the selected item in the explorer is a received mail item. To complete the scenario, you must hook up another set of events in the constructor of the OutlookExplorer class.

public OutlookExplorer(Outlook.Explorer explorer)

{

    m_Window = explorer;

    // Hook up Close event.

    ((Outlook.ExplorerEvents_Event)explorer).Close +=

        new Outlook.ExplorerEvents_CloseEventHandler(

        OutlookExplorerWindow_Close);

    // Hook up SelectionChange event.

    m_Window.SelectionChange +=

        new Outlook.ExplorerEvents_10_SelectionChangeEventHandler(

        m_Window_SelectionChange);

}

The SelectionChange event handler is very straightforward. The SelectionChange event occurs whenever the user changes the selection in an explorer window. When SelectionChange occurs, the RaiseInvalidateControl method is called and the control ID "MyTab" is passed to the method. RaiseInvalidateControl calls an event delegate named WrappedWindow_InvalidateControl in the ThisAddin class.

private void m_Window_SelectionChange()

{

    RaiseInvalidateControl("MyTab");

}

void WrappedWindow_InvalidateControl(object sender,

    OutlookExplorer.InvalidateEventArgs e)

{

    if (m_Ribbon != null)

    {

        m_Ribbon.InvalidateControl(e.ControlID);

    }

}

The m_Ribbon variable represents an IRibbonUI object. When the InvalidateControl method of the IRibbonUI object is called, ribbon callbacks occur for the "MyTab" control. You could also call the Invalidate method of IRibbonUI, but that method causes callbacks for all of the controls that your add-in adds to the ribbon. In general, make your invalidation more granular than global, especially when your callbacks load image resources with a getImage callback. For the "MyTab" control, a getVisible callback has been defined in the RibbonXAddin class that controls the visibility of the tab. If the getVisible callback returns True, the tab is visible; otherwise, "MyTab" is hidden. The following code is the MyTab_GetVisible callback in its entirety.

// Only show MyTab when explorer selection is

// a received mail or when inspector is a read note.

public bool MyTab_GetVisible(Office.IRibbonControl control)

{

    if (control.Context is Outlook.Explorer)

    {

        Outlook.Explorer explorer =

            control.Context as Outlook.Explorer;

        Outlook.Selection selection = explorer.Selection;

        if (selection.Count == 1)

        {

            if (selection[1] is Outlook.MailItem)

            {

                Outlook.MailItem oMail =

                    selection[1] as Outlook.MailItem;

                if (oMail.Sent == true)

                {

                    return true;

                }

                else

                {

                    return false;

                }

            }

            else

            {

                return false;

            }

        }

        else

        {

            return false;

        }

    }

    else if (control.Context is Outlook.Inspector)

    {

        Outlook.Inspector oInsp =

            control.Context as Outlook.Inspector;

        if (oInsp.CurrentItem is Outlook.MailItem)

        {

            Outlook.MailItem oMail =

                oInsp.CurrentItem as Outlook.MailItem;

            if (oMail.Sent == true)

            {

                return true;

            }

            else

            {

                return false;

            }

        }

        else

        {

            return false;

        }

    }

    else

    {

        return true;

    }

}

This walkthrough detailed the most important strategies for extending the ribbon in Outlook 2010. In summary, your code should support the following:

The use of multiple explorer or inspector windows in Outlook 2010. Wrap the windows in a separate class instance that can raise events appropriate to that specific window.
The appropriate use of the InvalidateControl or Invalidate methods of the IRibbonUI interface to cause callbacks to occur.
The evaluation of different item types (based on the message class, built-in properties, or custom properties of a specific item type) in both event handlers and ribbon callbacks.

Ribbon Identifiers

The following table lists the ribbon IDs that are passed to the GetCustomUI method of the IRibbonExtensibility interface. Use the ribbon ID to determine the XML to return in the GetCustomUI method.

Table 1. Ribbon IDs and Message Class

Ribbon ID	Message class
Microsoft.OMS.MMS.Compose	IPM.Note.Mobile.MMS.*
Microsoft.OMS.MMS.Read	IPM.Note.Mobile.MMS.*
Microsoft.OMS.SMS.Compose	IPM.Note.Mobile.SMS.*
Microsoft.OMS.SMS.Read	IPM.Note.Mobile.SMS.*
Microsoft.Outlook.Appointment	IPM.Appointment.*
Microsoft.Outlook.Contact	IPM.Contact.*
Microsoft.Outlook.DistributionList	IPM.DistList.*
Microsoft.Outlook.Journal	IPM.Activity.*
Microsoft.Outlook.Mail.Compose	IPM.Note.*
Microsoft.Outlook.Mail.Read	IPM.Note.*
Microsoft.Outlook.MeetingRequest.Read	IPM.Schedule.Meeting.Request or IPM.Schedule.Meeting.Canceled
Microsoft.Outlook.MeetingRequest.Send	IPM.Schedule.Meeting.Request
Microsoft.Outlook.Post.Compose	IPM.Post.*
Microsoft.Outlook.Post.Read	IPM.Post.*
Microsoft.Outlook.Report	IPM.Report.*
Microsoft.Outlook.Resend	IPM.Resend.*
Microsoft.Outlook.Response.Compose	IPM.Schedule.Meeting.Resp.*
Microsoft.Outlook.Response.CounterPropose	IPM.Schedule.Meeting.Resp.*
Microsoft.Outlook.Response.Read	IPM.Schedule.Meeting.Resp.*
Microsoft.Outlook.RSS	IPM.Post.Rss.*
Microsoft.Outlook.Sharing.Compose	IPM.Sharing.*
Microsoft.Outlook.Sharing.Read	IPM.Sharing.*
Microsoft.Outlook.Task	IPM.Task.* and IPM.TaskRequest.*
Microsoft.Outlook.Explorer	Not applicable. Use this ribbon ID to return XML markup for explorer ribbons, context menus, and Backstage view.

Explorer

Ribbon ID

Microsoft.Outlook.Explorer

IRibbonControl.Context

Explorer object

Remarks

When Outlook 2010 starts, it calls the GetCustomUI method of the IRibbonExtensibility interface and specifies the ribbon ID in the RibbonID parameter for the add-in. The add-in should implement the GetCustomUI method such that if RibbonID is Microsoft.Outlook.Explorer, GetCustomUI returns the XML markup for explorer and context menu customizations.

[转]Extending the User Interface in Outlook 2010

Overview

Installation Instructions

Code Walkthrough

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID

IRibbonControl.Context

Remarks

XML Markup Example

User Interface Example

Ribbon ID