Migrieren zum Windows-Menübandframework

Artikel
06/13/2023

Eine Anwendung, die auf herkömmlichen Menüs, Symbolleisten und Dialogen basiert, kann zur umfangreichen, dynamischen und kontextgesteuerten Benutzeroberfläche des Windows-Menübandframeworkbefehlssystems migriert werden. Dies ist eine einfache und effektive Möglichkeit, die Anwendung zu modernisieren und zu revitalisieren und gleichzeitig die Barrierefreiheit, Benutzerfreundlichkeit und Auffindbarkeit der Funktionalität zu verbessern.

Einführung

Im Allgemeinen umfasst die Migration einer vorhandenen Anwendung zum Menübandframework Folgendes:

Das Entwerfen eines Menübandlayouts und -steuerelements organization, das die Funktionalität der vorhandenen Anwendung verfügbar macht und flexibel genug ist, um neue Funktionen zu unterstützen.
Anpassen des Codes der vorhandenen Anwendung.
Migrieren vorhandener Anwendungsressourcen (Zeichenfolgen und Images) zum Menübandframework.

Hinweis

Die Richtlinien für die Benutzeroberfläche des Menübands sollten überprüft werden, um festzustellen, ob die Anwendung ein geeigneter Kandidat für eine Menüband-Benutzeroberfläche ist.

Entwerfen des Menübandlayouts

Durch Ausführen der folgenden Schritte können Potenzielle Designs und Steuerelementlayouts des Menübands identifiziert werden:

Bestandsaufnahme aller vorhandenen Funktionen.
Übersetzen dieser Funktionalität in Menübandbefehle.
Organisieren der Befehle in logischen Gruppen.

Bestandserfassung

Im Menübandframework wird die von einer Anwendung verfügbar gemachte Funktionalität, die den Zustand oder die Ansicht eines Arbeitsbereichs oder Dokuments bearbeitet, als Befehl betrachtet. Was einen Befehl ausmacht, kann variieren und hängt von der Art und Domäne der vorhandenen Anwendung ab.

Die folgende Tabelle enthält eine Reihe grundlegender Befehle für eine hypothetische Textbearbeitungsanwendung:

Symbol	id	BESCHREIBUNG
ID_FILE_NEW	0xE100	Neues Dokument
ID_FILE_SAVE	0xE103	Dokument speichern
ID_FILE_SAVEAS	0xE104	Speichern unter... (Dialog)
ID_FILE_OPEN	0xE101	Öffnen... (Dialog)
ID_FILE_EXIT	0xE102	Beenden der Anwendung
ID_EDIT_UNDO	0xE12B	Rückgängig
ID_EDIT_CUT	0xE123	Markierten Text ausschneiden
ID_EDIT_COPY	0xE122	Kopieren von ausgewähltem Text
ID_EDIT_PASTE	0xE125	Einfügen von Text aus zwischenablage
ID_EDIT_CLEAR	0xE120	Markierten Text löschen
ID_VIEW_ZOOM	1242	Zoom... (Dialog)

Sehen Sie sich beim Erstellen eines Befehlsbestands über vorhandene Menüs und Symbolleisten hinaus. Berücksichtigen Sie alle Möglichkeiten, wie ein Benutzer mit dem Arbeitsbereich interagieren kann. Auch wenn nicht jeder Befehl für die Aufnahme in das Menüband geeignet ist, kann diese Übung sehr gut Befehle verfügbar machen, die zuvor durch Ebenen der Benutzeroberfläche verdeckt wurden.

Übersetzung

Nicht jeder Befehl muss auf der Menüband-Benutzeroberfläche dargestellt werden. Die Eingabe von Text, das Ändern einer Auswahl, das Scrollen oder das Verschieben der Einfügemarke mit der Maus gelten als Befehle im hypothetischen Text-Editor. Diese sind jedoch nicht geeignet, um in einer Befehlsleiste verfügbar zu machen, da jeder eine direkte Interaktion mit der Benutzeroberfläche der Anwendung beinhaltet.

Umgekehrt kann man sich einige Funktionen nicht als Befehl im herkömmlichen Sinne vordenken. Anstatt beispielsweise in einem Dialogfeld zu vergraben, können Seitenrandanpassungen des Druckers im Menüband als Gruppe von Spinner-Steuerelementen in einer kontextbezogenen Registerkarte oder im Anwendungsmodus dargestellt werden.

