Windows Dev Center

Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

Einführung in DirectWrite

Die Menschen verwenden bei ihrer tagtäglichen Kommunikation ständig Text. Er stellt die wichtigste Methode dar, die stets zunehmende Flut von Informationen zu verarbeiten. In der Vergangenheit geschah dies vor allem über gedruckte Inhalte, wie Dokumente, Zeitungen, Bücher usw. Heutzutage nimmt jedoch die Bedeutung von Inhalten, die auf einem Windows PC angezeigt werden, immer weiter zu. Ein typischer Windows-Benutzer verbringt einen Großteil seiner Zeit mit dem Lesen am Computerbildschirm. Er surft im Internet, liest seine E-Mails, erstellt einen Bericht, füllt eine Tabellenkalkulation aus oder schreibt Software, wobei der Benutzer im eigentlichen Sinne immer "liest". Obwohl Text und Schriftarten bei der Verwendung von Windows überall eine Rolle spielen, ziehen die meisten Benutzer das Lesen von gedruckten Inhalten dem Lesen am Bildschirm vor.

Für die Entwickler von Windows-Anwendungen ist das Schreiben von textverarbeitenden Anwendungen eine Herausforderung, da immer höhere Anforderungen an eine bessere Lesbarkeit, eine ausgereiftere Steuerung von Formatierung und Layout sowie an die Unterstützung der zahlreichen Sprachen, die von einer Anwendung unterstützt werden, gestellt werden. Selbst einfache Systeme zur Textverarbeitung müssen die Eingabe von Text, das Layout, Anzeigen, Bearbeiten sowie Kopieren und Einfügen unterstützten. Windows-Benutzer erwarten in der Regel mehr als diese Grundfunktionen, sodass selbst einfache Editoren mehrere Schriftarten, verschiedene Absatzformatierungen, eingebettete Bilder, die Rechtschreibuprüfung und andere Funktionen bieten müssen. Das Entwerfen moderner Benutzeroberflächen beschränkt sich auch nicht mehr auf nur ein einziges Format, einfachen Text, sondern muss mit umfangreichen Schriftarten und Textlayouts zu einer besseren Benutzerfreundlichkeit beitragen.

In dieser Einführung erfahren Sie, wie Sie mit DirectWrite die Benutzererfahrung in Bezug auf Text in der Benutzeroberfläche und in Dokumenten von Windows-Anwendungen optimieren können.

Verbessern der Texterfahrung

Die Anforderungen in Bezug auf Text in der Benutzeroberfläche und in Dokumenten sind für moderne Windows-Anwendungen sehr hoch. Hierzu zählen eine bessere Lesbarkeit, die Unterstützung verschiedener Sprachen und Schriften sowie eine hervorragende Renderingleistung. Darüber hinaus muss für die meisten vorhandenen Anwendungen sichergestellt werden, dass die bereits getätigten Investitionen beim Übergang zur WindowsWin32-Codebasis genutzt werden.

DirectWrite stellt die folgenden drei Funktionen bereit, mit denen Entwickler von Windows-Anwendungen die Texterfahrung in ihren Anwendungen verbessern können: Unabhängigkeit vom Renderingsystem, hochwertige Typografie sowie mehrere Funktionalitätsschichten.

Unabhängigkeit vom Renderingsystem

DirectWrite ist nicht von einer bestimmten Grafiktechnologie abhängig. Anwendungen können die Renderingtechnologie verwenden, die für ihre Zwecke am besten geeignet ist. Hierdurch können Anwendungen auf flexible Weise einen Teil der Anwendung über GDI und andere Teile direkt über Direct3D oder Direct2D rendern. In der Tat kann eine Anwendung DirectWrite auch durch einen herstellereigenen Renderingstapel rendern.

Hochwertige Typografie

DirectWrite nutzt die Fortschritte der OpenType-Schriftarttechnologie, um eine qualitativ hochwertige Typografie in Windows-Anwendungen zu ermöglichen. Das DirectWrite-Schriftsystem stellt Dienste zur Behandlung von Schriftartenaufzählung, Schriftartfallback und Schriftarten-Zwischenspeicherung zur Verfügung, die von Anwendungen zur Verarbeitung von Schriftarten benötigt werden.

Die von DirectWrite bereitgestellte OpenType-Unterstützung ermöglicht Entwicklern, ihren Anwendungen erweiterte typographische Funktionen und Unterstützung für internationalen Text hinzuzufügen.

