Procédure pas à pas : mise à niveau des contrôles sur un ruban au moment de l'exécution

Article
03/04/2013

Cette procédure pas à pas montre comment utiliser le modèle objet de ruban pour mettre à jour les contrôles sur un ruban après le chargement du ruban dans l'application Office.

S'applique à : Les informations contenues dans cette rubrique s'appliquent aux projets de niveau document et de niveau application pour les applications suivantes : Excel 2013 et Excel 2010 ; InfoPath 2013 et InfoPath 2010 ; Outlook 2013 et Outlook 2010 ; PowerPoint 2013 et PowerPoint 2010 ; Project 2013 et Project 2010 ; Visio 2013 et Visio 2010 ; Word 2013 et Word 2010. Pour plus d'informations, consultez Fonctionnalités disponibles par type d'application et de projet Office.

L'exemple extrait des données de l'exemple de base de données Northwind pour remplir une zone de liste déroulante et un menu dans Microsoft Office Outlook.Les éléments que vous sélectionnez dans ces contrôles remplissent automatiquement des champs tels que À et Objet dans un message électronique.

Cette procédure pas à pas décrit les tâches suivantes :

Création d'un projet de complément Outlook.
Conception d'un groupe de ruban personnalisé.
Ajout du groupe personnalisé à un onglet intégré.
Mise à jour des contrôles sur le ruban au moment de l'exécution.

[!REMARQUE]

Il est possible que pour certains des éléments de l'interface utilisateur de Visual Studio, votre ordinateur affiche des noms ou des emplacements différents de ceux indiqués dans les instructions suivantes.Ces éléments dépendent de l'édition de Visual Studio dont vous disposez et des paramètres que vous utilisez.Pour plus d’informations, consultez Paramètres Visual Studio.

Composants requis

Pour exécuter cette procédure pas à pas, vous devez disposer des composants suivants :

Une édition de Visual Studio 2012 qui inclut les outils de développement Microsoft Office. Pour plus d'informations, consultez [Configuration d'un ordinateur pour développer des solutions Office](bb398242\(v=vs.110\).md).

Microsoft Outlook 2010 ou Office 2013.

Création d'un projet de complément Outlook

Commencez par créer un projet de complément Outlook.

Pour créer un projet de complément Outlook

Dans Visual Studio, créez un projet de Complément d' Outlook 2010 ou d' Outlook 2013 avec le nom Ribbon_Update_At_Runtime.
Dans la boîte de dialogue Nouveau projet, sélectionnez Créer le répertoire pour la solution.
Enregistrez le projet dans le répertoire de projet par défaut.

Pour plus d’informations, consultez Comment : créer des projets Office dans Visual Studio.

Conception d'un groupe de ruban personnalisé

Le ruban de cet exemple s'affichera lorsqu'un utilisateur composera un nouveau message électronique.Pour créer un groupe personnalisé pour le ruban, commencez par ajouter un élément Ruban à votre projet, puis concevez le groupe dans le Concepteur de ruban.Ce groupe personnalisé vous permet d'extraire d'une base de données les noms et les historiques de commande des clients pour créer des messages électronique de suivi.

Pour concevoir un groupe personnalisé

Dans le menu Projet, cliquez sur Ajouter un nouvel élément.
Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Ruban (Concepteur visuel).
Remplacez le nom du nouveau ruban par CustomerRibbon, puis cliquez sur Ajouter.

Le fichier CustomerRibbon.cs ou CustomerRibbon.vb s'ouvre dans le Concepteur de ruban et affiche un onglet et un groupe par défaut.
Cliquez sur le Concepteur de ruban pour le sélectionner.
Dans la fenêtre Propriétés, cliquez sur la flèche de déroulement en regard de la propriété RibbonType, puis sur Microsoft.Outlook.Mail.Compose.

Le ruban apparaîtra lorsque l'utilisateur composera un nouveau message électronique dans Outlook.
Dans le Concepteur de ruban, cliquez sur Group1 pour le sélectionner.
Dans la fenêtre Propriétés, affectez à Label la valeur Customer Purchases.
Dans l'onglet Contrôles de ruban Office de la Boîte à outils, faites glisser une zone de liste déroulante sur le groupe Customer Purchases.
Cliquez sur ComboBox1 pour le sélectionner.
Dans la fenêtre Propriétés, affectez à Label la valeur Customers.
Dans l'onglet Contrôles de ruban Office de la Boîte à outils, faites glisser un menu sur le groupe Customer Purchases.
Dans la fenêtre Propriétés, affectez à Label la valeur Product Purchased.
Affectez la valeur true à Dynamique.

