Einführung in DirectWrite

Personen in ihrem täglichen Leben ständig mit Text kommunizieren. Es ist die primäre Möglichkeit für Menschen, eine wachsende Menge an Informationen zu nutzen. Früher waren es gedruckte Inhalte, hauptsächlich Dokumente, Zeitungen, Bücher usw. Zunehmend sind es Online-Inhalte auf ihrem Windows-PC. Ein typischer Windows-Benutzer verbringt viel Zeit damit, von ihrem Computerbildschirm zu lesen. Sie können im Web surfen, E-Mails scannen, einen Bericht verfassen, eine Tabelle ausfüllen oder Software schreiben, aber was sie wirklich tun, ist das Lesen. Obwohl Text und Schriftarten nahezu jeden Teil der Benutzeroberfläche in Windows durchdringen, ist das Lesen auf dem Bildschirm für die meisten Benutzer nicht so angenehm wie das Lesen der gedruckten Ausgabe.

Für Entwickler von Windows-Anwendungen stellt das Schreiben von Textverarbeitungscode eine Herausforderung dar, da die Anforderungen an bessere Lesbarkeit, anspruchsvolle Formatierung und Layoutsteuerung sowie die Unterstützung für die verschiedenen Sprachen, die die Anwendung anzeigen muss, eine Herausforderung ist. Selbst das grundlegendste Textverarbeitungssystem muss Texteingabe, Layout, Anzeige, Bearbeitung sowie Kopieren und Einfügen ermöglichen. Windows-Benutzer erwarten in der Regel sogar mehr als diese grundlegenden Features, sodass sogar einfache Editoren mehrere Schriftarten, verschiedene Absatzarten, eingebettete Bilder, Rechtschreibprüfung und andere Features unterstützen müssen. Das moderne UI-Design ist auch nicht mehr auf ein einzelnes Format beschränkt, nur Text, sondern muss eine bessere Erfahrung mit umfangreichen Schriftarten und Textlayouts bieten.

Dies ist eine Einführung in die DirectWrite windows-Anwendungen ermöglicht, die Textoberfläche für Ui und Dokumente zu verbessern.

Verbessern der Textdarstellung

Moderne Windows-Anwendungen haben anspruchsvolle Anforderungen an Text in ihrer Benutzeroberfläche und in Dokumenten. Dazu gehören eine bessere Lesbarkeit, Unterstützung für eine Vielzahl von Sprachen und Skripts sowie eine hervorragende Renderingleistung. Darüber hinaus erfordern die meisten vorhandenen Anwendungen eine Möglichkeit, bestehende Investitionen in die WindowsWin32-Codebasis weiterzuleiten.

DirectWrite bietet die folgenden drei Features, mit denen Windows-Anwendungsentwickler die Texterfahrung in ihren Anwendungen verbessern können: Unabhängigkeit vom Renderingsystem, hochwertige Typografie und mehrere Funktionalitätsebenen.

Rendering-System Unabhängigkeit

DirectWrite ist unabhängig von einer bestimmten Grafiktechnologie. Anwendungen können die Renderingtechnologie verwenden, die ihren Anforderungen am besten entspricht. Dies gibt Anwendungen die Flexibilität, einige Teile ihrer Anwendung weiterhin über GDI und andere Teile über Direct3D oder Direct2D zu rendern. Tatsächlich könnte eine Anwendung DirectWrite über einen proprietären Renderingstapel rendern.

High-Quality Typografie

DirectWrite nutzt die Fortschritte in der OpenType Font-Technologie, um hochwertige Typografie in einer Windows-Anwendung zu ermöglichen. Das DirectWrite-Schriftartsystem bietet Dienste für die Aufzählung von Schriftarten, Das Fallback von Schriftarten und die Schriftartzwischenspeicherung, die alle von Anwendungen für die Behandlung von Schriftarten benötigt werden.

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

Unterstützung für erweiterte typografische Features

DirectWrite ermöglicht Anwendungsentwicklern das Entsperren der Features von OpenType-Schriftarten, die sie in WinForms oder GDI nicht verwenden konnten. Das DirectWrite IDWriteTypography-Objekt macht viele der erweiterten Features von OpenType-Schriftarten verfügbar, z. B. stilistische Alternativen und Swashes. Das Microsoft Windows Software Development Kit (SDK) bietet eine Reihe von OpenType-Beispielschriftarten , die mit umfangreichen Features wie den Schriftarten Pericles und Pescadero entworfen wurden. Weitere Informationen zu OpenType-Funktionen finden Sie unter Funktionen von OpenType-Schriftarten.

Unterstützung für internationalen Text

DirectWrite verwendet OpenType-Schriftarten, um eine breite Unterstützung für internationalen Text zu ermöglichen. Unicode-Features wie Ersatzzeichen, BIDI, Zeilenumbruch und UVS werden unterstützt. Sprachgesteuerte Skriptelementisierung, Zahlenersetzung und Glyphenstrukturierung stellen sicher, dass text in jedem Skript das richtige Layout und Das richtige Rendering aufweist.

Die folgenden Skripts werden zurzeit unterstützt:

Hinweis

Für Skripts, die mit * gekennzeichnet sind, gibt es keine Standardsystemschriftarten. Anwendungen müssen Schriftarten installieren, die diese Skripts unterstützen.

 

• Arabisch
• Armenisch
• Bengala
• Bopomofo
• Braille*
• Kanadische Aboriginessillabien
• Cherokee
• Chinesisch (vereinfacht & traditionell)
• Kyrillisch
• Koptischen*
• Devanagari
• Ethiopisch
• Georgisch
• Glagolitisch*
• Griechisch
• Gujarati
• Gurmukhi
• Hebräisch
• Japanisch
• Kannada
• Khmer
• Koreanisch
• Laotisch
• Lateinisch
• Malayalam
• Mongolisch
• Myanmar
• Neu-Tai-Lue
• Ogham*
• Odia
• 'Phags-pa
• Runic*
• Singhalesisch
• Syrisch
• Tai Le
• Tamilisch
• Telugu
• Thaana
• Thailändisch
• Tibetisch
• Yi

Mehrere Funktionalitätsebenen

DirectWrite bietet faktorierte Funktionalitätsebenen, wobei jede Ebene nahtlos mit der nächsten interagiert. Der API-Entwurf bietet Anwendungsentwicklern die Freiheit und Flexibilität, einzelne Ebenen abhängig von ihren Anforderungen und ihrem Zeitplan zu übernehmen. Das folgende Diagramm zeigt die Beziehung zwischen diesen Ebenen.

Die Textlayout-API bietet die Funktionalität der höchsten Ebene, die von DirectWrite verfügbar ist. Es bietet Dienste für die Anwendung zum Messen, Anzeigen und Interagieren mit reich formatierten Textzeichenfolgen. Diese Text-API kann in Anwendungen verwendet werden, die derzeit drawText von Win32 verwenden, um eine moderne Benutzeroberfläche mit reich formatiertem Text zu erstellen.

Textintensive Anwendungen, die eine eigene Layout-Engine implementieren, können die nächste Ebene nach unten verwenden: den Skriptprozessor. Der Skriptprozessor unterteilt einen Textblock in Skriptblöcke und verarbeitet die Zuordnung zwischen Unicode-Darstellungen und der entsprechenden Glyphendarstellung in der Schriftart, sodass der Text des Skripts ordnungsgemäß in der richtigen Sprache angezeigt werden kann. Das von der Textlayout-API-Ebene verwendete Layoutsystem basiert auf dem Schrift- und Skriptverarbeitungssystem.

Die Glyphenrenderingebene ist die niedrigste Funktionalitätsebene und bietet Glyphenrenderingfunktionen für Anwendungen, die eine eigene Textlayout-Engine implementieren. Die Glyphenrenderingebene ist auch für Anwendungen nützlich, die einen benutzerdefinierten Renderer implementieren, um das Glyphenzeichnungsverhalten über die Rückruffunktion in der DirectWrite Textformatierungs-API zu ändern.

Das DirectWrite Schriftsystem ist für alle DirectWrite Funktionsschichten verfügbar und ermöglicht es einer Anwendung, auf Schriftart- und Glypheninformationen zuzugreifen. Es ist für die Verarbeitung gängiger Schriftarttechnologien und Datenformate konzipiert. Das DirectWrite Schriftmodell folgt der üblichen typografischen Praxis, eine beliebige Anzahl von Gewichtungen, Formatvorlagen und Dehnungen in derselben Schriftfamilie zu unterstützen. Dieses Modell, das gleiche Modell gefolgt von WPF und CSS, gibt an, dass Schriftarten, die sich nur in der Gewichtung (fett, leicht usw.), dem Stil (aufrecht, kursiv oder schräg) oder stretch (schmal, kondensiert, breit usw.) unterscheiden, als Mitglieder einer einzelnen Schriftfamilie gelten.

Verbessertes Textrendering mit ClearType

Die Verbesserung der Lesbarkeit auf dem Bildschirm ist eine wichtige Voraussetzung für alle Windows-Anwendungen. Die Erkenntnisse aus der Forschung in der Kognitiven Psychologie zeigen, dass wir jeden Buchstaben genau erkennen müssen und dass sogar der Abstand zwischen Buchstaben für eine schnelle Verarbeitung entscheidend ist. Buchstaben und Wörter, die nicht symmetrisch sind, werden als hässlich empfunden und beeinträchtigen das Leseerlebnis. Kevin Larson, Microsoft Advanced Reading Technologies Group, schrieb einen Artikel zu diesem Thema, der in Spectrum IEEE veröffentlicht wurde. Der Artikel heißt "The Technology of Text".

Text in DirectWrite wird mit Microsoft ClearType gerendert, wodurch die Übersichtlichkeit und Lesbarkeit von Text verbessert wird. ClearType nutzt die Tatsache, dass moderne LCD-Displays RGB-Streifen für jedes Pixel haben, die einzeln gesteuert werden können. DirectWrite verwendet die neuesten Verbesserungen an ClearType, die zuerst in Windows Vista mit Windows Presentation Foundation enthalten sind, mit denen nicht nur die einzelnen Buchstaben, sondern auch der Abstand zwischen Buchstaben ausgewertet werden kann. Vor diesen ClearType-Erweiterungen war Text mit einer "Lesegröße" von 10 oder 12 Punkten schwer anzuzeigen: Wir konnten entweder 1 Pixel zwischen Buchstaben platzieren, was oft zu wenig war, oder 2 Pixel, was oft zu viel war. Durch die Verwendung der zusätzlichen Auflösung in den Subpixeln erhalten wir einen Bruchabstand, der die Gleichmäßigkeit und Symmetrie der gesamten Seite verbessert.

Die folgenden beiden Abbildungen zeigen, wie Glyphen auf jeder Unterpixelgrenze beginnen können, wenn die Positionierung von Unterpixeln verwendet wird.

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

Die folgende Abbildung wird mit der DirectWrite Version des ClearType-Renderers gerendert, der die Positionierung von Subpixeln verwendet.

Beachten Sie, dass der Abstand zwischen den Buchstaben h und n im zweiten Bild gleichmäßiger ist und der Buchstabe o weiter vom Buchstaben n entfernt ist, genauer mit dem Buchstaben l. Beachten Sie auch, dass die Stiele auf den Buchstaben l natürlicher aussehen.

Die ClearType-Positionierung des Unterpixels bietet den genauesten Abstand von Zeichen auf dem Bildschirm, insbesondere bei kleinen Größen, bei denen der Unterschied zwischen einem Subpixel und einem ganzen Pixel einen signifikanten Anteil der Glyphenbreite darstellt. Es ermöglicht es, Text im idealen Auflösungsbereich zu messen und an seiner natürlichen Position am LCD-Farbstreifen mit Subpixelgranularität gerendert zu werden. Text, der mit dieser Technologie gemessen und gerendert wird, ist per Definition auflösungsunabhängig, was bedeutet, dass das gleiche Layout von Text über den Bereich verschiedener Anzeigeauflösungen hinweg erreicht wird.

Im Gegensatz zu beiden Arten von GDI ClearType-Rendering bietet ClearType unter Pixel die genaueste Breite von Zeichen.

Die Textzeichenfolgen-API verwendet standardmäßig subpixelbasierte Textrenderings, d. h., sie misst Text in seiner idealen Auflösung unabhängig von der aktuellen Anzeigeauflösung und erzeugt das Ergebnis der Glyphenpositionierung basierend auf den wirklich skalierten Glyphenbreiten und Denpositionierungsoffsets.

Für großen Text ermöglicht DirectWrite auch Antialiasing entlang der y-Achse, um die Kanten glatter zu machen und Buchstaben wie vom Schriftarten-Designer vorgesehen zu rendern. Die folgende Abbildung zeigt antialiasing in y-Richtung.

