MFC-ActiveX-Steuerelemente: Verwenden von Schriftarten

Artikel
10/12/2023

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: Aktien oder benutzerdefiniert. Eigenschaften von Aktienschriftarten sind vorimplementierte Schriftarteigenschaften, die Sie mithilfe des Assistenten zum Hinzufügen von Eigenschaften hinzufügen können. Benutzerdefinierte Schriftarteigenschaften sind nicht 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

Verwenden der Stock Font-Eigenschaft

Stock Font-Eigenschaften werden von der Klasse COleControl implementiert. Darüber hinaus ist eine Standardmäßige Schriftart-Eigenschaftenseite verfügbar, sodass der Benutzer verschiedene Attribute des Schriftartobjekts ändern kann, z. B. name, Schriftgrad und Formatvorlage.

Greifen Sie über die 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 erläutert: Eigenschaften, ist das Hinzufügen von Aktieneigenschaften mit dem Assistenten zum Hinzufügen von Eigenschaften einfach. Sie wählen die Eigenschaft "Schriftart" aus, und der Assistent zum Hinzufügen von Eigenschaften fügt automatisch den Eintrag "Aktienschriftart" in die Verteilerzuordnung des Steuerelements ein.

So fügen Sie die Eigenschaft "Aktienschriftart" mithilfe des Assistenten zum Hinzufügen von Eigenschaften hinzu

Laden Sie das Steuerelementprojekt.
Erweitern Sie in der Klassenansicht den Bibliotheksknoten des 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 "Schriftart".
Klicken Sie auf Fertig stellen.

Der Assistent zum Hinzufügen von Eigenschaften fügt die folgende Zeile zur Verteilerzuordnung des Steuerelements hinzu, 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 zum Steuerelement hinzu. IDL-Datei:

[id(DISPID_FONT)] IFontDisp* Font;

Die Stock Caption-Eigenschaft ist ein Beispiel für eine Texteigenschaft, die mithilfe der Eigenschafteninformationen der Schriftart für Aktien gezeichnet 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 des 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.
Wählen Sie im Feld Eigenschaftenname Caption aus.
Klicken Sie auf Fertig stellen.

Der Assistent zum Hinzufügen von Eigenschaften fügt die folgende Zeile zur Verteilerzuordnung des Steuerelements hinzu, 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.

Verwenden von benutzerdefinierten Schriftarteigenschaften in Ihrem Steuerelement

Zusätzlich zur Eigenschaft "Schriftart für Aktien" kann das ActiveX-Steuerelement über benutzerdefinierte Schriftarteigenschaften verfügen. So fügen Sie eine benutzerdefinierte Schriftarteigenschaft hinzu, die Sie benötigen:

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 benutzerdefinierte HeadingFont Eigenschaft zum Beispielsteuerelement hinzufügen.

So fügen Sie die benutzerdefinierte Schriftarteigenschaft mithilfe des Assistenten zum Hinzufügen von Eigenschaften hinzu

Laden Sie das Steuerelementprojekt.
Erweitern Sie in der Klassenansicht den Bibliotheksknoten des 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 unter Implementierungstypauf 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 der Klasse und dem SAMPLE die HeadingFont benutzerdefinierte Eigenschaft CSampleCtrl hinzuzufügen. IDL-Datei. Da HeadingFont es sich um einen Get/Set-Eigenschaftstyp handelt, ändert der Assistent zum Hinzufügen von Eigenschaften die Verteilerzuordnung der CSampleCtrl Klasse so, dass sie einen DISP_PROPERTY_EX_IDDISP_PROPERTY_EX Makroeintrag enthält:

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

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

Der Assistent zum Hinzufügen von Eigenschaften fügt auch eine Deklaration in der Steuerelementkopfzeilendatei (. H) für die GetHeadingFont und SetHeadingFont die Funktionen und fügt ihre 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 das Steuerelement. IDL-Datei durch Hinzufügen eines Eintrags für die HeadingFont Eigenschaft:

[id(1)] IDispatch* HeadingFont;

Änderungen am Steuerelementcode

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 Steuerelementimplementierungsdatei (. Führen Sie die folgenden Schritte 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 Steuerelementelementfunktion DoPropExchange einen Aufruf der PX_Font Funktion 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);
}

Abschließen der Implementierung der Steuerelementelementfunktion GetHeadingFont .

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

   return m_fontHeading.GetFontDispatch();
}

Abschließen der Implementierung der Steuerelementelementfunktion SetHeadingFont .

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 Steuerelementelementfunktion OnDraw , um die benutzerdefinierte Schriftart im Gerätekontext auszuwählen, indem Sie die folgende Zeile hinzufügen, wo die Schriftart verwendet werden soll.
```
pOldHeadingFont = SelectFontObject(pdc, m_fontHeading);
```
Ändern Sie die Steuerelementelementfunktion OnDraw , um die vorherige Schriftart wieder in den Gerätekontext zu markieren, 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 Eigenschaftenseiten-ID für die Standardeigenschaftsseite "Schriftart" 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. Die folgende Zeile veranschaulicht dies:

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.

Wenn das Steuerelement die Eigenschaft "Stock Font" verwendet, werden die Benachrichtigungen von der OnFontChanged Memberfunktion behandelt COleControl. Wenn Sie benutzerdefinierte Schriftarteigenschaften hinzufügen, können Sie die gleiche Implementierung verwenden. Im Beispiel im vorherigen Abschnitt wurde dies durch Übergeben von &m_xFontNotification beim Initialisieren der m_fontHeading Membervariable erreicht.

Implementing multiple font object interfaces.
Implementieren mehrerer Schnittstellen für Schriftartobjekte

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 erstellt, die IPropertyNotifySink aufgerufen wird HeadingFontNotify. Diese neue Schnittstelle enthält eine Methode namens OnChanged.

Ergänzungen zur Implementierungsdatei

Ändern Sie im Code, der die Überschriftenschriftart (im Steuerelementkonstruktor) initialisiert, &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 Methoden und Release Methoden in der IPropertyNotifySink Schnittstelle verfolgen die Referenzanzahl für das ActiveX-Steuerelementobjekt. Wenn das Steuerelement Zugriff auf den Schnittstellenzeiger erhält, ruft AddRef das Steuerelement auf, um die Referenzanzahl zu erhöhen. Wenn das Steuerelement mit dem Zeiger fertig ist, wird Releasees auf die gleiche Weise aufgerufen, wie GlobalFree sie aufgerufen werden kann, 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 Controls (MFC-ActiveX-Steuerelemente)
MFC-ActiveX-Steuerelemente: Verwenden von Bildern in einem ActiveX-Steuerelement
MFC-ActiveX-Steuerelemente: Verwenden von vordefinierten Eigenschaftenseiten

Teilen über