Hinweis

Notieren Sie sich die numerische ID, die jedem Befehl zugewiesen werden kann. Einige Benutzeroberflächenframeworks, z. B. Microsoft Foundation-Klassen (MFC), definieren IDs für Befehle wie das Datei- und Das Bearbeitungsmenü (0xE100 zu 0xE200).

Organisieren

Bevor Sie versuchen, den Befehlsbestand zu organisieren, sollten die Richtlinien für die Benutzeroberfläche des Menübands auf bewährte Methoden beim Implementieren einer Menübandbenutzeroberfläche überprüft werden.

Im Allgemeinen können die folgenden Regeln auf menübandbefehl organization angewendet werden:

Befehle, die für die Datei oder die gesamte Anwendung ausgeführt werden, gehören wahrscheinlich in das Anwendungsmenü.
Häufig verwendete Befehle wie Ausschneiden, Kopieren und Einfügen (wie im Text-Editor-Beispiel) werden normalerweise auf einer Standardregisterkarte platziert. In komplexeren Anwendungen können sie an anderer Stelle auf der Menübandbenutzeroberfläche dupliziert werden.
Wichtige oder häufig verwendete Befehle können die Standardeinfügung in der Symbolleiste für den Schnellzugriff rechtfertigen.

Das Menübandframework stellt auch ContextMenu- und MiniToolbar-Steuerelemente über die ContextPopup-Ansicht bereit. Diese Features sind nicht obligatorisch, aber wenn Ihre Anwendung über ein oder mehrere Kontextmenüs verfügt, kann die Migration der enthaltenen Befehle die Wiederverwendung der vorhandenen Codebasis mit automatischer Bindung an vorhandene Ressourcen ermöglichen.

Da jede Anwendung anders ist, lesen Sie die Richtlinien, und versuchen Sie, sie so weit wie möglich anzuwenden. Eines der Ziele des Menübandframeworks besteht darin, eine vertraute, konsistente Benutzeroberfläche zu bieten, und dieses Ziel ist besser erreichbar, wenn Designs für neue Anwendungen so weit wie möglich vorhandene Menübandanwendungen Spiegel.

Anpassen ihres Codes

Nachdem die Menübandbefehle identifiziert und in logische Gruppierungen organisiert wurden, hängt die Anzahl der Schritte beim Integrieren des Menübandframeworks in vorhandenen Anwendungscode von der Komplexität der ursprünglichen Anwendung ab. Im Allgemeinen gibt es drei grundlegende Schritte:

Erstellen Sie das Menübandmarkup basierend auf der Befehls- organization- und Layoutspezifikation.
Ersetzen Sie legacy-Menü- und Symbolleistenfunktionen durch Menübandfunktionen.
Implementieren Sie einen IUICommandHandler-Adapter.

Erstellen des Markups

Die Liste der Befehle sowie deren organization und Layout werden über die Menübandmarkupdatei deklariert, die vom Markupcompiler des Menübands verwendet wird.

Hinweis

Viele der Schritte, die zum Anpassen einer vorhandenen Anwendung erforderlich sind, ähneln denen, die zum Starten einer neuen Menübandanwendung erforderlich sind. Weitere Informationen finden Sie im Tutorial Erstellen einer Menübandanwendung für eine neue Menübandanwendung.

Das Menübandmarkup enthält zwei hauptabschnitte. Der erste Abschnitt ist ein Manifest der Befehle und der zugehörigen Ressourcen (Zeichenfolgen und Bilder). Im zweiten Abschnitt wird die Struktur und Platzierung von Steuerelementen im Menüband angegeben.

Das Markup für den einfachen Text-Editor könnte etwa wie das folgende Beispiel aussehen:

Hinweis

Bild- und Zeichenfolgenressourcen werden weiter unten in diesem Artikel behandelt.