Unterstützung erweiterter typographischer Funktionen

DirectWrite ermöglicht es Anwendungsentwicklern, die Funktionen von OpenType-Schriftarten zu nutzen, die sie in WinForms oder GDI nicht verwenden konnten. Das DirectWrite IDWriteTypography-Objekt ermöglicht die Nutzung zahlreicher erweiteter Funktionen von OpenType-Schriften, wie z. B. Stilalternativen und Schwungbuchstaben. Das Microsoft Windows Software Development Kit (SDK) stellt einen Satz von OpenType-Schriftarten mit besonderen Merkmalen als Beispiele bereit, wie z. B. die Schriftarten Pericles und Pescadero. Weitere Details zu OpenType-Merkmalen finden Sie unter OpenType-Schriftartmerkmale.

Unterstützung von internationalem Text

DirectWrite verwendet OpenType-Schriftarten für eine weitreichende Unterstützung internationalen Texts. Unicode-Funktionen, wie z. B. Ersatzzeichen, BIDI, Zeilenumbrüche und UVS werden unterstützt. Die sprachengeführte Schriftenaufschlüsselung, Zahlenersetzung und Glyphenstrukturierung stellen sicher, dass Text in einer beliebigen Schrift das richtige Layout und Rendering aufweist.

Die folgenden Schriften werden derzeit unterstützt:

Hinweis  Für Schriften, die mit * markiert sind, gibt es keine Standard-Systemschriftarten. Für Anwendungen, die diese Schriften unterstützen, müssen Schriftarten installiert werden.

  • Arabisch
  • Armenisch
  • Bengali
  • Bopomofo
  • Braille*
  • Kanadische Aboriginal Syllabics
  • Cherokee
  • Chinesisch (vereinfacht und traditionell)
  • Kyrillisch
  • Koptisch*
  • Devanagari
  • Äthiopisch
  • Georgisch
  • Glagolitisch*
  • Griechisch
  • Gujarati
  • Gurmukhi
  • Hebräisch
  • Japanisch
  • Kannada
  • Khmer
  • Koreanisch
  • Laotisch
  • Lateinisch
  • Malayalam
  • Mongolisch
  • Birmanisch
  • Neues Tai Lue
  • Ogham*
  • Oriya
  • 'Phags-pa
  • Runisch*
  • Sinhala
  • Syrisch
  • Tai Le
  • Tamil
  • Telugu
  • Thaana
  • Thailändisch
  • Tibetisch
  • Yi

Mehrere Funktionalitätsschichten

DirectWrite stellt verschiedene Funktionalitätsschichten bereit, wobei die einzelnen Schichten nahtlos miteinander interagieren. Das API-Design bietet Anwendungsentwicklern die Freiheit und Flexibilität, je nach Anforderungen und Zeitplan einzelne Schichten anzuwenden. Im folgenden Diagramm ist die Beziehung zwischen diesen Schichten dargestellt.

Diagramm der DirectWrite-Schichten und deren Kommunikation mit einer Anwendung oder einem Benutzeroberflächen-Framework

Die Textlayout-API stellt die höchste Funktionsstufe in DirectWrite dar. Sie stellt der Anwendung Dienste bereit, formatierungsreiche Textzeichenfolgen zu messen, anzuzeigen und mit ihnen zu interagieren. Diese Text-API kann in Anwendungen verwendet werden, die derzeit DrawText von Win32 verwenden, um eine moderne Benutzeroberfläche mit umfangreich formatiertem Text zu erstellen.

Textintensive Anwendungen, die ein eigenes Layoutmodul implementieren, können die nächste, darunter liegende Schicht verwenden: die Schriftenverarbeitung. Die Schriftenverarbeitung teilt eine Textmenge in Schriftblöcke und verarbeitet die Zuordnung zwischen den Unicode-Darstellungen und der entsprechenden Glyphendarstellung in der Schriftart, damit der Text der Schrift ordnungsgemäß in der richtigen Sprache angezeigt wird. Das von der Textlayout-API-Schicht verwendete Layoutsystem baut auf dem Schriftart- und Schriftverarbeitungssystem auf.

