Egyéni betűkészletek

Ez a témakör az egyéni betűtípusok alkalmazásbeli használatának különböző módjait ismerteti.

• bevezetési
• API-k összegzése
• főbb fogalmak
• Betűtípusok és betűformátumok
• Betűtípuskészletek és betűtípusgyűjtemények
• gyakori forgatókönyvek
  • Betűkészlet létrehozása tetszőleges betűtípusokkal a helyi fájlrendszerben
  • Betűtípuskészlet létrehozása ismert betűtípusokkal a helyi fájlrendszerben
  • Egyéni betűtípuskészlet létrehozása ismert, távoli betűtípusokkal a webes
  • Egyéni betűtípuskészlet létrehozása a memóriába betöltött betűtípusadatokkal
• Speciális forgatókönyvek
  • Betűkészletek egyesítése
  • Helyi WOFF vagy WOFF2 betűtípusadatok használata
  • A DirectWrite távoli betűtípus-mechanizmusainak használata egyéni, alacsony szintű hálózati implementációval
  • Korábbi Windows-verziók támogatási forgatókönyvei

Bevezetés

Az alkalmazások legtöbbször a rendszeren helyileg telepített betűtípusokat használják. A DirectWrite hozzáférést biztosít ezekhez a betűtípusokhoz az IDWriteFactory3::GetSystemFontSet vagy IDWriteFactory::GetSystemFontCollection metódusokkal. Bizonyos esetekben előfordulhat, hogy az alkalmazások olyan betűtípusokat is használni szeretnének, amelyek a Windows 10 részeként szerepelnek, de jelenleg nincsenek telepítve az aktuális rendszeren. Az ilyen betűtípusok a Windows betűtípus-szolgáltatásból érhetők el a GetSystemFontSet metódussal, vagy az IDWriteFactory3::GetSystemFontCollection meghívásával, ha az includeDownloadableFonts értéke TRUE. 

Bizonyos alkalmazási helyzetekben azonban az alkalmazásoknak olyan betűtípusokat kell használniuk, amelyek nincsenek telepítve a rendszerben, és amelyeket a Windows Font Service nem biztosít. Az alábbi példák ilyen forgatókönyvekre mutatnak be példákat:

• A betűtípusok erőforrásokként vannak beágyazva egy alkalmazás bináris fájlba.
• A betűtípusfájlok egy alkalmazáscsomagon belül vannak csomagolva, és az alkalmazás telepítési mappája alatti lemezen vannak tárolva.
• Az alkalmazás egy olyan betűtípus-fejlesztő eszköz, amely be kell töltenie a felhasználó által megadott betűtípusfájlokat. 
• A betűtípusok olyan dokumentumfájlokba vannak beágyazva, amelyek megtekinthetők vagy szerkeszthetők az alkalmazásban. 
• Az alkalmazás nyilvános webes betűtípus-szolgáltatásból beszerzett betűtípusokat használ. 
• Az alkalmazás privát hálózati protokollon keresztül streamelt betűtípus-adatokat használ. 

A DirectWrite API-kat biztosít az egyéni betűtípusok kezeléséhez ezekben és más hasonló helyzetekben. Előfordulhat, hogy az egyéni betűtípusadatok a helyi fájlrendszer fájljaiból származnak; HTTP használatával elért távoli, felhőalapú forrásokból; vagy tetszőleges forrásokból, miután betöltődött egy memóriapufferbe. 

AZ API-k összefoglalása

Ez a témakör a következő API-k által biztosított funkciókkal foglalkozik:

• IDWriteFontSet interfész
• IDWriteFontSetBuilder felület
• IDWriteFontSetBuilder1 felület
• IDWriteFontFaceReference felület
• IDWriteFontFile felület
• IDWriteFactory::CreateFontFileReference metódus
• IDWriteFactory::CreateCustomFontFileReference metódus
• IDWriteFactory3::CreateFontFaceReference metódusok
• DWRITE_FONT_PROPERTY szerkezet
• DWRITE_FONT_PROPERTY_ID számbavétel
• IDWriteFontFileLoader felület
• IDWriteFactory::RegisterFontFileLoader metódus
• IDWriteFactory::UnregisterFontFileLoader metódus
• IDWriteFactory5::CreateInMemoryFontFileLoader metódus
• IDWriteInMemoryFontFileLoader felület
• IDWriteFactory5::CreateHttpFontFileLoader metódus
• IDWriteRemoteFontFileLoader interfész
• IDWriteFontDownloadQueue felület
• IDWriteFontDownloadListener felület
• IDWriteFontFileStream felület
• IDWriteRemoteFontFileStream felület
• IDWriteAsyncResult felület
• IDWriteFactory5::AnalyzeContainerType metódus
• IDWriteFactory5::UnpackFontFile metódus

Főbb fogalmak

Az egyéni betűtípusok használatához használt DirectWrite API-k megértéséhez hasznos lehet megérteni az ezen API-k alapjául szolgáló elméleti modellt. A főbb fogalmakat itt ismertetjük. 

Amikor a DirectWrite tényleges szövegelrendezést vagy -megjelenítést végez, hozzá kell férnie a tényleges betűtípusadatokhoz. A betűtípus-arc objektum tényleges betűtípusadatokat tartalmaz, amelyeknek a helyi rendszerben kell lenniük. Más műveletek, például egy adott betűtípus rendelkezésre állásának ellenőrzése vagy a felhasználók számára történő betűtípus-választási lehetőségek megjelenítése esetén azonban csak egy adott betűtípusra kell hivatkozni, nem pedig a tényleges betűtípusadatokra. A DirectWrite-ban a betűtípusok archivatkozási objektuma csak a betűtípusok megkereséséhez és példányosításához szükséges információkat tartalmazza. Mivel a betűtípus archivatkozása nem tartalmaz tényleges adatokat, a DirectWrite képes kezelni azokat a betűtípus-archivatkozásokat, amelyek tényleges adatai távoli hálózati helyen találhatók, valamint ha a tényleges adatok helyiek.

A betűtípuskészletek olyan betűtípus-archivatkozások, valamint bizonyos alapvető, információs tulajdonságok, amelyek felhasználhatók a betűtípusra való hivatkozáshoz vagy más betűtípusokhoz, például a családnévhez vagy a betűvastagsági értékhez való összehasonlításhoz. A különböző betűtípusok tényleges adatai lehetnek helyiek, vagy lehet, hogy az összes távoli, vagy valamilyen keverék.

