Demonstra Passo a passo: A atualização de controles em uma faixa de opções em tempo de execução

Artigo
08/08/2011

Esta explicação passo a passo demonstra como usar o modelo de objeto de faixa de opções para atualizar os controles em uma faixa de opções, depois que a faixa de opções é carregada no aplicativo do Office.

Aplicável a: As informações neste tópico se aplicam a projetos de nível de documento e projetos de nível de aplicativo para os seguintes aplicativos: Excel 2007 e Excel 2010; InfoPath 2010; Outlook 2007 e Outlook 2010; PowerPoint 2007 e PowerPoint 2010; Project 2010; Visio 2010; Word 2007 e Word 2010. Para obter mais informações, consulte Recursos disponíveis pelo aplicativo do Office e o tipo de projeto.

O exemplo extrai os dados do banco de dados de exemplo Northwind para preencher uma caixa de combinação e um menu de Microsoft Office Outlook. Os itens que você selecionar nesses controles automaticamente preencher os campos, como para e assunto em uma mensagem de email.

This walkthrough illustrates the following tasks:

Criando um novo Outlook suplemento do projeto.
Criando um grupo de faixa de opções personalizado.
Adicionando o grupo personalizado para a guia interna.
Atualizando os controles da faixa de opções em tempo de execução.

Observação
Your computer might show different names or locations for some of the Visual Studio user interface elements in the following instructions. The Visual Studio edition that you have and the settings that you use determine these elements. For more information, see Trabalhando com configurações.

Pré-requisitos

You need the following components to complete this walkthrough:

Uma edição do Visual Studio 2010 que inclua as ferramentas de desenvolvedor do Microsoft Office. Para obter mais informações, consulte [Configurando um computador para desenvolver soluções do Office](bb398242\(v=vs.100\).md).

Microsoft Office Outlook 2007 ouMicrosoft Outlook 2010

Criar um novo Outlook suplemento do projeto

Primeiro, crie um projeto de suplemento do Outlook.

Para criar um novo Outlook suplemento do projeto

Em Visual Studio, criar um Outlook 2007 ou Outlook 2010 projeto de suplemento com o nome Ribbon_Update_At_Runtime.
No Novo projeto caixa de diálogo, selecione Create directory for solution.
Salve o projeto para o diretório de projeto padrão.

For more information, see Como: Criar projetos do Office em Visual Studio.

A criação de um grupo de faixa de opções personalizada

A faixa de opções para esse exemplo será exibido quando um usuário compõe uma nova mensagem de email. Para criar um grupo personalizado para a faixa de opções, primeiro adicione um item de faixa de opções ao seu projeto e, em seguida, o grupo no Designer de faixa de opções de design. Este grupo personalizado irá ajudá-lo a gerar mensagens de email de acompanhamento de clientes, puxando os nomes e históricos de um banco de dados do pedido.

Para criar um grupo personalizado

On the Project menu, click Add New Item.
No Add New Item caixa de diálogo, selecione a faixa de opções (Visual Designer).
Alterar o nome da nova faixa de opções para CustomerRibbone em seguida, clique em Add.

O CustomerRibbon.cs ou CustomerRibbon.vb abre no Designer de faixa de opções de arquivo e exibe uma guia de padrão e o grupo.
Clique em Designer de faixa de opções para selecioná-lo.
No Propriedades janela, clique na seta suspensa ao lado do RibbonType propriedade e clique Microsoft.Outlook.Mail.Compose.

Isso permite que a faixa de opções que aparecem quando o usuário compõe uma nova mensagem de email no Outlook.
No Designer de faixa de opções, clique em Grupo1 para selecioná-lo.
No Propriedades janela, defina rótulo aquisições do cliente.
Do Controles de faixa de opções do Office guia da Toolbox, arraste um ComboBox até o Compras do cliente grupo.
Clique em ComboBox1 para selecioná-lo.
No Propriedades janela, defina rótulo aos clientes.
Do Controles de faixa de opções do Office guia da Toolbox, arraste um Menu até o Compras do cliente grupo.
No Propriedades janela, defina rótulo para o produto adquirido.
Set Dynamic to true.

