Schriftart-Steuerelement
Um die Integration und Konfiguration der Schriftartunterstützung in Anwendungen zu vereinfachen, die Textverarbeitungs- und Textbearbeitungsfunktionen erfordern, stellt das Windows-Menübandframework ein spezialisiertes Schriftarten-Steuerelement bereit, das eine Vielzahl von Schriftarteigenschaften verfügbar macht, z. B. Schriftartname, Stil, Punktgröße und Effekte.
- Introduction (Einführung)
- Eine konsistente Erfahrung
- Einfache Integration und Konfiguration
- Ausrichtung an allgemeinen GDI-Textstrukturen
- Hinzufügen eines FontControl-Objekts
- Definieren eines FontControl-Befehlshandlers
- Zugehörige Themen
Einführung
Das Schriftart-Steuerelement ist ein zusammengesetztes Steuerelement, das aus Schaltflächen, Umschaltflächen, Dropdownlistenfeldern und Kombinationsfeldern besteht, die alle zum Angeben einer bestimmten Schriftarteigenschaft oder Formatierungsoption verwendet werden.
Der folgende Screenshot zeigt das Menüband-Schriftart-Steuerelement in WordPad für Windows 7.

Eine konsistente Erfahrung
Als integriertes Menüband-Steuerelement verbessert das Schriftarten-Steuerelement die allgemeine Schriftartverwaltung, Auswahl und Formatierung und bietet eine umfassende, konsistente Benutzeroberfläche für alle Menübandanwendungen.
Zu dieser konsistenten Erfahrung gehören:
Standardisierte Formatierung und Auswahl von Schriftarten in Menübandanwendungen.
Standardisierte Schriftdarstellung über Menübandanwendungen hinweg.
Automatische Schriftartaktivierung in Windows 7, die auf der Einstellung Ein- oder Ausblenden für jede Schriftart in der Systemsteuerung Schriftarten basiert. Das Schriftart-Steuerelement zeigt nur die Schriftarten an, die auf Anzeigen festgelegt sind.
Hinweis
In Windows Vista bietet die Systemsteuerung Schriftarten nicht die Funktion Ein- oder Ausblenden, sodass alle Schriftarten aktiviert sind.
Die Schriftartverwaltung, die direkt über das -Steuerelement verfügbar ist.
Der folgende Screenshot zeigt, dass direkt über das Schriftart-Steuerelement auf die Systemsteuerung Schriftarten zugegriffen werden kann.