A megfelelő betűtípuscsoport-objektum beolvasható betűtípuskészlettel. További részletekért tekintse meg az alábbi betűtípuskészleteket és betűtípusgyűjteményeket. 

Az IDWriteFontSet felület olyan metódusokat biztosít, amelyek lehetővé teszik az olyan tulajdonságértékek lekérdezését, mint a családnév vagy a betűsúly, illetve az adott tulajdonságértékeknek megfelelő betűtípus-archivatkozások. Egy adott kijelölésre való szűrés után lekérjük az IDWriteFontFaceReference felület egy példányát, a letöltési módszerekkel (ha a tényleges betűtípusadatok jelenleg távoliak), a megfelelő IDWriteFontFace3 objektum beszerzéséhez, amely az elrendezéshez és a rendereléshez használható. 

Az IDWriteFontFile felület az egyes betűtípusok arc- vagy betűlap-hivatkozásainak alapjául szolgál. Ez egy betűtípusfájl helyét jelöli, és két összetevőből áll: egy betűtípusfájl-betöltőből és egy betűtípusfájlkulcsból. A betűtípusfájl-betöltő (IDWriteFontFileLoader) segítségével szükség esetén megnyithat egy fájlt, és visszaad egy adatfolyamot az adatokkal (IDWriteFontFileStream). A betöltőtől függően előfordulhat, hogy az adatok helyi fájlelérési útvonalon, távoli URL-címen vagy memóriapufferben találhatók. A kulcs egy betöltő által definiált érték, amely egyedileg azonosítja a fájlt a betöltőkörnyezetben, lehetővé téve a betöltő számára az adatok megkeresését és egy stream létrehozását. 

Az egyéni betűtípusok egyszerűen hozzáadhatók az egyéni betűtípuskészletekhez, amelyek viszont felhasználhatók a betűtípus-információk szűrésére vagy rendszerezésére olyan célokra, mint például a betűválasztó felhasználói felületének létrehozása. A betűtípuskészlettel olyan betűtípusgyűjteményeket is létrehozhat, amelyeket magasabb szintű API-kban, például IDWriteTextFormat és IDWriteTextLayouthasználhat. Az IDWriteFontSetBuilder felülettel létrehozhat egy egyéni betűtípuskészletet, amely több egyéni betűtípust is tartalmaz. Egyéni betűtípuskészletek létrehozására is használható, amelyek egyéni betűtípusokat és rendszer által biztosított betűtípusokat kevernek; vagy a betűtípusokat a tényleges adatok különböző forrásaival – a helyi tárolással, a távoli URL-címekkel és a memóriával – keveri. 

Mint már említettük, a betűtípus-archivatkozások hivatkozhatnak a távoli forrásban lévő betűtípusadatokra, de az adatoknak helyinek kell lenniük ahhoz, hogy olyan betűtípus-arc objektumot szerezzenek be, amely az elrendezéshez és a rendereléshez használható. A távoli adatok letöltését egy betűtípus-letöltési üzenetsor kezeli. Az alkalmazások az IDWriteFontDownloadQueue felületével kérhetik le a letöltési folyamatot távoli betűtípusok letöltésére, és regisztrálhatnak egy IDWriteFontDownloadListener objektumot, hogy a letöltési folyamat befejeződésekor műveletet hajtsanak végre. 

Az itt ismertetett felületek többségéhez a DirectWrite rendszer-implementációkat biztosít. Az egyetlen kivétel az IDWriteFontDownloadListener felület, amelyet egy alkalmazás implementál, hogy alkalmazásspecifikus műveleteket hajtson végre távoli betűtípusok helyi letöltésekor. Előfordulhat, hogy az alkalmazásoknak oka van arra, hogy saját egyéni implementációkat biztosítsanak bizonyos más felületekhez, bár erre csak meghatározott, fejlettebb forgatókönyvekben lenne szükség. Egy alkalmazásnak például az IDWriteFontFileLoader felületének egyéni implementációját kell biztosítania a WOFF2 tárolóformátumot használó helyi tárolóban lévő betűtípusfájlok kezeléséhez. További részleteket alább talál. 

Betűtípusok és betűformátumok

Egy másik fontos fogalom, amely hasznos lehet az egyes betűtípus-arcok és az őket tartalmazó betűtípusfájlok közötti kapcsolat. Az egyetlen betűtípust tartalmazó OpenType-betűtípusfájl (.ttf vagy .otf) fogalma ismerős. Az OpenType betűtípus formátuma azonban lehetővé teszi az OpenType betűtípusgyűjtemény (.ttc vagy .otc) használatát is, amely egyetlen fájl, amely több betűtípust tartalmaz. Az OpenType Collection-fájlokat gyakran használják olyan nagy betűtípusokhoz, amelyek szorosan kapcsolódnak, és bizonyos betűtípusadatokhoz azonos értékekkel rendelkeznek: ha egyetlen fájlban egyesítik a betűtípusokat, a közös adatok duplikálhatók. Ezért a betűlapra vagy betűlapra mutató hivatkozásnak nem csak egy betűtípusfájlra (vagy azzal egyenértékű adatforrásra) kell hivatkoznia, hanem meg kell adnia egy betűindexet is a fájlon belül, abban az általános esetben, amelyben a fájl gyűjteményfájl lehet. 

Az interneten használt betűtípusok esetében a betűtípusadatok gyakran bizonyos tárolóformátumokba vannak csomagolva, például WOFF vagy WOFF2, amelyek bizonyos szintű tömörítést biztosítanak a betűtípusadatokhoz, valamint bizonyos szintű védelmet nyújtanak a kalózkodás és a betűlicencek megsértése ellen. A WOFF- vagy WOFF2-fájlok funkcionálisan megegyeznek az OpenType betűtípussal vagy a Betűgyűjtemény fájllal, de az adatok más formátumban lesznek kódolva, amely a használat előtt kicsomagolást igényel. 

Egyes DirectWrite API-k az egyes betűtípusokkal foglalkozhatnak, míg más API-k képesek kezelni a több arcot tartalmazó OpenType Collection-fájlokat tartalmazó fájlokat. Hasonlóképpen bizonyos API-k csak nyers, OpenType formátumú adatokkal foglalkoznak, míg más API-k képesek kezelni a csomagolt, WOFF és WOFF2 tárolóformátumokat. Ezeket a részleteket az alábbi vitafórum tartalmazza. 

Betűkészletek és betűkészletek

