MFC ActiveX-Steuerelemente: Verwenden von Schriftarten

Hinweis

Die Microsoft Foundation Classes (MFC)-Bibliothek wird weiterhin unterstützt. Wir fügen jedoch keine Features mehr hinzu oder aktualisieren die Dokumentation.

Wenn Ihr ActiveX-Steuerelement Text anzeigt, können Sie dem Steuerelementbenutzer erlauben, die Textdarstellung durch Ändern einer Schriftarteigenschaft zu ändern. Schriftarteigenschaften werden als Schriftartobjekte implementiert und können eines von zwei Typen sein: Standard oder benutzerdefiniert. Standardschriftart-Eigenschaften sind vorimplementierte Schrifteigenschaften, die Sie mit dem Assistenten für neue Eigenschaften hinzufügen können. Benutzerdefinierte Schriftarteigenschaften sind nicht vorab implementiert, und der Steuerelemententwickler bestimmt das Verhalten und die Verwendung der Eigenschaft.

In diesem Artikel werden die folgenden Themen behandelt:

Verwenden der Stock Font-Eigenschaft
Verwenden von benutzerdefinierten Schriftarteigenschaften in Ihrem Steuerelement

Verwendung der Eigenschaft Standardschriftart

Stock Font-Eigenschaften sind von der Klasse COleControl vorimplementiert. Darüber hinaus ist eine Standard-Schriftart-Eigenschaftsseite verfügbar, sodass der Benutzer verschiedene Attribute der Schrift ändern kann, z. B. Name, Schriftgrad und Stil.

Greifen Sie mithilfe der Funktionen GetFont, SetFont und InternalGetFont auf das Schriftartobjekt zuCOleControl. Der Steuerelementbenutzer greift auf das Schriftartobjekt über die GetFont und SetFont funktionen auf die gleiche Weise wie jede andere Get/Set-Eigenschaft zu. Wenn der Zugriff auf das Schriftartobjekt innerhalb eines Steuerelements erforderlich ist, verwenden Sie die InternalGetFont Funktion.

Wie in MFC ActiveX-Steuerelementen: Eigenschaften erläutert, ist das Hinzufügen von Standard-Eigenschaften mit dem Assistenten zum Hinzufügen von Eigenschaften einfach. Sie wählen die Eigenschaft Schriftart aus und der Assistent für das Hinzufügen xvon Eigenschaften fügt den Eintrag Standardschriftart automatisch in die Dispatchzuordnung des Steuerelements ein.

So fügen Sie die Eigenschaft Standardschriftart mit dem Assistenten für neue Eigenschaften hinzu

Laden Sie das Steuerelementprojekt.
Erweitern Sie in der Klassenansicht den Bibliotheksknoten Ihres Steuerelements.
Klicken Sie mit der rechten Maustaste auf den Schnittstellenknoten des Steuerelements (den zweiten Knoten des Bibliotheksknotens), um das Kontextmenü zu öffnen.
Klicken Sie im Kontextmenü auf "Hinzufügen" und dann auf "Eigenschaft hinzufügen".

Dadurch wird der Assistent zum Hinzufügen von Eigenschaften geöffnet.
Klicken Sie im Feld Eigenschaftsname auf Schrift.
Klicken Sie auf Fertig stellen.

Der Assistent zum Hinzufügen von Eigenschaften fügt die folgende Zeile in die Dispatchzuordnung des Steuerelements ein, die sich in der Implementierungsdatei der Steuerelementklasse befindet:

DISP_STOCKPROP_FONT()

Darüber hinaus fügt der Assistent zum Hinzufügen von Eigenschaften die folgende Zeile zur Steuerelement-IDL-Datei hinzu:

[id(DISPID_FONT)] IFontDisp* Font;

Die Eigenschaft Standardbeschriftung ist ein Beispiel für eine Texteigenschaft, die mit Hilfe der Standardschriftart-Eigenschaften dargestellt werden kann. Beim Hinzufügen der Eigenschaft "Stock Caption" zum Steuerelement werden Schritte verwendet, die denen ähneln, die für die Eigenschaft "Stock Font" verwendet werden.

Hinzufügen der vordefinierten Caption-Eigenschaft mithilfe des Assistenten zum Hinzufügen von Eigenschaften

