Introduzione a DirectWrite

Persone comunicare con il testo tutto il tempo nella loro vita quotidiana. È il modo principale per le persone di utilizzare un crescente volume di informazioni. In passato, si usava per essere attraverso contenuti stampati, principalmente documenti, giornali, libri e così via. Sempre più spesso, è contenuto online sul pc Windows. Un utente di Windows tipico impiega molto tempo a leggere dallo schermo del computer. Potrebbero navigare sul Web, scansionare e-mail, comporre un report, compilare un foglio di calcolo o scrivere software, ma quello che stanno realmente facendo è leggere. Anche se il testo e i tipi di carattere permeano quasi ogni parte dell'esperienza utente in Windows, per la maggior parte degli utenti, la lettura sullo schermo non è altrettanto piacevole come la lettura dell'output stampato.

Per gli sviluppatori di applicazioni Windows, la scrittura di codice di gestione del testo è una sfida a causa dei requisiti maggiori per migliorare la leggibilità, la formattazione sofisticata e il controllo del layout e il supporto per più lingue che l'applicazione deve visualizzare. Anche il sistema di gestione del testo più semplice deve consentire input di testo, layout, visualizzazione, modifica e copia e incolla. Gli utenti di Windows in genere si aspettano ancora più di queste funzionalità di base, richiedendo anche semplici editor per supportare più tipi di carattere, vari stili di paragrafo, immagini incorporate, controllo ortografico e altre funzionalità. La progettazione moderna dell'interfaccia utente non è più limitata a un singolo formato, testo normale, ma deve presentare un'esperienza migliore con tipi di carattere e layout di testo avanzati.

Questa è un'introduzione al modo in cui DirectWrite consente alle applicazioni Windows di migliorare l'esperienza testuale per l'interfaccia utente e i documenti.

Miglioramento dell'esperienza testuale

Le applicazioni Windows moderne hanno requisiti sofisticati per il testo nell'interfaccia utente e nei documenti. Questi includono una migliore leggibilità, il supporto per un'ampia gamma di linguaggi e script e prestazioni di rendering superiori. Inoltre, la maggior parte delle applicazioni esistenti richiede un modo per portare avanti gli investimenti esistenti nella codebase di WindowsWin32.

DirectWrite offre le tre funzionalità seguenti che consentono agli sviluppatori di applicazioni Windows di migliorare l'esperienza testuale all'interno delle applicazioni: indipendenza dal sistema di rendering, tipografia di alta qualità e più livelli di funzionalità.

Indipendenza del sistema di rendering

DirectWrite è indipendente da qualsiasi particolare tecnologia grafica. Le applicazioni sono libere di usare la tecnologia di rendering più adatta alle proprie esigenze. Ciò offre alle applicazioni la flessibilità necessaria per continuare a eseguire il rendering di alcune parti dell'applicazione tramite GDI e altre parti tramite Direct3D o Direct2D. Infatti, un'applicazione potrebbe scegliere di eseguire il rendering di DirectWrite tramite uno stack di rendering proprietario.

Tipografia di alta qualità

DirectWrite sfrutta i progressi della tecnologia OpenType Font per abilitare la tipografia di alta qualità all'interno di un'applicazione Windows. Il sistema di tipi di carattere DirectWrite fornisce servizi per gestire l'enumerazione dei tipi di carattere, il fallback dei tipi di carattere e la memorizzazione nella cache dei tipi di carattere, che sono tutti necessari per le applicazioni per la gestione dei tipi di carattere.

Il supporto OpenType fornito da DirectWrite consente agli sviluppatori di aggiungere alle proprie applicazioni funzionalità tipografiche avanzate e supporto per il testo internazionale.

Supporto per funzionalità tipografiche avanzate