Egyes alkalmazások implementálhatók a betűtípusok IDWriteFontCollection felülettel való használatához. A betűkészletek és a betűtípuskészletek között közvetlen levelezés áll fenn. Mindegyik rendelkezhet ugyanazokkal a betűtípusokkal, de egy másik szervezetnél jelenítik meg őket. Bármely betűtípusgyűjteményből beszerezhető egy megfelelő betűtípuskészlet, és fordítva.

Ha több egyéni betűtípussal dolgozik, a legegyszerűbb, ha egy betűkészlet-szerkesztő felülettel egyéni betűtípuskészletet hoz létre, majd a betűtípuskészlet létrehozása után beolvas egy betűkészletet. Az egyéni betűtípuskészlet létrehozásának folyamatát az alábbiakban ismertetjük részletesen. Ha IDWriteFontCollection1 felületet szeretne beszerezni egy betűtípuskészletből, az IDWriteFactory3::CreateFontCollectionFromFontSet metódust használja.

Ha az alkalmazás rendelkezik gyűjteményobjektummal, és be kell szereznie egy megfelelő betűtípuskészletet, ezt az IDWriteFontCollection1::GetFontSet metódussal teheti meg. 

Gyakori forgatókönyvek

Ez a szakasz az egyéni betűkészleteket érintő leggyakoribb forgatókönyveket ismerteti:

• Egyéni betűtípuskészlet létrehozása tetszőleges betűtípusokkal a helyi fájlrendszer elérési útjainál.
• Egyéni betűtípuskészlet létrehozása a helyi fájlrendszerben tárolt ismert (esetleg az alkalmazással együtt) betűtípusokkal.
• Egyéni betűtípuskészlet létrehozása ismert, távoli betűtípusokkal a weben.
• Egyéni betűtípuskészlet létrehozása a memóriába betöltött betűtípusadatokkal.

Ezeknek a forgatókönyveknek a teljes implementációit a DirectWrite egyéni betűtípuskészletek mintanyújtja. Ez a minta egy speciálisabb forgatókönyvet is bemutat a WOFF vagy WOFF2 tárolóformátumban csomagolt betűtípusadatok kezelésére, amelyet az alábbiakban ismertetünk. 

Betűkészlet létrehozása tetszőleges betűtípusokkal a helyi fájlrendszerben

Ha tetszőleges betűtípusfájlokat kezel a helyi tárolóban, az IDWriteFontSetBuilder1::AddFontFile metódus kényelmes, mivel egyetlen hívásban képes kezelni az OpenType betűtípusgyűjtemény fájlban lévő összes betűtípust, valamint az OpenType változó betűtípusainak összes példányát. Ez elérhető a Windows 10 Alkotók frissítésében (előzetes build 15021 vagy újabb verzió), és mindig ajánlott, ha elérhető. 

A módszer használatához használja a következő folyamatot.

1. Először hozza létre az IDWriteFactory5 felületet:

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

 
2. Használja a gyárat a IDWriteFontSetBuilder1 felület beszerzéséhez:

IDWriteFontSetBuilder1* pFontSetBuilder; 
if (SUCCEEDED(hr)) 
{ 
  hr = pDWriteFactory->CreateFontSetBuilder(&pFontSetBuilder); 
}  
                

3. A helyi fájlrendszerben minden egyes betűtípusfájlhoz hozzon létre egy IDWriteFontFile, amely hivatkozik rá:

IDWriteFontFile* pFontFile; 
if (SUCCEEDED(hr)) 
{ 
  hr = pDWriteFactory->CreateFontFileReference(pFilePath, /* lastWriteTime*/ nullptr, &pFontFile); 
} 

 
4. Adja hozzá az IDWriteFontFile objektumot a betűkészlet-szerkesztőhöz az AddFontFile metódussal:

hr = pFontSetBuilder->AddFontFile(pFontFile); 

Ha a CreateFontFileReference hívásában megadott fájl elérési útja nem támogatott OpenType-fájlra hivatkozik, akkor az AddFontFilehívása hibát fog visszaadni, DWRITE_E_FILEFORMAT.

5. Miután az összes fájl hozzá lett adva a betűkészlet-szerkesztőhöz, létre lehet hozni az egyéni betűtípuskészletet:

IDWriteFontSet* pFontSet; 
hr = pFontSetBuilder->CreateFontSet(&pFontSet); 

 

Ha az alkalmazásnak a Windows 10 Alkotók frissítésénél korábbi Windows 10-verziókon kell futnia, akkor az AddFontFile metódus nem lesz elérhető. A rendelkezésre állás észlelhető egy IDWriteFactory3 felület létrehozásával, majd a QueryInterface használatával megpróbál beszerezni egy IDWriteFactory5 felületet: ha ez sikerül, akkor az IDWriteFontSetBuilder1 felület és AddFontFile metódus is elérhető lesz.

Ha az AddFontFile metódus nem érhető el, akkor az IDWriteFontSetBuilder::AddFontFaceReference metódust kell használni az egyes betűtípusok hozzáadásához. A több arcot tartalmazó OpenType betűtípusgyűjtemény-fájlok engedélyezéséhez az IDWriteFontFile::Analyze metódus használható a fájlban található arcok számának meghatározásához. A folyamat a következő.

1. Először hozza létre az IDWriteFactory3 felületet:

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

2. Használja a gyárat az IDWriteFontSetBuilder felület beszerzéséhez:

IDWriteFontSetBuilder* pFontSetBuilder; 
if (SUCCEEDED(hr)) 
{ 
  hr = pDWriteFactory->CreateFontSetBuilder(&pFontSetBuilder); 
} 

3. Minden betűtípusfájlhoz hozzon létre egy IDWriteFontFile, a fentieknek megfelelően:

IDWriteFontFile* pFontFile; 
if (SUCCEEDED(hr)) 
{ 
  hr = pDWriteFactory->CreateFontFileReference(pFilePath, /* lastWriteTime*/ nullptr, &pFontFile); 
} 

Ahelyett, hogy közvetlenül hozzáadnánk a fájlt a betűkészlet-szerkesztőhöz, meg kell határoznunk az arcok számát, és egyedi IDWriteFontFaceReference objektumokat kell létrehoznunk. 
4. A fájlban lévő arcok számának lekéréséhez használja az Elemzés metódust. 

BOOL isSupported; 
DWRITE_FONT_FILE_TYPE fileType; 
UINT32 numberOfFonts; 
hr = pFontFile->Analyze(&isSupported, &fileType, /* face type */ nullptr, &numberOfFonts); 

Az Analyze metódus az isSupported és a fileType paraméterek értékeit is beállítja. Ha a fájl nem támogatott formátum, akkor az isSupported értéke HAMIS lesz, és megfelelő műveletet hajthat végre, például figyelmen kívül hagyhatja a fájlt. 
5. Hurok a numberOfFonts paraméterben beállított betűtípusok száma felett. A cikluson belül hozzon létre egy IDWriteFontFaceReference minden fájl/index párhoz, és adja hozzá a betűtípuskészlet-szerkesztőhöz. 

for (uint32_t fontIndex = 0; fontIndex < numberOfFonts; fontIndex++) 
{ 
  IDWriteFontFaceReference* pFontFaceReference;
  hr = pDWriteFactory->CreateFontFaceReference(pFontFile, fontIndex, DWRITE_FONT_SIMULATIONS_NONE, &pFontFaceReference);

  if (SUCCEEDED(hr))
  {
    hr = pFontSetBuilder->AddFontFaceReference(pFontFaceReference);
  }
} 

6. Miután az összes arcot hozzáadta a betűkészlet-szerkesztőhöz, hozza létre az egyéni betűtípuskészletet a fent látható módon.

Az alkalmazás úgy tervezhető meg, hogy a Windows 10 Alkotói frissítésen való futtatáskor az előnyben részesített AddFontFile metódust használja, de a Windows 10 korábbi verzióiban való futtatáskor használja az AddFontFaceReference metódust. Tesztelje az IDWriteFactory5 felület rendelkezésre állását a fent leírtak szerint, majd ennek megfelelően ágazjon el. Ezt a megközelítést a DirectWrite egyéni betűtípuskészletek mintaszemlélteti. 

Betűtípuskészlet létrehozása ismert betűtípusokkal a helyi fájlrendszerben

Ahogy fentebb említettük, a betűtípuskészletek minden egyes betűtípus-archivatkozása bizonyos információs tulajdonságokhoz, például a családnévhez és a betűvastagsághoz van társítva. Ha egyéni betűtípusokat ad hozzá egy betűkészlet-szerkesztőhöz a fent felsorolt API-hívásokkal, ezek az információs tulajdonságok közvetlenül a tényleges betűtípusadatokból származnak, amelyek a betűtípus hozzáadásakor lesznek felolvasva. Bizonyos esetekben azonban, ha egy alkalmazás más információforrással rendelkezik egy betűtípusról, előfordulhat, hogy saját egyéni értékeket szeretne megadni ezekhez a tulajdonságokhoz. 

Tegyük fel, hogy ez hasznos lehet, tegyük fel, hogy egy alkalmazás olyan betűtípusokat köt össze, amelyek az alkalmazás bizonyos felhasználói felületi elemeinek bemutatására szolgálnak. Időnként , például egy új alkalmazásverzió esetén, előfordulhat, hogy az alkalmazás által ezekhez az elemekhez használt betűtípusokat módosítani kell. Ha az alkalmazás kódolt hivatkozásokat tartalmaz az adott betűtípusokra, akkor az egyik betűtípus lecserélése a másikra szükségessé teszi a hivatkozások mindegyikének módosítását. Ehelyett, ha az alkalmazás egyéni tulajdonságokat használ a funkcionális aliasok hozzárendeléséhez a renderelt elem vagy szöveg típusa alapján, az egyes aliasokat egy adott betűtípushoz rendeli egy helyen, majd az aliasokat használja az összes olyan környezetben, ahol a betűtípusok létrejönnek és módosítva vannak, majd az egyik betűtípust lecseréli egy másikra, csak azt a helyet kell módosítania, ahol az alias egy adott betűtípushoz van rendelve. 

Az információs tulajdonságok egyéni értékei az IDWriteFontSetBuilder::AddFontFaceReference metódus meghívásakor rendelhetők hozzá. Ennek módja a következő: ez bármely Windows 10-es verzióban használható. 

A fentieknek megfelelően először szerezze be az IDWriteFactory3 és IDWriteFontSet interfészeket. Minden egyes egyéni betűtípus-arc hozzáadásához hozzon létre egy IDWriteFontFaceReference, a fent látható módon. Mielőtt hozzáadja ezt a betűtípuskészlet-szerkesztőhöz (a fenti 5. lépésben látható hurokban), az alkalmazás azonban meghatározza a használni kívánt egyéni tulajdonságértékeket. 

Az egyéni tulajdonságértékek halmazát DWRITE_FONT_PROPERTY struktúrák tömbje határozza meg. Ezek mindegyike azonosít egy adott tulajdonságot a DWRITE_FONT_PROPERTY_ID enumerálásából, valamint a használni kívánt megfelelő tulajdonságértéket.  

Vegye figyelembe, hogy minden tulajdonságérték sztringként van hozzárendelve. Ha ezek később megjelenhetnek a felhasználók számára, előfordulhat, hogy egy adott tulajdonság alternatív értékei különböző nyelvekhez vannak beállítva, de ez nem kötelező. Vegye figyelembe azt is, hogy ha az alkalmazás beállítja az egyéni tulajdonságértékeket, akkor csak a megadott értékek lesznek használatban a Betűtípuskészleten belül; A DirectWrite nem származtat közvetlenül értékeket a betűtípuskészletben használt információs tulajdonságok betűtípusából. 

Az alábbi példa három információs tulajdonság egyéni értékeit határozza meg: családnév, teljes név és betűvastagság. 

DWRITE_FONT_PROPERTY props[] = 
{ 
  { DWRITE_FONT_PROPERTY_ID_FAMILY_NAME, L"My Icon Font", L"en-US" }, 
  { DWRITE_FONT_PROPERTY_ID_FULL_NAME, L"My Icon Font", L"en-US" }, 
  { DWRITE_FONT_PROPERTY_ID_WEIGHT, L"400", nullptr } 
}; 
               
            

Miután meghatározta a kívánt tulajdonságérték-tömböt egy betűtípushoz, hívja fel az AddFontFaceRefence függvényt, és adja át a tulajdonságtömböt és a betűtípus archivatkozását. 

hr = pFontSetBuilder->AddFontFaceReference(pFontFaceReference, props, ARRAYSIZE(props)); 

Miután az összes egyéni betűtípus-arcot hozzáadta a betűkészlet-szerkesztőhöz, az egyéni tulajdonságaikkal együtt hozza létre az egyéni betűtípuskészletet a fent látható módon. 

