Schriftart-Steuerelement
Um die Integration und Konfiguration der Schriftartunterstützung in Anwendungen zu vereinfachen, die Textverarbeitungs- und Textbearbeitungsfunktionen erfordern, bietet das Windows-Menübandframework ein spezielles Schriftartensteuerelement, das eine Vielzahl von Schriftarteigenschaften wie Schriftartname, Formatvorlage, Punktgröße und Effekte verfügbar macht.
- Introduction (Einführung)
- Eine konsistente Benutzeroberfläche
- Einfache Integration und Konfiguration
- Ausrichtung mit allgemeinen GDI-Textstrukturen
- Hinzufügen eines FontControl-Steuerelements
- Definieren eines FontControl-Befehlshandlers
- Zugehörige Themen
Einführung
Das Schriftartensteuerelement 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 Benutzeroberfläche
Als integriertes Menüband-Steuerelement verbessert das Schriftartensteuerelement die allgemeine Schriftverwaltung, Auswahl und Formatierung und bietet eine umfassende, konsistente Benutzeroberfläche für alle Menübandanwendungen.
Diese konsistente Benutzeroberfläche umfasst
Standardisierte Formatierung und Auswahl von Schriftarten in Menübandanwendungen.
Standardisierte Schriftartendarstellung in Menübandanwendungen.
Automatische Schriftartaktivierung in Windows 7, die auf der Einstellung Einblenden oder Ausblenden für jede Schriftart in der Schriftarten-Systemsteuerung basiert. Das Schriftartensteuerelement zeigt nur die Schriftarten an, die auf Anzeigen festgelegt sind.
Hinweis
In Windows Vista bietet die Schriftarten-Systemsteuerung nicht die Funktion Ein- oder Ausblenden , sodass alle Schriftarten aktiviert sind.
Schriftverwaltung, die direkt über das -Steuerelement verfügbar ist.
Der folgende Screenshot zeigt, dass auf die Schriftarten-Systemsteuerung direkt über das Schriftartensteuerelement zugegriffen werden kann.
Unterstützung für die automatische Vorschau.
Belichtung von Schriftarten, die für einen Benutzer am relevantesten sind, z. B.
- Lokalisierte Schriftartenlisten für internationale Benutzer.
- Schriftartlisten basierend auf dem Eingabegerät.
Hinweis
Die Unterstützung für diese Funktionalität ist auf keiner Plattform verfügbar, die älter als Windows 7 ist.
Einfache Integration und Konfiguration
Durch die Bereitstellung von standardmäßigen, wiederverwendbaren und einfach zu nutzenden Funktionen erleichtert die Menübandschriftsteuerung 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 Steuerelementinterpendenzen, die typisch für Schriftartensteuerelementimplementierungen sind.
- Erfordert einen einzelnen Befehlshandler für alle Funktionen, die von den Untersteuerelementen der Schriftarten verfügbar gemacht werden.
Dieser einzelne Befehlshandler ermöglicht es dem Schriftartensteuerelement, die Funktionalität verschiedener Untersteuerelemente intern zu verwalten. ein Untersteuerelement interagiert nie direkt mit der Anwendung, unabhängig von seiner Funktion.
Weitere Features des Schriftartsteuerelements sind:
Automatische, DPI-fähige Generierung einer WYSIWYG-Bitmapdarstellung (was Sie sehen, was Sie erhalten) für jede Schriftart im Menü "Schriftartenfamilie ".
Lokalisierte Bitmaps und QuickInfos für die Schriftartfamilie.
Schriftartenenumeration, Gruppierung und Metadaten zum Verwalten und Darstellen von Schriftarten.
Hinweis
Die Unterstützung für diese Funktionalität ist auf keiner Plattform verfügbar, die älter als Windows 7 ist.
Die Dropdownfarbauswahl Textfarbe und Textherhebungsfarbe, die das Verhalten der Menüband-Dropdown-Farbauswahl Spiegel.
Unterstützung der automatischen Vorschau durch alle katalogbasierten Schriftartensteuerelemente: Schriftfamilie, Schriftgrad, Textfarbe und Texthervorhebungsfarbe.
Ausrichtung mit allgemeinen GDI-Textstrukturen
GDI-Textstapelkomponenten (Windows Graphics Device Interface) werden verwendet, um die Schriftartauswahl und -formatierung über das Menübandschriftsteuerelement verfügbar zu machen. Die verschiedenen Schriftartfeatures, die von der LOGFONT-Struktur, der CHOOSEFONT-Struktur und der CHARFORMAT2-Struktur unterstützt werden, werden über die Untersteuerelemente verfügbar gemacht, die im Schriftartensteuerelement enthalten sind.
Die im Schriftartsteuerelement angezeigten Untersteuerelemente hängen von der im Menüband-Markup deklarierten Vorlage FontType ab. Die FontType-Vorlagen (die im folgenden Abschnitt näher erläutert werden) sind so konzipiert, dass sie an den allgemeinen GDI-Textstrukturen (Windows Graphics Device Interface) ausgerichtet sind.
Hinzufügen eines FontControl-Steuerelements
In diesem Abschnitt werden die grundlegenden Schritte zum Hinzufügen eines Schriftartsteuerelements zu einer Menübandanwendung beschrieben.
Deklarieren eines FontControl-Steuerelements im Markup
Wie andere Menübandsteuerelemente wird das Schriftartsteuerelement im Markup mit einem FontControl-Element deklariert und einer Command-Deklaration ü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 dem FontControl im Markup deklariert wird, wird eine vom Framework generiert.
Da die Untersteuerelemente des Schriftartensteuerelements nicht direkt verfügbar gemacht werden, ist die Anpassung des Schriftartsteuerelements auf drei vom Framework definierte Schriftarttyplayoutvorlagen beschränkt.
Weitere Anpassungen des Schriftartensteuerelements können durch Kombinieren der Layoutvorlage mit FontControl-Attributen wie IsHighlightButtonVisible, IsStrikethroughButtonVisible und IsUnderlineButtonVisible erreicht werden.
Hinweis
Die Schriftartfunktionalität, die über die von den Standardmäßigvorlagen und Attributen der Schriftartensteuerung verfügbar gemacht wird, erfordert eine benutzerdefinierte Schriftartensteuerelementimplementierung, die außerhalb des Bereichs dieses Artikels liegt.
In der folgenden Tabelle sind die Schriftartensteuerelementvorlagen und der Bearbeitungssteuerelementtyp aufgeführt, an dem jede Vorlage ausgerichtet ist.
| Vorlage | Unterstützt |
|---|---|
| FontOnly | LOGFONT-Struktur |
| FontWithColor | CHOOSEFONT-Struktur |
| RichFont | CHARFORMAT2-Struktur |
In der folgenden Tabelle sind die Steuerelemente aufgeführt, die jeder Vorlage 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ößern "
Ja
Ja
Ja
Ja
-
-
Schaltfläche "Schriftart verkleinern "
Ja
Ja
Ja
Ja
-
-
Fett formatierte Schaltfläche
Ja
Nein
Ja
Nein
Ja
Nein
Kursiv-Schaltfläche
Ja
Nein
Ja
Nein
Ja
Nein
Schaltfläche "Unterstrichen "
Ja
Nein
Ja
Ja
Ja
Ja
Schaltfläche "Durchschlagen"
Ja
Nein
Ja
Ja
Ja
Ja
Schaltfläche "Tiefgestellt "
Ja
Nein
-
-
-
-
Schaltfläche "Hochgestellt"
Ja
Nein
-
-
-
-
Farbschaltfläche für Textmarkierungen
Ja
Nein
Ja
Ja
-
-
Schaltfläche "Textfarbe "
Ja
Nein
Ja
Nein
-
-
Wenn das Layoutverhalten eines Schriftartsteuerelements deklariert wird, stellt das Menübandframework eine optionale SizeDefinition-Layoutvorlage bereit, OneFontControldie zwei Untersteuerelementkonfigurationen basierend auf der Größe des Menübands und dem für das Schriftartensteuerelement verfügbaren Platz definiert. Weitere Informationen finden Sie unter Anpassen eines Menübands durch Größendefinitionen und Skalierungsrichtlinien.
Hinzufügen eines FontControl-Steuerelements zu einem Menüband
Die folgenden Codebeispiele veranschaulichen die grundlegenden Markupanforderungen für das Hinzufügen eines Schriftartsteuerelements zu einem Menüband:
Dieser Codeabschnitt zeigt das FontControl Command-Deklarationsmarkup, einschließlich der Tabulator - 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 erforderlich ist, um ein FontControl-Steuerelement über eine Befehls-ID zu deklarieren und einem Befehl zuzuordnen. Dieses besondere Beispiel umfasst die Tabulator - 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 zu einem ContextPopup
Das Hinzufügen eines Schriftartsteuerelements zu einem Kontext-Popup erfordert eine Prozedur ähnlich dem Hinzufügen eines Schriftartsteuerelements zum Menüband. Ein Schriftsteuerelement in einer MiniToolbar ist jedoch auf den Satz der Standarduntersteuerelemente beschränkt, die allen Schriftartsteuerelementvorlagen gemeinsam sind: Schriftfamilie, Schriftgrad, Fett und Kursiv.
Die folgenden Codebeispiele veranschaulichen die grundlegenden Markupanforderungen für das Hinzufügen eines Schriftartsteuerelements zu einem Kontext-Popup:
Dieser Codeabschnitt zeigt das FontControl Command-Deklarationsmarkup, das zum Anzeigen eines FontControl-Steuerelements im ContextPopup erforderlich ist.
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" />
Dieser Codeabschnitt zeigt das Markup, das erforderlich ist, um ein FontControl-Steuerelement über eine Befehls-ID zu deklarieren und einem Befehl zuzuordnen.
<ContextPopup.MiniToolbars>
<MiniToolBar Name="MiniToolbar1">
<MenuCategory Class="StandardItems">
<FontControl CommandName="cmdFontControl" />
</MenuCategory>
</MiniToolBar>
</ContextPopup.MiniToolbars>
KeyTips
Auf jedes Untersteuerelement im Menüband-Schriftartsteuerelement kann über eine Tastenkombination oder eine Tastenkombination zugegriffen werden. Diese Keytip ist vordefiniert und jedem Untersteuerelement vom Framework zugewiesen.
Wenn dem FontControl-Element im Markup ein Keytip-Attributwert zugewiesen wird, wird dieser Wert als Präfix zur vom Framework definierten Keytip hinzugefügt.
Hinweis
Die Anwendung sollte eine Einzeichenregel für dieses Präfix erzwingen.
In der folgenden Tabelle sind die vom Framework definierten Schlüsselinfos aufgeführt.
| Untersteuerung | Keytip |
|---|---|
| Schriftfamilie | F |
| Schriftschnitt | T |
| Schriftgrad | E |
| Schriftart vergrößern | G |
| Schriftart verkleinern | K |
| Fett | B |
| Kursiv | I |
| Underline | U |
| Durchgestrichen | X |
| Hochgestellt | Y- oder Z-Hinweis: Wenn das Keytip-Attribut nicht im Markup deklariert ist, lautet die Standard-Keytip Y; Andernfalls ist die Standard-KeyTIP keytip + Z. |
| Tiefgestellt | Ein |
| Schriftfarbe | C |
| Schriftmarkierung | H |
Das empfohlene Präfix für ein MUI-Menüband (Multilingual User Interface) ist "F", wie im folgenden Beispiel gezeigt.
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" Keytip="F" />
Der folgende Screenshot veranschaulicht die Im vorherigen Beispiel definierten Tastenkombinationen für die Schriftartsteuerung.
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 Schriftartsteuerelements
Das Menübandframework definiert eine Auflistung von Eigenschaftenschlüsseln für das Schriftartsteuerelement und die darin enthaltenen Untersteuerelemente.
In der Regel wird eine Font Control-Eigenschaft in der Menübandbenutzeroberfläche aktualisiert, indem der dem Steuerelement zugeordnete Befehl durch einen Aufruf der IUIFramework::InvalidateUICommand-Methode ungültig wird. Das Invaliditätsereignis wird von der IUICommandHandler::UpdateProperty-Rückrufmethode behandelt und die Eigenschaft aktualisiert.
Die IUICommandHandler::UpdateProperty-Rückrufmethode wird nicht ausgeführt, und die Anwendung wird nach einem aktualisierten Eigenschaftswert abgefragt, bis die Eigenschaft vom Framework erforderlich ist. Beispielsweise, wenn eine Registerkarte aktiviert ist und ein Steuerelement auf der Menüband-Benutzeroberflä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 Schriftartsteuerelement zugeordnet sind.
| Eigenschaftenschlüssel | Hinweise |
|---|---|
| UI_PKEY_FontProperties | Macht im Aggregat als IPropertyStore-Objekt alle Eigenschaften des Schriftartsteuerelements verfügbar. Das Framework fragt diese Eigenschaft ab, wenn UI_INVALIDATIONS_VALUE als Wert von Flags im Aufruf von IUIFramework::InvalidateUICommand übergeben wird. |
| UI_PKEY_FontProperties_ChangedProperties | Macht im Aggregat als IUISimplePropertySet-Objekt nur die Geänderten Eigenschaften des Schriftartsteuerelements verfügbar. |
| UI_PKEY_Keytip | Kann nur durch ungültige Aktualisierung aktualisiert werden. |
| UI_PKEY_Enabled | Unterstützt IUIFramework::GetUICommandProperty und IUIFramework::SetUICommandProperty. |
Zusätzlich zu den Eigenschaften, die vom Schriftartsteuerelement selbst unterstützt werden, definiert das Menübandframework auch einen Eigenschaftenschlüssel für jedes Font Control-Untersteuerelement. Diese Eigenschaftenschlüssel und ihre Werte werden vom Framework über eine IPropertyStore-Schnittstellenimplementierung verfügbar gemacht, die die Methoden für die Verwaltung einer Sammlung von Namens- und Wertpaaren definiert, die auch als Eigenschaftenbehälter bezeichnet werden.
Die Anwendung übersetzt die Schriftartstrukturen in Eigenschaften, auf die über die IPropertyStore-Schnittstellenmethoden zugegriffen werden kann. Dieses Modell hebt die Unterscheidung zwischen dem Schriftartsteuerelement und den Textstapelkomponenten der Windows Graphics Device Interface (GDI) (LOGFONT-Struktur, CHOOSEFONT-Struktur und CHARFORMAT2-Struktur) hervor, die vom Framework unterstützt werden.
In der folgenden Tabelle sind die einzelnen Steuerelemente und die zugehörigen Eigenschaftenschlüssel aufgeführt.
| Steuerelemente | Eigenschaftenschlüssel | Hinweise |
|---|---|---|
| Schriftgrad | UI_PKEY_FontProperties_Size | Wenn eine Ausführung von Text mit heterogener Größe 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 gesamten hervorgehobenen Texts geändert, aber der relative Unterschied in den Textgrößen bleibt erhalten. |
| Schriftfamilie | UI_PKEY_FontProperties_Family | Die Namen der GDI-Schriftfamilie variieren je nach Systemgebietsschema. Wenn also der Wert von UI_PKEY_FontProperties_Family anwendungsübergreifend beibehalten wird, sollte dieser Wert bei jeder neuen Sitzung abgerufen werden. |
| Schriftart vergrößern | UI_PKEY_FontProperties_Size | Siehe Schriftgrad. |
| Schriftart verkleinern | UI_PKEY_FontProperties_Size | Siehe 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 auch der Hochgestellte nicht festgelegt werden. |
| Hochgestellt | UI_PKEY_FontProperties_VerticalPositioning | Wenn die Schaltfläche Hochgestellt festgelegt ist, kann auch der Subscript-Wert nicht festgelegt werden. |
| Textmarkerfarbe | UI_PKEY_FontProperties_BackgroundColor, UI_PKEY_FontProperties_BackgroundColorType | Bietet die gleiche Funktionalität wie die HighlightColors Vorlage des DropDownColorPicker-Elements .Es wird dringend empfohlen, nur einen anfänglichen Textmarkerungsfarbwert von der Anwendung festzulegen. Der zuletzt ausgewählte Wert sollte beibehalten und nicht festgelegt werden, wenn der Cursor in einem Dokument neu positioniert wird. Dies ermöglicht einen schnellen Zugriff auf die letzte Auswahl des Benutzers, und die Farbauswahl muss nicht erneut geöffnet werden. Farbfelder können nicht angepasst werden. |
| Textfarbe | UI_PKEY_FontProperties_ForegroundColor, UI_PKEY_FontProperties_ForegroundColorType | Bietet die gleiche Funktionalität wie die StandardColors Vorlage des DropDownColorPicker-Elements .Es wird dringend empfohlen, nur einen anfänglichen Textfarbwert von der Anwendung festzulegen. Der zuletzt ausgewählte Wert sollte beibehalten und nicht festgelegt werden, wenn der Cursor in einem Dokument neu positioniert wird. Dies ermöglicht einen schnellen Zugriff auf die letzte Auswahl des Benutzers, und die Farbauswahl muss nicht erneut geöffnet werden. Farbfelder können nicht angepasst werden. |
Definieren eines FontControl-Befehlshandlers
In diesem Abschnitt werden die Schritte beschrieben, die zum Binden eines Schriftartsteuerelements an einen Befehlshandler erforderlich sind.
Warnung
Jeder Versuch, ein Farbfeld aus der Farbauswahl eines Schriftartsteuerelements 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 werden, 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 Font-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 Font-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;
}
Zugehörige Themen
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für