Obwohl DirectWrite Text standardmäßig mit ClearType unter Pixel positioniert und gerendert wird, sind andere Renderingoptionen verfügbar. Viele vorhandene Anwendungen verwenden GDI, um den größten Teil ihrer Benutzeroberfläche zu rendern, und einige Anwendungen verwenden Steuerelemente für die Systembearbeitung, die weiterhin GDI für das Rendern von Text verwenden. Beim Hinzufügen von DirectWrite Text zu diesen Anwendungen kann es erforderlich sein, die Verbesserungen der Leseerfahrung zu opfern, die von ClearType unter Pixeln bereitgestellt werden, damit Text in der gesamten Anwendung einheitlich dargestellt wird.

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

• ClearType unter Pixel (Standard).
• ClearType-Subpixel mit Antialiasing in horizontalen und vertikalen Dimensionen.
• Text mit Alias.
• GDI mit natürlicher Breite (wird z. B. von Microsoft Word Leseansicht verwendet).
• GDI-kompatible Breite (einschließlich ostasiatischer eingebetteter Bitmap).

Jeder dieser Renderingmodi kann über die DirectWrite-API und den neuen ClearType-Tuner für den Windows 7-Posteingang optimiert werden.

Hinweis

Ab Windows 8 sollten Sie in den meisten Fällen Graustufentext-Antialiasing verwenden. Weitere Informationen finden Sie im nächsten Abschnitt.

 

Unterstützung für natürliches Layout

Das natürliche Layout ist auflösungsunabhängig, sodass sich der Abstand der Zeichen nicht ändert, wenn Sie vergrößern oder verkleineren, oder abhängig vom DPI-Wert der Anzeige. Ein sekundärer Vorteil ist, dass der Abstand für das Design der Schriftart gilt. Natürliches Layout wird durch DirectWrite Unterstützung für natürliches Rendering ermöglicht, was bedeutet, dass einzelne Glyphen auf einen Bruchteil eines Pixels positioniert werden können.

Während das natürliche Layout die Standardeinstellung ist, müssen einige Anwendungen Text mit demselben Abstand und derselben Darstellung wie GDI rendern. Für solche Anwendungen bietet DirectWrite GDI classic und GDI natürliche Messmodi sowie entsprechende Renderingmodi.

Jeder der oben genannten Renderingmodi kann mit einem der beiden Antialiasingmodi kombiniert werden: ClearType oder Graustufen. ClearType-Antialiasing simuliert eine höhere Auflösung, indem die roten, grünen und blauen Farbwerte jedes Pixels einzeln bearbeitet werden. Graustufen-Antialiasing berechnet nur einen Abdeckungswert (oder Alphawert) für jedes Pixel. ClearType ist die Standardeinstellung, aber Graustufen-Antialiasing wird für Windows Store-Apps empfohlen, da es schneller ist und mit standard-Antialiasing kompatibel ist, während es weiterhin gut lesbar ist.

API-Übersicht

Die IDWriteFactory-Schnittstelle ist der Ausgangspunkt für die Verwendung DirectWrite Funktionalität. Die Factory ist das Stammobjekt, das eine Gruppe von Objekten erstellt, die zusammen verwendet werden können.

Der Formatierungs- und Layoutvorgang ist eine Voraussetzung für die Vorgänge, da Text ordnungsgemäß formatiert und in einem bestimmten Satz von Einschränkungen angeordnet werden muss, bevor er gezeichnet oder treffergeprüft werden kann. Zwei Schlüsselobjekte, die Sie zu diesem Zweck mit einer IDWriteFactory erstellen können, sind IDWriteTextFormat und IDWriteTextLayout. Ein IDWriteTextFormat-Objekt stellt die Formatierungsinformationen für einen Textabsatz dar. Die IDWriteFactory::CreateTextLayout-Funktion akzeptiert die Eingabezeichenfolge, die zugeordneten Einschränkungen wie die Dimension des zu füllenden Raums und das IDWriteTextFormat-Objekt und fügt das vollständig analysierte und formatierte Ergebnis in IDWriteTextLayout ab, um es in nachfolgenden Vorgängen zu verwenden.