Laden Sie das Steuerelementprojekt.
Erweitern Sie in der Klassenansicht den Bibliotheksknoten Ihres Steuerelements.
Klicken Sie mit der rechten Maustaste auf den Schnittstellenknoten des Steuerelements (den zweiten Knoten des Bibliotheksknotens), um das Kontextmenü zu öffnen.
Klicken Sie im Kontextmenü auf "Hinzufügen" und dann auf "Eigenschaft hinzufügen".

Dadurch wird der Assistent zum Hinzufügen von Eigenschaften geöffnet.
Klicken Sie im Feld "Eigenschaftsname " auf "Beschriftung".
Klicken Sie auf Fertig stellen.

Der Assistent zum Hinzufügen von Eigenschaften fügt die folgende Zeile in die Dispatchzuordnung des Steuerelements ein, die sich in der Implementierungsdatei der Steuerelementklasse befindet:

DISP_STOCKPROP_CAPTION()

Ändern der OnDraw-Funktion

Die Standardimplementierung verwendet OnDraw die Windows-Systemschriftart für den gesamten text, der im Steuerelement angezeigt wird. Dies bedeutet, dass Sie den OnDraw Code ändern müssen, indem Sie das Schriftartobjekt im Gerätekontext auswählen. Rufen Sie dazu COleControl::SelectStockFont auf, und übergeben Sie den Gerätekontext des Steuerelements, wie im folgenden Beispiel gezeigt:

CFont* pOldFont;
TEXTMETRIC tm;
const CString& strCaption = InternalGetText();

pOldFont = SelectStockFont(pdc);
pdc->FillRect(rcBounds, CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH)));
pdc->Ellipse(rcBounds);
pdc->GetTextMetrics(&tm);
pdc->SetTextAlign(TA_CENTER | TA_TOP);
pdc->ExtTextOut((rcBounds.left + rcBounds.right) / 2,
(rcBounds.top + rcBounds.bottom - tm.tmHeight) / 2,
ETO_CLIPPED, rcBounds, strCaption, strCaption.GetLength(), NULL);

pdc->SelectObject(pOldFont);

Nachdem die OnDraw Funktion so geändert wurde, dass das Schriftartobjekt verwendet wird, wird jeder Text innerhalb des Steuerelements mit Merkmalen aus der Schriftarteneigenschaft des Steuerelements angezeigt.

Angepasste Schrifteigenschaften in Ihrem Steuerelement verwenden

Zusätzlich zur Standardeigenschaft "Schriftart" kann das ActiveX-Steuerelement über benutzerdefinierte Schriftarteigenschaften verfügen. Um eine benutzerdefinierte Schriftarteigenschaft hinzuzufügen, müssen Sie:

Verwenden Sie den Assistenten zum Hinzufügen von Eigenschaften, um die benutzerdefinierte Schriftarteigenschaft zu implementieren.
Verarbeiten von Schriftartbenachrichtigungen.
Implementieren einer neuen Benachrichtigungsschnittstelle für Schriftarten.

Implementieren einer benutzerdefinierten Schriftarteigenschaft

Um eine benutzerdefinierte Schriftarteigenschaft zu implementieren, verwenden Sie den Assistenten zum Hinzufügen von Eigenschaften, um die Eigenschaft hinzuzufügen und dann einige Änderungen am Code vorzunehmen. In den folgenden Abschnitten wird beschrieben, wie Sie die angepasste HeadingFont-Eigenschaft zum Beispiel-Steuerelement hinzufügen.

So fügen Sie die angepasste Eigenschaft Schriftart mit dem Assistenten für neue Eigenschaften hinzu

Laden Sie das Steuerelementprojekt.
Erweitern Sie in der Klassenansicht den Bibliotheksknoten Ihres Steuerelements.
Klicken Sie mit der rechten Maustaste auf den Schnittstellenknoten des Steuerelements (den zweiten Knoten des Bibliotheksknotens), um das Kontextmenü zu öffnen.
Klicken Sie im Kontextmenü auf "Hinzufügen" und dann auf "Eigenschaft hinzufügen".

Dadurch wird der Assistent zum Hinzufügen von Eigenschaften geöffnet.
Geben Sie im Feld "Eigenschaftsname " einen Namen für die Eigenschaft ein. Verwenden Sie in diesem Beispiel "HeadingFont".
Klicken Sie für den Implementierungstyp auf "Get/Set-Methoden".
Wählen Sie im Feld "Eigenschaftstyp " die Option "IDispatch* " für den Eigenschaftentyp aus.
Klicken Sie auf Fertig stellen.

