Memperkenalkan DirectWrite

Orang berkomunikasi dengan teks sepanjang waktu dalam kehidupan sehari-hari mereka. Ini adalah cara utama bagi orang untuk mengonsumsi volume informasi yang meningkat. Di masa lalu, dulunya melalui konten cetak, terutama dokumen, koran, buku, dan sebagainya. Semakin banyak, ini adalah konten online pada PC Windows mereka. Pengguna Windows yang khas menghabiskan banyak waktu membaca dari layar komputer mereka. Mereka mungkin berselancar di Web, memindai email, membuat laporan, mengisi spreadsheet, atau menulis perangkat lunak, tetapi apa yang mereka lakukan adalah membaca. Meskipun teks dan font meresap hampir setiap bagian dari pengalaman pengguna di Windows, bagi sebagian besar pengguna, membaca di layar tidak menyenangkan seperti membaca output cetak.

Bagi pengembang aplikasi Windows, menulis kode penanganan teks adalah tantangan karena peningkatan persyaratan untuk keterbacaan yang lebih baik, pemformatan canggih dan kontrol tata letak, dan dukungan untuk beberapa bahasa yang harus ditampilkan aplikasi. Bahkan sistem penanganan teks paling dasar harus memungkinkan input teks, tata letak, tampilan, pengeditan, dan penyalinan dan tempelan. Pengguna Windows biasanya mengharapkan lebih dari fitur dasar ini, bahkan mengharuskan editor sederhana untuk mendukung beberapa font, berbagai gaya paragraf, gambar yang disematkan, pemeriksaan ejaan, dan fitur lainnya. Desain UI modern juga tidak lagi terbatas pada format tunggal, teks biasa, tetapi perlu menyajikan pengalaman yang lebih baik dengan font dan tata letak teks yang kaya.

Ini adalah pengenalan tentang bagaimana DirectWrite memungkinkan aplikasi Windows untuk meningkatkan pengalaman teks untuk UI dan dokumen.

Meningkatkan Pengalaman Teks

Aplikasi Windows modern memiliki persyaratan canggih untuk teks di UI dan dokumen mereka. Ini termasuk keterbacaan yang lebih baik, dukungan untuk berbagai bahasa dan skrip, dan performa penyajian yang unggul. Selain itu, sebagian besar aplikasi yang ada memerlukan cara untuk meneruskan investasi yang ada di basis kode WindowsWin32.

DirectWrite menyediakan tiga fitur berikut yang memungkinkan pengembang aplikasi Windows meningkatkan pengalaman teks dalam aplikasi mereka: independensi dari sistem penyajian, tipografi berkualitas tinggi, dan beberapa lapisan fungsionalitas.

Rendering-System Kemerdekaan

DirectWrite independen dari teknologi grafis tertentu. Aplikasi bebas menggunakan teknologi penyajian yang paling sesuai dengan kebutuhan mereka. Ini memberi aplikasi fleksibilitas untuk terus merender beberapa bagian aplikasi mereka melalui GDI dan bagian lain melalui Direct3D atau Direct2D. Faktanya, sebuah aplikasi dapat memilih untuk menampilkan DirectWrite melalui tumpukan penyajian khusus.

High-Quality Tipografi

DirectWrite memanfaatkan kemajuan teknologi Font OpenType untuk memungkinkan tipografi berkualitas tinggi dalam aplikasi Windows. Sistem font DirectWrite menyediakan layanan untuk menangani enumerasi font, pemulihan font, dan penyimpanan dalam cache font, yang semuanya diperlukan oleh aplikasi untuk menangani font.

Dukungan OpenType yang disediakan oleh DirectWrite memungkinkan pengembang untuk menambahkan ke fitur dan dukungan tipografi tingkat lanjut aplikasi mereka untuk teks internasional.

Dukungan untuk Fitur Tipografi Tingkat Lanjut

DirectWrite memungkinkan pengembang aplikasi membuka kunci fitur font OpenType yang tidak dapat mereka gunakan di WinForms atau GDI. ObjekDirectWriteIDWriteTypography menampilkan banyak fungsi canggih font OpenType, seperti alternasi gaya dan swash. Microsoft Windows Software Development Kit (SDK) menyediakan serangkaian sampel Font OpenType yang dirancang dengan fitur kaya, seperti font Pericles dan Pescadero. Untuk detail selengkapnya tentang fitur OpenType, lihat Fitur Font OpenType.

Dukungan untuk Teks Internasional

DirectWrite menggunakan font OpenType untuk mengaktifkan dukungan luas untuk teks internasional. Fitur Unicode seperti pengganti, BIDI, pemisah baris, dan UVS didukung. Itemisasi skrip yang dipandu bahasa, penggantian angka, dan pembentukan glyph memastikan bahwa teks dalam skrip apa pun memiliki tata letak dan penyajian yang benar.

Skrip berikut saat ini didukung:

• Arab
• Orang Armenia / Bahasa Armenia
• Bengala
• Bopomofo
• Braille*
• Sistem Suku Kata Aborigin Kanada
• Cherokee
• Tionghoa (Sederhana & Tradisional)
• Sirilik
• Koptik*
• Devanagari
• Etiopik
• Georgian
• Glagolitik*
• Yunani
• Gujarat
• Gurmukhi
• Ibrani
• Jepang
• Kannada
• Khmer
• Korea
• Bahasa Laos
• Bahasa latin
• Malayalam
• Mongolia
• Myanmar
• Tai Lue Baru
• Ogham*
• Odia
• 'Phags-pa
• Runic*
• Sinhala
• Bahasa Suryani
• Tai Le
• Tamil
• Telugu
• Thaana
• Thai
• Tibet
• Yi

Beberapa Lapisan Fungsionalitas

DirectWrite menyediakan lapisan fungsionalitas yang diperhitungkan, dengan setiap lapisan berinteraksi dengan mulus dengan yang berikutnya. Desain API memberi pengembang aplikasi kebebasan dan fleksibilitas untuk mengadopsi lapisan individu tergantung pada kebutuhan dan jadwal mereka. Diagram berikut menunjukkan hubungan antara lapisan-lapisan ini.

API tata letak teks menyediakan fungsionalitas tingkat tertinggi yang tersedia dari DirectWrite. Ini menyediakan layanan bagi aplikasi untuk mengukur, menampilkan, dan berinteraksi dengan string teks yang diformat dengan kaya. API teks ini dapat digunakan dalam aplikasi yang saat ini menggunakan DrawText Win32 untuk membangun UI modern dengan teks yang berformat kaya.

Aplikasi intensif teks yang mengimplementasikan mesin tata letak mereka sendiri dapat menggunakan lapisan berikutnya ke bawah: prosesor skrip. Prosesor skrip memecah potongan teks menjadi blok skrip dan menangani pemetaan antara representasi Unicode ke representasi glyph yang sesuai dalam font sehingga teks skrip dapat ditampilkan dengan benar dalam bahasa yang benar. Sistem tata letak yang digunakan oleh lapisan API tata letak teks dibangun di atas font dan sistem pemrosesan skrip.

Lapisan penyajian glyph adalah lapisan fungsionalitas terendah dan menyediakan fungsionalitas penyajian glyph untuk aplikasi yang mengimplementasikan mesin tata letak teks mereka sendiri. Lapisan penyajian glyph juga berguna untuk aplikasi yang mengimplementasikan perender kustom untuk memodifikasi perilaku gambar glyph melalui fungsi panggilan balik di DirectWrite API pemformatan teks.