Die Glyphenrendering-Schicht ist die unterste Funktionalitätsschicht und ermöglicht das Glyphenrendering für Anwendungen, die ein eigenes Textlayoutmodul implementieren. Die Glyphenrenderingschicht ist auch für Anwendungen nützlich, die einen benutzerdefinierten Renderer implementieren, um das Glyphenzeichnungsverhalten durch die Rückruffunktion in der DirectWrite-Textformatierungs-API zu ändern.

Das DirectWrite-Schriftsystem steht allen Funktionsschichten von DirectWrite zur Verfügung und ermöglicht es Anwendungen, auf Schriftart- und Glypheninformationen zuzugreifen. Es ist darauf ausgelegt, allgemeine Schrifttechnologien und Datenformate zu verarbeiten. Das DirectWrite-Schriftmodell folgt der allgemeinen typographischen Vorgehensweise, eine beliebige Anzahl von Schnitten, Formaten und Streckungen in der gleichen Schriftfamilie zu unterstützen. Dieses Modell, das auch von WPF und CSS angewendet wird, gibt an, dass Schriftarten, die sich nur hinsichtlich Schriftschnitt (fett, schmal usw.), Format (hochkant, kursiv oder schräg) oder Streckung (schmal, verengt, weit usw.) unterscheiden, als Mitglieder einer Schriftfamilie angesehen werden.

Verbessertes Textrendering mit ClearType