Der Assistent zum Hinzufügen von Eigenschaften erstellt den Code, um die benutzerdefinierte Eigenschaft HeadingFont der CSampleCtrl-Klasse und der SAMPLE.IDL-Datei hinzuzufügen. Da HeadingFont ein Get/Set-Eigenschaftstyp ist, ändert der Assistent zum Hinzufügen von Eigenschaften die Dispatchzuordnung der Klasse CSampleCtrl, um einen Makroeintrag DISP_PROPERTY_EX_ID DISP_PROPERTY_EX einzufügen:

DISP_PROPERTY_EX_ID(CMyAxFontCtrl, "HeadingFont", dispidHeadingFont,
   GetHeadingFont, SetHeadingFont, VT_DISPATCH)

Das Makro DISP_PROPERTY_EX ordnet den HeadingFont Eigenschaftsnamen den entsprechenden CSampleCtrl Get- und Set-Methoden der Klasse, GetHeadingFont und SetHeadingFont, zu. Der Typ des Eigenschaftswerts wird ebenfalls angegeben; in diesem Fall VT_FONT.

Der Assistent zum Hinzufügen von Eigenschaften fügt außerdem eine Deklaration in der Steuerelementkopfzeilendatei (.H) für die Funktionen GetHeadingFont und SetHeadingFont hinzu und integriert deren Funktionsvorlagen in der Steuerelementimplementierungsdatei (.CPP).

IDispatch* CWizardGenCtrl::GetHeadingFont(void)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   // TODO: Add your dispatch handler code here

   return NULL;
}

void CWizardGenCtrl::SetHeadingFont(IDispatch* /*pVal*/)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   // TODO: Add your property handler code here

   SetModifiedFlag();
}

Schließlich ändert der Assistent zum Hinzufügen von Eigenschaften die Steuerelement-IDL-Datei, indem er einen Eintrag für die HeadingFont Eigenschaft hinzufügt.

[id(1)] IDispatch* HeadingFont;

Änderungen am Steuerungscode

Nachdem Sie die HeadingFont Eigenschaft dem Steuerelement hinzugefügt haben, müssen Sie einige Änderungen an den Steuerelementheader- und Implementierungsdateien vornehmen, um die neue Eigenschaft vollständig zu unterstützen.

In der Steuerelementkopfdatei (. H) fügen Sie die folgende Deklaration einer geschützten Membervariable hinzu:

protected:
   CFontHolder m_fontHeading;

In der Steuerelement-Implementierungsdatei (.CPP) führen Sie Folgendes aus:

Initialisieren Sie m_fontHeading im Steuerelementkonstruktor.

CMyAxFontCtrl::CMyAxFontCtrl()
   : m_fontHeading(&m_xFontNotification)
{
   InitializeIIDs(&IID_DNVC_MFC_AxFont, &IID_DNVC_MFC_AxFontEvents);
}

Deklarieren Sie eine statische FONTDESC-Struktur, die Standardattribute der Schriftart enthält.

static const FONTDESC _fontdescHeading =
{ sizeof(FONTDESC), OLESTR("MS Sans Serif"), FONTSIZE(12), FW_BOLD,
  ANSI_CHARSET, FALSE, FALSE, FALSE };

Fügen Sie in der Member-Funktion des Steuerelements DoPropExchange einen Aufruf der Funktion PX_Font hinzu. Dies stellt Initialisierung und Persistenz für Ihre benutzerdefinierte Schriftarteigenschaft bereit.

void CMyAxFontCtrl::DoPropExchange(CPropExchange* pPX)
{
   ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
   COleControl::DoPropExchange(pPX);

   // [...other PX_ function calls...]
   PX_Font(pPX, _T("HeadingFont"), m_fontHeading, &_fontdescHeading);
}

Schließen Sie die Implementierung der Member-Funktion für das Steuerelement GetHeadingFont ab.

IDispatch* CMyAxFontCtrl::GetHeadingFont(void)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   return m_fontHeading.GetFontDispatch();
}

Schließen Sie die Implementierung der Member-Funktion für das Steuerelement SetHeadingFont ab.