Sistem font DirectWrite tersedia untuk semua lapisan fungsional DirectWrite dan memungkinkan aplikasi mengakses informasi font dan glyph. Ini dirancang untuk menangani teknologi font umum dan format data. Model font DirectWrite mengikuti praktik tipografi umum untuk mendukung sejumlah bobot, gaya, dan peregangan dalam keluarga font yang sama. Model ini, model yang sama diikuti oleh WPF dan CSS, menentukan bahwa font yang hanya berbeda dalam berat (tebal, tipis, dan sebagainya), gaya huruf (tegak, miring, atau oblique), atau lebar (sempit, ringkas, lebar, dan sebagainya) dianggap sebagai anggota keluarga jenis huruf yang sama.

Penyajian Teks yang Disempurnakan dengan ClearType

Meningkatkan keterbacaan pada layar adalah persyaratan utama untuk semua aplikasi Windows. Bukti dari penelitian dalam psikologi kognitif menunjukkan bahwa kita harus dapat mengenali setiap huruf secara akurat dan bahwa bahkan penspasian antar huruf sangat penting untuk pemrosesan cepat. Huruf dan kata-kata yang tidak simetris dianggap jelek dan menurunkan pengalaman membaca. Kevin Larson, grup Microsoft Advanced Reading Technologies, menulis artikel tentang subjek yang diterbitkan dalam Spectrum IEEE. Artikel ini disebut "Teknologi Teks".

Teks dalam DirectWrite dirender menggunakan Microsoft ClearType, yang meningkatkan kejelasan dan keterbacaan teks. ClearType memanfaatkan fakta bahwa tampilan LCD modern memiliki garis RGB untuk setiap piksel yang dapat dikontrol satu per satu. DirectWrite menggunakan penyempurnaan terbaru untuk ClearType, pertama-tama disertakan dengan Windows Vista dengan Windows Presentation Foundation, yang memungkinkannya untuk mengevaluasi tidak hanya huruf individual tetapi juga penspasian antar huruf. Sebelum penyempurnaan ClearType ini, teks dengan ukuran "membaca" 10 atau 12 poin sulit ditampilkan: kita dapat menempatkan 1 piksel di antara huruf, yang sering terlalu sedikit, atau 2 piksel, yang seringkali terlalu banyak. Menggunakan resolusi ekstra dalam subpiksel memberi kita jarak pecahan, yang meningkatkan keseragaman dan simetri seluruh halaman.

Dua ilustrasi ini menunjukkan bagaimana glyph dapat dimulai pada batas mana saja dalam sub-piksel ketika posisi sub-piksel digunakan.

Ilustrasi berikut dirender menggunakan versi GDI dari perender ClearType, yang tidak menggunakan posisi sub-piksel.

Ilustrasi berikut dirender menggunakan versi DirectWrite perender ClearType, yang menggunakan posisi sub-piksel.

Perhatikan bahwa jarak antara huruf h dan n lebih merata di gambar kedua, dan huruf o dipisahkan lebih jauh dari huruf n, lebih sejajar dengan huruf l. Perhatikan juga bagaimana batang pada huruf l lebih terlihat alami.

Penempatan ClearType subpiksel menawarkan penspasian karakter yang paling akurat di layar, terutama pada ukuran kecil di mana perbedaan antara sub-piksel dan seluruh piksel mewakili proporsi lebar karakter yang signifikan. Ini memungkinkan teks diukur dalam ruang resolusi ideal dan dirender pada posisi alaminya di garis warna LCD, dengan granularitas subpiksel. Teks yang diukur dan dirender menggunakan teknologi ini adalah, berdasarkan definisi, independen resolusi, yang berarti bahwa tata letak teks yang sama persis dicapai di berbagai resolusi tampilan.

Tidak seperti kedua jenis rendering GDI ClearType, sub-piksel ClearType menawarkan lebar karakter yang paling akurat.

API Teks String mengadopsi penyajian teks sub-piksel secara default, yang berarti mengukur teks pada resolusi idealnya terlepas dari resolusi tampilan saat ini, dan menghasilkan hasil penempatan glyph berdasarkan lebar maju glyph yang telah benar-benar diskalakan dan memosisikan offset.