Unterstützung für die automatische Vorschau.
Verfügbar werden Schriftarten, die für einen Benutzer am relevantesten sind, z. B.
- Lokalisierte Schriftartlisten für internationale Benutzer.
- Schriftartlisten basierend auf dem Eingabegerät.
Hinweis
Unterstützung für diese Funktionalität ist auf einer Plattform, die älter als Windows 7 ist, nicht verfügbar.
Einfache Integration und Konfiguration
Durch die Bereitstellung von standarden, wiederverwendbaren und einfach zu nutzenden Funktionen erleichtert das Menüband-Schriftarten-Steuerelement die Integration der Schriftartunterstützung in eine Anwendung.
Die Details der Schriftartauswahl und -formatierung sind in einem eigenständigen logischen Element umschlossen, das
- Beseitigt die komplexe Verwaltung von Steuerelementabhängigkeiten, die typisch für Implementierungen von Schriftartsteuer steuerelementen sind.
- Erfordert einen einzelnen Befehlshandler für alle Funktionen, die von den Untersteuerelementen des Schriftartsteuerelementes verfügbar gemacht werden.
Mit diesem einzelnen Befehlshandler kann das Schriftartsteuerelemente die Funktionalität verschiedener Untergeordneter Steuerelemente intern verwalten. Ein Untergeordnetes Steuerelement interagiert nie direkt mit der Anwendung, unabhängig von seiner Funktion.
Weitere Funktionen des Schriftartsteuersteuer steuerelements sind:
Automatische, DPI-orientierte Generierung einer WYSIWYG-Bitmapdarstellung (was Sie sehen) für jede Schriftart im Menü der Schriftfamilie.
Lokalisierte Schriftartfamilienbitmaps und QuickInfos.
Schriftartenenumeration, -gruppierung und -metadaten zum Verwalten und Präsentieren von Schriftarten.
Hinweis
Unterstützung für diese Funktionalität ist auf einer Plattform, die älter als Windows 7 ist, nicht verfügbar.
Die Dropdownfarbauswahl Textfarbe und Text highlight color , die das Verhalten des Menüband-Dropdownmenüs Farbwähler spiegeln.
Unterstützung der automatischen Vorschau von allen katalogbasierten Untergeordneten Steuerelementen des Schriftartsteuerelementes: Schriftfamilie, Schriftgrad, Textfarbe und Text hervorhebungsfarbe.
Ausrichtung an allgemeinen GDI-Textstrukturen
Windows Graphics Device Interface -Textstapelkomponenten (GDI) werden verwendet, um Schriftartauswahl- und Formatierungsfunktionen über das Menübandschriftart-Steuerelement verfügbar zu machen. Die verschiedenen Schriftartfeatures, die von der LOGFONT-Struktur, der CHOOSEFONT-Strukturund der CHARFORMAT2-Struktur unterstützt werden, werden über die unteren Steuerelemente verfügbar gemacht, die im Schriftartsteuerelementen enthalten sind.
Die unteren Steuerelemente, die im Schriftartsteuerelementen angezeigt werden, hängen von der FontType-Vorlage ab, die im Menübandmarkup deklariert ist. Die FontType-Vorlagen (die im folgenden Abschnitt ausführlicher erläutert werden) sind so konzipiert, dass sie an den allgemeinen Windows Graphics Device Interface(GDI)-Textstrukturen ausgerichtet sind.
Hinzufügen eines FontControl-Objekts
In diesem Abschnitt werden die grundlegenden Schritte zum Hinzufügen eines Schriftartensteuerelementes zu einer Menübandanwendung beschrieben.
Deklarieren eines FontControl-Objekts im Markup
Wie andere Menübandsteuerelemente wird das Schriftartsteuerelement im Markup mit einem FontControl-Element deklariert und einer Befehlsdeklaration über eine Befehls-ID zugeordnet. Wenn die Anwendung kompiliert wird, wird die Befehls-ID verwendet, um den Befehl an einen Befehlshandler in der Hostanwendung zu binden.
Hinweis
Wenn keine Befehls-ID mit fontControl im Markup deklariert wird, wird eine vom Framework generiert.
Da die Untersteuerelemente des Schriftartsteuerelementes nicht direkt verfügbar gemacht werden, ist die Anpassung des Schriftartsteuerelementes auf drei vom Framework definierte FontType-Layoutvorlagen beschränkt.
Eine weitere Anpassung des Schriftartsteuerfelds kann durch Kombinieren der Layoutvorlage mit FontControl-Attributen wie IsHighlightButtonVisible, IsStrikethroughButtonVisible und IsUnderlineButtonVisible erreicht werden.
Hinweis
Die Schriftartfunktion, die über die von den Standardmäßigvorlagen und -attributen des Schriftartsteuersteuerbereichs verfügbar gemachten Funktionen hinaus verfügbar gemacht wird, erfordert eine implementierung eines benutzerdefinierten Schriftartsteuer steuerelements, die außerhalb des Rahmens dieses Artikels liegt.
In der folgenden Tabelle sind die Schriftartsteuersteuervorlagen und der Bearbeitungssteuertyp aufgeführt, an dem die einzelnen Vorlagen ausgerichtet sind.
| Vorlage | Unterstützt |
|---|---|
| FontOnly | LOGFONT-Struktur |
| FontWithColor | CHOOSEFONT-Struktur |
| RichFont | CHARFORMAT2-Struktur |
In der folgenden Tabelle sind die -Steuerelemente aufgeführt, die den einzelnen Vorlagen zugeordnet sind, und die Steuerelemente, die für eine zugeordnete Vorlage optional sind.
Steuerelemente
Vorlagen
RichFont
FontWithColor
FontOnly
Standard
Optional
Standard
Optional
Standard
Optional
Kombinationsfeld "Schriftgrad"
Ja
Nein
Ja
Nein
Ja
Nein
Kombinationsfeld "Schriftfamilie"
Ja
Nein
Ja
Nein
Ja
Nein
Schaltfläche "Schriftart vergrößeren"
Ja
Ja
Ja
Ja
-
-
Schaltfläche "Schriftart verkleinern"
Ja
Ja
Ja
Ja
-
-
Schaltfläche "Fett formatiert"
Ja
Nein
Ja
Nein
Ja
Nein
Schaltfläche "Italic"
Ja
Nein
Ja
Nein
Ja
Nein
Schaltfläche "Unterstrichen"
Ja
Nein
Ja
Ja
Ja
Ja
Schaltfläche "Durchgestreichen"
Ja
Nein
Ja
Ja
Ja
Ja
Schaltfläche "Unterschreiben"
Ja
Nein
-
-
-
-
Schaltfläche "Hochgestellt"
Ja
Nein
-
-
-
-
Schaltfläche "Farbe hervorheben" für Text
Ja
Nein
Ja
Ja
-
-
Schaltfläche "Textfarbe"
Ja
Nein
Ja
Nein
-
-
Wenn das Layoutverhalten eines Schriftartsteuerelementes deklariert wird, stellt das Menübandframework eine optionale SizeDefinition-Layoutvorlage bereit, die zwei Untersteuerelementekonfigurationen basierend auf der Größe des Menübands und des für das Schriftartsteuerelemente verfügbaren Platzes OneFontControl definiert. Weitere Informationen finden Sie unter Anpassen eines Menübands durch Größendefinitionen und Skalierungsrichtlinien.
Hinzufügen eines FontControl-Objekts zu einem Menüband
Die folgenden Codebeispiele veranschaulichen die grundlegenden Markupanforderungen für das Hinzufügen eines Schriftarten-Steuerelements zu einem Menüband:
Dieser Codeabschnitt zeigt das Markup der FontControl-Befehlsdeklaration, einschließlich der Tabstopp- und Gruppenbefehle, die zum Anzeigen eines Steuerelements im Menüband erforderlich sind.
<Command Name="cmdTab1"
Comment="These comments are optional and are inserted into the header file."
Symbol="cmdTab1" Id="10000" >
<Command.LabelTitle>Tab 1</Command.LabelTitle>
</Command>
<Command Name="cmdGroup1" Comment="Group #1" Symbol="cmdGroup1" Id="20000">
<!-- This image is used when the group scales to a pop-up. -->
<Command.SmallImages>
<Image>res/Button_Image.bmp</Image>
</Command.SmallImages>
</Command>
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" Keytip="F" />
Dieser Codeabschnitt zeigt das Markup, das zum Deklarieren und Zuordnen eines FontControl-Objekts zu einem Befehl über eine Befehls-ID erforderlich ist. Dieses spezielle Beispiel enthält die Tabstopp- und Gruppendeklarationen mit Skalierungseinstellungen.
<Ribbon.Tabs>
<Tab CommandName="cmdTab1">
<Tab.ScalingPolicy>
<ScalingPolicy>
<ScalingPolicy.IdealSizes>
<Scale Group="cmdGroup1" Size="Large" />
</ScalingPolicy.IdealSizes>
<!-- Describe how the FontControl group scales. -->
<Scale Group="cmdGroup1" Size="Medium" />
<Scale Group="cmdGroup1" Size="Popup" />
</ScalingPolicy>
<Group CommandName="cmdGroup1" SizeDefinition="OneFontControl">
<FontControl CommandName="cmdFontControl" FontType="RichFont" />
</Group>
</Tab>
</Ribbon.Tabs>
Hinzufügen eines FontControl-Objekts zu ContextPopup
Zum Hinzufügen eines Schriftartsteuerelementes zu einem Kontextpopup ist eine Vorgehensweise erforderlich, die dem Hinzufügen eines Schriftartsteuerelementes zum Menüband ähnelt. Ein Schriftart-Steuerelement in einer MiniToolbar ist jedoch auf den Satz von Standarduntersteuerelementen beschränkt, die allen Schriftartsteuerelementen-Vorlagen gemeinsam sind: Schriftfamilie, Schriftgrad, Fett und Italisch.
Die folgenden Codebeispiele veranschaulichen die grundlegenden Markupanforderungen für das Hinzufügen eines Schriftart-Steuerelements zu einem Kontext-Popup:
Dieser Codeabschnitt zeigt das Markup der FontControl-Befehlsdeklaration, das zum Anzeigen eines FontControl-Objekts in ContextPopup erforderlich ist.
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" />
Dieser Codeabschnitt zeigt das Markup, das zum Deklarieren und Zuordnen eines FontControl-Objekts zu einem Befehl über eine Befehls-ID erforderlich ist.
<ContextPopup.MiniToolbars>
<MiniToolBar Name="MiniToolbar1">
<MenuCategory Class="StandardItems">
<FontControl CommandName="cmdFontControl" />
</MenuCategory>
</MiniToolBar>
</ContextPopup.MiniToolbars>
KeyTips
Auf jedes untere Steuerelement im Menüband-Schriftartensteuerelemente kann über eine Tastenkombination oder eine Tastenkombination zugegriffen werden. Diese Keytip ist vordefiniert und wird jedem untergeordneten Steuerelement vom Framework zugewiesen.
Wenn dem FontControl-Element im Markup ein Keytip-Attributwert zugewiesen wird, wird dieser Wert dem frameworkdefinierten Keytip als Präfix hinzugefügt.
Hinweis
Die Anwendung sollte eine Einzelzeichenregel für dieses Präfix erzwingen.
In der folgenden Tabelle sind die vom Framework definierten KeyTips aufgeführt.
| Untersteuerung | Keytip |
|---|---|
| Schriftfamilie | F |
| Schriftschnitt | T |
| Schriftgrad | E |
| Schriftart vergrößeren | G |
| Verkleinern der Schriftart | K |
| Fett | B |
| Kursiv | I |
| Underline | U |
| Durchgestrichen | X |
| Hochgestellt | Y oder Z[!Note] |
| Tiefgestellt | Ein |
| Schriftfarbe | C |
| Hervorhebung der Schriftart | H |
Das empfohlene Präfix für ein mehrsprachige Benutzeroberfläche(SUFFIX) EN-US-Menüband ist "F", wie im folgenden Beispiel gezeigt.
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" Keytip="F" />
Der folgende Screenshot veranschaulicht die Tastentips für das Schriftartsteuersteuersystem, wie sie im vorherigen Beispiel definiert wurden.

