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
  • Kompilieren des Markups
• Erstellen der Anwendung
  • Initialisieren des Menübands
  • Verknüpfen des Markups mit der Anwendung
  • Kompilieren 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.

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>
        

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.

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.

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

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

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

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

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.

Zugehörige Themen

Deklarieren von Befehlen und Steuerelementen mit Menübandmarkup

Richtlinien für die Benutzeroberfläche des Menübands

Menübandentwurfsprozess