Passo a passo: Atualizar os controles em uma faixa de opções em tempo de execução

Artigo
02/25/2013

Essa explicação passo a passo demonstra como usar o modelo de objeto de fita para atualizar os controles em uma fita após a fita é 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 2013 e Excel 2010; InfoPath 2013 e InfoPath 2010; Outlook 2013 e Outlook 2010; PowerPoint 2013 e PowerPoint 2010; Project 2013 e Project 2010; Visio 2013 e Visio 2010; Word 2013 e Word 2010. Para obter mais informações, consulte Recursos disponíveis pelo aplicativo do Office e o tipo de projeto.

O exemplo recebe dados do banco de dados de exemplo Northwind para preencher uma caixa de combinação e um menu no Microsoft Office Outlook.Os itens que você seleciona em esses controles automaticamente preenchem campos como a e Assunto em uma mensagem de email.

Essa explicação passo a passo mostra as seguintes tarefas:

Criando um novo projeto do suplemento ao Outlook.
Criando um grupo personalizado de fita.
adicionando o grupo personalizado a um guia interno.
Atualizando controles em fita em tempo de execução.

Observação
Seu computador pode mostrar diferentes nomes ou localizações para alguns dos elementos de interface do usuário Visual Studio nas instruções a seguir.A edição Visual Studio que você possui e as configurações que você usa determinam esses elementos.Para obter mais informações, consulte Configurações de Visual Studio.

Pré-requisitos

Para completar este passo-a-passo, são necessários os seguintes componentes:

Uma edição do Visual Studio 2012 que inclui o Microsoft Office Developer Tools. Para obter mais informações, consulte [Configurando um computador para desenvolver soluções do Office](bb398242\(v=vs.110\).md).

Microsoft Outlook 2010 ou Office 2013.

Criando um novo projeto do suplemento do Outlook

Primeiro, crie um projeto do suplemento ao Outlook.

Para criar um novo projeto do suplemento do Outlook

Em Visual Studio, crie um projeto do suplemento a Outlook 2010 ou a Outlook 2013 com o nome Ribbon_Update_At_Runtime.
Em a caixa de diálogo de Novo Projeto , selecione Criar diretório para a solução.
Salvar o projeto para o diretório de projeto padrão.

Para obter mais informações, consulte Como: criar projetos do Office em Visual Studio.

Criando um grupo personalizado de fita

A fita para esse exemplo aparecerá quando um usuário composto uma nova mensagem de email.Para criar um grupo personalizado para fita, primeiro adicionar um item de fita ao seu projeto, e criar no grupo no designer de fita.Este grupo personalizado ajudará a gerar mensagens de email de continuação de linha para clientes recebendo nomes e a ordenação históricos de um banco de dados.

para criar um grupo personalizado

No menu Project, clique em Add New Item.
Em a caixa de diálogo de Adicionar novo item , **fita (designer visual)**selecione.
Altere o nome do novo fita a CustomerRibbon, clique em Adicionar.

O arquivo de CustomerRibbon.cs ou de CustomerRibbon.vb abre no designer de fita e exibe uma guia e um grupo padrão.
Clique no designer de fita para selecioná-lo.
Em a janela de Propriedades , clique na seta suspensa próxima à propriedade de RibbonType , clique em Microsoft.Outlook.Mail.Compose.

Isso permite que a fita para aparecer quando o usuário composto uma nova mensagem de email no Outlook.
Em o designer de fita, clique em Group1 para selecioná-lo.
Em a janela de Propriedades , defina a Rótulo compras de cliente.
De a guia de Controles de fita do Office de Caixa de Ferramentas, arraste ComboBox no grupo de Compras de cliente .
Clique ComboBox1 para selecioná-lo.
Em a janela de Propriedades , defina Rótulo para clientes.
De a guia de Controles de fita do Office de Caixa de Ferramentas, arraste Menu no grupo de Compras de cliente .
Em a janela de Propriedades , defina Rótulo ao produto comprado.
definir Dinâmico a true.

Isso permite que você adicione em tempo de execução e remover controles no menu após a fita é carregada no aplicativo do Office.