Untuk teks berukuran besar, DirectWrite juga memungkinkan anti-aliasing di sepanjang sumbu vertikal untuk membuat tepi lebih halus dan merender huruf sesuai dengan yang diinginkan perancang font. Ilustrasi berikut menunjukkan anti-alias arah y.

Meskipun DirectWrite teks diposisikan dan dirender menggunakan sub-piksel ClearType secara default, pilihan rendering lain juga tersedia. Banyak aplikasi yang ada menggunakan GDI untuk merender sebagian besar UI mereka, dan beberapa aplikasi menggunakan kontrol pengeditan sistem yang terus menggunakan GDI untuk penyajian teks. Saat menambahkan teks DirectWrite ke aplikasi ini, mungkin perlu untuk mengorbankan peningkatan pengalaman membaca yang disediakan oleh ClearType sub-piksel sehingga teks memiliki tampilan yang konsisten di seluruh aplikasi.

Untuk memenuhi persyaratan ini, DirectWrite juga mendukung opsi penyajian berikut:

• ClearType sub-pixel (bawaan).
• Sub-piksel ClearType dengan anti-aliasing dalam dimensi horizontal dan vertikal.
• Teks beralias
• Lebar alami GDI (digunakan oleh Tampilan Baca Microsoft Word, misalnya).
• Lebar yang kompatibel dengan GDI (termasuk bitmap tertanam Asia Timur).

Masing-masing mode penyajian ini dapat disempurnakan melalui API DirectWrite dan melalui tuner ClearType kotak masuk Windows 7 baru.

Dukungan untuk Tata Letak Alami

Tata letak alami independen resolusi, sehingga penspasian karakter tidak berubah saat Anda memperbesar atau memperkecil, atau tergantung pada DPI tampilan. Keuntungan sekunder adalah bahwa penspasian sesuai dengan desain font. Tata letak alami dimungkinkan oleh dukungan DirectWrite untuk penyajian alami, yang berarti setiap glyph dapat diposisikan ke sebagian kecil piksel.

Meskipun tata letak alami adalah default, beberapa aplikasi perlu merender teks dengan penspasian dan tampilan yang sama dengan GDI. Untuk aplikasi tersebut, DirectWrite menyediakan mode pengukuran GDI klasik dan GDI alami serta mode penyajian yang terkait.

Salah satu mode penyajian di atas dapat dikombinasikan dengan salah satu dari dua mode antialias: ClearType atau skala abu-abu. ClearType antialiasing mensimulasikan resolusi yang lebih tinggi dengan memanipulasi nilai warna merah, hijau, dan biru secara individual dari setiap piksel. Antialias skala abu-abu hanya menghitung satu nilai cakupan (atau alfa) untuk setiap piksel. ClearType adalah default, tetapi antialias skala abu-abu direkomendasikan untuk aplikasi Windows Store karena lebih cepat dan kompatibel dengan antialias standar, sementara masih sangat mudah dibaca.

Gambaran Umum API

AntarmukaIDWriteFactory adalah titik awal untuk menggunakan fungsionalitas DirectWrite. Pabrik adalah objek akar yang membuat sekumpulan objek yang dapat digunakan bersama-sama.

Operasi pemformatan dan tata letak adalah prasyarat untuk operasi tersebut, karena teks perlu diformat dengan tepat dan disusun sesuai dengan serangkaian batasan tertentu sebelum dapat dirender atau diuji interaksi. Dua objek utama yang dapat Anda buat dengan IDWriteFactory untuk tujuan ini adalah IDWriteTextFormat dan IDWriteTextLayout. Objek IDWriteTextFormat mewakili informasi pemformatan untuk paragraf teks. Fungsi IDWriteFactory::CreateTextLayout mengambil string input, batasan terkait seperti dimensi ruang yang akan diisi, dan objek IDWriteTextFormat, dan menempatkan hasil yang dianalisis dan diformat sepenuhnya ke IDWriteTextLayout untuk digunakan dalam operasi berikutnya.