<?xml version="1.0" encoding="utf-8"?>
<Application xmlns="http://schemas.microsoft.com/windows/2009/Ribbon">

  <Application.Commands>
    <Command Name="cmdNew" Id="0xE100" Symbol="ID_CMD_NEW" LabelTitle="New document" />
    <Command Name="cmdSave" Id="0xE103" Symbol="ID_CMD_SAVE" LabelTitle="Save" />
    <Command Name="cmdSaveAs" Id="0xE104" Symbol="ID_CMD_SAVEAS" LabelTitle="Save as" />
    <Command Name="cmdOpen" Id="0xE101" Symbol="ID_CMD_OPEN" LabelTitle="Open" />
    <Command Name="cmdExit" Id="0xE102" Symbol="ID_CMD_EXIT" LabelTitle="Exit" />
    <Command Name="cmdUndo" Id="0xE12B" Symbol="ID_CMD_UNDO" LabelTitle="Undo" />
    <Command Name="cmdCut" Id="0xE123" Symbol="ID_CMD_CUT" LabelTitle="Cut" />
    <Command Name="cmdCopy" Id="0xE122" Symbol="ID_CMD_COPY" LabelTitle="Copy" />
    <Command Name="cmdPaste" Id="0xE125" Symbol="ID_CMD_PASTE" LabelTitle="Paste" />
    <Command Name="cmdDelete" Id="0xE120" Symbol="ID_CMD_DELETE" LabelTitle="Delete" />
    <Command Name="cmdZoom" Id="1242" Symbol="ID_CMD_ZOOM" LabelTitle="Zoom" />
  </Application.Commands>

  <Application.Views>
    <Ribbon>
      <Ribbon.ApplicationMenu>
        <ApplicationMenu>
          <MenuGroup>
            <Button CommandName="cmdNew" />
            <Button CommandName="cmdOpen" />
            <Button CommandName="cmdSave" />
            <Button CommandName="cmdSaveAs" />
          </MenuGroup>
          <MenuGroup>
            <Button CommandName="cmdExit" />
          </MenuGroup>
        </ApplicationMenu>
      </Ribbon.ApplicationMenu>
      <Ribbon.QuickAccessToolbar>
        <QuickAccessToolbar>
          <QuickAccessToolbar.ApplicationDefaults>
            <Button CommandName="cmdSave" />
            <Button CommandName="cmdUndo" />
          </QuickAccessToolbar.ApplicationDefaults>
        </QuickAccessToolbar>
      </Ribbon.QuickAccessToolbar>
      <Ribbon.Tabs>
        <Tab>
          <Group CommandName="grpClipboard" SizeDefinition="FourButtons">
            <Button CommandName="cmdPaste" />
            <Button CommandName="cmdCut" />
            <Button CommandName="cmdCopy" />
            <Button CommandName="cmdDelete" />
          </Group>
        </Tab>
        <Tab>
          <Group CommandName="grpView" SizeDefinition="OneButton">
            <Button CommandName="cmdZoom" />
          </Group>
        </Tab>
      </Ribbon.Tabs>
    </Ribbon>
  </Application.Views>

</Application>

Um zu vermeiden, dass Symbole, die von einem Benutzeroberflächenframework wie MFC definiert werden, neu definiert werden, verwendet das vorherige Beispiel geringfügig andere Symbolnamen für jeden Befehl (ID_FILE_NEW im Vergleich zu ID_CMD_NEW). Die numerische ID, die jedem Befehl zugewiesen ist, muss jedoch gleich bleiben.

Um die Markupdatei in eine Anwendung zu integrieren, konfigurieren Sie einen benutzerdefinierten Buildschritt, um den Markupcompiler des Menübands auszuführen, UICC.exe. Die resultierenden Header- und Ressourcendateien werden dann in das vorhandene Projekt integriert. Wenn die Beispiel-Text-Editor-Menübandanwendung den Namen "RibbonPad" trägt, ist eine benutzerdefinierte Build-Befehlszeile wie die folgende erforderlich:

UICC.exe res\RibbonPad_ribbon.xml res\RibbonPad_ribbon.bin 
         /header:res\RibbonPad_ribbon.h /res:res\RibbonPad_ribbon.rc2

Der Markupcompiler erstellt eine Binärdatei, eine Headerdatei (H) und eine Ressourcendatei (RC). Da die vorhandene Anwendung wahrscheinlich über eine vorhandene RC-Datei verfügt, schließen Sie die generierten H- und RC-Dateien in diese RC-Datei ein, wie im folgenden Beispiel gezeigt:

#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//

#define _AFX_NO_SPLITTER_RESOURCES
#define _AFX_NO_OLE_RESOURCES
#define _AFX_NO_TRACKER_RESOURCES
#define _AFX_NO_PROPERTY_RESOURCES

#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
LANGUAGE 9, 1
#pragma code_page(1252)

