Procédure pas à pas : mettre à jour les contrôles sur un ruban au moment de l’exécution

Article
10/10/2023

Cette procédure pas à pas montre comment utiliser le modèle objet Ruban pour mettre à jour les contrôles d’un ruban une fois le ruban chargé dans la application Office lication.

S’applique à : Les informations contenues dans cette rubrique s’appliquent aux projets au niveau du document et aux projets de complément VSTO pour les applications suivantes : Excel ; InfoPath 2013 et InfoPath 2010 ; Outlook; Powerpoint; Projet; Visio; Mot. Pour plus d’informations, consultez Fonctionnalités disponibles par application Office lication et le type de projet.

L'exemple extrait des données de l'exemple de base de données Northwind pour remplir une zone de liste modifiable et un menu dans Microsoft Office Outlook. Les éléments que vous sélectionnez dans ces contrôles remplissent automatiquement les champs tels que To et Subject dans un e-mail.

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

Créez un projet de complément VSTO Outlook.
Concevoir un groupe de ruban personnalisé.
Ajoutez le groupe personnalisé à un onglet intégré.
Mettez à jour les 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. L'édition de Visual Studio dont vous disposez et les paramètres que vous utilisez déterminent ces éléments. Pour plus d’informations, consultez Personnaliser l’IDE Visual Studio.

Prérequis

Vous devez disposer des éléments suivants pour exécuter cette procédure pas à pas :

Une édition de Visual Studio qui inclut les outils de développement Microsoft Office. Pour plus d’informations, consultez Configurer un ordinateur pour développer des solutions Bureau.
Microsoft Outlook

Créer un projet de complément VSTO Outlook

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

Pour créer un projet de complément VSTO Outlook

Dans Visual Studio, créez un projet de complément VSTO Outlook 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 Guide pratique pour créer des projets Bureau dans Visual Studio.

Concevoir un groupe de ruban personnalisé

Le ruban de cet exemple s’affiche lorsqu’un utilisateur compose un nouveau message électronique. Pour créer un groupe personnalisé pour le ruban, commencez par ajouter un élément de ruban à votre projet, puis concevez le groupe dans le Concepteur de ruban. Ce groupe personnalisé vous aidera à générer des messages électroniques de suivi aux clients en extrayant les noms et les historiques des commandes d’une base de données.

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 déroulante en regard de la propriété RibbonType , puis cliquez sur Microsoft.Outlook.Mail.Compose.

Cela permet au ruban d’apparaître lorsque l’utilisateur compose un nouveau message électronique dans Outlook.
Dans le Concepteur de ruban, cliquez sur Groupe1 pour le sélectionner.
Dans la fenêtre Propriétés , définissez Étiquette sur Achats client.
À partir de l’onglet Contrôles du ruban Bureau de la boîte à outils, faites glisser un comboBox vers le groupe Achats client.
Cliquez sur ComboBox1 pour le sélectionner.
Dans la fenêtre Propriétés , définissez Étiquette sur Clients.
Dans l’onglet Contrôles du ruban Bureau de la boîte à outils, faites glisser un menu sur le groupe Achats du client.
Dans la fenêtre Propriétés , définissez Étiquette sur Produit acheté.
Définissez Dynamic sur true.

Cela vous permet d’ajouter et de supprimer des contrôles dans le menu au moment de l’exécution une fois le ruban chargé dans la application Office lication.

Ajouter le groupe personnalisé à un onglet intégré

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

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

Cliquez sur l’onglet TabAddins (intégré) pour le sélectionner.
Dans la fenêtre Propriétés, développez la propriété ControlId, puis définissez Bureau Id sur TabNewMailMessage.

Cela ajoute le groupe Achats client à l’onglet Messages du ruban qui apparaît dans un nouveau message électronique.
Cliquez sur le groupe Achats client pour le sélectionner.
Dans la fenêtre Propriétés, développez la propriété Position, cliquez sur la flèche déroulante en regard de la propriété PositionType, puis cliquez sur Before Bureau Id.
Définissez la propriété Bureau Id sur GroupClipboard.

Cela positionne le groupe Achats client avant le groupe Presse-papiers de l’onglet Messages .

Créer la source de données