Die Menübandressourcendatei
Wenn die Markupdatei kompiliert wird, wird eine Ressourcendatei generiert, die alle Ressourcenverweise für die Menübandanwendung enthält.
Beispiel für eine einfache Ressourcendatei:
// ******************************************************************************
// * This is an automatically generated file containing the ribbon resource for *
// * your application. *
// ******************************************************************************
#include ".\ids.h"
STRINGTABLE
BEGIN
cmdTab1_LabelTitle_RESID L"Tab 1"
/* LabelTitle cmdTab1_LabelTitle_RESID: These comments are optional and are
inserted into the header file. */
END
cmdGroup1_SmallImages_RESID BITMAP "res\\Button_Image.bmp"
/* SmallImages cmdGroup1_SmallImages_RESID: Group #1 */
STRINGTABLE
BEGIN
cmdFontControl_Keytip_RESID L"F" /* Keytip cmdFontControl_Keytip_RESID: FontControl */
END
FCSAMPLE_RIBBON UIFILE "Debug\\FCSample.bml"
Eigenschaften des Schriftart-Steuerelements
Das Menübandframework definiert eine Auflistung von Eigenschaftsschlüsseln für das Schriftart-Steuerelement und dessen konstituierende Untersteuerelemente.
In der Regel wird eine Font Control-Eigenschaft in der Menübandbenutzeroberfläche aktualisiert, indem der befehl, der dem Steuerelement zugeordnet ist, durch einen Aufruf der IUIFramework::InvalidateUICommand-Methode ungültig wird. Das Invalidierungsereignis wird von der IUICommandHandler::UpdateProperty-Rückrufmethode behandelt und die Eigenschaft aktualisiert.
Die IUICommandHandler::UpdateProperty-Rückrufmethode wird nicht ausgeführt, und die Anwendung fragt einen aktualisierten Eigenschaftswert ab, bis die Eigenschaft vom Framework benötigt wird. Beispielsweise, wenn eine Registerkarte aktiviert und ein Steuerelement auf der Menübandbenutzeroberfläche angezeigt wird oder wenn eine QuickInfo angezeigt wird.
Hinweis
In einigen Fällen kann eine Eigenschaft über die IUIFramework::GetUICommandProperty-Methode abgerufen und mit der IUIFramework::SetUICommandProperty-Methode festgelegt werden.
In der folgenden Tabelle sind die Eigenschaftenschlüssel aufgeführt, die dem Schriftartsteuersteuersystem zugeordnet sind.
| Eigenschaftsschlüssel | Hinweise |
|---|---|
| _ _ PKEY-Schriftarteigenschaften der Benutzeroberfläche | Macht in aggregierter Form als IPropertyStore-Objekt alle Eigenschaften des Untergeordneten Steuerelements des Schriftartsteuerfelds verfügbar. Das Framework fragt diese Eigenschaft ab, wenn als Wert von Flags im Aufruf von UI_INVALIDATIONS_VALUE IUIFramework::InvalidateUICommand übergeben wird. |
| UI _ PKEY _ FontProperties _ ChangedProperties | Macht im Aggregat als IUISimplePropertySet-Objekt nur Geänderte Eigenschaften des Untersteuersteuerfelds für Schriftarten verfügbar. |
| _ _ PKEY-Keytip der Benutzeroberfläche | Kann nur durch Ungültigkeit aktualisiert werden. |
| _Benutzeroberflächen-PKEY _ aktiviert | Unterstützt IUIFramework::GetUICommandProperty und IUIFramework::SetUICommandProperty. |
Zusätzlich zu den Eigenschaften, die vom Schriftartsteuerelemente selbst unterstützt werden, definiert das Menübandframework auch einen Eigenschaftsschlüssel für jedes Untersteuersteuerelemente des Schriftartensteuerelementes. Diese Eigenschaftsschlüssel und ihre Werte werden vom Framework über eine IPropertyStore-Schnittstellenimplementierung verfügbar gemacht, die die Methoden zum Verwalten einer Auflistung, auch als Eigenschaftensammlung bezeichnet, von Name-Wert-Paaren definiert.
Die Anwendung übersetzt die Schriftartstrukturen in Eigenschaften, auf die über die IPropertyStore-Schnittstellenmethoden zugegriffen werden kann. Dieses Modell hebt den Unterschied zwischen dem Schriftartsteuerelementen und den Windows Graphics Device Interface(GDI)-Textstapelkomponenten (LOGFONT-Struktur, CHOOSEFONT-Strukturund CHARFORMAT2-Struktur) hervor, die vom Framework unterstützt werden.
In der folgenden Tabelle sind die einzelnen Steuerelemente und die zugehörigen Eigenschaftsschlüssel aufgeführt.
| Steuerelemente | Eigenschaftsschlüssel | Hinweise |
|---|---|---|
| Schriftgrad | UI _ PKEY _ FontProperties _ Size | Wenn eine Ausführung von heterogenem Text hervorgehoben wird, legt das Menübandframework das Steuerelement Schriftgrad auf leer und den Wert von UI _ PKEY _ FontProperties _ Size auf 0 fest. Wenn auf die Schaltfläche Schriftart vergrößern oder Schriftart verkleinern geklickt wird, wird die Größe des markierten Texts geändert, aber der relative Unterschied in den Textgrößen wird beibehalten. |
| Schriftfamilie | _ _ PKEY-Schriftarteigenschaftenfamilie der _ Benutzeroberfläche | Die Namen der GDI-Schriftfamilien variieren je nach System locale. Wenn der Wert der _ PKEY _ FontProperties-Familie _ der Benutzeroberfläche für Anwendungssitzungen beibehalten wird, sollte dieser Wert daher in jeder neuen Sitzung abgerufen werden. |
| Schriftart vergrößeren | UI _ PKEY _ FontProperties _ Size | Weitere Informationen finden Sie unter Schriftgrad. |
| Verkleinern der Schriftart | UI _ PKEY _ FontProperties _ Size | Weitere Informationen finden Sie unter Schriftgrad. |
| Fett | UI _ PKEY _ FontProperties _ Bold | |
| Kursiv | UI _ PKEY _ FontProperties _ Italic | |
| Unterstreichen | UI _ PKEY _ FontProperties _ Underline | |
| Durchgestrichen | UI _ PKEY _ FontProperties _ Strikethrough | |
| Tiefgestellt | UI _ PKEY _ FontProperties _ VerticalPositioning | Wenn die Schaltfläche "Subscript" festgelegt ist, kann superscript nicht auch festgelegt werden. |
| Hochgestellt | UI _ PKEY _ FontProperties _ VerticalPositioning | Wenn die Schaltfläche "Superscript" festgelegt ist, kann der Unterskript nicht auch festgelegt werden. |
| Text highlight color | Benutzeroberfläche _ PKEY _ FontProperties _ BackgroundColor, UI _ PKEY _ FontProperties _ BackgroundColorType | Stellt die gleiche Funktionalität wie die HighlightColors Vorlage des DropDownColorPicker-Elements zur Verfügung.Es wird dringend empfohlen, dass von der Anwendung nur ein ursprünglicher Text-Hervorhebungsfarbwert festgelegt wird. Der zuletzt ausgewählte Wert sollte beibehalten und nicht festgelegt werden, wenn der Cursor innerhalb eines Dokuments neu positioniert wird. Dies ermöglicht den schnellen Zugriff auf die letzte Auswahl des Benutzers, und die Farbauswahl muss nicht erneut geöffnet werden. Farbuhren können nicht angepasst werden. |
| Textfarbe | Benutzeroberfläche _ PKEY _ FontProperties _ ForegroundColor, UI _ PKEY _ FontProperties _ ForegroundColorType | Stellt die gleiche Funktionalität wie die StandardColors Vorlage des DropDownColorPicker-Elements zur Verfügung.Es wird dringend empfohlen, dass von der Anwendung nur ein ursprünglicher Textfarbwert festgelegt wird. Der zuletzt ausgewählte Wert sollte beibehalten und nicht festgelegt werden, wenn der Cursor innerhalb eines Dokuments neu positioniert wird. Dies ermöglicht den schnellen Zugriff auf die letzte Auswahl des Benutzers, und die Farbauswahl muss nicht erneut geöffnet werden. Farbuhren können nicht angepasst werden. |
Definieren eines FontControl-Befehlshandlers
In diesem Abschnitt werden die Schritte beschrieben, die erforderlich sind, um ein Schriftartsteuerfeld an einen Befehlshandler zu binden.
Warnung
Jeder Versuch, ein Farbmuster aus der Farbauswahl eines Schriftartsteuerfelds auszuwählen, kann zu einer Zugriffsverletzung führen, wenn dem Steuerelement kein Befehlshandler zugeordnet ist.
Im folgenden Codebeispiel wird veranschaulicht, wie Befehle, die im Markup deklariert sind, an einen Command-Handler gebunden werden.
//
// FUNCTION: OnCreateUICommand(UINT, UI_COMMANDTYPE, IUICommandHandler)
//
// PURPOSE: Called by the Ribbon framework for each command specified in markup, to allow
// the host application to bind a command handler to that command.
//
STDMETHODIMP CApplication::OnCreateUICommand(
UINT nCmdID,
__in UI_COMMANDTYPE typeID,
__deref_out IUICommandHandler** ppCommandHandler)
{
UNREFERENCED_PARAMETER(typeID);
UNREFERENCED_PARAMETER(nCmdID);
if (NULL == m_pCommandHandler)
{
HRESULT hr = CCommandHandler::CreateInstance(&m_pCommandHandler);
if (FAILED(hr))
{
return hr;
}
}
return m_pCommandHandler->QueryInterface(IID_PPV_ARGS(ppCommandHandler));
}
Im folgenden Codebeispiel wird veranschaulicht, wie die IUICommandHandler::Execute-Methode für ein Schriftart-Steuerelement implementiert wird.
//
// FUNCTION: Execute()
//
// PURPOSE: Called by the Ribbon framework when a command is executed
// by the user. For example, when a button is pressed.
//
STDMETHODIMP CCommandHandler::Execute(
UINT nCmdID,
UI_EXECUTIONVERB verb,
__in_opt const PROPERTYKEY* key,
__in_opt const PROPVARIANT* ppropvarValue,
__in_opt IUISimplePropertySet* pCommandExecutionProperties)
{
UNREFERENCED_PARAMETER(nCmdID);
HRESULT hr = E_NOTIMPL;
if ((key) && (*key == UI_PKEY_FontProperties))
{
// Font properties have changed.
switch (verb)
{
case UI_EXECUTIONVERB_EXECUTE:
{
hr = E_POINTER;
if (pCommandExecutionProperties != NULL)
{
// Get the changed properties.
PROPVARIANT varChanges;
hr = pCommandExecutionProperties->GetValue(UI_PKEY_FontProperties_ChangedProperties, &varChanges);
if (SUCCEEDED(hr))
{
IPropertyStore *pChanges;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, varChanges, &pChanges);
if (SUCCEEDED(hr))
{
// Using the changed properties, set the new font on the selection on RichEdit control.
g_pFCSampleAppManager->SetValues(pChanges);
pChanges->Release();
}
PropVariantClear(&varChanges);
}
}
break;
}
case UI_EXECUTIONVERB_PREVIEW:
{
hr = E_POINTER;
if (pCommandExecutionProperties != NULL)
{
// Get the changed properties for the preview event.
PROPVARIANT varChanges;
hr = pCommandExecutionProperties->GetValue(UI_PKEY_FontProperties_ChangedProperties, &varChanges);
if (SUCCEEDED(hr))
{
IPropertyStore *pChanges;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, varChanges, &pChanges);
if (SUCCEEDED(hr))
{
// Set the previewed values on the RichEdit control.
g_pFCSampleAppManager->SetPreviewValues(pChanges);
pChanges->Release();
}
PropVariantClear(&varChanges);
}
}
break;
}
case UI_EXECUTIONVERB_CANCELPREVIEW:
{
hr = E_POINTER;
if (ppropvarValue != NULL)
{
// Cancel the preview.
IPropertyStore *pValues;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, *ppropvarValue, &pValues);
if (SUCCEEDED(hr))
{
g_pFCSampleAppManager->CancelPreview(pValues);
pValues->Release();
}
}
break;
}
}
}
return hr;
}
Im folgenden Codebeispiel wird veranschaulicht, wie die IUICommandHandler::UpdateProperty-Methode für ein Schriftart-Steuerelement implementiert wird.
//
// FUNCTION: UpdateProperty()
//
// PURPOSE: Called by the Ribbon framework when a command property (PKEY) needs to be updated.
//
// COMMENTS:
//
// This function is used to provide new command property values, such as labels, icons, or
// tooltip information, when requested by the Ribbon framework.
//
//
STDMETHODIMP CCommandHandler::UpdateProperty(
UINT nCmdID,
__in REFPROPERTYKEY key,
__in_opt const PROPVARIANT* ppropvarCurrentValue,
__out PROPVARIANT* ppropvarNewValue)
{
UNREFERENCED_PARAMETER(nCmdID);
HRESULT hr = E_NOTIMPL;
if (key == UI_PKEY_FontProperties)
{
hr = E_POINTER;
if (ppropvarCurrentValue != NULL)
{
// Get the font values for the selected text in the font control.
IPropertyStore *pValues;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, *ppropvarCurrentValue, &pValues);
if (SUCCEEDED(hr))
{
g_pFCSampleAppManager->GetValues(pValues);
// Provide the new values to the font control.
hr = UIInitPropertyFromInterface(UI_PKEY_FontProperties, pValues, ppropvarNewValue);
pValues->Release();
}
}
}
return hr;
}