DirectWrite consente agli sviluppatori di applicazioni di sbloccare le funzionalità dei tipi di carattere OpenType che non potevano usare in WinForms o GDI. L'oggetto DirectWrite IDWriteTypography espone molte delle funzionalità avanzate dei tipi di carattere OpenType, ad esempio alternative stilistiche e lavaggi. Microsoft Windows Software Development Kit (SDK) fornisce un set di tipi di carattere OpenType di esempio progettati con funzionalità avanzate, ad esempio i tipi di carattere Pericles e Pescadero. Per altre informazioni sulle funzionalità di OpenType, vedere OpenType Font Features.For more details on OpenType features, see OpenType Font Features.

Supporto per il testo internazionale

DirectWrite usa tipi di carattere OpenType per consentire un ampio supporto per il testo internazionale. Sono supportate funzionalità Unicode come surrogati, BIDI, interruzioni di riga e UVS. La creazione di elementi di script guidati dal linguaggio, la sostituzione dei numeri e il data shaping del glifo assicurano che il testo in qualsiasi script abbia il layout e il rendering corretti.

Sono attualmente supportati gli script seguenti:

Nota

Per gli script contrassegnati con *, non sono presenti tipi di carattere di sistema predefiniti. Le applicazioni devono installare tipi di carattere che supportano questi script.

 

• arabo
• Armeno
• Bengala
• Bopomofo
• Braille*
• Aborigeni canadesi sillabici
• Cherokee
• Cinese (semplificato e tradizionale)
• Cirillico
• Copta*
• Devanagari
• Etiope
• Georgiano
• Glagolitico*
• Greco
• Gujarati
• Gurmukhi
• Ebraico
• Giapponese
• Kannada
• Khmer
• Coreano
• Lao
• Latino
• Malayalam
• Mongolo
• Myanmar
• Nuovo Tai Lue
• Ogham*
• Odia
• 'Phags-pa
• Runic*
• Sinhala
• Siriaco
• Tai Le
• Tamil
• Telugu
• Thaana
• Thai
• Tibetano
• Yi

Più livelli di funzionalità

DirectWrite fornisce livelli di funzionalità a fattori, con ogni livello che interagisce perfettamente con il successivo. La progettazione api offre agli sviluppatori di applicazioni la libertà e la flessibilità di adottare singoli livelli in base alle esigenze e alla pianificazione. Il diagramma seguente illustra la relazione tra questi livelli.

L'API layout di testo offre le funzionalità di livello più elevato disponibili in DirectWrite. Fornisce servizi per l'applicazione per misurare, visualizzare e interagire con stringhe di testo formattate in modo avanzato. Questa API di testo può essere usata nelle applicazioni che attualmente usano DrawText di Win32 per creare un'interfaccia utente moderna con testo formattato in modo avanzato.

Le applicazioni a elevato utilizzo di testo che implementano il proprio motore di layout possono usare il livello successivo verso il basso: il processore di script. Il processore di script suddivide un blocco di testo in blocchi di script e gestisce il mapping tra le rappresentazioni Unicode alla rappresentazione glifo appropriata nel tipo di carattere in modo che il testo dello script possa essere visualizzato correttamente nella lingua corretta. Il sistema di layout usato dal livello API layout di testo è basato sul tipo di carattere e sul sistema di elaborazione degli script.

Il livello di rendering del glifo è il livello più basso di funzionalità e offre funzionalità di rendering del glifo per le applicazioni che implementano il proprio motore di layout di testo. Il livello di rendering del glifo è utile anche per le applicazioni che implementano un renderer personalizzato per modificare il comportamento del disegno del glifo tramite la funzione di callback nell'API di formattazione del testo DirectWrite .

Il sistema di tipi di carattere DirectWrite è disponibile per tutti i livelli funzionali DirectWrite e consente a un'applicazione di accedere alle informazioni sul tipo di carattere e sul glifo. È progettato per gestire tecnologie comuni per i tipi di carattere e i formati di dati. Il modello di carattere DirectWrite segue la pratica tipografica comune di supportare un numero qualsiasi di pesi, stili e estensioni nella stessa famiglia di caratteri. Questo modello, lo stesso modello seguito da WPF e CSS, specifica che i tipi di carattere che differiscono solo in peso (grassetto, chiaro e così via), stile (verticale, corsivo o obliquo) o stretch (stretto, condensato, largo e così via) vengono considerati membri di una singola famiglia di caratteri.

Miglioramento del rendering del testo con ClearType

Il miglioramento della leggibilità sullo schermo è un requisito fondamentale per tutte le applicazioni Windows. L'evidenza della ricerca in psicologia cognitiva indica che dobbiamo essere in grado di riconoscere ogni lettera in modo accurato e che anche la spaziatura tra lettere è fondamentale per l'elaborazione rapida. Lettere e parole che non sono simmetriche vengono percepite come brutte e degradano l'esperienza di lettura. Kevin Larson, gruppo Microsoft Advanced Reading Technologies, ha scritto un articolo sull'argomento pubblicato in Spectrum I edizione Enterprise E. L'articolo è chiamato "The Technology of Text".

Il rendering del testo in DirectWrite viene eseguito usando Microsoft ClearType, che migliora la chiarezza e la leggibilità del testo. ClearType sfrutta il fatto che i moderni display LCD abbiano strisce RGB per ogni pixel che può essere controllato singolarmente. DirectWrite usa i miglioramenti più recenti per ClearType, prima incluso in Windows Vista con Windows Presentation Foundation, che consente di valutare non solo le singole lettere, ma anche la spaziatura tra le lettere. Prima di questi miglioramenti di ClearType, il testo con una dimensione di "lettura" di 10 o 12 punti era difficile da visualizzare: potevamo posizionare 1 pixel tra lettere, che spesso era troppo piccolo o 2 pixel, che spesso era troppo grande. L'uso della risoluzione aggiuntiva nei subpixel ci offre una spaziatura frazionaria, che migliora la uniformità e la simmetria dell'intera pagina.

Le due illustrazioni seguenti mostrano come i glifi possono iniziare su qualsiasi limite di sub-pixel quando viene usato il posizionamento di sub-pixel.

Il rendering della figura seguente viene eseguito usando la versione GDI del renderer ClearType, che non ha usato il posizionamento dei sub pixel.

Il rendering seguente viene eseguito usando la versione DirectWrite del renderer ClearType, che usa il posizionamento dei sub pixel.

Si noti che la spaziatura tra le lettere h e n è più uniforme nella seconda immagine e la lettera o è spaziata più lontano dalla lettera n, più ancora con la lettera l. Si noti anche come gli steli sulle lettere l sono più naturali.

Il posizionamento ClearType del subpixel offre la spaziatura più accurata dei caratteri sullo schermo, soprattutto in piccole dimensioni in cui la differenza tra un sotto pixel e un pixel intero rappresenta una percentuale significativa della larghezza del glifo. Consente di misurare il testo nello spazio di risoluzione ideale ed eseguire il rendering alla sua posizione naturale nella striscia di colori LCD, con granularità subpixel. Il testo misurato e sottoposto a rendering usando questa tecnologia è, per definizione, indipendente dalla risoluzione, il che significa che l'esatto layout del testo viene ottenuto nell'intervallo di diverse risoluzioni di visualizzazione.

A differenza di entrambi i tipi di rendering GDI ClearType, ClearType sub-pixel offre la larghezza più accurata dei caratteri.

L'API Stringa di testo adotta il rendering del testo in pixel secondario per impostazione predefinita, il che significa che misura il testo alla risoluzione ideale indipendentemente dalla risoluzione di visualizzazione corrente e produce il risultato di posizionamento del glifo in base alle larghezze avanzate e agli offset di posizionamento del glifo effettivamente ridimensionati.

Per il testo di grandi dimensioni, DirectWrite consente anche l'anti-aliasing lungo l'asse y per rendere i bordi più uniformi ed eseguire il rendering delle lettere come previsto dalla finestra di progettazione dei caratteri. La figura seguente mostra l'anti-aliasing della direzione y.