void CMyAxFontCtrl::SetHeadingFont(IDispatch* pVal)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());

   m_fontHeading.InitializeFont(&_fontdescHeading, pVal);
   OnFontChanged();    //notify any changes
   SetModifiedFlag();
}

Ändern Sie die Steuerelementelementfunktion OnDraw , um eine Variable zu definieren, die die zuvor ausgewählte Schriftart enthält.
```
CFont* pOldHeadingFont;
```
Ändern Sie die Member-Funktion des Steuerelements OnDraw, um die angepasste Schriftart im Gerätekontext auszuwählen, indem Sie die folgende Zeile dort einfügen, wo die Schriftart verwendet werden soll.
```
pOldHeadingFont = SelectFontObject(pdc, m_fontHeading);
```
Ändern Sie die OnDraw-Funktion des Steuerelements, um die vorherige Schriftart wieder in den Gerätekontext auszuwählen, indem Sie die folgende Zeile hinzufügen, nachdem die Schriftart verwendet wurde.
```
pdc->SelectObject(pOldHeadingFont);
```

Nachdem die benutzerdefinierte Schriftart-Eigenschaft implementiert wurde, sollte die Standardmäßige Schriftart-Eigenschaftenseite implementiert werden, sodass Steuerelementbenutzer die aktuelle Schriftart des Steuerelements ändern können. Um die Eigenschaftsseiten-ID für die Standardeigenschaftsseite Font hinzuzufügen, fügen Sie die folgende Zeile nach dem Makro BEGIN_PROPPAGEIDS ein:

PROPPAGEID(CLSID_CFontPropPage)

Sie müssen auch den Count-Parameter ihres BEGIN_PROPPAGEIDS Makros um eins erhöhen. In der folgenden Zeile wird dies veranschaulicht:

BEGIN_PROPPAGEIDS(CMyAxFontCtrl, 2)

Nachdem diese Änderungen vorgenommen wurden, erstellen Sie das gesamte Projekt neu, um die zusätzliche Funktionalität zu integrieren.

Verarbeiten von Schriftartbenachrichtigungen

In den meisten Fällen muss das Steuerelement wissen, wann die Merkmale des Schriftartobjekts geändert wurden. Jedes Schriftartobjekt kann Benachrichtigungen bereitstellen, wenn es sich ändert, indem eine Memberfunktion der IFontNotification-Schnittstelle aufgerufen wird, die von COleControl implementiert wird.

Wenn das Steuerelement die Eigenschaft Standardschriftart verwendet, werden seine Benachrichtigungen von der OnFontChanged-Member-Funktion von COleControl behandelt. Wenn Sie angepasste Schrifteigenschaften hinzufügen, können Sie sie dieselbe Implementierung verwenden lassen. Im Beispiel im vorherigen Abschnitt wurde dies durch Übergeben von &m_xFontNotification beim Initialisieren der m_fontHeading Membervariable erreicht.

Implementieren mehrerer Schriftartobjektschnittstellen

Die einfarbigen Linien in der obigen Abbildung zeigen, dass beide Schriftartobjekte dieselbe Implementierung verwenden IFontNotification. Dies kann zu Problemen führen, wenn Sie unterscheiden möchten, welche Schriftart geändert wurde.

Eine Möglichkeit, zwischen den Schriftartobjektbenachrichtigungen des Steuerelements zu unterscheiden, besteht darin, eine separate Implementierung der IFontNotification Schnittstelle für jedes Schriftartobjekt im Steuerelement zu erstellen. Mit dieser Technik können Sie den Zeichnungscode optimieren, indem Sie nur die Zeichenfolge oder Zeichenfolgen aktualisieren, die die zuletzt geänderte Schriftart verwenden. In den folgenden Abschnitten werden die Schritte veranschaulicht, die erforderlich sind, um separate Benachrichtigungsschnittstellen für eine zweite Font-Eigenschaft zu implementieren. Die zweite Schriftarteigenschaft wird davon ausgegangen, dass sie die HeadingFont Eigenschaft ist, die im vorherigen Abschnitt hinzugefügt wurde.

Implementieren einer neuen Benachrichtigungsschnittstelle für Schriftarten

Um zwischen den Benachrichtigungen von zwei oder mehr Schriftarten zu unterscheiden, muss für jede Schriftart, die im Steuerelement verwendet wird, eine neue Benachrichtigungsschnittstelle implementiert werden. In den folgenden Abschnitten wird beschrieben, wie Sie eine neue Benachrichtigungsschnittstelle für Schriftarten implementieren, indem Sie die Steuerkopf- und Implementierungsdateien ändern.