Aplikasi kemudian dapat merender teks menggunakan fungsi DrawTextLayout yang disediakan oleh Direct2D atau dengan menerapkan fungsi panggilan balik yang dapat menggunakan GDI, Direct2D, atau sistem grafis lainnya untuk merender glyph. Untuk teks format tunggal, fungsiDrawTextdi Direct2D menyediakan cara yang lebih sederhana untuk menggambar teks tanpa harus terlebih dahulu membuat objekIDWriteTextLayout.

Memformat dan Menggambar "Halo Dunia" Menggunakan DirectWrite

Contoh kode berikut menunjukkan bagaimana aplikasi dapat memformat satu paragraf menggunakanIDWriteTextFormat dan menggambarnya menggunakan fungsiDirect2DDrawText.

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

Mengakses Sistem Font

Selain menentukan nama keluarga font untuk string teks dengan menggunakan antarmuka IDWriteTextFormat dalam contoh di atas, DirectWrite menyediakan kontrol lebih besar aplikasi atas pemilihan font melalui enumerasi font dan kemampuan untuk membuat koleksi font kustom berdasarkan font dokumen yang disematkan.

ObjekIDWriteFontCollection adalah kumpulan keluarga font. DirectWrite menyediakan akses ke set font yang diinstal pada sistem melalui koleksi font khusus yang disebut koleksi font sistem. Ini diperoleh dengan memanggil metodeGetSystemFontCollection dari objek IDWriteFactory. Aplikasi juga dapat membuat koleksi font kustom dari sekumpulan font yang dijumlahkan oleh panggilan balik yang ditentukan aplikasi, yaitu font privat yang diinstal oleh aplikasi, atau font yang disematkan dalam dokumen.

Aplikasi kemudian dapat memanggil GetFontFamily untuk masuk ke objek FontFamily tertentu dalam koleksi, lalu memanggil IDWriteFontFamily::GetFirstMatchingFont untuk sampai ke objekIDWriteFont tertentu. Objek IDWriteFont mewakili font dalam koleksi font dan mengekspos properti dan beberapa metrik font dasar.

IDWriteFontFace adalah objek lain yang mewakili font dan mengekspos sekumpulan metrik lengkap pada font. IDWriteFontFace dapat dibuat langsung dari nama font; aplikasi tidak harus mendapatkan koleksi font untuk mengaksesnya. Ini berguna untuk aplikasi tata letak teks seperti Microsoft Word yang perlu mengkueri detail untuk font tertentu.

Diagram berikut mengilustrasikan hubungan antara objek-objek ini.

IDWriteFontFace

ObjekIDWriteFontFace mewakili font dan memberikan informasi lebih rinci tentang font daripada objekIDWriteFont. Metrik font dan glyph dari IDWriteFontFace berguna untuk aplikasi yang menerapkan tata letak teks.

Sebagian besar aplikasi mainstream tidak akan menggunakan API ini secara langsung, dan sebaliknya akan menggunakanIDWriteFontatau menentukan nama keluarga font secara langsung.

Tabel berikut ini meringkas skenario penggunaan untuk dua objek tersebut.

Berikut ini adalah contoh aplikasi yang menghitung font dalam koleksi font sistem.

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

Penyajian teks

API penyajian teks memungkinkan glyph dalam font DirectWrite untuk dirender ke permukaan Direct2D atau ke bitmap independen perangkat GDI, atau untuk dikonversi ke kerangka atau bitmap. Penyajian ClearType di DirectWrite mendukung posisi sub-piksel dengan peningkatan ketajaman dan kontras dibandingkan dengan implementasi sebelumnya di Windows. DirectWrite juga mendukung teks hitam-putih beraliase untuk mendukung skenario yang melibatkan font Asia Timur dengan bitmap yang disematkan atau ketika pengguna menonaktifkan penghalusan font.