#include "res\RibbonPad_ribbon.h"  // Ribbon resources
#include "res\RibbonPad_ribbon.rc2"  // Ribbon resources

#include "res\RibbonPad.rc2"  // non-Microsoft Visual C++ edited resources
#include "afxres.rc"    // Standard components
#include "afxprint.rc"  // printing/print preview resources
#endif
#endif    // not APSTUDIO_INVOKED

Ersetzen von Legacymenüs und Symbolleisten

Das Ersetzen von Standardmenüs und Symbolleisten durch ein Menüband in einer Legacyanwendung erfordert Folgendes:

Entfernen Sie Symbolleisten- und Menüressourcenverweise aus der Ressourcendatei der Anwendung.
Löschen Sie den gesamten Symbolleisten- und Menüleisteninitialisierungscode.
Löschen Sie code, der zum Anfügen einer Symbolleiste oder Menüleiste an das Fenster der obersten Ebene der Anwendung verwendet wird.
Instanziieren Sie das Menübandframework.
Fügen Sie das Menüband an das Fenster der obersten Ebene der Anwendung an.
Laden Sie das kompilierte Markup.

Wichtig

Vorhandene status Balken- und Tastenkombinationstabellen sollten beibehalten werden, da das Menübandframework diese Features nicht ersetzt.

Im folgenden Beispiel wird veranschaulicht, wie Sie das Framework mithilfe von IUIFramework::Initialize initialisieren:

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
        return -1;
    
    if (!m_RibbonBar.Create(this, WS_CHILD|WS_DISABLED|WS_VISIBLE|CBRS_TOP|CBRS_HIDE_INPLACE,0))
        return -1;      // fail to create

    if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators,sizeof(indicators)/sizeof(UINT)))
        return -1;      // fail to create

    // Ribbon initialization
    InitRibbon(this, &m_spUIFramework);

    return 0;
}

Im folgenden Beispiel wird veranschaulicht, wie IUIFramework::LoadUI zum Laden des kompilierten Markups verwendet wird:

HRESULT InitRibbon(CMainFrame* pMainFrame, IUnknown** ppFramework)
{
    // Create the IUIFramework instance.
    CComPtr<IUIFramework> spFramework;
    HRESULT hr = ::CoCreateInstance(CLSID_UIRibbonFramework, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spFramework));
    if (FAILED(hr))
        return hr;
    
    // Instantiate the CApplication object.
    CComObject<CApplication>* pApplication;
    hr = CComObject<CApplication>::CreateInstance(&pApplication);   // Refcount is 0
    
    // Call AddRef on the CApplication object. The smart pointer will release the refcount when it is out of scope.
    CComPtr< CComObject<CApplication> > spApplication(pApplication);

    if (FAILED(hr))
        return hr;

    // Initialize and load the Ribbon.
    spApplication->Initialize(pMainFrame);

    hr = spFramework->Initialize(*pMainFrame, spApplication);
    if (FAILED(hr))
        return hr;

    hr = spFramework->LoadUI(GetModuleHandle(NULL), L"APPLICATION_RIBBON");
    if (FAILED(hr))
        return hr;

    // Return IUIFramework interface to the caller.
    hr = spFramework->QueryInterface(ppFramework);

    return hr;
}

Die oben erwähnte CApplication-Klasse muss ein Paar von COM-Schnittstellen (Component Object Model) implementieren, die vom Menübandframework definiert sind: IUIApplication und IUICommandHandler.

IUIApplication stellt die Standard Rückrufschnittstelle zwischen dem Framework und der Anwendung bereit (z. B. wird die Höhe des Menübands über IUIApplication::OnViewChanged kommuniziert), während die Rückrufe für einzelne Befehle als Antwort auf IUIApplication::OnCreateUICommand bereitgestellt werden.

Tipp: Einige Anwendungsframeworks, z. B. MFC, erfordern, dass die Höhe der Menübandleiste beim Rendern des Dokumentraums der Anwendung berücksichtigt wird. In diesen Fällen ist das Hinzufügen eines ausgeblendeten Fensters erforderlich, um die Menübandleiste zu überlagern und den Dokumentraum auf die gewünschte Höhe zu zwingen. Ein Beispiel für diesen Ansatz, bei dem eine Layoutfunktion basierend auf der von der IUIRibbon::GetHeight-Methode zurückgegebenen Menübandhöhe aufgerufen wird, finden Sie im HTMLEditRibbon-Beispiel.