Isso lhe permite adicionar e remover os controles no menu em tempo de execução após a faixa de opções é carregada no aplicativo do Office.

Adicionando o grupo personalizado para a guia interna

Uma guia interna é um que já está na faixa de um Outlook Explorer ou Inspetor. Esse procedimento, você adiciona o grupo personalizado para a guia interna e, em seguida, especifique a posição do grupo personalizado na guia.

Para adicionar o grupo personalizado para a guia interna

Clique na TabAddins (interno) guia para selecioná-lo.
No Propriedades janela, expanda o ControlId propriedade e defina OfficeId para TabNewMailMessage.

Isso adiciona o Compras do cliente grupo para o mensagens guia da faixa de opções que aparece em uma nova mensagem de email.
Clique o Compras do cliente o grupo para selecioná-lo.
No Propriedades janela, expandir o posição propriedade, clique na seta suspensa ao lado do PositionType propriedade e clique BeforeOfficeId.
Definir o OfficeId propriedade para GroupClipBoard.

Isso posiciona a Compras do cliente grupo antes de área de transferência grupo da mensagens guia.

Creating the Data Source

Use o Fontes de dados janela para adicionar um dataset tipado ao seu projeto.

To create the data source

On the Data menu, click Add New Data Source.

Isso inicia o Data Source Configuration Wizard.
Selecione banco de dadose em seguida, clique em próximo.
Selecione Datasete em seguida, clique em próximo.
Selecione uma conexão de dados no banco de dados do Microsoft SQL Server Compact 3.5 de exemplo Northwind ou adicionar uma nova conexão usando o Nova conexão botão.
Depois de uma conexão foi selecionada ou criada, clique em próximo.
Clique em próximo para salvar a seqüência de conexão.
Sobre o Escolha seus objetos de banco de dados de página, expanda tabelas.
Selecione a caixa de seleção ao lado de cada uma das seguintes tabelas:
1. Clientes
2. Detalhes do pedido
3. Pedidos
4. Produtos
Click Finish.

A atualização de controles do grupo personalizado em tempo de execução

Use o modelo de objeto de faixa de opções para realizar as seguintes tarefas:

Adicionar nomes de cliente para o os clientes caixa de combinação.
Adicionar controles de menu e botão para o Produtos adquiridos menu que representam as ordens de venda e de produtos vendidos.
Preencher o To, Subject, e Body campos de novas mensagens de email usando dados da os clientes caixa de combinação e Produtos adquiridos menu.

Para atualizar os controles no grupo personalizado usando o modelo de objeto de faixa de opções

On the Project menu, click Add Reference.
No Add Reference caixa de diálogo, clique no .NET guia, selecione o System.Data.Linq assembly e clique OK.

Este assembly contém classes para uso integrada de consultas (LINQ). Você irá usar o LINQ para preencher os controles do grupo personalizado com dados do banco de dados Northwind.
Em Solution Explorer, clique em CustomerRibbon.cs ou CustomerRibbon.vb para selecioná-lo.
Sobre o Exibir menu, clique em código.

O arquivo de código da faixa de opções é aberta no Editor de código.

Adicione as seguintes instruções para a parte superior do arquivo de código da faixa de opções. Estas instruções fornecem acesso fácil para namespaces do LINQ e o namespace da assembly de interoperabilidade primária (PIA) do Outlook.

Imports System.Data.Linq
Imports System.Linq
Imports System.Data.Linq.Mapping
Imports System.Linq.Expressions
Imports Outlook = Microsoft.Office.Interop.Outlook
Imports Ribbon_Update_At_Runtime.NorthwindDataSetTableAdapters

using System.Data.Linq;
using System.Linq;
using System.Data.Linq.Mapping;
using System.Linq.Expressions;
using Outlook = Microsoft.Office.Interop.Outlook;
using System.Data;
using System.IO;
using Ribbon_Update_At_Runtime.NorthwindDataSetTableAdapters;