Die Lesbarkeit auf dem Bildschirm zu verbessern ist eine Hauptanforderung für alle Windows-Anwendungen. Wie Hinweise aus Forschungen im Bereich der kognitiven Psychologie ergeben, müssen wir in der Lage sein, jeden Buchstaben genau zu erkennen, und dass hierbei sogar der Abstand zwischen den Buchstaben für eine schnelle Verarbeitung äußerst wichtig ist. Buchstaben und Wörter, die nicht symmetrisch sind, werden als hässlich wahrgenommen und beeinträchtigen das Lesen. Kevin Larson von der Microsoft Advanced Reading Technologies-Gruppe schrieb einen Artikel zu diesem Thema, der in Spectrum IEEE veröffentlicht wurde. Der Artikel heißt "The Technology of Text" (http://www.spectrum.ieee.org/print/5049).

Text in DirectWrite wird mit Microsoft ClearType gerendert, das die Klarheit und die Lesbarkeit des Texts verbessert. ClearType nutzt die Tatsache, dass moderne LCD-Monitore RGB-Streifen für jedes Pixel haben, die einzeln gesteuert werden können. DirectWrite verwendet die neuesten Verbesserungen von ClearType, die erstmalig in Windows Vista mit Windows Presentation Foundation enthalten waren. Diese ermöglichen DirectWrite, nicht nur die einzelnen Buchstaben auszuwerten, sondern auch den Abstand zwischen den Buchstaben. Bevor diese ClearType-Verbesserungen umgesetzt wurden, war Text mit einer Lesegröße von 10 oder 12 Punkten schwierig anzuzeigen: Es konnte entweder 1 Pixel zwischen den Buchstaben platziert werden, was oft zu wenig war, oder 2 Pixel, was oft zu viel war. Durch die Verwendung der zusätzlichen Auflösung in den Subpixeln ist es möglich, einen bruchteilhaften Abstand zu verwenden, wodurch sich die Gleichmäßigkeit und Symmetrie der gesamten Seite verbessern lässt.

Die folgenden beiden Abbildungen stellen dar, wie Glyphen möglicherweise auf einer beliebigen Subpixelgrenze beginnen können, wenn die Subpixelpositionierung verwendet wird.

Die folgende Abbildung wurde mit der GDI-Version des ClearType-Renderers gerendert, die keine Subpixelpositionierung verwendet.

Abbildung von "technology", gerendert ohne Subpixelpositionierung

Die folgende Abbildung wurde mit der DirectWriteVersion des ClearType-Renderers gerendert, die die Subpixelpositionierung verwendet.

Abbildung von "technology", gerendert mit Subpixelpositionierung

Beachten Sie, dass der Abstand zwischen den Buchstaben h und n in der zweiten Abbildung gleichmäßiger ist, und dass der Buchstabe o weiter vom Buchstaben n entfernt ist, gleichmäßiger mit dem Buchstaben l. Beachten Sie auch, dass die "Stiele" der Buchstaben l natürlicher wirken.

Die ClearType-Subpixelpositionierung ermöglicht den genausten Abstand von Zeichen auf Bildschirm, besonders bei kleinen Größen, wo der Unterschied zwischen einem Subpixel und einem ganzen Pixel einen bedeutenden Unterschied in der Glyphenbreite darstellt. Sie ermöglicht, dass Text in einem idealen Auflösungsraum gemessen wird und an seiner natürlichen Position beim LCD-Farbstreifen gerendert wird, mit Subpixelgranularität. Text, der mit dieser Technologie gemessen und gerendert wird, ist per Definition auflösungsunabhängig, was bedeutet, dass ein genau identisches Textlayout über verschiedene Anzeigeauflösungen hinweg erzielt wird.

Im Gegensatz zu den einzelnen Typen von GDI-ClearType-Rendering bietet Subpixel-ClearType die genaueste Zeichenbreite.

Die Textzeichenfolgen-API übernimmt standardmäßig das Subpixel-Textrendering. Das bedeutet, dass der Text unabhängig von der aktuellen Bildschirmauflösung an seiner idealen Auflösung gemessen wird und die Glyphenpositionierung basierend auf echt skalierten Glyphenvorschubsbreiten und Positionierungsversätzen erfolgt.

Für großformatigen Text aktiviert DirectWrite darüber hinaus das Antialiasing entlang der y-Achse, um die Ränder zu glätten und Buchstaben so zu rendern, wie vom Schriftendesigner beabsichtigt. In der folgenden Abbildung ist das Antialiasing in y-Richtung dargestellt.

Abbildung von "ClearType" als gerenderter GDI-Text und als DirectWrite-Text mit Antialiasing in y-Richtung

Obwohl DirectWrite-Text standardmäßig mit Subpixel-ClearType positioniert und gerendert wird, stehen auch andere Renderingoptionen zur Verfügung. In vielen bereits vorhandenen Anwendungen wird ein Großteil der Benutzeroberfläche mithilfe von GDI gerendert, und einige Anwendungen verwenden Systembearbeitungs-Steuerelemente, die weiterhin GDI für das Textrendering verwenden. Wenn diesen Anwendungen DirectWrite-Text hinzugefügt wird, werden die Verbesserungen der Leseerfahrung, die durch Subpixel-ClearType erzielt werden, möglicherweise wieder zunichte gemacht, damit der Text innerhalb der Anwendung ein einheitliches Erscheinungsbild abgibt.

Um diese Anforderungen zu erfüllen, unterstützt DirectWrite auch die folgenden Renderingoptionen:

  • Subpixel-ClearType (Standard)
  • Subpixel-ClearType mit Antialiasing in sowohl horizontalen als auch vertikalen Dimensionen
  • Aliastext
  • Natürliche GDI-Breite (z. B. in der Microsoft Word-Lesenansicht)
  • GDI-kompatible Breite (einschließlich ostasiatische eingebettete Bitmap)
Jeder dieser Renderingmodi kann durch die DirectWrite-API und durch den neuen Windows 7-internen ClearType-Tuner optimal angepasst werden.

API-Übersicht

Die IDWriteFactory-Schnittstelle ist der Ausgangspunkt für die Verwendung der DirectWrite-Funktionen. Die Factory ist das Stammobjekt, das einen Satz von Objekten erstellt, die zusammen verwendet werden können.

Eine Voraussetzung für diesen Vorgang ist die Formatierung und Layouterstellung, da der Text formatiert und das Layout hinsichtlich bestimmter Einschränkungen festgelegt werden muss, bevor er gezeichnet werden kann oder Treffertests durchgeführt werden können. Zwei Hauptobjekte, die Sie zu diesem Zweck mit einer IDWriteFactory erstellen können, sind IDWriteTextFormat und IDWriteTextLayout. Ein IDWriteTextFormat-Objekt beinhaltet die Formatierungsinformationen für einen Textabsatz. Die IDWriteFactory::CreateTextLayout-Funktion übernimmt die Eingabezeichenfolge, die zugehörigen Einschränkungen, wie z. B. die Maße der zu füllenden Fläche, und das IDWriteTextFormat Objekt. Anschließend übernimmt sie das vollständig analysierte und formatierte Ergebnis in IDWriteTextLayout, um es bei nachfolgenden Vorgängen anzuwenden.

Die Anwendung kann dann den Text mithilfe der DrawTextLayout-Funktion rendern, die von Direct2D bereitgestellt wird, oder indem sie eine Rückruffunktion implementiert, die GDI, Direct2D oder andere Grafiksysteme zum Rendern von Glyphen verwenden kann. Für Text mit einer einzelnen Formatierung bietet die DrawText-Funktion von Direct2D eine einfachere Möglichkeit zum Zeichnen von Text, ohne dass zuerst ein IDWriteTextLayout-Objekt erstellt werden muss.

Formatieren und Zeichnen von "Hello World" mit DirectWrite

Das folgende Codebeispiel veranschaulicht, wie eine Anwendung einen einzelnen Absatz mit IDWriteTextFormat formatieren und ihn mit der Direct2D DrawText-Funktion zeichnen kann.


HRESULT DemoApp::DrawHelloWorld(
    ID2D1HwndRenderTarget* pIRenderTarget
    )
{
    HRESULT hr = S_OK;
    ID2D1SolidColorBrush* pIRedBrush = NULL;
    IDWriteTextFormat* pITextFormat = NULL;
    IDWriteFactory* pIDWriteFactory = NULL;

    if (SUCCEEDED(hr))
    {
        hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,
                __uuidof(IDWriteFactory),
                reinterpret_cast<IUnknown**>(&pIDWriteFactory));
    }

    if(SUCCEEDED(hr))
    {
        hr = pIDWriteFactory->CreateTextFormat(
            L"Arial", 
            NULL,
            DWRITE_FONT_WEIGHT_NORMAL, 
            DWRITE_FONT_STYLE_NORMAL, 
            DWRITE_FONT_STRETCH_NORMAL, 
            10.0f * 96.0f/72.0f, 
            L"en-US", 
            &pITextFormat
        );
    }

    if(SUCCEEDED(hr))
    {
        hr = pIRenderTarget->CreateSolidColorBrush(
            D2D1:: ColorF(D2D1::ColorF::Red),
            &pIRedBrush
        );
    }
    
   D2D1_RECT_F layoutRect = D2D1::RectF(0.f, 0.f, 100.f, 100.f);

    // Actually draw the text at the origin.
    if(SUCCEEDED(hr))
    {
        pIRenderTarget->DrawText(
            L"Hello World",
            wcslen(L"Hello World"),
            pITextFormat,
            layoutRect, 
            pIRedBrush
        );
    }

    return hr;
}