Egyéni betűtípuskészlet létrehozása ismert, távoli betűtípusokkal a weben

Az egyéni tulajdonságok fontosak a távoli betűtípusok használatához. Minden betűlapra mutató hivatkozásnak rendelkeznie kell bizonyos információs tulajdonságokkal a betűtípus jellemzéséhez és a többi betűtípustól való megkülönböztetéséhez. Mivel a távoli betűtípusok betűtípusadatai nem helyiek, a DirectWrite nem tud közvetlenül a betűtípusadatokból tulajdonságokat származtatni. Ezért a tulajdonságokat explicit módon kell megadni, amikor távoli betűtípust ad hozzá a betűkészlet-szerkesztőhöz.

Az API-hívások sorozata távoli betűtípusok betűtípuskészlethez való hozzáadásához hasonló, mint az előző forgatókönyvben leírt sorrend. Mivel azonban a betűtípusadatok távoliak, a tényleges betűtípusadatok olvasásához szükséges műveletek eltérnek a helyi tárolóban lévő fájlok használatakor használt műveletekétől. Ebben a helyzetben a Windows 10 Alkotók frissítésében egy új, alacsonyabb szintű felületet, IDWriteRemoteFontFileLoader. 

A távoli betűkészletfájl-betöltő használatához először regisztrálni kell egy DirectWrite-gyárban. A betöltőt az alkalmazásnak kell tartania mindaddig, amíg a hozzá társított betűtípusok használatban vannak. Miután a betűtípusok már nem használhatók, és valamikor a gyár megsemmisítése előtt a rakodót regisztráció nélkül kell regisztrálni. Ez a rakodóobjektumot birtoklő osztály destruktorában végezhető el. Ezek a lépések az alábbiakban láthatók. 

Az egyéni betűtípuskészletek távoli betűtípusokkal való létrehozásának módja a következő; ehhez a Windows 10 Alkotók frissítése szükséges.  

1. Hozzon létre egy IDWriteFactory5 felületet a fent látható módon.  2. Hozzon létre egy IDWriteFontSetBuilder felületet a fent látható módon.  3. Használja a gyárat egy IDWriteRemoteFontFileLoaderbeszerzéséhez. 

IDWriteRemoteFontFileLoader* pRemoteFontFileLoader; 
if (SUCCEEDED(hr)) 
{ 
    hr = pDWriteFactory->CreateHttpFontFileLoader( 
        /* referrerURL */ nullptr, 
        /* extraHeaders */ nullptr, 
        &pRemoteFontFileLoader 
    ); 
} 

Ez a távoli betűkészlet-betöltő felület rendszer által biztosított implementációját adja vissza, amely képes kezelni a betűtípusadatok alkalmazás nevében történő letöltéséhez szükséges HTTP-interakciókat. Hivatkozó URL-címet vagy további fejléceket is megadhat, ha a betűtípusok forrását képező betűtípus-szolgáltatás vagy szolgáltatások igénylik.  

Fontos

Biztonsági megjegyzés: Távoli betűtípus lekérésekor fennáll annak a lehetősége, hogy a támadó meg hamisította a meghívni kívánt kiszolgálót. Ebben az esetben a cél- és hivatkozó URL-címek és fejlécadatok a támadó számára lesznek közzétenve. Az alkalmazásfejlesztők felelősek a kockázat csökkentéséért. HTTP helyett a HTTPS protokoll használata ajánlott. 

 

Egyetlen távoli betűtípusfájl-betöltő több betűtípushoz is használható, de különböző betöltők is használhatók, ha a betűtípusok több olyan szolgáltatásból származnak, amelyek eltérő követelményeket támasztanak a hivatkozó URL-címhez vagy a további fejlécekhez. 
4. Regisztrálja a távoli betűkészletfájl-betöltőt a gyárban. 

 if (SUCCEEDED(hr)) 
 { 
     hr = pDWriteFactory->RegisterFontFileLoader(pRemoteFontFileLoader); 
 } 

Ettől a ponttól kezdve az egyéni betűtípuskészlet létrehozásának lépései hasonlóak az ismert, helyi betűtípusfájlokhoz leírt lépésekhez, két fontos kivétellel. Először is az IDWriteFontFile objektum a távoli betűkészletfájl-betöltő felülettel jön létre a gyári helyett. Másodszor, az Elemzés metódus nem használható, mivel a betűtípus adatai nem helyiek. Ehelyett az alkalmazásnak tudnia kell, hogy a távoli betűtípusfájl egy OpenType betűtípusgyűjtemény-fájl-e, és ha igen, akkor tudnia kell, hogy a gyűjteményen belül melyik betűtípust fogja használni, és az indexet mindegyikhez. Ezért a többi lépés a következő. 
5. Minden távoli betűtípusfájlhoz a távoli betűkészlet-betöltő felülettel hozzon létre egy IDWriteFontFile, megadva a betűtípusfájl eléréséhez szükséges URL-címet. 

 IDWriteFontFile* pFontFile; 
 hr = pRemoteFontFileLoader->CreateFontFileReferenceFromUrl( 
     pDWriteFactory, 
     /* baseUrl */ L"https://github.com/", 
     /* fontFileUrl */ L"winjs/winjs/blob/master/src/fonts/Symbols.ttf?raw=true", 
     &pFontFile 
 ); 

Vegye figyelembe, hogy a teljes URL-cím megadható a fontFileUrl paraméterben, vagy felosztható alap- és relatív részekre. Ha alap URL-cím van megadva, akkor a baseUrl és a fontFileUrl értékek összefűzésének meg kell adnia a teljes URL-címet – a DirectWrite nem biztosít további elválasztójelet.

Fontos

Biztonsági / teljesítmény megjegyzés: Távoli betűtípus lekérésekor nincs garancia arra, hogy a Windows választ kap a kiszolgálótól. Bizonyos esetekben előfordulhat, hogy a kiszolgáló egy érvénytelen relatív URL-címhez nem található fájlhiba miatt válaszol, de nem válaszol, ha több érvénytelen kérést kap. Ha a kiszolgáló nem válaszol, a Windows végül időtúllépést okoz, de ez több lekérés kezdeményezése esetén több percet is igénybe vehet. Tegye meg, amit tud, hogy az URL-címek érvényesek legyenek a hívások során. 

 