Adicione o seguinte código dentro da classe CustomerRibbon. Esse código declara a tabela de dados e adaptadores de tabela que será usado para armazenar informações do cliente, pedidos, detalhes do pedido e produtos tabelas do banco de dados Northwind.

    'Declare the Northwind data set.

    Dim nwDataSet As NorthwindDataSet = New NorthwindDataSet()

    'Declare the data tables.

    Dim customerTable As NorthwindDataSet.CustomersDataTable
    Dim orderTable As NorthwindDataSet.OrdersDataTable
    Dim orderDetailsTable As NorthwindDataSet.Order_DetailsDataTable
    Dim productsTable As NorthwindDataSet.ProductsDataTable

    'Declare the data table adapters for each table.

    Dim customersTableAdapter As CustomersTableAdapter = New CustomersTableAdapter()
    Dim ordersTableAdapter As OrdersTableAdapter = New OrdersTableAdapter()
    Dim detailsTableAdapter As Order_DetailsTableAdapter = New Order_DetailsTableAdapter()
    Dim productsTableAdapter As ProductsTableAdapter = New ProductsTableAdapter()

//Declare the Northwind dataset.
NorthwindDataSet nwDataSet = new NorthwindDataSet();

//Declare the data tables.

NorthwindDataSet.CustomersDataTable customerTable;
NorthwindDataSet.OrdersDataTable orderTable;
NorthwindDataSet.Order_DetailsDataTable orderDetailsTable;
NorthwindDataSet.ProductsDataTable productsTable;

//Declare the data table adapters for each table.

CustomersTableAdapter customerTableAdapter = new CustomersTableAdapter();
OrdersTableAdapter ordersTableAdapter = new OrdersTableAdapter();
Order_DetailsTableAdapter detailsTableAdapter = new Order_DetailsTableAdapter();
ProductsTableAdapter productsTableAdapter = new ProductsTableAdapter();

Adicione um dos seguintes blocos de código para o CustomerRibbon classe. Este código adiciona três métodos auxiliares que criar controles para a faixa de opções em tempo de execução.

Se os destinos do projeto de .NET Framework 4, adicione o código a seguir.


Private Function CreateRibbonDropDownItem() As RibbonDropDownItem
    Return Me.Factory.CreateRibbonDropDownItem()
End Function

Private Function CreateRibbonMenu() As RibbonMenu
    Return Me.Factory.CreateRibbonMenu()
End Function

Private Function CreateRibbonButton() As RibbonButton
    Dim button As RibbonButton = Me.Factory.CreateRibbonButton()
    AddHandler (button.Click), AddressOf Button_Click
    Return button
End Function

private RibbonDropDownItem CreateRibbonDropDownItem()
{
    return this.Factory.CreateRibbonDropDownItem();
}
private RibbonMenu CreateRibbonMenu()
{
    return this.Factory.CreateRibbonMenu();
}
private RibbonButton CreateRibbonButton()
{
    RibbonButton button = this.Factory.CreateRibbonButton();
    button.Click += new RibbonControlEventHandler(button_Click);
    return button;
}

Se os destinos do projeto a.NET Framework 3.5, adicione o seguinte código.


Private Function CreateRibbonDropDownItem() As RibbonDropDownItem
    Return New RibbonDropDownItem()
End Function

Private Function CreateRibbonMenu() As RibbonMenu
    Return New RibbonMenu()
End Function

Private Function CreateRibbonButton() As RibbonButton
    Dim button As RibbonButton = New RibbonButton()
    AddHandler (button.Click), AddressOf Button_Click
    Return button
End Function

private RibbonDropDownItem CreateRibbonDropDownItem()
{
    return new RibbonDropDownItem();
}
private RibbonMenu CreateRibbonMenu()
{
    return new RibbonMenu();
}
private RibbonButton CreateRibbonButton()
{
    RibbonButton button = new RibbonButton();
    button.Click += new EventHandler<RibbonControlEventArgs>(button_Click);
    return button;
}

Substituir o CustomerRibbon_Load o método de manipulador de eventos com o código a seguir. Esse código usa uma consulta LINQ para realizar as seguintes tarefas:

Preencher o os clientes caixa de combinação usando o ID e o nome de 20 clientes no banco de dados Northwind.
Chamadas de PopulateSalesOrderInfo auxiliar método. Esse método atualiza o ProductsPurchased menu com os números de ordem de venda que pertencem ao cliente selecionado no momento.

    Private Sub CustomerRibbon_Load(ByVal sender As System.Object, _
   ByVal e As Microsoft.Office.Tools.Ribbon.RibbonUIEventArgs) _
       Handles MyBase.Load

        customerTable = nwDataSet.Customers
        customersTableAdapter.Fill(customerTable)

        Dim customerQuery = From customers In customerTable.AsEnumerable.Take(20) _
                Select CustomerID = customers.Customer_ID, _
                CustomerName = customers.Contact_Name

        ' Execute the query.
        For Each item In customerQuery
            Me.ComboBox1.Items.Add(CreateRibbonDropDownItem())

            Me.ComboBox1.Items.Last().Label = item.CustomerID.ToString() _
                + "|" + item.CustomerName
        Next item

        Me.ComboBox1.Text = Me.ComboBox1.Items.First().Label
        PopulateSalesOrderInfo()
    End Sub

private void CustomerRibbon_Load(object sender, RibbonUIEventArgs e)
{
    customerTable = nwDataSet.Customers;
    customerTableAdapter.Fill(customerTable);

    var customerQuery = from customers in customerTable.AsEnumerable().Take(20)
                        select new
                        {
                            CustomerID = customers.Field<string>("Customer ID"),
                            CustomerName = customers.Field<string>("Contact Name")
                        };


    // Execute the query.
    foreach (var item in customerQuery)
    {
        this.comboBox1.Items.Add(CreateRibbonDropDownItem());
        this.comboBox1.Items.Last().Label =
        item.CustomerName + "|" + item.CustomerID.ToString();
    }
    this.comboBox1.Text = this.comboBox1.Items.First().Label;
    PopulateSalesOrderInfo();
}

Add the following code to the CustomerRibbon class. Esse código usa consultas LINQ para realizar as seguintes tarefas:

Adiciona um submenu para o ProductsPurchased menu para cada ordem de venda relacionadas ao cliente selecionado.
Adiciona botões para cada submenu para os produtos relacionados à ordem de venda.
Adiciona manipuladores de eventos para cada botão.

Private Sub PopulateSalesOrderInfo()

    Dim tempArray As [String]() = comboBox1.Text.Split(New [Char]() {"|"c})
    Menu1.Items.Clear()

    orderTable = nwDataSet.Orders
    orderDetailsTable = nwDataSet.Order_Details
    productsTable = nwDataSet.Products

    ordersTableAdapter.Fill(orderTable)
    detailsTableAdapter.Fill(orderDetailsTable)
    productsTableAdapter.Fill(productsTable)

    Dim orderQuery = From order In orderTable.AsEnumerable() _
                     Where order.Customer_ID.ToString() = tempArray(0) _
                     Select New With {.SalesOrderID = order.Order_ID}

    For Each orderItem In orderQuery
        Me.Menu1.Items.Add(CreateRibbonMenu())

        Dim orderMenu As RibbonMenu = CType(Menu1.Items.Last(), RibbonMenu)
        orderMenu.Dynamic = True
        orderMenu.Label = orderItem.SalesOrderID.ToString()
        orderMenu.Tag = orderItem.SalesOrderID

        Dim productQuery = From orderDetail In orderDetailsTable.AsEnumerable(), _
                               product In productsTable.AsEnumerable() _
                           Where orderDetail.Product_ID = _
                               product.Product_ID _
                           And orderDetail.Order_ID = _
                           orderMenu.Tag _
        Select productName = product.Product_Name

        For Each productItem In productQuery
            Dim button As RibbonButton = CreateRibbonButton()
            button.Label = productItem
            orderMenu.Items.Add(button)
        Next productItem
    Next orderItem
End Sub