Zugreifen auf das Schriftsystem

Zusätzlich zum Festlegen eines Schriftfamiliennamens für die Textzeichenfolge mit der IDWriteTextFormat-Schnittstelle, wie im Beispiel weiter oben aufgeführt, bietet DirectWrite Anwendungen eine umfassendere Steuerung der Schriftartauswahl anhand der Schriftaufzählung und der Möglichkeit, basierend auf den eingebetteten Dokumentschriftarten eine benutzerdefinierte Schriftartsammlung zu erstellen.

Das IDWriteFontCollection-Objekt ist eine Sammlung von Schriftfamilien. DirectWrite bietet anhand einer speziellen Schriftsammlung, die als Systemschriftsammlung bezeichnet wird, Zugriff auf den Satz von Schriftarten, der auf dem System installiert ist. Diese wird durch den Aufruf der GetSystemFontCollection-Methode des IDWriteFactory-Objekts abgerufen. Eine Anwendung kann darüber hinaus auch eine benutzerdefinierte Schriftsammlung aus einem Satz von Schriftarten erstellen, der von einem anwendungsdefinierten Rückruf enumeriert wurde, das heißt, private Schriftarten, die von einer Anwendung installiert wurden, oder in ein Dokument eingebettete Schriftarten.

Die Anwendung kann dann GetFontFamily aufrufen, um zu einem speziellen FontFamily-Objekt in der Sammlung zu gelangen. Anschließend kann IDWriteFontFamily::GetFirstMatchingFont aufgerufen werden, um zu einem bestimmten IDWriteFont-Objekt zu gelangen. Das IDWriteFont-Objekt stellt eine Schriftart in einer Schriftsammlung dar und macht Eigenschaften und einige grundlegende Schriftmetriken verfügbar.