Azt is vegye figyelembe, hogy az URL-cím egy nyers OpenType-betűtípusfájlra (.ttf, .otf, .ttc, .otc) mutathat, de egy WOFF vagy WOFF2 tárolófájl betűtípusára is mutathat. Ha WOFF- vagy WOFF2-fájlra hivatkozik, akkor a távoli betűtípusfájl-betöltő DirectWrite-implementációja automatikusan kicsomagolja a betűtípusadatokat a tárolófájlból. 
6. A használni kívánt távoli betűtípusfájl minden betűlapindexéhez hozzon létre egy IDWriteFontFaceReference. 

 IDWriteFontFaceReference* pFontFaceReference; 
 hr = pDWriteFactory->CreateFontFaceReference(pFontFile, /* faceIndex */ 0, DWRITE_FONT_SIMULATIONS_NONE, &pFontFaceReference);

7. A betűlap egyéni tulajdonságainak definiálása a fent látható módon. 
8. Adja hozzá a betűtípus-arc referenciát és az egyéni tulajdonságokat a betűkészlet-szerkesztőhöz a fent látható módon. 
9. Miután az összes betűtípust hozzáadta a betűtípuskészlet-szerkesztőhöz, hozza létre a betűtípuskészletet a fent látható módon. 
10. Amikor a távoli betűtípusok már nem lesznek használatban, törölje a távoli betűtípusfájl betöltőjének regisztrációjának megszüntetését. 

hr = pDWriteFactory->UnregisterFontFileLoader(pRemoteFontFileLoader); 

Miután létrehozott egy egyéni, távoli betűtípusokat tartalmazó egyéni betűtípuskészletet, a betűtípuskészlet hivatkozásokat és információs tulajdonságokat tartalmaz a távoli betűtípusokhoz, de a tényleges adatok továbbra is távoliak. A Távoli betűtípusok DirectWrite-támogatása lehetővé teszi, hogy a betűtípuskészletben megmaradjon a betűlapra mutató hivatkozás, és hogy ki legyen jelölve egy betűtípus elrendezésben és renderelésben való használatra, de a tényleges adatok csak akkor töltődnek le, ha ténylegesen szükség van rá, például a szövegelrendezés végrehajtására.  

Az alkalmazások első lépésként kérhetik, hogy a DirectWrite töltse le a betűtípusadatokat, majd várjon a sikeres letöltés megerősítésére, mielőtt megkezdődhet a betűtípussal végzett feldolgozás. A hálózati letöltés azonban kiszámíthatatlan időtartamú késést jelez, és a sikeresség is bizonytalan. Emiatt általában jobb, ha más megközelítést alkalmazunk, lehetővé téve az elrendezést és a renderelést kezdetben a már helyi alternatív vagy tartalék betűtípusok használatával, miközben a kívánt távoli betűtípus letöltését kérjük párhuzamosan, majd a kívánt betűtípus letöltése után frissítjük az eredményeket. 

A teljes betűtípus letöltésének igényléséhez a IDWriteFontFaceReference::EnqueueFontDownloadRequest metódus használható. Ha a betűtípus nagyon nagy, előfordulhat, hogy az adatoknak csak egy része szükséges bizonyos sztringek feldolgozásához. A DirectWrite további módszerekkel kérheti le az adott tartalomhoz szükséges betűtípus-adatok egy részét, EnqueueCharacterDownloadRequest és EnqueueGlyphDownloadRequest.  

Tegyük fel, hogy az alkalmazásban az a módszer, hogy lehetővé teszi a feldolgozást kezdetben helyi, alternatív vagy tartalék betűtípusok használatával. A IDWriteFontFallback::MapCharacters metódus használható a helyi tartalék betűtípusok azonosítására, és automatikusan kérést küld az előnyben részesített betűtípus letöltésére. Ha IDWriteTextLayout van használatban, és az elrendezésben lévő szöveg egy része vagy egésze távoli betűtípus-hivatkozással van formázva, akkor a DirectWrite automatikusan a MapCharacters metódust használja a helyi tartalék betűtípusok lekéréséhez és a távoli betűtípusadatok letöltésére vonatkozó kérés létrehozásához. 

A DirectWrite minden egyes gyárhoz egy betűtípus-letöltési várólistát tart fenn, és a fent említett módszerekkel végrehajtott kérések hozzá lesznek adva az üzenetsorhoz. A betűtípus-letöltési üzenetsor az IDWriteFactory3::GetFontDownloadQueue metódussal kérhető le. 

Ha letöltési kérelem érkezik, de a betűtípus adatai már helyiek, ez egy no-operedményez: Semmi nem lesz hozzáadva a letöltési üzenetsorhoz. Az alkalmazások az IDWriteFontDownloadQueue::IsEmptymetódusmeghívásával ellenőrizhetik, hogy az üzenetsor üres-e, vagy függőben lévő letöltési kérelmek vannak-e. 

Miután a távoli betűkészlet-kérelmeket hozzáadták az üzenetsorhoz, a letöltési folyamatot meg kell indítani. Ha távoli betűtípusokat használ IDWriteTextLayout, a letöltés automatikusan elindul, amikor az alkalmazás meghívja IDWriteTextLayout elrendezési vagy renderelési műveleteket kényszerítő metódusokat, például a GetLineMetrics vagy a Rajz metódust. Más esetekben az alkalmazásnak közvetlenül kell elindítania a letöltést IDWriteFontDownloadQueue::BeginDownloadmeghívásával.  

A letöltés befejezésekor az alkalmazásnak kell elvégeznie a megfelelő műveleteket – a függőben lévő műveletek elvégzését, vagy az eredetileg tartalék betűtípusokkal végrehajtott műveletek ismétlését. (Ha a DirectWrite szövegelrendezését használja, akkor IDWriteTextLayout3::InvalidateLayout használható a tartalék betűtípusokkal kiszámított ideiglenes eredmények törlésére.) Annak érdekében, hogy az alkalmazás értesítést kapjon a letöltési folyamat befejezéséről és a megfelelő műveletek elvégzéséről, az alkalmazásnak biztosítania kell az IDWriteFontDownloadListener felületének implementálását, és ezt továbbítania kell a BeginDownload hívásba. 

A DirectWrite betűtípus-letöltési üzenetsorával és az IDWriteFontDownloadListener felületével folytatott interakciók minta implementációi a DirectWrite egyéni betűtípuskészletek minta, valamint a DirectWrite letölthető betűtípusok mintájában. 

Egyéni betűtípuskészlet létrehozása a memóriába betöltött betűtípusadatokkal