private void PopulateSalesOrderInfo()
{
    String[] tempArray = comboBox1.Text.Split(new Char[] { '|' });
    menu1.Items.Clear();

    orderTable = nwDataSet.Orders;
    orderDetailsTable = nwDataSet.Order_Details;
    productsTable = nwDataSet.Products;

    ordersTableAdapter.Fill(orderTable);
    detailsTableAdapter.Fill(orderDetailsTable);
    productsTableAdapter.Fill(productsTable);

    var orderQuery = from orders in orderTable.AsEnumerable()
                     where orders.Field<string>("Customer ID") == tempArray[1]
                     select new { OrderID = orders.Field<int>("Order ID") };

    foreach (var orderItem in orderQuery)
    {
        menu1.Items.Add(CreateRibbonMenu());

        RibbonMenu orderMenu = (RibbonMenu)menu1.Items.Last();
        orderMenu.Dynamic = true;
        orderMenu.Label = orderItem.OrderID.ToString();
        orderMenu.Tag = orderItem.OrderID;

        var productQuery = from orderDetail in orderDetailsTable.AsEnumerable()
                           join product in productsTable.AsEnumerable() on
                               orderDetail.Field<int>("Product ID")
                           equals product.Field<int>("Product ID")
                           where orderDetail.Field<int>("Order ID") ==
                               orderItem.OrderID
                           select new { ProductName = product.Field<string>("Product Name") };

        foreach (var productItem in productQuery)
        {
            RibbonButton button = CreateRibbonButton();
            button.Label = productItem.ProductName;
            orderMenu.Items.Add(button);
        }
    }
}

Em Solution Explorer, duas vezes no arquivo de código da faixa de opções.

O Designer de faixa de opções é aberto.
No Designer de faixa de opções, clique duas vezes o os clientes caixa de combinação.

O arquivo de código da faixa de opções é aberta no Editor de código e o ComboBox1_TextChanged aparece de manipulador de eventos.
Substituir o ComboBox1_TextChanged o manipulador de eventos com o código a seguir. Esse código realiza as seguintes tarefas:
- Chamadas de PopulateSalesOrderInfo auxiliar método. Esse método atualiza o Produtos adquiridos menu com as ordens de venda se relacionam com o cliente selecionado.
- Chamadas de PopulateMailItem método auxiliar e passagens do texto atual, que é o nome do cliente selecionado. Este método popula a To, Subject, e Body campos de novas mensagens de email.
```
Private Sub ComboBox1_TextChanged(ByVal sender As System.Object, _
    ByVal e As Microsoft.Office.Tools.Ribbon.RibbonControlEventArgs) _
        Handles ComboBox1.TextChanged
    PopulateSalesOrderInfo()
    PopulateMailItem(ComboBox1.Text)
End Sub
```
```
private void comboBox1_TextChanged(object sender,
    RibbonControlEventArgs e)
{
    PopulateSalesOrderInfo();
    PopulateMailItem(comboBox1.Text);
}
```

Adicionar o clique seguinte manipulador de eventos para o CustomerRibbon classe. Este código adiciona o nome de produtos selecionados para o Body campo novas mensagens de email.

Private Sub Button_Click(ByVal sender As System.Object, _
    ByVal e As Microsoft.Office.Tools.Ribbon.RibbonControlEventArgs)
    Dim application As Outlook.Application = Globals.ThisAddIn.Application
    Dim inspector As Outlook.Inspector = application.ActiveInspector()
    Dim myMailItem As Outlook.MailItem = CType(inspector.CurrentItem,  _
        Outlook.MailItem)
    Dim myButton As RibbonButton = CType(sender, RibbonButton)
    myMailItem.Subject = "Following up on your order"
    myMailItem.Body = myMailItem.Body + ControlChars.Lf + "* " _
        + myButton.Label
End Sub

void button_Click(object sender, RibbonControlEventArgs e)
{
    Outlook.Application application = Globals.ThisAddIn.Application;
    Outlook.Inspector inspector = application.ActiveInspector();
    Outlook.MailItem myMailItem = (Outlook.MailItem)inspector.CurrentItem;
    RibbonButton myCheckBox = (RibbonButton)sender;
    myMailItem.Subject = "Following up on your order";
    myMailItem.Body = myMailItem.Body + "\n" + "* " + myCheckBox.Label;
}