Sebbene il testo DirectWrite sia posizionato e sottoposto a rendering usando ClearType sub-pixel per impostazione predefinita, sono disponibili altre opzioni di rendering. Molte applicazioni esistenti usano GDI per eseguire il rendering della maggior parte dell'interfaccia utente e alcune applicazioni usano controlli di modifica del sistema che continuano a usare GDI per il rendering del testo. Quando si aggiunge testo DirectWrite a queste applicazioni, potrebbe essere necessario sacrificare i miglioramenti dell'esperienza di lettura forniti da ClearType sub-pixel in modo che il testo abbia un aspetto coerente nell'applicazione.

Per soddisfare questi requisiti, DirectWrite supporta anche le opzioni di rendering seguenti:

• ClearType sub-pixel (impostazione predefinita).
• ClearType in pixel secondario con anti-aliasing in dimensioni orizzontali e verticali.
• Testo con alias.
• Larghezza naturale GDI (usata, ad esempio, dalla visualizzazione di lettura di Microsoft Word).
• Larghezza compatibile GDI (inclusa la bitmap incorporata nell'Asia orientale).

Ognuna di queste modalità di rendering può essere ottimizzata tramite l'API DirectWrite e tramite il nuovo tuner ClearType della posta in arrivo di Windows 7.

Nota

A partire da Windows 8, è consigliabile usare l'anti-aliasing del testo in scala di grigi nella maggior parte dei casi. Per altre informazioni, vedere la sezione seguente.

 

Supporto per il layout naturale

Il layout naturale è indipendente dalla risoluzione, quindi la spaziatura dei caratteri non cambia quando si esegue lo zoom avanti o indietro o a seconda del DPI dello schermo. Un vantaggio secondario è che la spaziatura è vera per la progettazione del tipo di carattere. Il layout naturale è reso possibile dal supporto di DirectWrite per il rendering naturale, il che significa che i singoli glifi possono essere posizionati in una frazione di un pixel.

Anche se il layout naturale è l'impostazione predefinita, alcune applicazioni devono eseguire il rendering del testo con la stessa spaziatura e aspetto di GDI. Per tali applicazioni, DirectWrite fornisce modalità di misurazione naturali GDI classiche e GDI e le modalità di rendering corrispondenti.

Una delle modalità di rendering precedenti può essere combinata con una delle due modalità di anti-aliasing: ClearType o gradazioni di grigio. ClearType antialiasing simula una risoluzione più elevata modificando singolarmente i valori di colore rosso, verde e blu di ogni pixel. L'antialiasing in scala di grigi calcola un solo valore di copertura (o alfa) per ogni pixel. ClearType è il valore predefinito, ma l'antialiasing in scala di grigi è consigliato per le app di Windows Store perché è più veloce ed è compatibile con l'anti-aliasing standard, pur essendo ancora altamente leggibile.

Panoramica API

L'interfaccia IDWriteFactory è il punto di partenza per l'uso della funzionalità DirectWrite. La factory è l'oggetto radice che crea un set di oggetti che possono essere usati insieme.

L'operazione di formattazione e layout è un prerequisito per le operazioni, perché il testo deve essere formattato correttamente e disposto in un set specificato di vincoli prima di poter essere disegnato o sottoposto a hit test. Due oggetti chiave che è possibile creare con un IDWriteFactory a questo scopo sono IDWriteTextFormat e IDWriteTextLayout. Un oggetto IDWriteTextFormat rappresenta le informazioni di formattazione per un paragrafo di testo. La funzione IDWriteFactory::CreateTextLayout accetta la stringa di input, i vincoli associati, ad esempio la dimensione dello spazio da riempire, e l'oggetto IDWriteTextFormat e inserisce il risultato completamente analizzato e formattato in IDWriteTextLayout da usare nelle operazioni successive.

L'applicazione può quindi eseguire il rendering del testo usando la funzione DrawTextLayout fornita da Direct2D o implementando una funzione di callback che può usare GDI, Direct2D o altri sistemi grafici per eseguire il rendering dei glifi. Per un singolo testo in formato, la funzione DrawText in Direct2D offre un modo più semplice per disegnare testo senza dover prima creare un oggetto IDWriteTextLayout.

Formattazione e disegno di "Hello World" con DirectWrite

Nell'esempio di codice seguente viene illustrato come un'applicazione può formattare un singolo paragrafo usando IDWriteTextFormat e disegnarlo usando la funzione DrawText Direct2D.

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

Accesso al sistema dei tipi di carattere

Oltre a specificare un nome di famiglia di caratteri per la stringa di testo usando l'interfaccia IDWriteTextFormat nell'esempio precedente, DirectWrite fornisce alle applicazioni un maggiore controllo sulla selezione dei tipi di carattere tramite l'enumerazione dei tipi di carattere e la possibilità di creare una raccolta di tipi di carattere personalizzata in base ai tipi di carattere incorporati.

L'oggetto IDWriteFontCollection è un insieme di famiglie di caratteri. DirectWrite consente di accedere al set di tipi di carattere installati nel sistema tramite una raccolta di tipi di carattere speciale denominata raccolta di tipi di carattere di sistema. Questa operazione viene ottenuta chiamando il metodo GetSystemFontCollection dell'oggetto IDWriteFactory. Un'applicazione può anche creare una raccolta di tipi di carattere personalizzata da un set di tipi di carattere enumerati da un callback definito dall'applicazione, ovvero tipi di carattere privati installati da un'applicazione o tipi di carattere incorporati in un documento.

L'applicazione può quindi chiamare GetFontFamily per ottenere un oggetto FontFamily specifico all'interno dell'insieme e quindi chiamare IDWriteFontFamily::GetFirstMatchingFont per ottenere un oggetto IDWriteFont specifico. L'oggetto IDWriteFont rappresenta un tipo di carattere in una raccolta di tipi di carattere ed espone le proprietà e alcune metriche dei tipi di carattere di base.

IDWriteFontFace è un altro oggetto che rappresenta un tipo di carattere ed espone un set completo di metriche su un tipo di carattere. L'IDWriteFontFace può essere creato direttamente da un nome di tipo di carattere. Un'applicazione non deve ottenere una raccolta di tipi di carattere per accedervi. È utile per un'applicazione di layout di testo, ad esempio Microsoft Word, che deve eseguire una query sui dettagli per un tipo di carattere specifico.

Il diagramma seguente illustra la relazione tra questi oggetti.

IDWriteFontFace

L'oggetto IDWriteFontFace rappresenta un tipo di carattere e fornisce informazioni più dettagliate sul tipo di carattere rispetto all'oggetto IDWriteFont. Le metriche relative al tipo di carattere e al glifo di IDWriteFontFace sono utili per le applicazioni che implementano il layout del testo.

La maggior parte delle applicazioni mainstream non userà direttamente queste API e userà invece IDWriteFont o specificherà direttamente il nome della famiglia di caratteri.

La tabella seguente riepiloga gli scenari di utilizzo per i due oggetti .

Category	IDWriteFont	IDWriteFontFace
API per supportare l'interazione dell'utente, ad esempio un'interfaccia utente del tipo di scelta dei tipi di carattere: descrizione e altre API informative	Sì	No
API per supportare il mapping dei tipi di carattere: famiglia, stile, spessore, estensione, copertura dei caratteri	Sì	No
DrawText API	Sì	No
API usate per il rendering	No	Sì
API usate per il layout di testo: metriche del glifo e così via	No	Sì
API per il controllo dell'interfaccia utente e il layout di testo: metriche a livello di carattere	Sì	Sì

 

Di seguito è riportata un'applicazione di esempio che enumera i tipi di carattere nella raccolta di tipi di carattere di sistema.

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

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

void wmain()
{
    IDWriteFactory* pDWriteFactory = NULL;

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

    IDWriteFontCollection* pFontCollection = NULL;

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

    UINT32 familyCount = 0;

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

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

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

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

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

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

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

        UINT32 length = 0;

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

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

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

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

        delete [] name;
    }

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

Rendering del testo

Le API per il rendering del testo consentono il rendering dei glifi in un tipo di carattere DirectWrite in una superficie Direct2D o in una bitmap indipendente dal dispositivo GDI oppure per essere convertiti in contorni o bitmap. Il rendering ClearType in DirectWrite supporta il posizionamento dei sub-pixel con nitidezza e contrasto migliorate rispetto alle implementazioni precedenti in Windows. DirectWrite supporta anche il testo bianco e nero con alias per supportare scenari che coinvolgono tipi di carattere asiatici con bitmap incorporate o in cui l'utente ha disabilitato lo smussamento dei tipi di carattere di qualsiasi tipo.

Tutte le opzioni sono regolabili da tutte le manopole ClearType disponibili accessibili tramite le API DirectWrite e esposte anche tramite la nuova applet del pannello di controllo ClearType di Windows 7.

Sono disponibili due API per il rendering dei glifi, una che fornisce il rendering accelerato dell'hardware tramite Direct2D e l'altra che fornisce il rendering software a una bitmap GDI. Un'applicazione che usa IDWriteTextLayout e implementa il callback IDWriteTextRenderer può chiamare una di queste funzioni in risposta a un callback DrawGlyphRun. Inoltre, le applicazioni che implementano il proprio layout o gestiscono i dati a livello di glifo possono usare queste API.

1. ID2DRenderTarget::D rawGlyphRun

   Le applicazioni possono usare l'API Direct2D DrawGlyphRun per fornire accelerazione hardware per il rendering del testo usando la GPU. L'accelerazione hardware influisce su tutte le fasi della pipeline di rendering del testo, dall'unione di glifi alle esecuzioni del glifo e al filtro della bitmap di esecuzione del glifo, all'applicazione dell'algoritmo di fusione ClearType all'output visualizzato finale. Si tratta dell'API consigliata per ottenere prestazioni di rendering ottimali.

2. IDWriteBitmapRenderTarget::D rawGlyphRun

   Le applicazioni possono usare il metodo IDWriteBitmapRenderTarget::D rawGlyphRun per eseguire un rendering software di un'esecuzione di glifi in una bitmap da 32 bpp. L'oggetto IDWriteBitmapRenderTarget incapsula una bitmap e un contesto di dispositivo di memoria che può essere usato per il rendering dei glifi. Questa API è utile se si vuole rimanere con GDI perché si dispone di una codebase esistente di cui viene eseguito il rendering in GDI.

Se si dispone di un'applicazione con codice di layout di testo esistente che usa GDI e si vuole mantenere il codice di layout esistente, ma usare DirectWrite solo per il passaggio finale del rendering dei glifi, IDWriteGdiInterop::CreateFontFaceFromHdc fornisce il bridge tra le due API. Prima di chiamare questa funzione, l'applicazione userà la funzione IDWriteGdiInterop::CreateFontFaceFromHdc per ottenere un riferimento di tipo carattere da un contesto di dispositivo.

Nota

Per la maggior parte degli scenari, le applicazioni potrebbero non dover usare queste API per il rendering del glifo. Dopo aver creato un oggetto IDWriteTextLayout , un'applicazione può usare il metodo ID2D1RenderTarget::D rawTextLayout per eseguire il rendering del testo.

 

Modalità di rendering personalizzate

Un certo numero di parametri influisce sul rendering del testo, ad esempio gamma, livello ClearType, geometria pixel e contrasto avanzato. I parametri di rendering vengono incapsulati da un oggetto , che implementa l'interfaccia PUBLIC IDWriteRenderingParams. L'oggetto parametri di rendering viene inizializzato automaticamente in base alle proprietà hardware e/o alle preferenze utente specificate tramite l'applet del pannello di controllo ClearType in Windows 7. In genere, se un client usa l'API di layout DirectWrite, DirectWrite selezionerà automaticamente una modalità di rendering corrispondente alla modalità di misurazione specificata.

Le applicazioni che vogliono un maggiore controllo possono usare IDWriteFactory::CreateCustomRenderingParams per implementare le diverse opzioni di rendering. Questa funzione può essere usata anche per impostare la gamma, la geometria pixel e il contrasto avanzato.

Di seguito sono riportate le varie opzioni di rendering disponibili:

• Anti-aliasing dei sub pixel

  L'applicazione imposta il parametro renderingMode su DWRITE_RENDERING_MODE_NATURAL per specificare il rendering con anti-aliasing solo nella dimensione orizzontale.

• Anti-aliasing dei sub pixel in dimensioni orizzontali e verticali.

  L'applicazione imposta il parametro renderingMode su DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC per specificare il rendering con anti-aliasing in dimensioni orizzontali e verticali. In questo modo le curve e le linee diagonali sembrano più uniformi a scapito di una certa flessibilità, ed è in genere utilizzato a dimensioni superiori a 16 dpim.

• Testo con alias

  L'applicazione imposta il parametro renderingMode su DWRITE_RENDERING_MODE_ALIAedizione Standard D per specificare il testo con alias.

• Testo in scala di grigi

  L'applicazione imposta il parametro pixelGeometry su DWRITE_PIXEL_GEOMETRY_FLAT per specificare il testo in scala di grigi.

• Larghezza compatibile GDI (inclusa la bitmap incorporata dell'Asia orientale)

  L'applicazione imposta il parametro renderingMode su DWRITE_RENDERING_MODE_GDI_CLASSIC per specificare l'anti-aliasing di larghezza compatibile GDI.

• Larghezza naturale GDI

  L'applicazione imposta il parametro renderingMode su DWRITE_RENDERING_MODE_GDI_NATURAL per specificare l'anti-aliasing compatibile con GDI a larghezza naturale.

• Testo struttura

  Per il rendering con dimensioni elevate, uno sviluppatore di applicazioni potrebbe preferire il rendering usando il contorno del carattere anziché rasterizzazione in una bitmap. L'applicazione imposta il parametro renderingMode su DWRITE_RENDERING_MODE_OUTLINE per specificare che il rendering deve ignorare il rasterizzatore e usare direttamente le struttura.

Interoperabilità GDI

L'interfaccia IDWriteGdiInterop fornisce l'interoperabilità con GDI. Ciò consente alle applicazioni di continuare l'investimento esistente nelle codebase GDI e di usare in modo selettivo DirectWrite per il rendering o il layout.

Di seguito sono riportate le API che consentono a un'applicazione di eseguire la migrazione da o verso il sistema di tipi di carattere GDI:

• CreateFontFromLOGFONT

  Crea un oggetto IDWriteFont che corrisponde alle proprietà specificate dalla struttura LOGFONT.

• ConvertFontToLOGFONT

  Inizializza una struttura LOGFONT basata sulle proprietà compatibili con GDI dell'IDWriteFont specificato.

• ConvertFontFaceToLOGFONT

  Inizializza una struttura LOGFONT basata sulle proprietà compatibili con GDI dell'IDWriteFontFace specificato.

• CreateFontFaceFromHdc

  Crea un oggetto IDWriteFontFace che corrisponde all'oggetto HFONT attualmente selezionato.

Conclusione

Migliorare l'esperienza di lettura è di grande valore per gli utenti, sia sullo schermo che sulla carta. DirectWrite offre la facilità d'uso e il modello di programmazione a più livelli per gli sviluppatori di applicazioni per migliorare l'esperienza testuale per le applicazioni Windows. Le applicazioni possono usare DirectWrite per eseguire il rendering di testo formattato in modo avanzato per l'interfaccia utente e i documenti con l'API di layout. Per scenari più complessi, un'applicazione può lavorare direttamente con glifi, accedere ai tipi di carattere e così via e sfruttare la potenza di DirectWrite per offrire tipografia di alta qualità.

Le funzionalità di interoperabilità di DirectWrite consentono agli sviluppatori di applicazioni di portare avanti le codebase Win32 esistenti e adottare DirectWrite in modo selettivo all'interno delle applicazioni.