IDWriteFontFace ist ein anderes Objekt, das eine Schriftart darstellt und einen vollständigen Metriksatz für eine Schriftart verfügbar macht. IDWriteFontFace kann direkt aus einem Schriftnamen erstellt werden; eine Anwendung muss keine Schriftsammlung abrufen, um darauf zuzugreifen. Sie ist für eine Textlayoutanwendung, wie z. B. Microsoft Word, die Details einer bestimmten Schriftart abrufen muss, nützlich.

Im folgenden Diagramm ist die Beziehung zwischen diesen Objekten dargestellt.

Diagramm der Beziehung zwischen einer Schriftsammlung, Schriftfamilie und Schriftart

IDWriteFontFace

Das IDWriteFontFace-Objekt stellt eine Schriftart dar und stellt ausführlichere Informationen zur Schriftart bereit als das IDWriteFont-Objekt. Die Schriftart- und die Glyphenmetrik von IDWriteFontFace sind nützlich für Anwendungen, die das Textlayout implementieren.

Herkömmliche Anwendungen verwenden diese APIs nicht direkt, sondern verwenden stattdessen IDWriteFont oder geben den Schriftfamiliennamen direkt an.

In der folgenden Tabelle sind die Verwendungsszenarien für die beiden Objekte zusammengefasst.

KategorieIDWriteFontIDWriteFontFace
APIs für die Unterstützung der Benutzerinteraktion, z. B. eine Benutzeroberfläche zur Schriftartauswahl: Beschreibung und andere Informations-APIsJaNein
APIs zur Unterstützung der Schriftzuordnung: Familie, Format, Schnitt, Streckung, ZeichenabdeckungJaNein
DrawText-APIJaNein
APIs für das RendernNeinJa
APIs für das Textlayout: Glyphenmetrik usw.NeinJa
APIs für UI-Steuerelemente und Textlayout: Schriftartübergreifende MetrikJaJa

 

Nachfolgend ist eine Beispielanwendung aufgeführt, mit der die Schriftarten in der Systemschriftsammlung enumeriert werden.



#include <dwrite.h>
#include <string.h>
#include <stdio.h>
#include <new>

// SafeRelease inline function.
template <class T> inline void SafeRelease(T **ppT)
{
    if (*ppT)
    {
        (*ppT)->Release();
        *ppT = NULL;
    }
}

void wmain()
{
    IDWriteFactory* pDWriteFactory = NULL;

    HRESULT hr = DWriteCreateFactory(
            DWRITE_FACTORY_TYPE_SHARED,
            __uuidof(IDWriteFactory),
            reinterpret_cast<IUnknown**>(&pDWriteFactory)
            );

    IDWriteFontCollection* pFontCollection = NULL;

    // Get the system font collection.
    if (SUCCEEDED(hr))
    {
        hr = pDWriteFactory->GetSystemFontCollection(&pFontCollection);
    }

    UINT32 familyCount = 0;

    // Get the number of font families in the collection.
    if (SUCCEEDED(hr))
    {
        familyCount = pFontCollection->GetFontFamilyCount();
    }

    for (UINT32 i = 0; i < familyCount; ++i)
    {
        IDWriteFontFamily* pFontFamily = NULL;

        // Get the font family.
        if (SUCCEEDED(hr))
        {
            hr = pFontCollection->GetFontFamily(i, &pFontFamily);
        }

        IDWriteLocalizedStrings* pFamilyNames = NULL;
        
        // Get a list of localized strings for the family name.
        if (SUCCEEDED(hr))
        {
            hr = pFontFamily->GetFamilyNames(&pFamilyNames);
        }

        UINT32 index = 0;
        BOOL exists = false;
        
        wchar_t localeName[LOCALE_NAME_MAX_LENGTH];

        if (SUCCEEDED(hr))
        {
            // Get the default locale for this user.
            int defaultLocaleSuccess = GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH);

            // If the default locale is returned, find that locale name, otherwise use "en-us".
            if (defaultLocaleSuccess)
            {
                hr = pFamilyNames->FindLocaleName(localeName, &index, &exists);
            }
            if (SUCCEEDED(hr) && !exists) // if the above find did not find a match, retry with US English
            {
                hr = pFamilyNames->FindLocaleName(L"en-us", &index, &exists);
            }
        }
        
        // If the specified locale doesn't exist, select the first on the list.
        if (!exists)
            index = 0;

        UINT32 length = 0;

        // Get the string length.
        if (SUCCEEDED(hr))
        {
            hr = pFamilyNames->GetStringLength(index, &length);
        }

        // Allocate a string big enough to hold the name.
        wchar_t* name = new (std::nothrow) wchar_t[length+1];
        if (name == NULL)
        {
            hr = E_OUTOFMEMORY;
        }

        // Get the family name.
        if (SUCCEEDED(hr))
        {
            hr = pFamilyNames->GetString(index, name, length+1);
        }
        if (SUCCEEDED(hr))
        {
            // Print out the family name.
            wprintf(L"%s\n", name);
        }

        SafeRelease(&pFontFamily);
        SafeRelease(&pFamilyNames);

        delete [] name;
    }

    SafeRelease(&pFontCollection);
    SafeRelease(&pDWriteFactory);
}