Vous pouvez maintenant ajouter des contrôles sur le menu et en supprimer au moment de l'exécution, après le chargement du ruban dans l'application Office.

Ajout du groupe personnalisé à un onglet intégré

Un onglet intégré est un onglet qui se trouve déjà sur le ruban d'un explorateur ou inspecteur Outlook.Au cours de cette procédure, vous allez ajouter le groupe personnalisé à un onglet intégré, puis spécifier la position du groupe sur l'onglet.

Pour ajouter le groupe personnalisé à un onglet intégré

Cliquez sur l'onglet TabAddins (Built-In) pour le sélectionner.
Dans la fenêtre Propriétés, développez la propriété ControlId, puis affectez la valeur TabNewMailMessage à OfficeId.

Le groupe Customer Purchases est alors ajouté à l'onglet Messages du ruban qui apparaît dans un nouveau message électronique.
Cliquez sur le groupe Customer Purchases pour le sélectionner.
Dans la fenêtre Propriétés, développez la propriété Position, cliquez sur la flèche de déroulement en regard de la propriété PositionType, puis cliquez sur BeforeOfficeId.
Affectez la valeur GroupClipBoard à la propriété OfficeId.

Le groupe Customer Purchases est alors placé avant le groupe Presse-papiers de l'onglet Messages.

Création de la source de données

Utilisez la fenêtre Sources de données pour ajouter un groupe de données typé à votre projet.

Pour créer la source de données

Dans le menu Données, cliquez sur Ajouter une nouvelle source de données.

Cette action démarre l'Assistant Configuration de source de données.
Sélectionnez Base de données, puis cliquez sur Suivant.
Sélectionnez Dataset, puis cliquez sur Suivant.
Sélectionnez une connexion de données à l'exemple de base de données Northwind de Microsoft SQL Server Compact 4.0 ou ajoutez une nouvelle connexion à l'aide du bouton Nouvelle connexion.
Après avoir sélectionné ou créé une connexion, cliquez sur Suivant.
Cliquez sur Suivant pour enregistrer la chaîne de connexion.
Dans la page Choisir vos objets de base de données, développez Tables.
Activez la case à cocher en regard de chacune des tables suivantes :
1. Customers
2. Order Details
3. Orders
4. Products
Cliquez sur Terminer.

Mise à jour de contrôles dans le groupe personnalisé au moment de l'exécution

Utilisez le modèle objet de ruban pour effectuer les tâches suivantes :

Ajouter des noms de client à la zone de liste déroulante Customers.
Ajouter des contrôles de menu et de bouton au menu Products Purchased qui représente les commandes et les produits vendus.
Remplir les champs To, Subject et Body de nouveaux messages électronique avec des données de la zone de liste déroulante Customers et du menu Products Purchased.

Pour mettre à jour des contrôles dans le groupe personnalisé en utilisant le modèle objet de ruban

Dans le menu Projet, cliquez sur Ajouter une référence.
Dans la boîte de dialogue Ajouter une référence, cliquez sur l'onglet .NET, sélectionnez l'assembly System.Data.Linq, puis cliquez sur OK.

Cet assembly contient des classes pour l'utilisation de requêtes LINQ (Language-Integrated Queries).Vous utiliserez LINQ pour remplir des contrôles du groupe personnalisé avec des données de la base de données Northwind.
Dans l'Explorateur de solutions, cliquez sur CustomerRibbon.cs ou CustomerRibbon.vb pour le sélectionner.
Dans le menu Affichage, cliquez sur Code.

Le fichier de code du ruban s'ouvre dans l'éditeur de code.

Ajoutez les instructions suivantes au début du fichier de code du ruban.Ces instructions facilitent l'accès aux espaces de noms LINQ et à l'espace de noms de l'assembly PIA (Primary Interop Assembly) d'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;

Ajoutez le code suivant dans la classe CustomerRibbon :Ce code déclare les adaptateurs de table et de table de données que vous utiliserez pour stocker les informations des tables Customer, Orders, Order Details et Product de la base de données 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();

Ajoutez le bloc de code suivant à la classe d' CustomerRibbon .Ce code ajoute trois méthodes d'assistance qui créent des contrôles pour le ruban au moment de l'exécution.


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

Remplacez la méthode de gestionnaire d'événements CustomerRibbon_Load par le code suivant.Ce code utilise une requête LINQ pour effectuer les tâches suivantes :

