Migrazione a Windows Ribbon Framework

Articolo
06/13/2023

È possibile eseguire la migrazione di un'applicazione basata su menu, barre degli strumenti e finestre di dialogo tradizionali nell'interfaccia utente avanzata, dinamica e basata sul contesto del sistema di comandi del framework della barra multifunzione di Windows. Si tratta di un modo semplice ed efficace per modernizzare e rigenerare l'applicazione, migliorando al contempo l'accessibilità, l'usabilità e l'individuabilità delle sue funzionalità.

Introduzione

In generale, la migrazione di un'applicazione esistente al framework della barra multifunzione prevede quanto segue:

Progettazione di un layout della barra multifunzione e di un'organizzazione di controllo che espone le funzionalità dell'applicazione esistente ed è sufficientemente flessibile per supportare nuove funzionalità.
Adattamento del codice dell'applicazione esistente.
Migrazione di risorse dell'applicazione esistenti (stringhe e immagini) al framework della barra multifunzione.

Nota

Le linee guida per l'esperienza utente della barra multifunzione devono essere esaminate per determinare se l'applicazione è un candidato adatto per un'interfaccia utente della barra multifunzione.

Progettare il layout della barra multifunzione

È possibile identificare i potenziali layout di interfaccia utente della barra multifunzione eseguendo questi passaggi:

Inventario di tutte le funzionalità esistenti.
Conversione di questa funzionalità in comandi della barra multifunzione.
Organizzazione dei comandi in gruppi logici.

Prendi inventario

Nel framework della barra multifunzione, la funzionalità esposta da un'applicazione che modifica lo stato o la visualizzazione di un'area di lavoro o di un documento viene considerata un comando. Ciò che costituisce un comando può variare e dipende dalla natura e dal dominio dell'applicazione esistente.

La tabella seguente elenca un set di comandi di base per un'applicazione ipotetica di modifica del testo:

Simbolo	ID	Descrizione
ID_FILE_NEW	0xE100	Nuovo documento
ID_FILE_SAVE	0xE103	Salva documento
ID_FILE_SAVEAS	0xE104	Salva con nome... (finestra di dialogo)
ID_FILE_OPEN	0xE101	Aperto... (finestra di dialogo)
ID_FILE_EXIT	0xE102	Uscire dall'applicazione
ID_EDIT_UNDO	0xE12B	Annulla
ID_EDIT_CUT	0xE123	Taglia testo selezionato
ID_EDIT_COPY	0xE122	Copia testo selezionato
ID_EDIT_PASTE	0xE125	Incollare testo dagli Appunti
ID_EDIT_CLEAR	0xE120	Elimina testo selezionato
ID_VIEW_ZOOM	1242	Zoom... (finestra di dialogo)

Esaminare i menu e le barre degli strumenti esistenti durante la creazione di un inventario dei comandi. Considerare tutti i modi in cui un utente può interagire con l'area di lavoro. Anche se non tutti i comandi sono adatti per l'inclusione nella barra multifunzione, questo esercizio può esporre molto bene i comandi precedentemente nascosti dai livelli dell'interfaccia utente.

Traduci

Non tutti i comandi devono essere rappresentati nell'interfaccia utente della barra multifunzione. Ad esempio, l'immissione di testo, la modifica di una selezione, lo scorrimento o lo spostamento del punto di inserimento con il mouse sono tutti qualificati come comandi nell'editor di testo ipotetico, tuttavia, non sono adatti per l'esposizione in una barra dei comandi, in quanto ognuna implica un'interazione diretta con l'interfaccia utente dell'applicazione.

Al contrario, alcune funzionalità potrebbero non essere considerate come un comando nel senso tradizionale. Ad esempio, invece di essere sepolto in una finestra di dialogo, le regolazioni del margine di pagina della stampante possono essere rappresentate nella barra multifunzione come gruppo di controlli Spinner in una scheda contestuale o in modalità applicazione.

Nota

Prendere nota dell'ID numerico che può essere assegnato a ogni comando. Alcuni framework dell'interfaccia utente, ad esempio Microsoft Foundation Classes (MFC), definiscono gli ID per i comandi, ad esempio il file e il menu di modifica (0xE100 a 0xE200).

