Création d’une application ruban
L’infrastructure du ruban Windows est composée de deux plateformes de développement distinctes, mais dépendantes : un langage de balisage basé sur XAML (Extensible Application Markup Language) pour déclarer les contrôles et leur disposition visuelle, et un ensemble d’interfaces basées sur le modèle objet de composants C++ (COM) pour définir les fonctionnalités de commande et les hooks d’application. Cette division du travail au sein de l’architecture de l’infrastructure ribbon nécessite qu’un développeur qui souhaite tirer parti des fonctionnalités d’interface utilisateur enrichies offertes par l’infrastructure doit concevoir et décrire l’interface utilisateur dans le balisage, puis utiliser les interfaces COM de l’infrastructure Ribbon pour connecter l’infrastructure à l’application hôte.
- Feuille de route du ruban
- Écrire le balisage
- Générer l’application
- Exécution Mises à jour et exécutions
- Prise en charge OLE
- Rubriques connexes
Feuille de route du ruban
Les aspects visuels d’une application ruban, tels que les contrôles affichés et leur emplacement, sont déclarés dans le balisage (voir Déclaration de commandes et de contrôles avec balisage du ruban). La logique de commande d’application, telle que ce qui se passe quand un bouton est enfoncé, est implémentée dans le code.
Le processus d’implémentation d’un ruban et de son incorporation dans une application Windows nécessite quatre tâches de base : écrire le balisage, compiler le balisage, écrire le code et compiler et lier l’ensemble de l’application.
Le diagramme suivant illustre le flux de travail d’une implémentation de ruban classique.
Les sections suivantes décrivent ce processus plus en détail.
Écrire le balisage
Une fois l’interface utilisateur du ruban conçue, la première tâche d’un développeur d’application consiste à décrire l’interface utilisateur avec le balisage du ruban.
Important
Le fichier de schéma de balisage du framework ribbon, UICC.xsd, est installé avec le Kit de développement logiciel (SDK) Microsoft Windows pour Windows 7 et .NET Framework 4.0. À l’aide du chemin d’installation standard, le fichier se trouve dans le dossier %ProgramFiles%\Microsoft SDKs\Windows\[numéro de version]\Bin, où il peut être référencé par de nombreux éditeurs XML pour fournir des indicateurs et une saisie semi-automatique.
Les contrôles du ruban, les commandes du ruban (les éléments indépendants des contrôles qui fournissent la fonctionnalité de base des contrôles ruban) et toutes les relations visuelles et de disposition des contrôles sont déclarés dans le balisage. La structure du balisage du ruban souligne la distinction entre les contrôles du ruban et les commandes par le biais de deux hiérarchies de nœuds principaux : une arborescence Commandes et Ressources et une arborescence Vues .
Tous les conteneurs et actions exposés par le ruban sont déclarés dans l’arborescence Commandes et ressources . Chaque élément Command est associé à un ensemble de ressources, comme requis par la conception de l’interface utilisateur.
Après avoir créé les commandes d’une application, vous déclarez des contrôles dans l’arborescence Vues et liez chaque contrôle à une commande pour exposer la fonctionnalité Command. L’infrastructure du ruban détermine le positionnement réel des contrôles en fonction de la hiérarchie de contrôle déclarée ici.
L’exemple de code suivant montre comment déclarer un contrôle Button, intitulé Exit application, et l’associer à une commande exit.
<Application xmlns="http://schemas.microsoft.com/windows/2009/Ribbon">
<Application.Commands>
<Command Name="cmdExit" LabelTitle="Exit application" />
</Application.Commands>
<Application.Views>
<Ribbon>
<Ribbon.Tabs>
<Tab>
<Group>
<Button CommandName="cmdExit" />
</Group>
</Tab>
</Ribbon.Tabs>
</Ribbon>
</Application.Views>
</Application>
Conseil
Bien qu’il soit possible d’utiliser n’importe quelle extension de nom de fichier pour le fichier de balisage du ruban, .xml est l’extension recommandée qui est utilisée dans toute la documentation.
Compiler le balisage
Une fois le fichier de balisage du ruban créé, il doit être compilé dans un format binaire par le compilateur de balisage du ruban, UICC (UI Command Compiler), qui est inclus avec le Kit de développement logiciel (SDK) Windows. Une référence à ce fichier binaire est passée à la méthode IUIFramework::LoadUI lors de l’initialisation de l’infrastructure ribbon par l’application hôte.
UICC peut être exécuté directement à partir d’une fenêtre de ligne de commande ou ajouté en tant qu’étape de génération personnalisée dans Visual Studio.
L’image suivante montre le compilateur de balisage UICC dans la fenêtre Windows 7 SDK CMD Shell.
L’image suivante montre UICC ajouté en tant qu’étape de génération personnalisée dans Visual Studio.
L’UICC génère trois fichiers : une version binaire du balisage (.bml), un en-tête de définition d’ID (fichier .h) pour exposer des éléments de balisage à l’application hôte du ruban et un script de définition de ressource (fichier .rc) pour lier l’image du ruban et les ressources de chaîne à l’application hôte au moment de la compilation.
Pour plus d’informations sur la compilation du balisage de l’infrastructure du ruban, consultez Compilation du balisage du ruban.
Générer l'application
Une fois que l’interface utilisateur préliminaire d’une application ruban a été conçue et implémentée dans le balisage, le code d’application doit être écrit pour initialiser l’infrastructure, consommer le balisage et lier les commandes déclarées dans le balisage aux gestionnaires de commandes appropriés dans l’application.
Important
Étant donné que l’infrastructure du ruban est basée sur COM, il est recommandé que les projets ruban utilisent l’opérateur __uuidof() pour référencer les GUID pour les interfaces d’infrastructure du ruban (IID). Dans les cas où il n’est pas possible d’utiliser l’opérateur __uuidof(), par exemple lorsqu’un compilateur non Microsoft est utilisé ou que l’application hôte est basée sur C, les ID doivent être définis par l’application, car ils ne sont pas contenus dans uuid.lib.
Si les IDI sont définis par l’application, les GUID spécifiés dans UIRibbon.idl doivent être utilisés.
UIRibbon.idl est fourni dans le cadre du Kit de développement logiciel (SDK) Windows et se trouve sur le chemin d’installation standard de %ProgramFiles%\Microsoft SDKs\Windows\v7.0\Include.
Initialiser le ruban
Le diagramme suivant illustre les étapes requises pour implémenter une application ruban simple.
Les étapes suivantes décrivent en détail comment implémenter une application ruban simple.
CoCreateInstance
L’application appelle la fonction COM CoCreateInstance standard avec l’ID de classe d’infrastructure Ribbon pour obtenir un pointeur vers l’infrastructure.
IUIFramework* pFramework = NULL; HRESULT hr = ::CoCreateInstance( CLSID_UIRibbonFramework, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFramework)); if (FAILED(hr)) { return hr; }Initialize(hwnd, IUIApplication*)
L’application appelle IUIFramework::Initialize, en passant deux paramètres : le handle vers la fenêtre de niveau supérieur qui contiendra le ruban et un pointeur vers l’implémentation IUIApplication qui permet à l’infrastructure d’effectuer des rappels à l’application.
![Important]
L’infrastructure du ruban est initialisée en tant qu’appartement à thread unique (STA).hr = pFramework->Initialize(hWndHost, pApplication); if (FAILED(hr)) { return hr; }LoadUI(instance, resourceName)
L’application appelle IUIFramework::LoadUI pour lier la ressource de balisage. Le premier paramètre de cette fonction est un handle de l’application Ribbon instance. Le deuxième paramètre est le nom de la ressource de balisage binaire qui a été compilée précédemment. En transmettant le balisage binaire à l’infrastructure du ruban, l’application indique ce que doit être la structure du ruban et la façon dont les contrôles doivent être organisés. Il fournit également à l’infrastructure un manifeste de commandes à exposer (telles que Coller, Couper, Rechercher), qui sont utilisées par l’infrastructure lorsqu’elle effectue des rappels liés aux commandes au moment de l’exécution.
hr = pFramework->LoadUI(GetModuleHandle(NULL), L"APPLICATION_RIBBON"); if (FAILED(hr)) { return hr; }IUIApplication::OnCreateUICommand rappels
Une fois les étapes 1 à 3 terminées, l’infrastructure du ruban sait quelles commandes exposer dans le ruban. Toutefois, l’infrastructure a encore besoin de deux éléments avant que le ruban ne soit entièrement fonctionnel : un moyen d’indiquer à l’application quand les commandes sont exécutées et un moyen d’obtenir des ressources de commande, ou des propriétés, au moment de l’exécution. Par exemple, si une zone de liste modifiable doit apparaître dans l’interface utilisateur, l’infrastructure doit demander les éléments avec lesquels remplir la zone de liste déroulante.
Ces deux fonctionnalités sont gérées via l’interface IUICommandHandler . Plus précisément, pour chaque commande déclarée dans le balisage binaire (voir étape 3 ci-dessus), le framework appelle IUIApplication::OnCreateUICommandCommand pour demander à l’application un objet IUICommandHandler pour cette commande
Notes
L’interface IUICommandHandler permet à un gestionnaire de commandes d’être lié à une ou plusieurs commandes.
Au minimum, l’application doit implémenter des stubs de méthodes IUIApplication qui retournent E_NOTIMPL comme illustré dans l’exemple suivant.
STDMETHOD(OnViewChanged)(UINT32 viewId,
UI_VIEWTYPE typeID,
IUnknown *view,
UI_VIEWVERB verb,
INT32 uReasonCode)
{
return E_NOTIMPL;
}
STDMETHOD(OnCreateUICommand)(UINT32 commandId,
UI_COMMANDTYPE typeID,
IUICommandHandler **commandHandler)
{
return E_NOTIMPL;
}
STDMETHOD(OnDestroyUICommand)(UINT32 commandId,
UI_COMMANDTYPE typeID,
IUICommandHandler *commandHandler)
{
return E_NOTIMPL;
}
Lier le balisage à l’application
À ce stade, les fichiers de ressources de balisage doivent être liés à l’application hôte en incluant une référence au fichier de définition de ressource de balisage (qui contient une référence au fichier d’en-tête de balisage) dans le fichier de ressources de l’application. Par exemple, une application appelée RibbonApp avec un fichier de ressources appelé ribbonUI.rc nécessite la ligne suivante dans le fichier RibbonApp.rc.
#include "ribbonUI.rc"
Selon le compilateur et l’éditeur de liens utilisés, le script de définition de ressource peut également nécessiter la compilation avant que l’application ruban puisse être compilée. L’outil de ligne de commande RC (Resource Compiler) fourni avec Microsoft Visual Studio et le Kit de développement logiciel (SDK) Windows peut être utilisé pour cette tâche.
Compiler l’application
Une fois l’application ruban compilée, elle peut être exécutée et l’interface utilisateur testée. Si l’interface utilisateur nécessite un ajustement et qu’aucune modification n’est apportée aux gestionnaires de commandes associés dans le code principal de l’application, modifiez le fichier source de balisage, recompilez le balisage avec UICC.exe et liez les nouveaux fichiers de ressources de balisage. Lorsque l’application est redémarrée, l’interface utilisateur modifiée s’affiche.
Tout cela est possible sans toucher au code principal de l’application, ce qui représente une amélioration significative par rapport au développement et à la distribution d’applications standard.
Exécution Mises à jour et exécutions
La structure de communication au moment de l’exécution de l’infrastructure du ruban est basée sur un modèle push-pull, ou appelant bidirectionnel.
Ce modèle permet à l’infrastructure d’informer l’application lorsqu’une commande est exécutée et permet à l’infrastructure et à l’application d’interroger, de mettre à jour et d’invalider les valeurs de propriété et les ressources du ruban. Cette fonctionnalité est fournie par le biais d’un certain nombre d’interfaces et de méthodes.
L’infrastructure extrait les informations de propriété mises à jour de l’application Ribbon via la méthode de rappel IUICommandHandler::UpdateProperty . Un ID de commande et une clé de propriété, qui identifie la propriété Command à mettre à jour, sont transmis à la méthode qui retourne ou envoie (push) une valeur pour cette clé de propriété au framework.
L’infrastructure appelle IUICommandHandler::Execute lorsqu’une commande est exécutée, en identifiant à la fois l’ID de commande et le type d’exécution qui s’est produit (UI_EXECUTIONVERB). C’est là que l’application spécifie la logique d’exécution d’une commande.
Le diagramme suivant illustre la communication au moment de l’exécution de la commande entre l’infrastructure et l’application.
Notes
L’implémentation des fonctions IUICommandHandler::UpdateProperty et IUICommandHandler::Execute n’est pas nécessaire pour afficher initialement un ruban dans une application. Toutefois, ces méthodes sont nécessaires pour garantir que l’application fonctionne correctement lorsque les commandes sont exécutées par l’utilisateur.
Prise en charge OLE
Une application ruban peut être configurée en tant que serveur OLE pour prendre en charge l’activation OLE hors place.
Les objets créés dans une application serveur OLE conservent leur association avec l’application serveur lorsqu’ils sont insérés (collés ou placés) dans une application cliente OLE (ou un conteneur). Lors de l’activation OLE hors place, double-cliquez sur l’objet dans l’application cliente pour ouvrir une instance dédiée de l’application serveur et charge l’objet pour modification. Lorsque l’application serveur est fermée, toutes les modifications apportées à l’objet sont répercutées dans l’application cliente.
Notes
L’infrastructure du ruban ne prend pas en charge l’activation OLE sur place. Les objets créés dans un serveur OLE basé sur le ruban ne peuvent pas être modifiés à partir de l’application cliente OLE. Une instance dédiée externe de l’application serveur est requise.
Rubriques connexes
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour