A DirectWrite bemutatása

Az emberek a mindennapi életük során folyamatosan kommunikálnak a szöveggel. Ez az elsődleges módja annak, hogy az emberek egyre több információt használjanak fel. Régebben nyomtatott tartalmak révén, elsősorban dokumentumok, újságok, könyvek, stb. Egyre inkább online tartalom a Windows rendszerű pc-n. Egy tipikus Windows-felhasználó sok időt tölt olvasással a számítógép képernyőjén. Lehet, hogy a weben szörföznek, e-maileket keresnek, jelentést írnak, számolótáblát töltenek ki, vagy szoftvereket írnak, de valójában az olvasást végzik. Annak ellenére, hogy a windowsos felhasználói élmény szinte minden részét átjárja a szöveg és a betűtípus, a legtöbb felhasználó számára a képernyőn való olvasás nem olyan élvezetes, mint a nyomtatott kimenet olvasása.

A Windows-alkalmazásfejlesztők számára a szövegkezelési kód írása kihívást jelent a jobb olvashatóság, a kifinomult formázás és elrendezésvezérlés megnövekedett követelményei, valamint az alkalmazás által megjelenítendő nyelvek támogatása miatt. Még a legalapvetőbb szövegkezelő rendszernek is lehetővé kell tennie a szövegbevitelt, elrendezést, megjelenítést, szerkesztést, másolást és beillesztést. A Windows felhasználói általában még ennél is többet várnak el ezeknél az alapfunkcióknál, és még az egyszerű szerkesztőknek is támogatniuk kell a több betűtípust, a különböző bekezdésstílusokat, a beágyazott képeket, a helyesírás-ellenőrzést és más funkciókat. A modern felhasználói felület kialakítása már nem korlátozódik egyetlen formátumra, egyszerű szövegre, hanem jobb élményt kell mutatnia a gazdag betűtípusokkal és szövegelrendezésekkel.

Ez a bevezetés bemutatja, hogyan DirectWrite lehetővé teszi a Windows-alkalmazások számára a felhasználói felület és a dokumentumok szövegélményének növelését.

A szöveg élményének javítása

A modern Windows-alkalmazások kifinomult követelményeket támasztanak a felhasználói felületen és a dokumentumokban található szövegekre vonatkozóan. Ezek közé tartozik a jobb olvashatóság, a nyelvek és szkriptek széles körének támogatása, valamint a kiváló renderelési teljesítmény. Emellett a legtöbb meglévő alkalmazásnak szüksége van arra, hogy továbbvihesse a meglévő beruházásokat a WindowsWin32 kódbázisában.

DirectWrite a következő három funkciót biztosítja, amelyek lehetővé teszik a Windows-alkalmazásfejlesztők számára, hogy javítsák a szövegélményt az alkalmazásaikban: a renderelési rendszertől való függetlenség, a kiváló minőségű tipográfia és a funkciók több rétege.

Rendering-System Függetlenség

DirectWrite független az egyes grafikus technológiáktól. Az alkalmazások szabadon használhatják az igényeiknek leginkább megfelelő renderelési technológiát. Ez lehetővé teszi az alkalmazások számára, hogy továbbra is rendereljék alkalmazásuk egyes részeit a GDI-ben és más részeken keresztül Direct3D vagy Direct2D. Valójában egy alkalmazás dönthet úgy, hogy a DirectWrite-et egy saját renderelési veremen keresztül jeleníti meg.

High-Quality Tipográfia

DirectWrite kihasználja a OpenType Font technológia előnyeit, hogy magas minőségű tipográfiai lehetőségeket biztosíthasson egy Windows-alkalmazásban. A DirectWrite betűtípus-rendszer a betűtípus-számbavétel, a betűtípus-tartalék és a betűtípus-gyorsítótárazás kezelésére szolgáló szolgáltatásokat nyújt, amelyekre az alkalmazásoknak szükségük van a betűtípusok kezeléséhez.

A DirectWrite által biztosított OpenType lehetővé teszi a fejlesztők számára, hogy speciális tipográfiai funkciókat és nemzetközi szövegtámogatást adjanak alkalmazásukhoz.

Speciális tipográfiai funkciók támogatása

DirectWrite lehetővé teszi az alkalmazásfejlesztők számára, hogy feloldják az OpenType betűtípusok olyan funkcióit, amelyeket nem tudtak használni a WinFormsban vagy a GDI-ben. A DirectWrite IDWriteTypography objektum az OpenType betűtípusok számos speciális funkcióját teszi elérhetővé, például stilisztikai alternatívákat és swasheket. A Microsoft Windows szoftverfejlesztői készlet (SDK) számos OpenType betűtípust kínál, amelyek olyan gazdag funkciókkal vannak megtervezve, mint például a Periklék és a Pescadero betűtípusok. Az OpenType-funkciókkal kapcsolatos további információkért lásd OpenType betűtípus-szolgáltatások.

Nemzetközi szöveg támogatása

DirectWriteOpenType betűtípusokkal támogatja a nemzetközi szövegeket. A Unicode-funkciók, például a helyettesítők, a BIDI, a vonaltörés és az UVS támogatottak. A nyelv által irányított szkriptelemezés, a számhelyettesítés és a karakteralakítás biztosítja, hogy bármely szkript szövegének megfelelő elrendezése és renderelése legyen.

Jelenleg a következő szkriptek támogatottak:

• Arab
• Örmény
• Bengála
• Bopomofo
• Braille-írás*
• Kanadai őslakos szillabics
• Cherokee
• Kínai (egyszerűsített: &; hagyományos)
• Cirill
• Kopt*
• Devanagari
• Etióp
• Grúz
• Glagolita*
• Görög
• Gudzsaráti
• Gurmukhi
• Héber nyelv
• Japán
• Kannada
• Khmer
• Koreai
• Lao
• Latin
• Malajálam
• Mongol
• Mianmar
• Új Tai Lue
• Ogham*
• Odia
• 'Phags-pa
• Runikális*
• Sinhala
• Szír nyelv
• Tai Le
• Tamil
• Telugu
• Thaana
• Thai
• Tibeti
• Yi

Több funkcióréteg

DirectWrite faktorált funkcionalitási rétegeket biztosít, és minden réteg zökkenőmentesen kommunikál a következővel. Az API-tervezés szabadságot és rugalmasságot biztosít az alkalmazásfejlesztők számára, hogy egyéni rétegeket alkalmazzanak az igényeiktől és ütemezésüktől függően. Az alábbi diagram a rétegek közötti kapcsolatot mutatja be.

A szövegelrendezési API a DirectWriteelérhető legmagasabb szintű funkciókat biztosítja. Szolgáltatásokat nyújt az alkalmazás számára a gazdagon formázott szöveges sztringek mérésére, megjelenítésére és kezelésére. Ez a szöveges API olyan alkalmazásokban használható, amelyek jelenleg a Win32 DrawTextjét használják egy modern felhasználói felület gazdagon formázott szöveggel való létrehozásához.

A saját elrendezési motort implementáló szövegigényes alkalmazások a következő réteget használhatják: a szkriptfeldolgozót. A szkriptfeldolgozó szkriptblokkokra bontja a szövegrészeket, és kezeli a Unicode-reprezentációk közötti megfeleltetést a betűtípus megfelelő karakterjel-ábrázolására, hogy a szkript szövege helyesen jelenjen meg a megfelelő nyelven. A szövegelrendezési API-réteg által használt elrendezési rendszer a betűtípus- és szkriptfeldolgozó rendszerre épül.

A glyph-rendering réteg a legalacsonyabb funkcionalitási réteg, és a saját szövegelrendezési motort implementáló alkalmazásokhoz biztosít glyph-rendering funkciót. A glyph renderelési réteg olyan alkalmazások számára is hasznos, amelyek egyéni renderelőt implementálnak a glyph-drawing viselkedés módosításához a DirectWrite szövegformázási API visszahívási függvényén keresztül.