Ahogyan a betűtípusfájlokból származó adatok olvasásának alacsony szintű műveletei eltérnek a helyi lemezen lévő fájlok és a távoli webes fájlok esetében, ugyanez igaz a memóriapufferbe betöltött betűtípus-adatokra is. A Windows 10 Creators Update IDWriteInMemoryFontFileLoaderúj, alacsony szintű felület lett hozzáadva a memóriabeli betűtípusadatok kezeléséhez. 

A távoli betűtípusfájl-betöltőkhez hasonlóan a memóriában lévő betűtípusfájl-betöltőt is először regisztrálni kell egy DirectWrite-gyárban. A betöltőt az alkalmazásnak kell tartania mindaddig, amíg a hozzá társított betűtípusok használatban vannak. Miután a betűtípusok már nem használhatók, és valamikor a gyár megsemmisítése előtt a rakodót regisztráció nélkül kell regisztrálni. Ez a rakodóobjektumot birtoklő osztály destruktorában végezhető el. Ezek a lépések az alábbiakban láthatók. 

Ha az alkalmazás külön információval rendelkezik az adatok által képviselt betűtípus-arcokról, egyéni betűtípus-archivatkozásokat adhat hozzá egy egyéni tulajdonságokat tartalmazó betűtípuskészlet-szerkesztőhöz. Mivel a betűtípusadatok helyi memóriában találhatóak, ez azonban nem kötelező; A DirectWrite képes lesz közvetlenül beolvasni az adatokat a tulajdonságértékek származtatásához. 

A DirectWrite feltételezi, hogy a betűtípusadatok nyers, OpenType formátumúak, egy OpenType-fájlnak (.ttf, .otf, .ttc, .otc) felel meg, de a memóriában nem lemezen. Az adatok nem lehetnek WOFF vagy WOFF2 tárolóformátumban. Az adatok egy OpenType betűtípusgyűjteményt jelölhetnek. Ha nem használ egyéni tulajdonságokat, akkor az IDWriteFontSetBuilder1::AddFontFile metódussal egyetlen hívásban adhat hozzá minden betűarcot az adatokhoz. 

A memórián belüli forgatókönyv egyik fontos szempontja az adatok élettartama. Ha a DirectWrite a pufferre mutató mutatót ad meg anélkül, hogy egyértelmű jelzést ad arról, hogy van tulajdonos, akkor a DirectWrite másolatot készít az adatokról egy új memóriapufferbe, amely a tulajdonában lesz. Az adatok másolásának és a memória további lefoglalásának elkerülése érdekében az alkalmazás átadhat egy adattulajdonos objektumot, amely megvalósítja az IUnknown objektumot, és amely a betűtípusadatokat tartalmazó memóriapuffer tulajdonosa. Ennek az interfésznek a implementálásával a DirectWrite hozzá tud adni az objektum hiv-számához, ezáltal biztosítva a saját adatok élettartamát. 

Az egyéni betűtípuskészletek memóriabeli betűtípusadatokkal való létrehozásának módja a következő; ehhez a Windows 10 Alkotók frissítése szükséges. Ez egy alkalmazás által implementált adattulajdonosi objektumot feltételez, amely implementálja az IUnknown objektumot, és olyan metódusokkal is rendelkezik, amelyek mutatót adnak vissza a memóriapufferhez és a puffer méretéhez. 

1. Hozzon létre egy IDWriteFactory5 felületet a fent látható módon. 2. Hozzon létre egy [**IDWriteFontSetBuilder1**](/windows/win32/api/dwrite_3/nn-dwrite_3-idwritefontsetbuilder1) felületet a fent látható módon. 3. Használja a gyárat egy IDWriteInMemoryFontFileLoader beszerzéséhez. 

 IDWriteInMemoryFontFileLoader* pInMemoryFontFileLoader; 
if (SUCCEEDED(hr)) 
{ 
    hr = pDWriteFactory->CreateInMemoryFontFileLoader(&pInMemoryFontFileLoader); 
}

Ez a memóriabeli betűtípus-betöltő felület rendszer által biztosított implementációját adja vissza. 
4. Regisztrálja a memóriában lévő betűtípusfájl-betöltőt a gyárban. 

if (SUCCEEDED(hr)) 
{ 
    hr = pDWriteFactory->RegisterFontFileLoader(pInMemoryFontFileLoader); 
}

 
5. Minden memóriabeli betűtípusfájlhoz használja a memóriában lévő betűtípusfájl-betöltőt egy IDWriteFontFilelétrehozásához. 

IDWriteFontFile* pFontFile; 
hr = pInMemoryFontFileLoader->CreateInMemoryFontFileReference( 
    pDWriteFactory, 
    pFontDataOwner->fontData /* returns void* */, 
    pFontDataOwner->fontDataSize /* returns UINT32 */, 
    pFontDataOwner /* ownerObject, owns the memory with font data and implements IUnknown */, 
    &pFontFile 
); 

 
6. Adja hozzá az IDWriteFontFile objektumot a betűkészlet-szerkesztőhöz a AddFontFile metódussal, ahogyan az fent látható.  Ha szükség van rá, az alkalmazás ehelyett létrehozhat egyéni IDWriteFontFaceReference objektumokat az IDWriteFontFilealapján, opcionálisan egyéni tulajdonságokat határozhat meg az egyes betűtípus-archivatkozásokhoz, majd a fent látható AddFontFaceReference metódussal egyéni tulajdonságokkal rendelkező betűtípus-referenciát adhat hozzá a betűtípuskészlethez. 
7. Miután az összes betűtípus hozzá lett adva a betűkészlet-szerkesztőhöz, hozza létre az egyéni betűtípuskészletet a fent látható módon. 
8. Amikor a memóriabeli betűtípusok már nem lesznek használatban, törölje a memóriabeli betűtípus-betöltő regisztrációját. 

hr = pDWriteFactory->UnregisterFontFileLoader(pInMemoryFontFileLoader);

Speciális forgatókönyvek

Egyes alkalmazások speciális követelményekkel rendelkezhetnek, amelyek a fent leírtaknál fejlettebb feldolgozást igényelnek. 

Betűkészletek kombinálása

Előfordulhat, hogy egyes alkalmazásoknak olyan betűtípuskészletet kell létrehozniuk, amely más betűtípuskészletek elemeinek bizonyos kombinációjából áll. Előfordulhat például, hogy egy alkalmazás olyan betűtípuskészletet szeretne létrehozni, amely a rendszeren telepített összes betűtípust egyesíti az egyéni betűtípusok kiválasztásával, vagy egyesít bizonyos feltételeknek megfelelő telepített betűtípusokat más betűtípusokkal. A DirectWrite API-kkal támogatja a betűtípuskészletek kezelését és kombinálását. 