Textrendering

Mit den Textrendering-APIs können Glyphen einer DirectWrite-Schriftart in eine Direct2D-Oberfläche oder eine geräteunabhängige GDI-Bitmap gerendert oder in Konturen oder Bitmaps konvertiert werden. Das ClearType-Rendering in DirectWrite unterstützt die Subpixelpositionierung mit verbesserter Schärfe und Kontrast im Vergleich zu früheren Implementierungen in Windows. DirectWrite unterstützt auch schwarzweißen Aliastext, um ostasiatischen Schriftarten mit eingebetteten Bitmaps zu unterstützen bzw. die vom Benutzer deaktivierte Schriftglättung jeden Typs.

Alle Optionen können über die verfügbaren ClearType-Regler, auf die Sie über die DirectWrite-APIs zugreifen können, angepasst werden. Sie können außerdem über das neue Windows 7 ClearType-Tuner-Systemsteuerungsapplet verfügbar gemacht werden.

Zum Rendern von Glyphen stehen zwei APIs zur Verfügung. Die eine stellt das Rendern mit Hardwarebeschleunigung über Direct2D bereit und die andere das Softwarerendering in eine GDI-Bitmap. Eine Anwendung, die IDWriteTextLayout verwendet und den IDWriteTextRenderer-Rückruf implementiert, kann eine dieser Funktionen in Antwort auf einen DrawGlyphRun-Rückruf aufrufen. Diese APIs können auch von Anwendungen verwendet werden, die ein eigenes Layout implementieren oder Daten auf Glyphenebenen verarbeiten.

  1. ID2DRenderTarget::DrawGlyphRun

    Anwendungen können die Direct2D-API DrawGlyphRun verwenden, um Hardwarebeschleunigung für das Textrendering mit der GPU bereitzustellen. Die Hardwarebeschleunigung wirkt sich auf alle Phasen der Textrenderingpipeline aus, vom Zusammenführen von Glyphen zu Glyphenserien und dem Filtern der Glyphenserienbitmap über das Anwenden des ClearTypes-Mischalgorithmus bis zur abschließend angezeigten Ausgabe. Diese API wird empfohlen, um die beste Renderingleistung zu erzielen.

  2. IDWriteBitmapRenderTarget::DrawGlyphRun

    Anwendungen können mithilfe der IDWriteBitmapRenderTarget::DrawGlyphRun-Methode ein Softwarerendering einer Glyphenserie in eine 32-bpp-Bitmap ausführen. Das IDWriteBitmapRenderTarget-Objekt kapselt eine Bitmap und einen Speichergerätkontext, die zum Rendern von Glyphen verwendet werden können. Diese API ist nützlich, wenn Sie weiterhin GDI verwenden möchten, da die vorhandene Codebasis in GDI rendert.

Wenn eine vorhandene Anwendung über Textlayoutcode verfügt, der GDI verwendet, und sie diesen Layoutcode beibehalten möchten, jedoch DirectWrite nur für den letzten Schritt beim Rendern von Glyphen verwenden möchten, stellt IDWriteGdiInterop::CreateFontFaceFromHdc die Verknüpfung zwischen den beiden APIs dar. Vor dem Aufrufen dieser Funktion verwendet die Anwendung die IDWriteGdiInterop::CreateFontFaceFromHdc-Funktion zum einen Schriftartverweis aus einem Gerätekontext abzurufen.

Hinweis  In den meisten Szenarien müssen Anwendungen diese Glyphenrendering-APIs wahrscheinlich nicht verwenden. Nachdem eine Anwendung ein IDWriteTextLayout-Objekt erstellt hat, kann sie die ID2D1RenderTarget::DrawTextLayout-Methode zum Rendern des Texts verwenden.