Organizza

Prima di tentare di organizzare l'inventario dei comandi, è consigliabile esaminare le linee guida per l'esperienza utente della barra multifunzione per le procedure consigliate durante l'implementazione di un'interfaccia utente della barra multifunzione.

In generale, è possibile applicare le regole seguenti all'organizzazione dei comandi della barra multifunzione:

I comandi che operano sul file o sull'applicazione complessiva appartengono più probabilmente al menu dell'applicazione.
I comandi usati di frequente, ad esempio Taglia, Copia e Incolla ,come nell'esempio dell'editor di testo, vengono in genere posizionati in una scheda home predefinita. Nelle applicazioni più complesse possono essere duplicate altrove nell'interfaccia utente della barra multifunzione.
I comandi importanti o usati di frequente possono garantire l'inclusione predefinita nella barra di accesso rapido.

Il framework della barra multifunzione fornisce anche controlli ContextMenu e MiniToolbar tramite la visualizzazione ContextPopup. Queste funzionalità non sono obbligatorie, ma se l'applicazione dispone di uno o più menu di scelta rapida esistenti, la migrazione dei comandi che contengono può consentire il riutilizzo della codebase esistente con l'associazione automatica alle risorse esistenti.

Poiché ogni applicazione è diversa, leggere le linee guida e provare ad applicarle al massimo possibile. Uno degli obiettivi del framework della barra multifunzione è offrire un'esperienza utente familiare e coerente e questo obiettivo sarà più fattibile se le progettazioni per le nuove applicazioni rispecchiano le applicazioni della barra multifunzione esistenti il più possibile.

Adattare il codice

Dopo che i comandi della barra multifunzione sono stati identificati e organizzati in raggruppamenti logici, il numero di passaggi necessari quando si incorpora il framework della barra multifunzione nel codice dell'applicazione esistente dipende dalla complessità dell'applicazione originale. In generale, esistono tre passaggi di base:

Creare il markup della barra multifunzione in base all'organizzazione dei comandi e alla specifica del layout.
Sostituire la funzionalità del menu e della barra degli strumenti legacy con la funzionalità della barra multifunzione.
Implementare un adattatore IUICommandHandler.

Creare il markup

L'elenco dei comandi e la relativa organizzazione e layout vengono dichiarati tramite il file di markup della barra multifunzione utilizzato dal compilatore di markup della barra multifunzione.

Nota

Molti dei passaggi necessari per adattare un'applicazione esistente sono simili a quelli necessari per avviare una nuova applicazione della barra multifunzione. Per altre informazioni, vedere la procedura dettagliata Creazione di un'applicazione della barra multifunzione per una nuova applicazione della barra multifunzione.

Sono disponibili due sezioni principali per il markup della barra multifunzione. La prima sezione è un manifesto dei comandi e delle relative risorse associate (stringhe e immagini). La seconda sezione specifica la struttura e il posizionamento dei controlli sulla barra multifunzione.

Il markup per l'editor di testo semplice potrebbe essere simile all'esempio seguente:

Nota

Le risorse immagine e stringa sono descritte più avanti in questo articolo.

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

Per evitare di ridefinire i simboli definiti da un framework dell'interfaccia utente, ad esempio MFC, l'esempio precedente usa nomi di simboli leggermente diversi per ogni comando (ID_FILE_NEW rispetto a ID_CMD_NEW). Tuttavia, l'ID numerico assegnato a ogni comando deve rimanere invariato.

Per integrare il file di markup in un'applicazione, configurare un passaggio di compilazione personalizzato per eseguire il compilatore di markup della barra multifunzione UICC.exe. I file di intestazione e risorse risultanti vengono quindi incorporati nel progetto esistente. Se l'applicazione della barra multifunzione dell'editor di testo di esempio è denominata "RibbonPad", è necessaria una riga di comando di compilazione personalizzata simile alla seguente:

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