adicionando o grupo personalizado a um guia interno

Um guia interno é um que já esteja na guia do Outlook fita Explorer ou inspector.Em esse procedimento, você adicionará o grupo personalizado a um guia interno, e então especifica a posição do grupo personalizado na guia.

para adicionar o grupo personalizado a um guia interno

Clique na guia de TabAddins (built-in) para selecioná-lo.
Em a janela de Propriedades , expanda a propriedade de ControlId , e defina OfficeId a TabNewMailMessage.

Isso adiciona o grupo de Compras de cliente a guia de Mensagens de fita que aparece em uma nova mensagem de email.
Clique no grupo de Compras de cliente para selecioná-lo.
Em a janela de Propriedades , expanda a propriedade de Posição , clique na seta suspensa próxima à propriedade de PositionType , clique em BeforeOfficeId.
Defina a propriedade de OfficeId a GroupClipboard.

Isso posiciona o grupo de Compras de cliente antes que o grupo de Área de Transferência da guia de Mensagens .

Criando o DataSet

Usar a janela de Fontes de Dados para adicionar um dataset tipado ao seu projeto.

Para criar o DataSet

No menu Data, clique em Add New Data Source.

Isso é Assistente para Configuração de Fonte de Dados.
Banco de DadosSelecione, e clique em Avançar.
Conjunto de DadosSelecione, e clique em Avançar.
Selecione uma conexão de dados ao banco de dados do Microsoft SQL Server compact 4,0 de exemplo Northwind, ou adicione uma nova conexão usando o botão de Nova Conexão .
Após uma conexão foi selecionada ou criada, clique Avançar.
clique Avançar para salvar a cadeia de conexão.
Em a página de Escolher Objetos do Banco de Dados , expanda Tabelas.
Selecione a caixa de seleção ao lado de cada uma das tabelas a seguir:
1. clientes
2. Detalhes do pedido
3. Pedidos
4. produtos
Clique em Concluir.

Atualizando controles no grupo personalizado em tempo de execução

Use o modelo de objeto de fita para executar as seguintes tarefas:

Adicione nomes de cliente para a caixa de combinação de Clientes .
Adicione o menu e botão dos controles no menu produtos comprados que representam os pedidos de venda e os produtos vendidos.
Preencher To, Subject, e campos de Body de novos mensagens de email usando dados da caixa combo Clientes e do menu de produtos comprados .

Para atualizar controles no grupo personalizado usando o modelo de objeto de fita

No menu Project, escolha Add Reference.
Em a caixa de diálogo de Adicionar Referência , clique na guia de .NET , selecione o conjunto de System.Data.Linq , clique em OK.

Este assembly contém classes para usar consultas Integradas linguagem (LINQ).Você usará LINQ para preencher controles no grupo personalizado com dados de banco de dados Northwind.
Em Gerenciador de Soluções, clique em CustomerRibbon.cs ou CustomerRibbon.vb para selecioná-lo.
Em o menu de Modo de Visualização , clique em Código.

O arquivo de código de fita abre na editor de códigos.

Adicione as instruções a seguir à parte superior do arquivo de código de fita.Essas instruções fornecem acesso fácil para namespaces LINQ e para o namespace do 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.Northwind40DataSetTableAdapters

using System.Data.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.Northwind40DataSetTableAdapters;

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

    'Declare the Northwind data set.

    Dim nwDataSet As Northwind40DataSet = New Northwind40DataSet()

    'Declare the data tables.

    Dim customerTable As Northwind40DataSet.CustomersDataTable
    Dim orderTable As Northwind40DataSet.OrdersDataTable
    Dim orderDetailsTable As Northwind40DataSet.Order_DetailsDataTable
    Dim productsTable As Northwind40DataSet.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.
Northwind40DataSet nwDataSet = new Northwind40DataSet();

//Declare the data tables.