Semua opsi dapat disesuaikan oleh semua kenop ClearType yang tersedia yang dapat diakses melalui DirectWrite API, dan juga diekspos melalui applet panel kontrol tuner ClearType Windows 7 yang baru.

Ada dua API yang tersedia untuk merender glyph, satu menyediakan rendering yang dipercepat oleh perangkat keras melalui Direct2D dan yang lainnya menyediakan rendering perangkat lunak ke bitmap GDI. Aplikasi yang menggunakan IDWriteTextLayout dan menerapkan panggilan balikIDWriteTextRendererdapat memanggil salah satu fungsi ini sebagai respons terhadap panggilan balik DrawGlyphRun. Selain itu, aplikasi yang menerapkan tata letak mereka sendiri atau menangani data tingkat glyph dapat menggunakan API ini.

1. ID2DRenderTarget::DrawGlyphRun

   Aplikasi dapat menggunakan Direct2D API DrawGlyphRun untuk menyediakan akselerasi perangkat keras untuk penyajian teks menggunakan GPU. Akselerasi perangkat keras memengaruhi semua fase alur penyajian teks—dari menggabungkan glyph ke dalam jalur glyph dan memfilter bitmap hasil jalur glyph, hingga menerapkan algoritma blending ClearType ke output akhir yang ditampilkan. Ini adalah API yang direkomendasikan untuk mendapatkan performa penyajian terbaik.

2. IDWriteBitmapRenderTarget::DrawGlyphRun

   Aplikasi dapat menggunakan metode IDWriteBitmapRenderTarget::DrawGlyphRun untuk melakukan perenderan perangkat lunak dari serangkaian glyph ke bitmap 32-bpp. Objek IDWriteBitmapRenderTarget merangkum bitmap dan konteks perangkat memori yang dapat digunakan untuk merender glyph. API ini berguna jika Anda ingin tetap menggunakan GDI karena Anda memiliki basis kode yang ada yang dirender di GDI.

Jika Anda memiliki aplikasi yang memiliki kode tata letak teks yang sudah ada yang menggunakan GDI, dan Anda ingin mempertahankan kode tata letak yang ada tetapi menggunakan DirectWrite hanya untuk langkah akhir merender glyph, IDWriteGdiInterop::CreateFontFaceFromHdc menyediakan jembatan antara kedua API. Sebelum memanggil fungsi ini, aplikasi akan menggunakan fungsi IDWriteGdiInterop::CreateFontFaceFromHdc untuk mendapatkan referensi font-face dari konteks perangkat.

Mode Penyajian Kustom

Sejumlah parameter memengaruhi penyajian teks, seperti gamma, tingkat ClearType, geometri piksel, dan kontras yang ditingkatkan. Parameter rendering dienkapsulasi oleh suatu objek, yang mengimplementasikan antarmuka IDWriteRenderingParams publik. Objek parameter penyajian secara otomatis diinisialisasi berdasarkan properti perangkat keras dan/atau preferensi pengguna yang ditentukan melalui applet panel kontrol ClearType di Windows 7. Umumnya, jika klien menggunakan DirectWrite layout API, DirectWrite akan secara otomatis memilih mode penyajian yang sesuai dengan mode ukur yang ditentukan.

Aplikasi yang menginginkan lebih banyak kontrol dapat menggunakan IDWriteFactory::CreateCustomRenderingParams untuk mengimplementasikan berbagai opsi penyajian. Fungsi ini juga dapat digunakan untuk mengatur gamma, geometri piksel, dan kontras yang ditingkatkan.

Berikut ini adalah berbagai opsi penyajian yang tersedia:

• Sub-piksel anti-alias

  Aplikasi mengatur parameter renderingMode ke DWRITE_RENDERING_MODE_NATURAL untuk menentukan penyajian dengan anti-aliasing hanya dalam dimensi horizontal.

• Sub-piksel anti-aliasing dalam dimensi horizontal dan vertikal.

  Aplikasi mengatur parameter renderingMode ke DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC untuk menentukan rendering dengan anti-aliasing dalam dimensi horizontal dan vertikal. Ini membuat kurva dan garis diagonal terlihat lebih halus dengan mengorbankan beberapa kelembutan, dan biasanya digunakan pada ukuran di atas 16 ppem.

• Teks yang Dialias

  Aplikasi mengatur parameter renderingMode ke DWRITE_RENDERING_MODE_ALIASED untuk menentukan teks teralias.

• Teks Grayscale

  Aplikasi mengatur parameter pixelGeometry ke DWRITE_PIXEL_GEOMETRY_FLAT untuk menentukan teks skala abu-abu.

• Lebar cocok GDI (termasuk bitmap tertanam Asia Timur)

  Aplikasi mengatur renderingMode parameter ke DWRITE_RENDERING_MODE_GDI_CLASSIC untuk menentukan anti-aliasing yang kompatibel dengan lebar GDI.

• Lebar alami GDI

  Aplikasi mengatur parameter renderingMode ke DWRITE_RENDERING_MODE_GDI_NATURAL untuk menentukan anti-aliasing yang kompatibel dengan lebar alami GDI.

• Teks kerangka

  Untuk penyajian dalam ukuran besar, pengembang aplikasi mungkin lebih suka merender dengan menggunakan kerangka font daripada dengan melakukan rasterisasi menjadi bitmap. Aplikasi mengatur parameter renderingMode ke DWRITE_RENDERING_MODE_OUTLINE untuk menentukan bahwa penyajian harus melewati rasterizer dan menggunakan kerangka secara langsung.

Interoperabilitas GDI

AntarmukaIDWriteGdiInteropmemberikan interoperabilitas dengan GDI. Ini memungkinkan aplikasi untuk melanjutkan investasi yang ada dalam basis kode GDI dan secara selektif menggunakan DirectWrite untuk penyajian atau tata letak.

Berikut ini adalah API yang memungkinkan aplikasi untuk bermigrasi ke atau dari sistem font GDI:

• CreateFontFromLOGFONT

  Membuat objek IDWriteFont yang cocok dengan properti yang ditentukan oleh struktur LOGFONT.

• ConvertFontToLOGFONT

  Menginisialisasi struktur LOGFONT berdasarkan properti dariIDWriteFontyang kompatibel dengan GDI yang ditentukan.

• ConvertFontFaceToLOGFONT

  Menginisialisasi struktur LOGFONT berdasarkan properti yang kompatibel dengan GDI dari IDWriteFontFace yang ditentukan.

• CreateFontFaceFromHdc

  Membuat objek IDWriteFontFace yang sesuai dengan HFONT yang dipilih saat ini.

Kesimpulan

Meningkatkan pengalaman membaca adalah nilai besar bagi pengguna baik di layar maupun di atas kertas. DirectWrite memberikan kemudahan penggunaan dan model pemrograman berlapis bagi pengembang aplikasi untuk meningkatkan pengalaman teks untuk aplikasi Windows mereka. Aplikasi dapat menggunakan DirectWrite untuk merender teks berformat kaya untuk UI dan dokumen mereka dengan API tata letak. Untuk skenario yang lebih kompleks, aplikasi dapat bekerja langsung dengan glyph, mengakses font, dan sebagainya, dan memanfaatkan kekuatan DirectWrite untuk memberikan tipografi berkualitas tinggi.

Kemampuan interoperabilitas DirectWrite memungkinkan pengembang aplikasi untuk meneruskan basis kode Win32 yang ada dan mengadopsi DirectWrite secara selektif dalam aplikasi mereka.