Im folgenden Codebeispiel wird eine IUIApplication::OnViewChanged-Implementierung veranschaulicht:

// This is the Ribbon implementation that is done by an application.
// Applications have to implement IUIApplication and IUICommandHandler to set up communication with the Windows Ribbon.
class CApplication
    : public CComObjectRootEx<CComSingleThreadModel>
    , public IUIApplication
    , public IUICommandHandler
{
public:

    BEGIN_COM_MAP(CApplication)
        COM_INTERFACE_ENTRY(IUIApplication)
        COM_INTERFACE_ENTRY(IUICommandHandler)
    END_COM_MAP()

    CApplication() : _pMainFrame(NULL)
    {
    }

    void Initialize(CMainFrame* pFrame)
    {
        // Hold a reference to the main frame.
        _pMainFrame = pFrame;
    }

    void FinalRelease()
    {
        // Release the reference.
        _pMainFrame = NULL;
        __super::FinalRelease();
    }

    STDMETHOD(OnViewChanged)(UINT32 nViewID, __in UI_VIEWTYPE typeID, __in IUnknown* pView, UI_VIEWVERB verb, INT32 uReasonCode)
    {
        HRESULT hr;

        // The Ribbon size has changed.
        if (verb == UI_VIEWVERB_SIZE)
        {
            CComQIPtr<IUIRibbon> pRibbon = pView;
            if (!pRibbon)
                return E_FAIL;

            UINT ulRibbonHeight;
            // Get the Ribbon height.
            hr = pRibbon->GetHeight(&ulRibbonHeight);
            if (FAILED(hr))
                return hr;

            // Update the Ribbon bar so that the main frame can recalculate the child layout.
            _pMainFrame->m_RibbonBar.SetRibbonHeight(ulRibbonHeight);
            _pMainFrame->RecalcLayout();
        }

        return S_OK;
    }

    STDMETHOD(OnCreateUICommand)(UINT32 nCmdID, 
                               __in UI_COMMANDTYPE typeID,
                               __deref_out IUICommandHandler** ppCommandHandler)
    {
        // This application uses one command handler for all ribbon commands.
        return QueryInterface(IID_PPV_ARGS(ppCommandHandler));
    }

    STDMETHOD(OnDestroyUICommand)(UINT32 commandId, __in UI_COMMANDTYPE typeID,  __in_opt  IUICommandHandler *commandHandler)
    {        
        return E_NOTIMPL;
    }

private:
    CMainFrame* _pMainFrame;
};

Implementieren eines IUICommandHandler-Adapters

Je nach Entwurf der ursprünglichen Anwendung kann es einfacher sein, mehrere Command-Handlerimplementierungen oder einen einzelnen Bridging Command-Handler zu verwenden, der die Befehlslogik der vorhandenen Anwendung aufruft. Viele Anwendungen verwenden zu diesem Zweck WM_COMMAND Nachrichten, bei denen es ausreicht, einen einzigen Allzweckbefehlshandler bereitzustellen, der einfach WM_COMMAND Nachrichten an das Fenster der obersten Ebene weiterleitet.

Dieser Ansatz erfordert jedoch eine spezielle Behandlung für Befehle wie Beenden oder Schließen. Da das Menüband während der Verarbeitung einer Fensternachricht nicht zerstört werden kann, sollte die WM_CLOSE Nachricht an den UI-Thread der Anwendung gesendet und nicht synchron verarbeitet werden, wie im folgenden Beispiel gezeigt:

// User action callback, with transient execution parameters.
    STDMETHODIMP Execute(UINT nCmdID,
        UI_EXECUTIONVERB verb, 
        __in_opt const PROPERTYKEY* key,
        __in_opt const PROPVARIANT* ppropvarValue,
        __in_opt IUISimplePropertySet* pCommandExecutionProperties)
    {       
        switch(nCmdID)
        {
        case cmdExit:
            ::PostMessage(*_pMainFrame, WM_CLOSE, nCmdID, 0);
            break;
        default:
            ::SendMessage(*_pMainFrame, WM_COMMAND, nCmdID, 0);
        }
        return S_OK;
    }

    STDMETHODIMP UpdateProperty(UINT32 nCmdID, 
                                __in REFPROPERTYKEY key,
                                __in_opt  const PROPVARIANT *currentValue,
                                __out PROPVARIANT *newValue) 
    {        
        return S_OK;
    }