Die Anwendung kann dann den Text mithilfe der DrawTextLayout-Funktion rendern, die von Direct2D bereitgestellt wird, oder indem eine Rückruffunktion implementiert wird, die GDI, Direct2D oder andere Grafiksysteme zum Rendern der Glyphen verwenden kann. Für einen Text im einzelnen Format bietet die DrawText-Funktion in Direct2D eine einfachere Möglichkeit, Text zu zeichnen, ohne zuerst ein IDWriteTextLayout-Objekt erstellen zu müssen.

Formatieren und Zeichnen von "Hallo Welt" mit DirectWrite

Das folgende Codebeispiel zeigt, wie eine Anwendung einen einzelnen Absatz mithilfe von IDWriteTextFormat formatieren und mit der Direct2DDrawText-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
        );
    }

    // Clean up.
    SafeRelease(&pIRedBrush);
    SafeRelease(&pITextFormat);
    SafeRelease(&pIDWriteFactory);

    return hr;
}

Zugreifen auf das Schriftsystem

Zusätzlich zum Angeben eines Schriftartfamiliennamens für die Textzeichenfolge mithilfe der IDWriteTextFormat-Schnittstelle im obigen Beispiel bietet DirectWrite Anwendungen mehr Kontrolle über die Schriftartauswahl durch Schriftartenumeration und die Möglichkeit, eine benutzerdefinierte Schriftartensammlung basierend auf eingebetteten Dokumentschriftarten zu erstellen.

Das IDWriteFontCollection-Objekt ist eine Auflistung von Schriftartfamilien. DirectWrite ermöglicht den Zugriff auf die im System installierten Schriftarten über eine spezielle Schriftartensammlung, die als Systemschriftartensammlung bezeichnet wird. Dies wird durch Aufrufen der GetSystemFontCollection-Methode des IDWriteFactory-Objekts abgerufen. Eine Anwendung kann auch eine benutzerdefinierte Schriftartensammlung aus einer Reihe von Schriftarten erstellen, die von einem anwendungsdefinierten Rückruf aufgezählt werden, d. h. von einer Anwendung installierte private Schriftarten oder in ein Dokument eingebettete Schriftarten.

Die Anwendung kann dann GetFontFamily aufrufen, um zu einem bestimmten FontFamily-Objekt innerhalb der Auflistung zu gelangen, und dann IDWriteFontFamily::GetFirstMatchingFont aufrufen, um zu einem bestimmten IDWriteFont-Objekt zu gelangen. Das IDWriteFont-Objekt stellt eine Schriftart in einer Schriftartsammlung dar und macht Eigenschaften und einige grundlegende Schriftartmetriken verfügbar.

Das IDWriteFontFace ist ein weiteres Objekt, das eine Schriftart darstellt und einen vollständigen Satz von Metriken für eine Schriftart verfügbar macht. Das IDWriteFontFace kann direkt aus einem Schriftartennamen erstellt werden; Eine Anwendung muss keine Schriftartsammlung abrufen, um darauf zuzugreifen. Dies ist nützlich für eine Textlayoutanwendung wie Microsoft Word, die die Details für eine bestimmte Schriftart abfragen muss.

Das folgende Diagramm veranschaulicht die Beziehung zwischen diesen Objekten.

IDWriteFontFace

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

Die meisten gängigen Anwendungen verwenden diese APIs nicht direkt und verwenden stattdessen IDWriteFont oder geben den Namen der Schriftfamilie direkt an.

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

Category	IDWriteFont	IDWriteFontFace
APIs zur Unterstützung von Benutzerinteraktionen, z. B. eine Benutzeroberfläche für die Schriftartenwährung: Beschreibung und andere Informations-APIs	Ja	Nein
APIs zur Unterstützung der Schriftartzuordnung: Familie, Stil, Gewicht, Stretch, Zeichenabdeckung	Ja	Nein
DrawText-API	Ja	Nein
Zum Rendern verwendete APIs	Nein	Ja
Für das Textlayout verwendete APIs: Glyphenmetriken usw.	Nein	Ja
APIs für Benutzeroberflächensteuerung und Textlayout: schriftartweite Metriken	Ja	Ja

 

Im Folgenden finden Sie eine Beispielanwendung, die die Schriftarten in der Systemschriftartenauflistung aufzählt.

#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);
}

Rendering von Text

Mit den Textrendering-APIs können Glyphen in einer DirectWrite Schriftart auf einer Direct2D-Oberfläche oder in eine von GDI-Geräten unabhängige Bitmap gerendert oder in Konturen oder Bitmaps konvertiert werden. Das ClearType-Rendering in DirectWrite unterstützt die Subpixelpositionierung mit verbesserter Schärfe und verbessertem Kontrast im Vergleich zu früheren Implementierungen unter Windows. DirectWrite unterstützt auch schwarzweißen Text mit Alias, um Szenarien mit ostasiatischen Schriftarten mit eingebetteten Bitmaps zu unterstützen oder wenn der Benutzer die Schriftartglättung eines beliebigen Typs deaktiviert hat.

Alle Optionen sind über alle verfügbaren ClearType-Regler einstellbar, auf die über die DirectWrite-APIs zugegriffen werden kann, und auch über das neue Windows 7 ClearType-Tuner-Systemsteuerungs-Applet verfügbar gemacht.

Für das Rendern von Glyphen stehen zwei APIs zur Verfügung, von denen eine das hardwarebeschleunigte Rendering über Direct2D und die andere das Softwarerendering für eine GDI-Bitmap bereitstellt. Eine Anwendung, die IDWriteTextLayout verwendet und den IDWriteTextRenderer-Rückruf implementiert, kann eine dieser Funktionen als Reaktion auf einen DrawGlyphRun-Rückruf aufrufen. Auch Anwendungen, die ein eigenes Layout implementieren oder daten auf Glyphenebene verarbeiten, können diese APIs verwenden.

1. ID2DRenderTarget::D rawGlyphRun

   Anwendungen können die Direct2D-APIDrawGlyphRun verwenden, um die Hardwarebeschleunigung für das Rendern von Text mithilfe der GPU bereitzustellen. Die Hardwarebeschleunigung wirkt sich auf alle Phasen der Textrenderingpipeline aus – vom Zusammenführen von Glyphen in Glyphenausführungen über das Filtern der Bitmap mit Glyphenausführung bis hin zum Anwenden des ClearType-Mischalgorithmus auf die endgültige angezeigte Ausgabe. Dies ist die empfohlene API, um die beste Renderingleistung zu erzielen.

2. IDWriteBitmapRenderTarget::D rawGlyphRun

   Anwendungen können die IDWriteBitmapRenderTarget::D rawGlyphRun-Methode verwenden, um ein Softwarerendering einer Ausführung von Glyphen in eine 32-bpp-Bitmap durchzuführen. Das IDWriteBitmapRenderTarget-Objekt kapselt eine Bitmap und einen Speichergerätekontext, die zum Rendern von Glyphen verwendet werden können. Diese API ist nützlich, wenn Sie bei GDI bleiben möchten, da Sie über eine vorhandene Codebasis verfügen, die in GDI gerendert wird.

Wenn Sie über eine Anwendung verfügen, die über vorhandenen Textlayoutcode verfügt, der GDI verwendet, und Sie den vorhandenen Layoutcode beibehalten möchten, aber DirectWrite nur für den letzten Schritt des Renderns von Glyphen verwenden möchten, stellt IDWriteGdiInterop::CreateFontFaceFromHdc die Brücke zwischen den beiden APIs bereit. Vor dem Aufrufen dieser Funktion verwendet die Anwendung die IDWriteGdiInterop::CreateFontFaceFromHdc-Funktion , um einen Schriftartenverweis aus einem Gerätekontext abzurufen.

Hinweis

In den meisten Szenarien müssen Anwendungen diese Glyphenrendering-APIs möglicherweise nicht verwenden. Nachdem eine Anwendung ein IDWriteTextLayout-Objekt erstellt hat, kann sie die ID2D1RenderTarget::D rawTextLayout-Methode verwenden, um den Text zu rendern.

 

Benutzerdefinierte Renderingmodi

Eine Reihe von Parametern wirkt sich auf das Rendern von Text aus, z. B. Gamma, ClearType-Ebene, Pixelgeometrie und verbesserter Kontrast. Renderingparameter werden von einem -Objekt gekapselt, das die öffentliche IDWriteRenderingParams-Schnittstelle implementiert. Das Renderingparameterobjekt wird automatisch basierend auf Hardwareeigenschaften und/oder Benutzereinstellungen initialisiert, die über das ClearType-Systemsteuerungs-Applet in Windows 7 angegeben werden. Wenn ein Client die DirectWrite Layout-API verwendet, wählt DirectWrite im Allgemeinen automatisch einen Renderingmodus aus, der dem angegebenen Messmodus entspricht.