Remplissez la zone de liste déroulante Customers en utilisant l'ID et le nom de 20 clients de la base de données Northwind.
Appelle la méthode d'assistance PopulateSalesOrderInfo.Cette méthode met à jour le menu ProductsPurchased avec les numéros de commande relatifs au client sélectionné.

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

Ajoutez le code suivant à la classe CustomerRibbon.Ce code utilise des requêtes LINQ pour effectuer les tâches suivantes :

Ajoute un sous-menu au menu ProductsPurchased pour chaque commande relative au client sélectionné.
Ajoute des boutons à chaque sous-menu pour les produits relatifs à la commande.
Ajoute des gestionnaires d'événements à chaque bouton.

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

Dans l'Explorateur de solutions, double-cliquez sur le fichier de code du ruban.

Le Concepteur de ruban s'ouvre.
Dans le Concepteur de ruban, double-cliquez sur la zone de liste déroulante Customers.

Le fichier de code du ruban s'ouvre dans l'éditeur de code et le gestionnaire d'événements ComboBox1_TextChanged s'affiche.
Remplacez le gestionnaire d'événements ComboBox1_TextChanged par le code suivant.Ce code exécute les tâches suivantes :
- Appelle la méthode d'assistance PopulateSalesOrderInfo.Cette méthode met à jour le menu Products Purchased avec les commandes relatives au client sélectionné.
- Appelle la méthode d'assistance PopulateMailItem et passe le texte actuel, qui est le nom de client sélectionné.Cette méthode renseigne les champs To, Subject et Body de nouveaux messages électroniques.
```
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);
}
```

Ajoutez le gestionnaire d'événements Click suivant à la classe CustomerRibbon.Ce code ajoute le nom des produits sélectionnés au champ Body de nouveaux messages électroniques.

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

Ajoutez le code suivant à la classe CustomerRibbon.Ce code exécute les tâches suivantes :

Renseigne la ligne To de nouveaux messages électroniques avec l'adresse électronique du client sélectionné.
Ajoute du texte aux champs Subject et Body de nouveaux messages électroniques.

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

Test des contrôles dans le groupe personnalisé

Lorsque vous ouvrez un nouveau formulaire de courrier dans Outlook, un groupe personnalisé nommé Customer Purchases apparaît sur l'onglet Messages du ruban.

Pour créer un message électronique de suivi client, sélectionnez un client, puis des produits achetés par ce client.Les contrôles du groupe Customer Purchases sont mis à jour au moment de l'exécution avec les données de la base de données Northwind.

Pour tester les contrôles dans le groupe personnalisé

Appuyez sur F5 pour exécuter votre projet.

Outlook démarre.
Dans le menu Fichier d'Outlook, pointez sur Nouveau, puis cliquez sur Message.

Les actions suivantes ont lieu :
- Une nouvelle fenêtre de l'inspecteur de message électronique apparaît.
- Sous l'onglet Messages du ruban, le groupe Customer Purchases apparaît avant le groupe Presse-papiers.
- La zone de liste déroulante Customer Purchases du groupe est mise à jour avec les noms de clients de la base de données Northwind.
Sous l'onglet Message du ruban, dans le groupe Customer Purchases, sélectionnez un client de la zone de liste déroulante Customers.

Les actions suivantes ont lieu :
- Le menu Products Purchased est mis à jour pour afficher chaque commande pour le client sélectionné.
- Chaque sous-menu de commande client est mis à jour pour afficher les produits achetés dans cette commande.
- L'adresse électronique du client sélectionné est ajoutée à la ligne À du message électronique et l'objet et le corps du message sont remplis avec du texte.
Cliquez sur le menu Products Purchases, pointez sur une commande, puis cliquez sur un produit de la commande.

Le nom du produit est ajouté au corps du message électronique.

Étapes suivantes

Pour plus d'informations sur la personnalisation de l'interface utilisateur d'Office, consultez les rubriques suivantes :

Ajouter une interface utilisateur contextuelle à une personnalisation au niveau du document.Pour plus d’informations, consultez Vue d'ensemble du volet Actions.
Étendre un formulaire Microsoft Office standard ou personnalisé.Pour plus d’informations, consultez Procédure pas à pas : conception d'une zone de formulaire Outlook.
Ajouter un volet de tâches personnalisé à Outlook.Pour plus d’informations, consultez Volets de tâches personnalisés.

Voir aussi

Partager via