Il compilatore di markup crea un file binario, un file di intestazione (H) e un file di risorse (RC). Poiché l'applicazione esistente ha probabilmente un file RC esistente, includere i file H e RC generati in tale file RC, come illustrato nell'esempio seguente:

#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

Sostituisci menu e barre degli strumenti legacy

La sostituzione di menu e barre degli strumenti standard con una barra multifunzione in un'applicazione legacy richiede quanto segue:

Rimuovere i riferimenti alle risorse della barra degli strumenti e dei menu dal file di risorse dell'applicazione.
Elimina tutto il codice di inizializzazione della barra degli strumenti e della barra dei menu.
Eliminare qualsiasi codice usato per collegare una barra degli strumenti o una barra dei menu alla finestra di primo livello dell'applicazione.
Creare un'istanza del framework della barra multifunzione.
Collegare la barra multifunzione alla finestra di primo livello dell'applicazione.
Caricare il markup compilato.

Importante

Le tabelle di scelta rapida e barra di stato esistenti devono essere mantenute perché il framework della barra multifunzione non sostituisce queste funzionalità.

L'esempio seguente illustra come inizializzare il framework usando IUIFramework::Initialize:

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

L'esempio seguente illustra come usare IUIFramework::LoadUI per caricare il markup compilato:

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

La classe CApplication, a cui si fa riferimento in precedenza, deve implementare una coppia di interfacce COM (Component Object Model) definite dal framework della barra multifunzione: IUIApplication e IUICommandHandler.