Migrieren von Ressourcen

Wenn das Manifest von Befehlen definiert, die Struktur des Menübands deklariert und der Anwendungscode zum Hosten des Menübandframeworks angepasst wurde, ist der letzte Schritt die Spezifikation der Zeichenfolgen- und Bildressourcen für jeden Befehl.

Hinweis

Zeichenfolgen- und Bildressourcen werden in der Regel in der Markupdatei bereitgestellt. Sie können jedoch programmgesteuert generiert oder ersetzt werden, indem die IUICommandHandler::UpdateProperty-Rückrufmethode implementiert wird.

Zeichenfolgenressourcen

Command.LabelTitle ist die am häufigsten für einen Befehl definierte Zeichenfolgeneigenschaft. Diese werden als Textbeschriftungen für Registerkarten, Gruppen und einzelne Steuerelemente gerendert. Eine Bezeichnungszeichenfolge aus einem Legacymenüelement kann in der Regel ohne große Bearbeitung für ein Command.LabelTitle-Element wiederverwendet werden.

Die folgenden Konventionen haben sich jedoch mit dem Aufkommen des Menübands geändert:

Das Suffix mit den Auslassungspunkten (...), das zum Anzeigen eines Dialogstartbefehls verwendet wird, ist nicht mehr erforderlich.
Ampersand (&) kann weiterhin verwendet werden, um eine Tastenkombination für einen Befehl anzugeben, der in einem Menü angezeigt wird, aber die vom Framework unterstützte Command.Keytip-Eigenschaft erfüllt einen ähnlichen Zweck.

Wenn Sie auf das Beispiel des Text-Editors verweisen, können die folgenden Zeichenfolgen für LabelTitle und Keytip angegeben werden:

Symbol	Ursprüngliche Zeichenfolge	LabelTitle-Zeichenfolge	KeyTIP-Zeichenfolge
ID_FILE_NEW	&Neu	&Neu	N
ID_FILE_SAVE	&Speichern	&Speichern	E
ID_FILE_SAVEAS	Speichern unter &...	Speichern unter &	A
ID_FILE_OPEN	&Öffnen...	&Öffnen	O
ID_FILE_EXIT	Been&den	Been&den	X
ID_EDIT_UNDO	&Rückgängig	Rückgängig	Z
ID_EDIT_CUT	Cu&t	Cu&t	X
ID_EDIT_COPY	&Kopieren	&Kopieren	C
ID_EDIT_PASTE	&Einfügen	&Einfügen	V
ID_EDIT_CLEAR	&Löschen	&Löschen	D
ID_VIEW_ZOOM	&Zoom...	Zoom	Z

Im Folgenden finden Sie eine Liste anderer Zeichenfolgeneigenschaften, die für die meisten Befehle festgelegt werden sollten:

Registerkarten, Gruppen und andere Features der Menüband-Benutzeroberfläche können jetzt mit allen angegebenen Zeichenfolgen- und Bildressourcen deklariert werden.

Im folgenden Menübandmarkupbeispiel werden verschiedene Zeichenfolgenressourcen veranschaulicht:

<Application.Commands>
    <!-- Tabs -->
    <Command Name="tabHome" LabelTitle="Home" Keytip="H" />
    <Command Name="tabView" LabelTitle="View" Keytip="V" />

    <!-- Groups -->
    <Command Name="grpClipboard" LabelTitle="Clipboard" />
    <Command Name="grpZoom" LabelTitle="Zoom" />

    <!-- App menu commands -->
    <Command Name="cmdNew" Id="0xE100" Symbol="ID_CMD_NEW" LabelTitle="New document" Keytip="N" >
      <Command.TooltipTitle>New (Ctrl+N)</Command.TooltipTitle>
      <Command.TooltipDescription>Create a new document.</Command.TooltipDescription>
    </Command>
    <Command Name="cmdSave" Id="0xE103" Symbol="ID_CMD_SAVE" LabelTitle="Save" Keytip="S">
      <Command.TooltipTitle>Save (Ctrl+S)</Command.TooltipTitle>
      <Command.TooltipDescription>Save the current document.</Command.TooltipDescription>
    </Command>
    <Command Name="cmdSaveAs" Id="0xE104" Symbol="ID_CMD_SAVEAS" LabelTitle="Save as" Keytip="A">
      <Command.TooltipDescription>Save the current document with a new name.</Command.TooltipDescription>
    </Command>
    <Command Name="cmdOpen" Id="0xE101" Symbol="ID_CMD_OPEN" LabelTitle="Open" Keytip="O">
      <Command.TooltipTitle>Open (Ctrl+O)</Command.TooltipTitle>
      <Command.TooltipDescription>Open a document.</Command.TooltipDescription>
    </Command>
    <Command Name="cmdExit" Id="0xE102" Symbol="ID_CMD_EXIT" LabelTitle="Exit" Keytip="X">
      <Command.TooltipDescription>Exit the application.</Command.TooltipDescription>
    </Command>

    <!-- ...other commands -->

  </Application.Commands>