Add the following code to the CustomerRibbon class. Esse código realiza as seguintes tarefas:

Preenche o To a linha de novas mensagens de email usando o endereço de email do cliente selecionado no momento.
Adiciona o texto para o Subject e Body campos de novas mensagens de email.

Private Sub PopulateMailItem(ByVal addressToLine As String)
    Dim application As Outlook.Application = Globals.ThisAddIn.Application
    Dim inspector As Outlook.Inspector = application.ActiveInspector()
    Dim myMailItem As Outlook.MailItem = _
        CType(inspector.CurrentItem, Outlook.MailItem)

    myMailItem.To = ""
    Dim tempArray As [String]() = addressToLine.Split(New [Char]() {"|"c})
    myMailItem.To = tempArray(1) + "@example.com"
    myMailItem.Subject = "Following up on your order"
    myMailItem.Body = "Hello " + tempArray(1) + "," _
        + ControlChars.Lf + "We would like to get your feedback" + _
        "on the following products that you recently ordered: "
End Sub

private void PopulateMailItem(string addressToLine)
{
    Outlook.Application application = Globals.ThisAddIn.Application;
    Outlook.Inspector inspector = application.ActiveInspector();
    Outlook.MailItem myMailItem = (Outlook.MailItem)inspector.CurrentItem;

    myMailItem.To = "";
    String[] tempArray = addressToLine.Split(new Char[] { '|' });
    myMailItem.To = tempArray[0] + "@example.com";
    myMailItem.Subject = "Following up on your order";
    myMailItem.Body = "Hello " + tempArray[0] + "," +
        "\n" + "We would like to get your feedback on the " +
        "following products that you recently ordered: ";
}

Teste os controles no grupo personalizado

Quando você abre um novo formulário de email no Outlook, um grupo personalizado chamado Compras do cliente aparece na mensagens guia da faixa de opções.

Para criar uma mensagem de email de acompanhamento do cliente, selecione um cliente e, em seguida, selecione os produtos adquiridos pelo cliente. Os controles de Compras do cliente grupo são atualizadas em tempo de execução com dados do banco de dados Northwind.

Para testar os controles no grupo personalizado

Pressione F5 para executar seu projeto.

Inicia o Outlook.
No Outlook, no arquivo , aponte para novae em seguida, clique em Mensagem de correio.

As seguintes ações ocorrerão:
- Uma nova janela de Inspetor de mensagens de email é exibida.
- No mensagem guia da faixa de opções, o Compras do cliente grupo aparece antes do área de transferência grupo.
- O os clientes caixa de combinação do grupo é atualizada com os nomes dos clientes no banco de dados Northwind.
No mensagem guia da faixa de opções, no Compras do cliente grupo, selecione um cliente da os clientes caixa de combinação.

As seguintes ações ocorrerão:
- O Produtos adquiridos menu é atualizada para mostrar cada ordem de venda para o cliente selecionado.
- Cada submenu ordem de venda é atualizada para mostrar os produtos adquiridos nessa ordem.
- Endereço de email do cliente selecionado é adicionado para o para a linha da mensagem de email e o assunto e corpo da mensagem de email são preenchidas com texto.
Clique o As compras de produtos menu, aponte para ordem de venda e, em seguida, clique em um produto da ordem de venda.

O nome do produto é adicionado ao corpo da mensagem de correio.

Próximas etapas

Você pode aprender mais sobre como personalizar a interface do Office com estes tópicos:

Adicione a interface do usuário baseada em contexto qualquer personalização de nível de documento. For more information, see Visão geral painel Ações.
Estenda um formulário de Microsoft Office Outlook de padrão ou personalizado. For more information, see Demonstra Passo a passo: A criação de uma região de formulário do Outlook.
Adicione um painel de tarefas personalizado ao Outlook. For more information, see Visão geral sobre painéis de tarefas personalizado.

Consulte também

Partilhar via