IUIApplication fornisce l'interfaccia di callback principale tra il framework e l'applicazione (ad esempio, l'altezza della barra multifunzione viene comunicata tramite IUIApplication::OnViewChanged) mentre i callback per singoli comandi vengono forniti in risposta a IUIApplication::OnCreateUICommand.

Suggerimento: alcuni framework dell'applicazione, ad esempio MFC, richiedono che l'altezza della barra multifunzione venga presa in considerazione durante il rendering dello spazio del documento dell'applicazione. In questi casi, è necessaria l'aggiunta di una finestra nascosta per sovrapporre la barra multifunzione e forzare lo spazio del documento all'altezza desiderata. Per un esempio di questo approccio, in cui viene chiamata una funzione di layout in base all'altezza della barra multifunzione restituita dal metodo IUIRibbon::GetHeight, vedere l'esempio HTMLEditRibbon.

L'esempio di codice seguente illustra un'implementazione di IUIApplication::OnViewChanged :

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

Implementare un adapter IUICommandHandler

A seconda della progettazione dell'applicazione originale, può essere più semplice avere più implementazioni del gestore dei comandi o un singolo gestore di comandi bridging che richiama la logica dei comandi dell'applicazione esistente. Molte applicazioni usano WM_COMMAND messaggi a questo scopo, in cui è sufficiente fornire un unico gestore di comandi all-purpose che inoltra semplicemente i messaggi WM_COMMAND alla finestra di primo livello.

Tuttavia, questo approccio richiede una gestione speciale per i comandi, ad esempio Exit o Close. Poiché la barra multifunzione non può essere eliminata definitivamente durante l'elaborazione di un messaggio di finestra, il messaggio WM_CLOedizione Standard deve essere inviato al thread dell'interfaccia utente dell'applicazione e non deve essere elaborato in modo sincrono, come illustrato nell'esempio seguente:

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

Migrazione delle risorse

Quando è stato definito il manifesto dei comandi, la struttura della barra multifunzione è stata dichiarata e il codice dell'applicazione adattato per ospitare il framework della barra multifunzione, il passaggio finale è la specifica delle risorse stringa e immagine per ogni comando.

Nota

Le risorse stringa e immagine vengono in genere fornite nel file di markup. Tuttavia, possono essere generati o sostituiti a livello di codice implementando il metodo di callback IUICommandHandler::UpdateProperty.

Risorse stringa

Command.LabelTitle è la proprietà stringa più comune definita per un comando. Il rendering viene eseguito come etichette di testo per schede, gruppi e singoli controlli. Una stringa di etichetta da una voce di menu legacy può in genere essere riutilizzata per un oggetto Command.LabelTitle senza modificare molto.

Tuttavia, le convenzioni seguenti sono cambiate con l'avvento della barra multifunzione:

Il suffisso (...) con i puntini di sospensione , usato per indicare un comando di avvio del dialogo, non è più necessario.
La e commerciale (&) può comunque essere usata per indicare un tasto di scelta rapida per un comando visualizzato in un menu, ma la proprietà Command.Keytip supportata dal framework soddisfa uno scopo simile.

Facendo riferimento all'esempio dell'editor di testo, è possibile specificare le stringhe seguenti per LabelTitle e Keytip:

Simbolo	Stringa originale	Stringa LabelTitle	Stringa di descrizione chiave
ID_FILE_NEW	&Nuovo	&Nuovo	N
ID_FILE_SAVE	&Salva	&Salva	S
ID_FILE_SAVEAS	Salva con nome...	Salva con nome	Un
ID_FILE_OPEN	&Apri...	&Apri	O
ID_FILE_EXIT	&Esci	&Esci	X
ID_EDIT_UNDO	&Annulla	Annulla	Z
ID_EDIT_CUT	Cu&t	Cu&t	X
ID_EDIT_COPY	&Copia	&Copia	A
ID_EDIT_PASTE	&Incolla	&Incolla	V
ID_EDIT_CLEAR	&elimina	&elimina	D
ID_VIEW_ZOOM	&Zoom...	Zoom	Z

Di seguito è riportato un elenco di altre proprietà stringa che devono essere impostate nella maggior parte dei comandi:

Le schede, i gruppi e altre funzionalità dell'interfaccia utente della barra multifunzione possono ora essere dichiarate con tutte le risorse stringa e immagine specificate.

Nell'esempio di markup della barra multifunzione seguente vengono illustrate varie risorse stringa:

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

Risorse immagine

Il framework della barra multifunzione supporta formati di immagine che offrono un aspetto molto più completo rispetto ai formati di immagine supportati dai componenti del menu e della barra degli strumenti precedenti.

Per Windows 8 e versioni successive, il framework della barra multifunzione supporta i formati grafici seguenti: file bitmap ARGB (BMP) a 32 bit e file PNG (Portable Network Graphics) con trasparenza.

Per Windows 7 e versioni precedenti, le risorse immagine devono essere conformi al formato di grafica BMP standard usato in Windows.

Nota

I file di immagine esistenti possono essere convertiti in entrambi i formati. Tuttavia, i risultati potrebbero essere meno soddisfacenti se i file di immagine non supportano l'anti-aliasing e la trasparenza.

Non è possibile specificare una singola dimensione predefinita per le risorse immagine nel framework della barra multifunzione. Tuttavia, per supportare il layout adattivo dei controlli, le immagini possono essere specificate in due dimensioni (grandi e piccole). Tutte le immagini nel framework della barra multifunzione vengono ridimensionate in base alla risoluzione dei punti per pollice (dpi) dello schermo con le dimensioni esatte di cui è stato eseguito il rendering dipendono da questa impostazione dpi. Per altre informazioni, vedere Specifica delle risorse dell'immagine della barra multifunzione.

L'esempio seguente illustra come viene fatto riferimento a un set di immagini specifiche dpi nel markup:

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

Specifica delle risorse dell'immagine della barra multifunzione

Condividi tramite

Migrazione a Windows Ribbon Framework

Introduzione

Progettare il layout della barra multifunzione

Prendi inventario

Traduci

Organizza

Adattare il codice

Creare il markup

Sostituisci menu e barre degli strumenti legacy

Implementare un adapter IUICommandHandler

Migrazione delle risorse

Risorse stringa

Risorse immagine

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Migrazione a Windows Ribbon Framework

Introduzione

Progettare il layout della barra multifunzione

Prendi inventario

Traduci

Organizza

Adattare il codice

Creare il markup

Sostituisci menu e barre degli strumenti legacy

Implementare un adapter IUICommandHandler

Migrazione delle risorse

Risorse stringa

Risorse immagine

Argomenti correlati

Commenti e suggerimenti

Risorse aggiuntive