Erstellen einer Menübandanwendung
Das Windows-Menübandframework besteht aus zwei unterschiedlichen, aber abhängigen Entwicklungsplattformen: einer Markupsprache, die auf Extensible Application Markup Language (XAML) basiert, um Steuerelemente und deren visuelles Layout zu deklarieren, und einem COM-basierten C++-basierten Satz von Schnittstellen zum Definieren von Befehlsfunktionen und Anwendungshaken. Diese Arbeitsteilung innerhalb der Architektur des Menübandframeworks erfordert, dass ein Entwickler, der die umfangreichen Benutzeroberflächenfunktionen des Frameworks nutzen möchte, die Benutzeroberfläche im Markup entwerfen und beschreiben und dann die COM-Schnittstellen des Menübandframeworks verwenden muss, um das Framework mit der Hostanwendung zu verbinden.
- Menüband-Roadmap
- Schreiben des Markups
- Erstellen der Anwendung
- Laufzeit Updates und Ausführungen
- OLE-Unterstützung
- Zugehörige Themen
Menüband-Roadmap
Die visuellen Aspekte einer Menübandanwendung, z. B. welche Steuerelemente angezeigt werden und wo sie platziert werden, werden im Markup deklariert (siehe Deklarieren von Befehlen und Steuerelementen mit Menübandmarkup). Die Anwendungsbefehlslogik, z. B. was geschieht, wenn eine Schaltfläche gedrückt wird, wird im Code implementiert.
Das Implementieren eines Menübands und dessen Integration in eine Windows-Anwendung erfordert vier grundlegende Aufgaben: Schreiben des Markups, Kompilieren des Markups, Schreiben des Codes sowie Kompilieren und Verknüpfen der gesamten Anwendung.
Das folgende Diagramm veranschaulicht den Workflow für eine typische Menübandimplementierung.
In den folgenden Abschnitten wird dieser Prozess ausführlicher beschrieben.
Schreiben des Markups
Nachdem die Menübandbenutzeroberfläche entworfen wurde, besteht die erste Aufgabe für einen Anwendungsentwickler darin, die Benutzeroberfläche mit Menübandmarkup zu beschreiben.
Wichtig
Die Markupschemadatei des Menübandframeworks UICC.xsd wird mit dem Microsoft Windows Software Development Kit (SDK) für Windows 7 und .NET Framework 4.0 installiert. Unter Verwendung des Standardinstallationspfads befindet sich die Datei im Ordner %ProgramFiles%\Microsoft SDKs\Windows\[Versionsnummer]\Bin, wo von vielen XML-Editoren darauf verwiesen werden kann, um Hinweise und automatische Vervollständigung bereitzustellen.
Menübandsteuerelemente, Menübandbefehle (die steuerelementunabhängigen Elemente, die die Basisfunktionalität für Menübandsteuerelemente bereitstellen) und alle Steuerelementlayouts und visuellen Beziehungen werden im Markup deklariert. Die Struktur des Menübandmarkups hebt die Unterscheidung zwischen Menübandsteuerelementen und Befehlen durch zwei primäre Knotenhierarchien hervor: eine Befehls- und Ressourcenstruktur und eine Views-Struktur .
Alle Container und Aktionen, die vom Menüband verfügbar gemacht werden, werden in der Struktur Befehle und Ressourcen deklariert. Jedes Command-Element ist einer Gruppe von Ressourcen zugeordnet, wie es für den UI-Entwurf erforderlich ist.
Nachdem Sie die Befehle für eine Anwendung erstellt haben, deklarieren Sie Steuerelemente in der Struktur Ansichten und binden jedes Steuerelement an einen Befehl, um die Befehlsfunktionalität verfügbar zu machen. Das Menübandframework bestimmt die tatsächliche Positionierung der Steuerelemente basierend auf der hier deklarierten Steuerelementhierarchie.
Im folgenden Codebeispiel wird veranschaulicht, wie sie ein Button-Steuerelement mit der Bezeichnung Exit-Anwendung deklarieren und einem Exit-Befehl zuordnen.
<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>
Tipp
Obwohl es möglich ist, eine beliebige Dateinamenerweiterung für die Menübandmarkierungsdatei zu verwenden, ist .xml die empfohlene Erweiterung, die in der gesamten Dokumentation verwendet wird.
Kompilieren des Markups
Nachdem die Menübandmarkupdatei erstellt wurde, muss sie vom Menüband-Markupcompiler UICC (UICC) in ein Binärformat kompiliert werden, der im Lieferumfang des Windows Software Development Kit (SDK) enthalten ist. Ein Verweis auf diese Binärdatei wird während der Initialisierung des Menübandframeworks durch die Hostanwendung an die IUIFramework::LoadUI-Methode übergeben.
UICC kann direkt über ein Befehlszeilenfenster ausgeführt oder als "Benutzerdefinierter Buildschritt" in Visual Studio hinzugefügt werden.
Die folgende Abbildung zeigt den UICC-Markupcompiler im Windows 7 SDK CMD Shell-Fenster.
Die folgende Abbildung zeigt UICC, die als benutzerdefinierter Buildschritt in Visual Studio hinzugefügt wurde.
Die UICC generiert drei Dateien: eine binärversion des Markups (.bml), einen ID-Definitionsheader (.h-Datei), um Markupelemente für die Menübandhostanwendung verfügbar zu machen, und ein Ressourcendefinitionsskript (RC-Datei ), um Menübandimage- und Zeichenfolgenressourcen zur Kompilierzeit mit der Hostanwendung zu verknüpfen.
Weitere Informationen zum Kompilieren des Menübandframework-Markups finden Sie unter Kompilieren von Menübandmarkup.
Erstellen der Anwendung
Nachdem die vorläufige Benutzeroberfläche für eine Menübandanwendung entworfen und im Markup implementiert wurde, muss Anwendungscode geschrieben werden, der das Framework initialisiert, das Markup nutzt und die im Markup deklarierten Befehle an die entsprechenden Befehlshandler in der Anwendung bindet.
Wichtig
Da das Menübandframework COM-basiert ist, wird empfohlen, dass Menübandprojekte den Operator __uuidof() verwenden, um auf die GUIDs für Menübandframeworkschnittstellen (IIDs) zu verweisen. In den Fällen, in denen es nicht möglich ist, den Operator __uuidof() zu verwenden, z. B. wenn ein Nicht-Microsoft-Compiler verwendet wird oder die Hostanwendung C-basiert, müssen die IIDs von der Anwendung definiert werden, da sie nicht in uuid.lib enthalten sind.
Wenn die IIDs von der Anwendung definiert werden, müssen die in UIRibbon.idl angegebenen GUIDs verwendet werden.
UIRibbon.idl wird als Teil des Windows Software Development Kit (SDK) ausgeliefert und finden Sie im Standardinstallationspfad von %ProgramFiles%\Microsoft SDKs\Windows\v7.0\Include.
Initialisieren des Menübands
Das folgende Diagramm veranschaulicht die Schritte, die zum Implementieren einer einfachen Menübandanwendung erforderlich sind.
In den folgenden Schritten wird detailliert beschrieben, wie eine einfache Menübandanwendung implementiert wird.
Cocreateinstance
Die Anwendung ruft die Com-CoCreateInstance-Standardfunktion mit der Framework-Klassen-ID des Menübands auf, um einen Zeiger auf das Framework abzurufen.
IUIFramework* pFramework = NULL; HRESULT hr = ::CoCreateInstance( CLSID_UIRibbonFramework, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFramework)); if (FAILED(hr)) { return hr; }Initialize(hwnd, IUIApplication*)
Die Anwendung ruft IUIFramework::Initialize auf und übergibt zwei Parameter: das Handle an das Fenster auf oberster Ebene, das das Menüband enthält, und einen Zeiger auf die IUIApplication-Implementierung , mit der das Framework Rückrufe an die Anwendung vornehmen kann.
![Wichtig]
Das Menübandframework wird als Singlethread-Apartment (STA) initialisiert.hr = pFramework->Initialize(hWndHost, pApplication); if (FAILED(hr)) { return hr; }LoadUI(instance, resourceName)
Die Anwendung ruft IUIFramework::LoadUI auf , um die Markupressource zu binden. Der erste Parameter dieser Funktion ist ein Handle für die Menübandanwendung instance. Der zweite Parameter ist der Name der binären Markupressource, die zuvor kompiliert wurde. Durch Übergeben des binären Markups an das Menübandframework signalisiert die Anwendung, wie die Menübandstruktur aussehen soll und wie Steuerelemente angeordnet werden sollen. Außerdem stellt es dem Framework ein Manifest von Befehlen bereit, die verfügbar gemacht werden sollen (z. B. Einfügen, Ausschneiden, Suchen), die vom Framework verwendet werden, wenn es befehlsbezogene Rückrufe zur Laufzeit ausgibt.
hr = pFramework->LoadUI(GetModuleHandle(NULL), L"APPLICATION_RIBBON"); if (FAILED(hr)) { return hr; }IUIApplication::OnCreateUICommand-Rückrufe
Nachdem die Schritte 1 bis 3 abgeschlossen sind, weiß das Menübandframework, welche Befehle im Menüband verfügbar gemacht werden sollen. Das Framework benötigt jedoch noch zwei Dinge, bevor das Menüband voll funktionsfähig ist: eine Möglichkeit, der Anwendung mitzuteilen, wann Befehle ausgeführt werden, und eine Möglichkeit, Befehlsressourcen oder -eigenschaften zur Laufzeit abzurufen. Wenn beispielsweise ein Kombinationsfeld auf der Benutzeroberfläche angezeigt werden soll, muss das Framework nach den Elementen fragen, mit denen das Kombinationsfeld gefüllt werden soll.
Diese beiden Funktionen werden über die IUICommandHandler-Schnittstelle verarbeitet. Insbesondere ruft das Framework für jeden im binären Markup deklarierten Befehl (siehe Schritt 3 oben) IUIApplication::OnCreateUICommand auf, um die Anwendung nach einem IUICommandHandler-Objekt für diesen Befehl zu fragen.
Hinweis
Mit der IUICommandHandler-Schnittstelle kann ein Befehlshandler an einen oder mehrere Befehle gebunden werden.
Die Anwendung ist mindestens erforderlich, um IUIApplication-Methoden-Stubs zu implementieren, die E_NOTIMPL zurückgeben, wie im folgenden Beispiel gezeigt.
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;
}
Verknüpfen des Markups mit der Anwendung
An diesem Punkt müssen die Markupressourcendateien mit der Hostanwendung verknüpft werden, indem in der Anwendungsressourcendatei ein Verweis auf die Markupressourcendefinitionsdatei (die einen Verweis auf die Markupheaderdatei enthält) hinzugefügt werden. Beispielsweise erfordert eine Anwendung namens RibbonApp mit einer Ressourcendatei namens ribbonUI.rc die folgende Zeile in der Datei RibbonApp.rc.
#include "ribbonUI.rc"
Je nach verwendetem Compiler und Linker muss das Ressourcendefinitionsskript möglicherweise auch kompiliert werden, bevor die Menübandanwendung kompiliert werden kann. Das Befehlszeilentool des Ressourcencompilers (RC), das im Lieferumfang von Microsoft Visual Studio und dem Windows SDK enthalten ist, kann für diese Aufgabe verwendet werden.
Kompilieren der Anwendung
Nachdem die Menübandanwendung kompiliert wurde, kann sie ausgeführt und die Benutzeroberfläche getestet werden. Wenn die Benutzeroberfläche optimiert werden muss und keine Änderungen an zugehörigen Befehlshandlern im Kernanwendungscode vorgenommen werden, überarbeiten Sie die Markupquelldatei, kompilieren Sie das Markup mit UICC.exe neu, und verknüpfen Sie die neuen Markupressourcendateien. Wenn die Anwendung neu gestartet wird, wird die geänderte Benutzeroberfläche angezeigt.
All dies ist möglich, ohne den kernigen Anwendungscode zu berühren – eine erhebliche Verbesserung gegenüber der Standardanwendungsentwicklung und -verteilung.
Laufzeit Updates und Ausführungen
Die Laufzeitkommunikationsstruktur des Menübandframeworks basiert auf einem Push- und Pullmodell oder einem bidirektionalen Aufrufermodell.
Dieses Modell ermöglicht es dem Framework, die Anwendung zu informieren, wenn ein Befehl ausgeführt wird, und ermöglicht es sowohl dem Framework als auch der Anwendung, Eigenschaftswerte und Menübandressourcen abzufragen, zu aktualisieren und ungültig zu machen. Diese Funktionalität wird über eine Reihe von Schnittstellen und Methoden bereitgestellt.
Das Framework ruft aktualisierte Eigenschafteninformationen aus der Ribbon-Anwendung über die IUICommandHandler::UpdateProperty-Rückrufmethode ab. Eine Befehls-ID und ein Eigenschaftenschlüssel, der die zu aktualisierende Command-Eigenschaft identifiziert, werden an die -Methode übergeben, die dann einen Wert für diesen Eigenschaftsschlüssel an das Framework zurückgibt oder überträgt.
Das Framework ruft IUICommandHandler::Execute auf, wenn ein Befehl ausgeführt wird, und identifiziert sowohl die Befehls-ID als auch den Typ der ausgeführten Ausführung (UI_EXECUTIONVERB). Hier gibt die Anwendung die Ausführungslogik für einen Befehl an.
Das folgende Diagramm veranschaulicht die Laufzeitkommunikation für die Befehlsausführung zwischen dem Framework und der Anwendung.
Hinweis
Die Implementierung der Funktionen IUICommandHandler::UpdateProperty und IUICommandHandler::Execute ist nicht erforderlich, um zunächst ein Menüband in einer Anwendung anzuzeigen. Diese Methoden sind jedoch erforderlich, um sicherzustellen, dass die Anwendung ordnungsgemäß funktioniert, wenn Befehle vom Benutzer ausgeführt werden.
OLE-Unterstützung
Eine Menübandanwendung kann als OLE-Server konfiguriert werden, um die out-of-place-OLE-Aktivierung zu unterstützen.
Objekte, die in einer OLE-Serveranwendung erstellt werden, behalten ihre Zuordnung zur Serveranwendung bei, wenn sie in eine OLE-Clientanwendung (oder einen Container) eingefügt (eingefügt oder platziert) werden. Wenn Sie bei der out-of-situ-OLE-Aktivierung auf das Objekt in der Clientanwendung doppelklicken, wird eine dedizierte instance der Serveranwendung geöffnet und das Objekt zur Bearbeitung geladen. Wenn die Serveranwendung geschlossen wird, werden alle am Objekt vorgenommenen Änderungen in der Clientanwendung widerzuspiegeln.
Hinweis
Das Menübandframework unterstützt keine direkte OLE-Aktivierung. Objekte, die auf einem menübandbasierten OLE-Server erstellt werden, können nicht innerhalb der OLE-Clientanwendung bearbeitet werden. Ein externer dedizierter instance der Serveranwendung ist erforderlich.
Zugehörige Themen