A DirectWrite betűtípusrendszer az összes DirectWrite funkcionális réteg számára elérhető, és lehetővé teszi az alkalmazások számára a betűtípus- és karakterjeladatok elérését. Úgy tervezték, hogy kezelje a gyakori betűtípus-technológiákat és adatformátumokat. A DirectWrite betűtípusmodell az azonos betűcsaládban található tetszőleges számú súly, stílus és nyújtás támogatásának gyakori tipográfiai gyakorlatát követi. Az a modell, amelyet a WPF és a CSS is követ, meghatározza, hogy a betűtípusok, amelyek csak vastagságban (félkövér, világos stb.), stílusban (függőleges, dőlt vagy ferde) vagy nyúlásban (keskeny, sűrített, széles stb.) különböznek, egyetlen betűtípuscsalád tagjainak minősülnek.

Továbbfejlesztett szövegmegjelenítés a ClearType használatával

A képernyőn való olvashatóság javítása kulcsfontosságú követelmény minden Windows-alkalmazás számára. A kognitív pszichológia kutatásainak bizonyítékai azt mutatják, hogy minden betűt pontosan kell felismernünk, és még a betűk közötti térköz is kritikus fontosságú a gyors feldolgozáshoz. A nem szimmetrikus betűket és szavakat csúnyának tekintik, és rontják az olvasási élményt. Kevin Larson, a Microsoft Advanced Reading Technologies csoportja cikket írt a Spectrum IEEE-ben közzétett témáról. A cikk neve "A szöveg technológiája".

A DirectWrite szövegét a Microsoft ClearType használatával jeleníti meg, amely javítja a szöveg érthetőségét és olvashatóságát. A ClearType kihasználja azt a tényt, hogy a modern LCD-kijelzők minden képponthoz RGB csíkokkal rendelkeznek, amelyek egyenként szabályozhatók. A DirectWrite a ClearType legújabb fejlesztéseit használja, amelyeket először a Windows Vista és a Windows Presentation Foundation tartalmaz, így nem csak az egyes betűket, hanem a betűk közötti térközt is kiértékelheti. A ClearType fejlesztései előtt a 10 vagy 12 pontos "olvasási" mérettel rendelkező szöveg nehezen jeleníthető meg: 1 képpontot is elhelyezhettünk a betűk között, ami gyakran túl kicsi volt, vagy 2 képpont volt, ami gyakran túl sok volt. Az alpixelek extra felbontásának használata törtrészes távolságot biztosít számunkra, ami javítja a teljes oldal egyenletességét és szimmetriáját.

Az alábbi két ábra bemutatja, hogyan kezdődhetnek a karakterjelek a képpont alatti határvonalon a képpont alatti elhelyezés használatakor.

Az alábbi ábra a ClearType renderelő GDI-verziójával jelenik meg, amely nem alkalmazott képpont alatti elhelyezést.

Az alábbi ábra a ClearType renderelő DirectWrite verziójával jelenik meg, amely képpont alatti elhelyezést használ.

Vegye figyelembe, hogy a h és az n betűk közötti térköz a második képen egyenletesebb, az o betű pedig az n betűtől távolabb, még inkább az l betűvel van elválasztva. Azt is vegye figyelembe, hogy az l betűk szárai sokkal természetesebb megjelenésűek.

A ClearType alkép elhelyezése a karakterek legpontosabb térközét biztosítja a képernyőn, különösen kis méretekben, ahol az al-képpont és az egész képpont közötti különbség a karakterjelek szélességének jelentős részét képviseli. Lehetővé teszi a szöveg ideális felbontásban történő mérését és természetes pozíciójában az LCD színsávon, a szubpixel granularitással. Az ezzel a technológiával mért és renderelt szöveg definíció szerint felbontásfüggetlen, ami azt jelenti, hogy a különböző megjelenítési felbontások között pontosan ugyanaz a szövegelrendezés érhető el.

A GDI ClearType megjelenítési típusától eltérően az al képpontos ClearType a karakterek legpontosabb szélességét kínálja.

A Text String API alapértelmezés szerint a képpont alatti szövegmegjelenítést alkalmazza, ami azt jelenti, hogy az aktuális megjelenítési felbontástól független ideális felbontásban méri a szöveget, és a valóban skálázott karakterjelek előreszélessége és a pozícióeltolódások alapján hozza létre a karakterjelek elhelyezésének eredményét.