Két vagy több betűtípuskészlet kombinálásához az IDWriteFontSetBuilder::AddFontSet metódus hozzáadja az adott betűtípuskészlet összes betűtípusát, amelyet egyetlen hívásban adhat hozzá egy betűkészlet-szerkesztőhöz. Ha az új betűtípuskészletben csak bizonyos betűtípusokat szeretne használni, az IDWriteFontSet::GetMatchingFonts metódussal olyan új betűtípuskészlet-objektum származtatható, amely szűrve lett, és csak a megadott tulajdonságoknak megfelelő betűtípusokat tartalmazza. Ezekkel a módszerekkel egyszerűen létrehozhat egy egyéni betűtípuskészletet, amely két vagy több meglévő betűtípuskészletből kombinálja a betűtípusokat

Helyi WOFF vagy WOFF2 betűtípusadatok használata

Ha egy alkalmazás betűtípusfájlokat tartalmaz a helyi fájlrendszerben vagy egy memóriapufferben, de WOFF vagy WOFF2 tárolóformátumot használ, a DirectWrite (Windows 10 Creator Update vagy újabb) metódust biztosít a tárolóformátum kicsomagolásához, IDWriteFactory5::UnpackFontFile, amely egy IDWriteFontFileStreamad vissza. 

Az alkalmazásnak azonban módot kell adnia arra, hogy az IDWriteFontFileStream beolvassa egy betűtípusfájl-betöltő objektumba. Ennek egyik módja egy egyéni IDWriteFontFileLoader implementáció létrehozása, amely a streamet burkolja. A többi betűtípusfájl-betöltőhöz hasonlóan ezt is használat előtt regisztrálni kell, és nem kell regisztrálnia, mielőtt a gyár kiesik a hatókörből.  

Ha az egyéni betöltőt nyers (nem csomagolt) betűtípusfájlokkal is használni fogja, akkor az alkalmazásnak az IDWriteFontFileStream felületének egyéni implementációját is biztosítania kell a fájlok kezeléséhez. A nyers betűtípusfájlok kezelésére azonban a fentiekben tárgyalt API-k egyszerűbben használhatók. Az egyéni streamek implementálásának szükségességét elkerülheti, ha külön kódútvonalakat használ a csomagolt betűtípusfájlokhoz és a nyers betűtípusfájlokhoz. 

Az egyéni betűtípusfájl-betöltő objektum létrehozása után a rendszer alkalmazásspecifikus módon hozzáadja a betöltőhöz a csomagolt betűtípusfájl adatait. A betöltő több betűtípusfájlt is képes kezelni, amelyek mindegyike egy, a DirectWrite számára átlátszatlan alkalmazásalapú kulccsal van azonosítva. Miután hozzáadott egy csomagolt betűtípusfájlt a betöltőhöz, a rendszer az IDWriteFactory::CreateCustomFontFileReference metódust használja egy IDWriteFontFile lekéréséhez az adott kulcs által azonosított betűtípusadatok betöltője alapján.  

A betűtípusadatok tényleges kicsomagolása elvégezhető a betöltőhöz hozzáadott betűtípusokkal, de kezelhető az IDWriteFontFileLoader::CreateStreamFromKey metódusban is, amelyet a DirectWrite meghív, amikor először be kell olvasnia a betűtípusadatokat. 

Miután létrehozott egy IDWriteFontFile objektumot, a betűtípusok egyéni betűtípuskészlethez való hozzáadásának további lépései a fent leírtak szerint lesznek bemutatva. 

Az ezt a megközelítést használó implementációt a DirectWrite egyéni betűtípuskészletek mintaszemlélteti. 

A DirectWrite távoli betűtípus-mechanizmusainak használata egyéni, alacsony szintű hálózati implementációval

A Távoli betűtípusok kezelésére szolgáló DirectWrite-mechanizmusok magasabb szintű mechanizmusokra oszthatók – olyan betűtípuskészletekkel, amelyek a távoli betűtípusokra mutató betűtípus-archivatkozásokat, a betűtípusadatok helyének ellenőrzését és a betűtípusletöltési kérelmek várólistájának kezelését tartalmazzák – és a tényleges letöltést kezelő alsó szintű mechanizmusokra. Egyes alkalmazások használhatják a magasabb szintű távoli betűtípus-mechanizmusokat, de egyéni hálózati interakciókat is igényelhetnek, például a http protokollon kívüli protokollokat használó kiszolgálókkal való kommunikációt. 

Ebben a helyzetben az alkalmazásnak létre kell hoznia az IDWriteRemoteFontFileLoader interfész egyéni implementációját, amely a szükséges módokon kommunikál más alacsonyabb szintű felületekkel. Az alkalmazásnak ezen alacsonyabb szintű felületek egyéni implementációit is biztosítania kell: IDWriteRemoteFontFileStreamés IDWriteAsyncResult. Ez a három felület visszahívási metódusokkal rendelkezik, amelyeket a DirectWrite a letöltési műveletek során hív meg. 

Ha IDWriteFontDownloadQueue::BeginDownload meghívja, a DirectWrite lekérdezéseket küld a távoli betűkészletfájl betöltőjének az adatok helyéről, és a távoli streamet kéri. Ha az adatok nem helyiek, akkor meghívja a stream BeginDownload metódusát. A stream implementációjának nem szabad blokkolnia a hívást, hanem azonnal vissza kell térnie, és vissza kell adnia egy IDWriteAsyncResult objektumot, amely a DirectWrite várakozási leíróját használja az aszinkron letöltési műveletre való várakozáshoz. Az egyéni stream implementációja felelős a távoli kommunikáció kezeléséért. A befejezési esemény bekövetkezésekor a DirectWrite meghívja IDWriteAsyncResult::GetResult a művelet eredményének meghatározásához. Ha az eredmény sikeres, akkor várható, hogy a letöltött tartományok streambe irányuló későbbi ReadFragment-hívásai sikeresek lesznek. 

Korábbi Windows-verziók támogatási forgatókönyvei

A leírt forgatókönyvek támogatottak a DirectWrite-ban a Windows korábbi verzióiban, de sokkal egyénibb implementációt igényelne az alkalmazás részéről a Windows 10 előtt elérhető korlátozottabb API-k használatával. További információ: Egyéni betűtípusgyűjtemények (Windows 7/8).