Utilisez la fenêtre Sources de données pour ajouter un dataset 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.

L’Assistant Configuration de la source de données démarre.
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 Microsoft SQL Server Compact 4.0 ou ajoutez une nouvelle connexion à l’aide du bouton New Connecter ion.
Une fois qu’une connexion a été sélectionnée ou créée, cliquez sur Suivant.
Cliquez sur Suivant pour enregistrer le chaîne de connexion.
Dans la page Choisir vos objets de base de données, développez Tables.
Cochez la case située en regard de chacune des tables suivantes :
1. Clients
2. Détails de la commande
3. Commandes
4. Produits
Cliquez sur Terminer.

Mettre à jour les 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 :

Ajoutez des noms de clients à la zone de liste déroulante Clients .
Ajoutez des contrôles de menu et de bouton au menu Produits achetés qui représentent les commandes et les produits vendus.
Remplissez les champs À, Objet et Corps des nouveaux messages électroniques à l’aide des données de la zone de liste déroulante Clients et du menu Produits achetés .

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 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.

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;

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

Ajoutez le code suivant à l’intérieur de la CustomerRibbon classe. 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 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();

'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()

Ajoutez le bloc de code suivant à la classe 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 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;
}


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

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 Clients à l’aide de l’ID et du nom de 20 clients dans la base de données Northwind.

Appeler la méthode d'assistance PopulateSalesOrderInfo. Cette méthode met à jour le menu ProductsPurchased avec des numéros de commande qui concernent le client actuellement sélectionné.

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

 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

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 de vente liée au client sélectionné.
Ajouter des boutons à chaque sous-menu pour les produits associés à la commande client.

Ajouter des gestionnaires d'événements à chaque bouton.

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

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

Dans 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 Clients .

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 effectue les tâches suivantes :
- Appeler la méthode d'assistance PopulateSalesOrderInfo. Cette méthode met à jour le menu Produits achetés avec les commandes commerciales relatives au client sélectionné.
- Appeler la méthode d'assistance PopulateMailItem et passer le texte actuel, qui est le nom du client sélectionné. Cette méthode remplit les champs To, Subject et Body des nouveaux messages électroniques.
  - C#
  - VB
```
private void comboBox1_TextChanged(object sender,
    RibbonControlEventArgs e)
{
    PopulateSalesOrderInfo();
    PopulateMailItem(comboBox1.Text);
}
```
```
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
```

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

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

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

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

Remplit la ligne To des nouveaux messages électroniques à l’aide de l’adresse e-mail du client actuellement sélectionné.

Ajoute du texte aux champs Objet et Corps des nouveaux messages électroniques.

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

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

Tester les contrôles dans le groupe personnalisé

Lorsque vous ouvrez un nouveau formulaire de messagerie dans Outlook, un groupe personnalisé nommé Achats clients s’affiche sous l’onglet Messages du ruban.

Pour créer un message électronique de suivi client, sélectionnez un client, puis sélectionnez les produits achetés par le client. Les contrôles du groupe Achats client 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 Outlook, dans le menu Fichier , pointez sur Nouveau, puis cliquez sur Courrier électronique.

Les actions suivantes se produisent :
- Une nouvelle fenêtre de l'inspecteur de message électronique s'affiche.
- Sous l’onglet Message du ruban, le groupe Achats client s’affiche avant le groupe Presse-papiers.
- La zone de liste modifiable Clients du groupe est mise à jour avec les noms des clients dans la base de données Northwind.
Sous l’onglet Message du ruban, dans le groupe Achats du client, sélectionnez un client dans la zone de liste déroulante Clients.

Les actions suivantes se produisent :
- Le menu Produits achetés 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 e-mail du client sélectionnée est ajoutée à la ligne À du message électronique, et l’objet et le corps du message sont renseignés avec du texte.
Cliquez sur le menu Achats de produits, pointez sur n’importe quelle commande, puis cliquez sur un produit dans 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 la vue d’ensemble du volet Actions.
Étendre un formulaire Microsoft Office standard ou personnalisé. Pour plus d’informations, consultez Procédure pas à pas : Concevoir une zone de formulaire Outlook.
Ajouter un volet de tâches personnalisé dans Outlook. Pour plus d’informations, consultez les volets Office personnalisés.