Nagy méretű szöveg esetén a DirectWrite az y-tengely mentén végzett simítást is lehetővé teszi, hogy a szélek simábbak legyenek, és a betűk a betűkészlet-tervező szándékai szerint kerüljenek megjelenítésre. Az alábbi ábrán az y irányú élsimítás látható.

Bár DirectWrite szöveg alapértelmezés szerint a képpont alatti ClearType használatával van elhelyezve és renderelve, más megjelenítési lehetőségek is elérhetők. Sok meglévő alkalmazás A GDI használatával jeleníti meg a felhasználói felület nagy részét, egyes alkalmazások pedig olyan rendszerszerkesztési vezérlőket használnak, amelyek továbbra is a GDI-t használják a szövegmegjelenítéshez. Ha DirectWrite-szöveget ad hozzá ezekhez az alkalmazásokhoz, előfordulhat, hogy fel kell áldozni a képpont alatti ClearType olvasási felületének fejlesztéseit, hogy a szöveg egységesen jelenjen meg az alkalmazásban.

A fenti követelmények teljesítéséhez DirectWrite a következő megjelenítési beállításokat is támogatja:

• Sub-pixel ClearType (alapértelmezett).
• Alpixeles ClearType élsimítással mind vízszintes, mind függőleges dimenziókban.
• Aliasos szöveg.
• A GDI természetes szélessége (ezt például a Microsoft Word Olvasó nézete használja).
• GDI-kompatibilis szélesség (beleértve a kelet-ázsiai beágyazott bitképet).

Ezen renderelési módok mindegyike finomhangolható a DirectWrite API-n és az új Windows 7 beérkezett üzenetek clearType tunerén keresztül.

Természetes elrendezés támogatása

A természetes elrendezés felbontásfüggetlen, így a karakterek térköze nem változik nagyításkor vagy kicsinyítéskor, illetve a kijelző DPI-jától függően. Másodlagos előnye, hogy a távolságok hűek a betűtípus tervezéséhez. A természetes elrendezést a DirectWrite természetes megjelenítésének támogatása teszi lehetővé, ami azt jelenti, hogy az egyes glifák a képpont töredékére helyezhetők.

Bár a természetes elrendezés az alapértelmezett, egyes alkalmazásoknak a GDI-vel megegyező térközű és megjelenésű szöveget kell renderelniük. Az ilyen alkalmazások esetében a DirectWrite klasszikus GDI és GDI természetes mérési módokat és megfelelő renderelési módokat biztosít.

A fenti megjelenítési módok bármelyike kombinálható a két antialiasing mód valamelyikével: ClearType vagy szürkeárnyalatos. A ClearType antialiasing szimulációk nagyobb felbontást adnak, ha egyenként módosítják az egyes képpontok piros, zöld és kék színértékeit. A szürkeárnyalatos antialiasing minden képponthoz csak egy lefedettségi (vagy alfa) értéket számít ki. A ClearType az alapértelmezett, de a szürkeárnyalatos antialiasing a Windows Áruházbeli alkalmazásokhoz ajánlott, mivel gyorsabb, és kompatibilis a standard antialiasinggal, miközben továbbra is magas olvashatóságú.

AZ API áttekintése

Az IDWriteFactory felület a DirectWrite-funkciók használatának kiindulópontja. A gyár az a gyökérobjektum, amely együtt használható objektumok készletét hozza létre.

A formázási és elrendezési művelet előfeltétele a műveleteknek, mivel a szövegeket megfelelően kell formázni, és meghatározott kényszerek szerint kell elhelyezni ahhoz, hogy meg lehessen rajzolni vagy tesztelni. Az IDWriteFactory segítségével két fontos objektumot hozhat létre ehhez a célra: IDWriteTextFormat és IDWriteTextLayout. Az IDWriteTextFormat objektum egy szöveg bekezdésének formázási adatait jelöli. A IDWriteFactory::CreateTextLayout függvény a bemeneti sztringet, a kapcsolódó korlátozásokat, például a kitöltendő tér dimenzióját és az IDWriteTextFormat objektumot veszi fel, és a teljes elemzést és a formázott eredményt IDWriteTextLayout-ba helyezi a későbbi műveletekhez.

Az alkalmazás ezután a Direct2D által biztosított DrawTextLayout függvénnyel vagy egy visszahívási függvénnyel jelenítheti meg a szöveget, amely GDI-t, Direct2D-t vagy más grafikus rendszereket használhat a glifák megjelenítéséhez. Egyetlen formátumú szöveg esetén a DrawText függvény a Direct2D-n egyszerűbben rajzolhat szöveget anélkül, hogy először létre kellene hoznia egy IDWriteTextLayout objektumot.

A "Hello World" formázása és rajzolása a DirectWrite használatával

Az alábbi példakód bemutatja, hogyan formázhat egy alkalmazás egyetlen bekezdést IDWriteTextFormat használatával, és hogyan rajzolhatja meg a Direct2DDrawText függvénnyel.

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

A betűtípus-rendszer elérése

A fenti példában szereplő IDWriteTextFormat felülettel a szövegsztring betűtípuscsaládjának megadása mellett DirectWrite lehetővé teszi az alkalmazások számára a betűtípusok számbavétele révén történő betűtípus-kijelölést, valamint az egyéni betűtípusgyűjtemény beágyazott dokumentum betűtípusok alapján történő létrehozását.

Az IDWriteFontCollection objektum betűtípuscsaládok gyűjteménye. A DirectWrite hozzáférést biztosít a rendszeren telepített betűtípuskészlethez a rendszer betűtípusgyűjteményének nevezett speciális betűtípusgyűjteményen keresztül. Ezt az IDWriteFactory objektum GetSystemFontCollection metódusának meghívásával szerezheti be. Az alkalmazások egyéni betűtípusgyűjteményt is létrehozhatnak egy alkalmazás által definiált visszahívás által számba helyezett betűtípuskészletből, vagyis az alkalmazás által telepített privát betűtípusokból vagy a dokumentumba ágyazott betűtípusokból.

Az alkalmazás ezután meghívhatja GetFontFamily, hogy egy adott FontFamily objektumhoz jusson a gyűjteményen belül, majd meghívhatja IDWriteFontFamily::GetFirstMatchingFont, hogy egy adott IDWriteFont objektumhoz jusson. Az IDWriteFont objektum egy betűtípust jelöl egy betűtípusgyűjteményben, és elérhetővé teszi a tulajdonságokat és néhány alapvető betűmetrikát.

Az IDWriteFontFace egy másik objektum, amely egy betűtípust jelöl, és teljes metrikakészletet tesz elérhetővé egy betűtípuson. Az IDWriteFontFace közvetlenül egy betűnévből hozható létre; az alkalmazásnak nem kell betűkészletet lekérnie a hozzáféréshez. Olyan szövegelrendezési alkalmazások esetében hasznos, mint a Microsoft Word, amelyeknek le kell kérdeznie egy adott betűtípus részleteit.

Az alábbi ábra az objektumok közötti kapcsolatot mutatja be.

IDWriteFontFace

Az IDWriteFontFace objektum egy betűtípust jelöl, és részletesebb információkat nyújt a betűtípusról, mint az IDWriteFontobjektum. Az IDWriteFontFace betűtípus- és karakterjelmetrikái a szövegelrendezést megvalósító alkalmazások számára hasznosak.

A legtöbb általános alkalmazás nem használja közvetlenül ezeket az API-kat, hanem IDWriteFont vagy közvetlenül adja meg a betűcsalád nevét.

Az alábbi táblázat a két objektum használati forgatókönyveit foglalja össze.

Az alábbiakban egy példaalkalmazás látható, amely számba adja a rendszer betűtípusgyűjteményének betűtípusait.

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

Szövegmegjelenítés