Anwendungen, die mehr Kontrolle benötigen, können IDWriteFactory::CreateCustomRenderingParams verwenden, um die verschiedenen Renderingoptionen zu implementieren. Diese Funktion kann auch zum Festlegen von Gamma, Pixelgeometrie und erweitertem Kontrast verwendet werden.

Im Folgenden finden Sie die verschiedenen verfügbaren Renderingoptionen:

• Antialiasing für Subpixel

  Die Anwendung legt den RenderingMode-Parameter auf DWRITE_RENDERING_MODE_NATURAL fest, um rendering mit Antialiasing nur in der horizontalen Dimension anzugeben.

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

  Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC fest, um rendering mit Antialiasing sowohl in horizontaler als auch in vertikaler Dimension anzugeben. Dadurch sehen Kurven und diagonale Linien auf Kosten einer gewissen Weichheit glatter aus und werden in der Regel bei Größen über 16 Psam verwendet.

• Aliastext

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

• Graustufentext

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

• GDI-kompatible Breite (einschließlich ostasiatischer eingebetteter Bitmap)

  Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_GDI_CLASSIC fest, um GDI-kompatibles Breiten-Antialiasing anzugeben.

• GDI (natürliche Breite)

  Die Anwendung legt den RenderingMode-Parameter auf DWRITE_RENDERING_MODE_GDI_NATURAL fest, um GDI-kompatibles Antialiasing mit natürlicher Breite anzugeben.

• Gliederungstext

  Für das Rendern mit großen Größen zieht es ein Anwendungsentwickler möglicherweise vor, das Rendern mithilfe der Schriftartgliederung zu verwenden, anstatt in eine Bitmap zu rastern. Die Anwendung legt den renderingMode-Parameter auf DWRITE_RENDERING_MODE_OUTLINE fest, um anzugeben, dass das Rendering den Rasterizer umgehen und die Gliederungen direkt verwenden soll.

GDI-Interoperabilität

Die IDWriteGdiInterop-Schnittstelle bietet Interoperabilität mit GDI. Dadurch können Anwendungen ihre vorhandenen Investitionen in GDI-Codebasen fortsetzen und selektiv DirectWrite für Rendering oder Layout verwenden.

Im Folgenden sind die APIs aufgeführt, die es einer Anwendung ermöglichen, zum oder aus dem GDI-Schriftartensystem zu migrieren:

• CreateFontFromLOGFONT

  Erstellt ein IDWriteFont-Objekt , das den von der LOGFONT-Struktur angegebenen Eigenschaften entspricht.

• ConvertFontToLOGFONT

  Initialisiert eine LOGFONT-Struktur basierend auf den GDI-kompatiblen Eigenschaften des angegebenen IDWriteFont.

• ConvertFontFaceToLOGFONT

  Initialisiert eine LOGFONT-Struktur basierend auf den GDI-kompatiblen Eigenschaften des angegebenen IDWriteFontFace.

• CreateFontFaceFromHdc

  Erstellt ein IDWriteFontFace-Objekt , das dem aktuell ausgewählten HFONT entspricht.

Zusammenfassung

Die Verbesserung des Leseerlebnisses ist für Benutzer von großem Wert, unabhängig davon, ob es sich um den Bildschirm oder um Papier handelt. DirectWrite bietet Anwendungsentwicklern die Benutzerfreundlichkeit und das mehrschichtige Programmiermodell, um die Texterfahrung für ihre Windows-Anwendungen zu verbessern. Anwendungen können DirectWrite verwenden, um reich formatierten Text für ihre Benutzeroberfläche und Dokumente mit der Layout-API zu rendern. In komplexeren Szenarien kann eine Anwendung direkt mit Glyphen arbeiten, auf Schriftarten usw. zugreifen und die Leistungsfähigkeit der DirectWrite nutzen, um hochwertige Typografie zu liefern.

Die Interoperabilitätsfunktionen von DirectWrite es Anwendungsentwicklern ermöglichen, ihre vorhandenen Win32-Codebasen weiterzuleiten und DirectWrite selektiv in ihren Anwendungen einzuführen.