Ergänzungen zur Headerdatei

In der Steuerelementkopfdatei (. H) fügen Sie der Klassendeklaration die folgenden Zeilen hinzu:

protected:
   BEGIN_INTERFACE_PART(HeadingFontNotify, IPropertyNotifySink)
      INIT_INTERFACE_PART(CMyAxFontCtrl, HeadingFontNotify)
      STDMETHOD(OnRequestEdit)(DISPID);
   STDMETHOD(OnChanged)(DISPID);
   END_INTERFACE_PART(HeadingFontNotify)

Dadurch wird eine Implementierung der Schnittstelle IPropertyNotifySink namens HeadingFontNotify erstellt. Diese neue Schnittstelle enthält eine Methode namens OnChanged.

Ergänzungen zur Implementierungsdatei

Ändern Sie im Code, der die Überschriftenschriftart initialisiert (im Steuerelementkonstruktor), &m_xFontNotification in &m_xHeadingFontNotify. Fügen Sie dann den folgenden Code hinzu:

STDMETHODIMP_(ULONG) CMyAxFontCtrl::XHeadingFontNotify::AddRef()
{
   METHOD_MANAGE_STATE(CMyAxFontCtrl, HeadingFontNotify)
      return 1;
}
STDMETHODIMP_(ULONG) CMyAxFontCtrl::XHeadingFontNotify::Release()
{
   METHOD_MANAGE_STATE(CMyAxFontCtrl, HeadingFontNotify)
      return 0;
}

STDMETHODIMP CMyAxFontCtrl::XHeadingFontNotify::QueryInterface(REFIID iid, LPVOID FAR* ppvObj)
{
   METHOD_MANAGE_STATE(CMyAxFontCtrl, HeadingFontNotify)
      if (IsEqualIID(iid, IID_IUnknown) || IsEqualIID(iid, IID_IPropertyNotifySink))
      {
         *ppvObj = this;
         AddRef();
         return NOERROR;
      }
   return ResultFromScode(E_NOINTERFACE);
}

STDMETHODIMP CMyAxFontCtrl::XHeadingFontNotify::OnChanged(DISPID)
{
   METHOD_MANAGE_STATE(CMyAxFontCtrl, HeadingFontNotify)
      pThis->InvalidateControl();
   return NOERROR;
}

STDMETHODIMP CMyAxFontCtrl::XHeadingFontNotify::OnRequestEdit(DISPID)
{
   return NOERROR;
}

Die AddRef- und Release-Methode in der IPropertyNotifySink-Schnittstelle überwachen die Referenzanzahl des ActiveX-Steuerelements. Wenn das Steuerelement Zugriff auf den Schnittstellenzeiger erhält, ruft es AddRef auf, um die Referenzanzahl zu erhöhen. Wenn das Steuerelement mit dem Zeiger fertig ist, ruft es Release auf, ähnlich wie GlobalFree aufgerufen werden könnte, um einen globalen Speicherblock freizugeben. Wenn die Referenzanzahl für diese Schnittstelle auf Null gesetzt wird, kann die Schnittstellenimplementierung freigegeben werden. In diesem Beispiel gibt die QueryInterface Funktion einen Zeiger auf eine IPropertyNotifySink Schnittstelle für ein bestimmtes Objekt zurück. Mit dieser Funktion kann ein ActiveX-Steuerelement ein Objekt abfragen, um zu bestimmen, welche Schnittstellen unterstützt werden.

Nachdem diese Änderungen an Ihrem Projekt vorgenommen wurden, erstellen Sie das Projekt neu, und verwenden Sie den Testcontainer, um die Schnittstelle zu testen. Informationen zum Zugriff auf den Testcontainer finden Sie unter Testen von Eigenschaften und Ereignissen mit dem Testcontainer .

Siehe auch

MFC ActiveX-Steuerelemente
MFC ActiveX-Steuerelemente: Verwenden von Bildern in einem ActiveX-Steuerelement
MFC ActiveX-Steuerelemente: Verwenden von Standard-Eigenschaftsseiten

Feedback

War diese Seite hilfreich?

Last updated on 2026-02-23