A szövegmegjelenítési API-k lehetővé teszik, hogy a DirectWrite betűtípusban lévő karakterjelek Direct2D felületre vagy GDI-eszközfüggetlen bitképre legyenek renderelve, vagy vázlatokká vagy bitképekké alakíthatók. A DirectWrite ClearType-renderelése támogatja a képpontok alatti elhelyezést a Windows korábbi implementációihoz képest jobb élességgel és kontraszttal. A DirectWrite az aliasos fekete-fehér szöveget is támogatja a beágyazott bitképekkel rendelkező kelet-ázsiai betűtípusokat érintő forgatókönyvek támogatásához, vagy ha a felhasználó letiltotta a betűtípusok bármilyen típusú simítását.

Minden beállítás módosítható az összes elérhető ClearType-gomb által, amelyek hozzáférhetők a DirectWrite API-kon keresztül, és szintén elérhetők a Windows 7 új ClearType tuner vezérlőpult appletjén keresztül.

Két API érhető el a karakterjelek rendereléséhez, az egyik hardveresen gyorsított renderelést biztosít Direct2D-, a másik pedig szoftveres renderelést biztosít egy GDI-bitképhez. Az IDWriteTextLayout és az IDWriteTextRenderer visszahívást használó alkalmazások a DrawGlyphRun visszahívásra válaszul bármelyik függvényt meghívhatják. Emellett azok az alkalmazások is használhatják ezeket az API-kat, amelyek saját elrendezést implementálnak, vagy glyph szintű adatokkal foglalkoznak.

1. ID2DRenderTarget::DrawGlyphRun

   Az alkalmazások a Direct2D API DrawGlyphRun használatával hardveres gyorsítást biztosíthatnak a GPU-val történő szövegmegjelenítéshez. A hardveres gyorsítás a szövegmegjelenítési folyamat minden fázisára hatással van – a glifák glyph-futtatásokká való egyesítésétől és a glifób-futtatás bitképének szűrésétől kezdve a ClearType keverési algoritmusnak a végleges megjelenített kimenetre való alkalmazásáig. Ez az ajánlott API a legjobb megjelenítési teljesítmény eléréséhez.

2. IDWriteBitmapRenderTarget::DrawGlyphRun

   Az alkalmazások az IDWriteBitmapRenderTarget::DrawGlyphRun metódussal szoftveres renderelést végezhetnek egy glifasorozat 32 bites bitképre történő rendereléséhez. Az IDWriteBitmapRenderTarget objektum egy bitképet és egy memóriaeszköz-környezetet foglal magában, amely a karakterjelek renderelésére használható. Ez az API akkor hasznos, ha a GDI-vel szeretne maradni, mert van egy meglévő kódbázisa, amely a GDI-ben jelenik meg.

Ha olyan alkalmazással rendelkezik, amely már rendelkezik GDI-t használó szövegelrendezési kóddal, és meg szeretné őrizni a meglévő elrendezési kódját, de a DirectWrite csak a karakterjelek renderelésének utolsó lépéséhez használja, IDWriteGdiInterop::CreateFontFaceFromHdc biztosítja a hidat a két API között. A függvény meghívása előtt az alkalmazás az IDWriteGdiInterop::CreateFontFaceFromHdc függvényt fogja használni egy eszközkörnyezet betűtípus-arc hivatkozásának lekéréséhez.

Egyéni renderelési módok

Számos paraméter befolyásolja a szövegmegjelenítést, például a gamma- és ClearType-szintet, a képpontgeometriát és a továbbfejlesztett kontrasztot. A renderelési paramétereket egy objektum foglalja magában, amely implementálja a nyilvános IDWriteRenderingParams interfészt. A renderelési paraméterek objektuma automatikusan inicializálódik a Windows 7 ClearType vezérlőpultján megadott hardvertulajdonságok és/vagy felhasználói beállítások alapján. Ha egy ügyfél a DirectWrite layout API-t használja, a DirectWrite automatikusan kiválaszt egy, a megadott mérési módnak megfelelő megjelenítési módot.

A több vezérlést igénylő alkalmazások használhatják az IDWriteFactory::CreateCustomRenderingParams a különböző megjelenítési beállítások implementálásához. Ez a függvény a gamma, a képpontgeometria és a továbbfejlesztett kontraszt beállítására is használható.

A következő megjelenítési lehetőségek érhetők el:

• Szubpixeles élsimítás

  Az alkalmazás a renderingMode paramétert úgy állítja be DWRITE_RENDERING_MODE_NATURAL, hogy csak a vízszintes dimenzióban adjon meg alias-ellenes megjelenítést.

• Al-képpontos élsimítás vízszintes és függőleges méretekben is.

  Az alkalmazás a renderingMode paramétert a DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC értékre állítja be, hogy a renderelés vízszintes és függőleges dimenziókban is simítással történjen. Így a görbék és az átlós vonalak simábbnak tűnnek bizonyos lágyság rovására, és általában 16 ppem feletti méretekben használják.

• Aliasos szöveg

  Az alkalmazás a renderingMode paramétert a DWRITE_RENDERING_MODE_ALIASED értékre állítja az aliasos szöveg jelzésére.

• Szürkeárnyalatos szöveg

  Az alkalmazás a pixelGeometry paramétert a szürkeárnyalatos szöveg megadásához DWRITE_PIXEL_GEOMETRY_FLAT értékre állítja.

• GDI-kompatibilis szélesség (beleértve a kelet-ázsiai beágyazott bitképet is)

  Az alkalmazás a renderingMode paramétert a GDI-kompatibilis szélességű élsimítás megadásához DWRITE_RENDERING_MODE_GDI_CLASSIC értékre állítja.

• GDI természetes szélesség

  Az alkalmazás a renderingMode paramétert DWRITE_RENDERING_MODE_GDI_NATURAL értékre állítja be a GDI természetes szélességével kompatibilis élsimítás megadásához.

• Vázlatszöveg

  Nagy méretű renderelés esetén előfordulhat, hogy az alkalmazás fejlesztője inkább a betűszerkezet használatával jeleníti meg a megjelenítést, nem pedig bittérképre való raszterizálással. Az alkalmazás beállítja a renderingMode paramétert DWRITE_RENDERING_MODE_OUTLINE annak megadásához, hogy a renderelésnek meg kell kerülnie a raszterizátort, és közvetlenül kell használnia a körvonalakat.

GDI-együttműködés

Az IDWriteGdiInterop interfész biztosítja a GDI-vel való együttműködést. Ez lehetővé teszi az alkalmazások számára, hogy folytathassák a GDI-kódbázisokban meglévő befektetéseiket, és szelektíven használják DirectWrite rendereléshez vagy elrendezéshez.

A következők azok az API-k, amelyek lehetővé teszik az alkalmazások áttelepítését a GDI betűtípusrendszerbe vagy onnan:

• CreateFontFromLOGFONT

  Létrehoz egy IDWriteFont objektumot, amely megfelel a LOGFONT struktúra által megadott tulajdonságoknak.

• ConvertFontToLOGFONT

  Inicializál egy LOGFONT struktúrát a megadott IDWriteFontGDI-kompatibilis tulajdonságai alapján.

• ConvertFontFaceToLOGFONT

  Inicializál egy LOGFONT struktúrát a megadott IDWriteFontFaceGDI-kompatibilis tulajdonságai alapján.

• CreateFontFaceFromHdc

  Létrehoz egy IDWriteFontFace objektumot, amely megfelel a jelenleg kijelölt HFONT.

Következtetés

Az olvasási élmény javítása nagy értéket jelent a felhasználóknak, akár a képernyőn, akár papíron. DirectWrite egyszerű használatot és rétegzett programozási modellt biztosít az alkalmazásfejlesztőknek a Windows-alkalmazások szöveghasználatának javítása érdekében. Az alkalmazások a DirectWrite használatával jeleníthetnek meg gazdagon formázott szöveget a felhasználói felületükhöz és a dokumentumokhoz az elrendezési API-val. Összetettebb forgatókönyvek esetén az alkalmazások közvetlenül használhatják a karakterjeleket, hozzáférhetnek a betűtípusokhoz stb., és kihasználhatják a DirectWrite erejét a kiváló minőségű tipográfia érdekében.

A DirectWrite együttműködési képességei lehetővé teszik, hogy az alkalmazásfejlesztők továbbvihessék meglévő Win32-kódbázisaikat, és szelektíven fogadhassák el a DirectWrite-et az alkalmazásaikban.