Benutzerdefinierte Renderingmodi

Eine Reihe von Parametern wirkt sich auf das Textrendering aus, wie zum Beispiel Gamma, ClearType-Ebene, Pixelgeometrie und verbesserter Kontrast. Renderparameter werden von einem Objekt gekapselt, das die öffentliche IDWriteRenderingParams-Schnittstelle implementiert. Das Renderparameter-Objekt wird auf der Grundlage von Hardwareeigenschaften und/oder Benutzereinstellungen, die über das ClearType-Systemsteuerungsapplet in Windows 7 festgelegt werden, automatisch initialisiert. Generell gilt, wenn ein Client die DirectWrite-Layout-API verwendet, wählt DirectWrite automatisch einen Rendermodus aus, der dem angegebenen Messmodus entspricht.

Anwendungen, für die weitere Steuerungsmöglichkeiten gewünscht sind, können IDWriteFactory::CreateCustomRenderingParams zum Implementieren der verschiedenen Renderingoptionen verwenden. Diese Funktion kann auch verwendet werden, um den Gammawert, die ClearType-Ebene, die Pixelgeometrie und den verbesserten Kontrast festzulegen.

Nachfolgend sind die verschiedenen verfügbaren Renderingoptionen aufgeführt:

  • Subpixel-ClearType

    Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL fest, um ClearType-Rendering mit Antialiasing nur in der horizontalen Dimension anzugeben.

  • Subpixel-ClearType mit Antialiasing in sowohl horizontaler als auch vertikaler Dimension.

    Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC fest, um ClearType-Rendering mit Antialiasing in sowohl horizontaler als auch vertikaler Dimension anzugeben. Hierdurch erscheinen Kurven und diagonale Linien glatter, wobei einige Weichheit eingebüßt wird. Dies wird in der Regel für Größen über 16 ppem verwendet.

  • Aliastext

    Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_ALIASED fest, um Aliastext anzugeben.

  • Graustufentext

    Die Anwendung legt den pixelGeometry-Parameter auf DWRITE_PIXEL_GEOMETRY_FLAT fest, um Graustufentext anzugeben.

  • GDI-kompatible Breite (einschließlich ostasiatische eingebettete Bitmap)

    Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC fest, um ClearType in GDI-kompatibler Breite anzugeben.

  • Natürliche GDI-Breite

    Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL fest, um mit der natürlichen GDI-Breite kompatibles ClearType anzugeben.

  • Konturentext

    Zum Rendern in großen Größen bevorzugt ein Anwendungsentwickler möglicherweise das Rendern durch Schriftkonturen, statt durch das Rastern in eine Bitmap. Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_OUTLINE fest, um anzugeben, dass beim Rendern die Rastererstellung umgehen werden soll und Konturen direkt verwendet werden.

GDI-Interoperabilität

Die IDWriteGdiInterop-Schnittstelle bietet Interoperabilität mit GDI. Auf diese Weise können Anwendungen bereits in GDI-Codebasen getätigte Investitionen weiter nutzen und DirectWrite bei Bedarf zum Rendern oder für das Layout verwenden.

Nachfolgend sind die APIs aufgeführt, die einer Anwendung den Übergang in ein oder aus einem GDI-Schriftartsystem ermöglichen:

Zusammenfassung

Eine verbesserte Lesbarkeit ist für Benutzer von großer Bedeutung, auf dem Bildschirm genauso wie auf Papier. DirectWrite stellt die Anwendungsfreundlichkeit und ein Programmiermodul mit verschiedenen Schichten bereit, mit denen Anwendungsentwickler die Textdarstellung ihrer Windows-Anwendungen verbessern können. Anwendungen können DirectWrite verwenden, um formatierungsreichen Text für die Benutzeroberfläche und Dokumente mit der Layout-API zu rendern. In komplexeren Szenarien kann eine Anwendung direkt mit Glyphen arbeiten, auf Schriftarten zugreifen usw. sowie die Funktionen von DirectWrite nutzen, um hochwertige Typografie zu erzeugen.

Die Möglichkeiten zur Interoperabilität von DirectWrite ermöglichen es Anwendungsentwicklern, bereits vorhandene Win32-Codebasen weiter zu nutzen und DirectWrite in Anwendungen selektiv einzusetzen.

 

 

Anzeigen:
© 2015 Microsoft