Bildressourcen

Das Menübandframework unterstützt Bildformate, die ein wesentlich reichhaltigeres Erscheinungsbild bieten als die Bildformate, die von vorherigen Menü- und Symbolleistenkomponenten unterstützt werden.

Für Windows 8 und höher unterstützt das Menübandframework die folgenden Grafikformate: 32-Bit-ARGB-Bitmapdateien (BMP) und PNG-Dateien (Portable Network Graphics) mit Transparenz.

Für Windows 7 und früher müssen Bildressourcen dem in Windows verwendeten Standard-BMP-Grafikformat entsprechen.

Hinweis

Vorhandene Bilddateien können in beide Formate konvertiert werden. Die Ergebnisse können jedoch weniger als zufriedenstellend sein, wenn die Bilddateien keine Antialiasing und Transparenz unterstützen.

Es ist nicht möglich, eine einzelne Standardgröße für Bildressourcen im Menübandframework anzugeben. Zur Unterstützung des adaptiven Layouts von Steuerelementen können Bilder jedoch in zwei Größen (groß und klein) angegeben werden. Alle Bilder im Menübandframework werden entsprechend der Dpi-Auflösung (Dots per Inch) der Anzeige skaliert, wobei die genaue gerenderte Größe abhängig von dieser DPI-Einstellung ist. Weitere Informationen finden Sie unter Angeben von Menübandbildressourcen .

Im folgenden Beispiel wird veranschaulicht, wie im Markup auf eine Gruppe von dpi-spezifischen Bildern verwiesen wird:

<Command Name="cmdNew" Id="0xE100" Symbol="ID_CMD_NEW" LabelTitle="New document" Keytip="N" >
      <Command.TooltipTitle>New (Ctrl+N)</Command.TooltipTitle>
      <Command.TooltipDescription>Create a new document.</Command.TooltipDescription>
      <Command.LargeImages>
        <Image Source="cmdNew-32px.png" MinDPI="96" />
        <Image Source="cmdNew-40px.png" MinDPI="120" />
        <Image Source="cmdNew-48px.png" MinDPI="144" />
        <Image Source="cmdNew-64px.png" MinDPI="192" />
      </Command.LargeImages>
      <Command.SmallImages>
        <Image Source="cmdNew-16px.png" MinDPI="96" />
        <Image Source="cmdNew-20px.png" MinDPI="120" />
        <Image Source="cmdNew-24px.png" MinDPI="144" />
        <Image Source="cmdNew-32px.png" MinDPI="192" />
      </Command.SmallImages>
    </Command>

Angeben von Menübandbildressourcen

Freigeben über

Migrieren zum Windows-Menübandframework

Einführung

Entwerfen des Menübandlayouts

Bestandserfassung

Übersetzung

Organisieren

Anpassen ihres Codes

Erstellen des Markups

Ersetzen von Legacymenüs und Symbolleisten

Implementieren eines IUICommandHandler-Adapters

Migrieren von Ressourcen

Zeichenfolgenressourcen

Bildressourcen

Feedback

Zusätzliche Ressourcen

Freigeben über

Migrieren zum Windows-Menübandframework

Einführung

Entwerfen des Menübandlayouts

Bestandserfassung

Übersetzung

Organisieren

Anpassen ihres Codes

Erstellen des Markups

Ersetzen von Legacymenüs und Symbolleisten

Implementieren eines IUICommandHandler-Adapters

Migrieren von Ressourcen

Zeichenfolgenressourcen

Bildressourcen

Zugehörige Themen

Feedback

Zusätzliche Ressourcen