Northwind40DataSet.CustomersDataTable customerTable;
Northwind40DataSet.OrdersDataTable orderTable;
Northwind40DataSet.Order_DetailsDataTable orderDetailsTable;
Northwind40DataSet.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 o seguinte bloco de código para a classe de CustomerRibbon .Este código adiciona três métodos auxiliares que criam controles para a fita em tempo de execução.


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;
}

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

Preencher a caixa combo Clientes usando a identificação e o nome de 20 clientes no banco de dados Northwind.
Chama o método auxiliar de PopulateSalesOrderInfo .Este método atualiza o menu de ProductsPurchased com números de ordem de venda que pertencem ao cliente selecionado.

    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();
}

Adicione o seguinte código à classe CustomerRibbon:Esse código usa consultas LINQ para executar as seguintes tarefas:

Adiciona um submenu o menu de ProductsPurchased para cada pedido de venda relativo para o cliente selecionado.
Adicionar botões a 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 Gerenciador de Soluções, clique duas vezes no arquivo de código de fita.

O designer abre. de fita
Em o designer de fita, clique duas vezes na caixa combo Clientes .

O arquivo de código de fita abre na editor de códigos, e o manipulador de eventos de ComboBox1_TextChanged aparece.
Substitua o manipulador de eventos de ComboBox1_TextChanged com o código a seguir.Esse código executa as seguintes tarefas:
- Chama o método auxiliar de PopulateSalesOrderInfo .Este método atualiza o menu de produtos comprados com os pedidos de venda relacionadas ao cliente selecionado.
- Chama o método auxiliar de PopulateMailItem e passar no texto atual, que é o nome do cliente selecionado.Este método preenche To, Subject, e campos de Body de novos 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);
}
```

Adicione o seguinte manipulador de eventos na classe de CustomerRibbon .Este código adiciona o nome do produto selecionados para o campo de Body de novos 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;
}

Adicione o seguinte código à classe CustomerRibbon:Esse código executa as seguintes tarefas:

Preenche a linha de To de novos mensagens de email usando o endereço de email de cliente selecionado.
Adiciona texto a campos de Subject e de Body de novos 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: ";
}

Testando os controles no grupo personalizado

Quando você abre um novo formulário de e-mail no Outlook, um grupo personalizado chamado Compras de cliente aparece na guia de Mensagens de fita.

Para criar uma mensagem de email de continuação de cliente, selecione um cliente, e selecione os produtos comprados pelo cliente.Os controles no grupo de Compras de cliente é atualizado em tempo de execução com dados de banco de dados Northwind.

Para testar os controles no grupo personalizado

Pressione F5 para executar o seu projeto.

Inicia do Outlook.
Em o Outlook, no menu de Arquivo , aponte para Novo, e clique em Email.

as seguintes ações ocorrem:
- Uma nova janela de inspector de mensagem de email aparece.
- Em a guia de Mensagem de fita, o grupo de Compras de cliente aparece antes do grupo de Área de Transferência .
- A caixa de combinação de Clientes no grupo é atualizada com os nomes dos clientes no banco de dados Northwind.
Em a guia de Mensagem de fita, no grupo de Compras de cliente , selecione um cliente da caixa combo Clientes .

as seguintes ações ocorrem:
- O menu de produtos comprados é atualizado para mostrar a cada ordem de venda para o cliente selecionado.
- Cada submenu de ordem de venda é atualizado para mostrar os produtos comprados em essa ordem.
- O email de cliente selecionado é adicionado para a linha de a de mensagem, e o assunto e corpo da mensagem de email são preenchidos com texto.
Clique no menu, aponte para Compras de produtos de qualquer ordem de venda, clique em um produto pedido de venda.

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

Próximas etapas

Você pode aprender mais sobre como personalizar o Office interface do usuário de esses tópicos:

Adicione de contexto com base interface de usuário para qualquer personalização da nível.Para obter mais informações, consulte Visão geral do painel de ações.
Estender um formulário do Microsoft Office Outlook de padrão ou personalizada.Para obter mais informações, consulte Passo a passo: Criando uma região de formulário do Outlook.
Adicionar um painel de tarefa adequada para Outlook.Para obter mais informações, consulte Painéis de tarefas personalizados.

Consulte também

Compartilhar via