Présentation de DirectWrite

Personnes communiquer avec du texte tout le temps dans leur vie quotidienne. Il s’agit du principal moyen pour les gens de consommer un volume croissant d’informations. Dans le passé, il s’agit de contenu imprimé, principalement des documents, des journaux, des livres, etc. De plus en plus, il s’agit de contenu en ligne sur leur PC Windows. Un utilisateur Windows classique passe beaucoup de temps à lire à partir de son écran d’ordinateur. Ils peuvent naviguer sur le Web, analyser des e-mails, composer un rapport, remplir une feuille de calcul ou écrire des logiciels, mais ce qu’ils font vraiment, c’est lire. Même si le texte et les polices imprèment presque toutes les parties de l’expérience utilisateur dans Windows, pour la plupart des utilisateurs, la lecture à l’écran n’est pas aussi agréable que la lecture de la sortie imprimée.

Pour les développeurs d’applications Windows, l’écriture de code de gestion de texte est un défi en raison des exigences accrues en matière de lisibilité, de mise en forme sophistiquée et de contrôle de la disposition, ainsi que de la prise en charge des multiples langues que l’application doit afficher. Même le système de gestion de texte le plus simple doit autoriser l’entrée, la disposition, l’affichage, la modification et le copier-coller du texte. Les utilisateurs de Windows attendent généralement davantage que ces fonctionnalités de base, nécessitant même des éditeurs simples pour prendre en charge plusieurs polices, différents styles de paragraphe, images incorporées, vérification orthographique et autres fonctionnalités. La conception moderne de l’interface utilisateur n’est plus limitée au format unique, le texte brut, mais doit présenter une meilleure expérience avec des polices et des dispositions de texte enrichies.

Il s’agit d’une introduction à la façon dont DirectWrite permet aux applications Windows d’améliorer l’expérience de texte pour l’interface utilisateur et les documents.

Amélioration de l’expérience de texte

Les applications Windows modernes ont des exigences sophistiquées pour le texte dans leur interface utilisateur et leurs documents. Il s’agit notamment d’une meilleure lisibilité, de la prise en charge d’une grande variété de langages et de scripts, ainsi que de performances de rendu supérieures. En outre, la plupart des applications existantes nécessitent un moyen de reporter les investissements existants dans la base de code WindowsWin32.

DirectWrite fournit les trois fonctionnalités suivantes qui permettent aux développeurs d’applications Windows d’améliorer l’expérience de texte au sein de leurs applications : indépendance par rapport au système de rendu, typographie de haute qualité et plusieurs couches de fonctionnalités.

indépendance Rendering-System

DirectWrite est indépendante de toute technologie graphique particulière. Les applications sont libres d’utiliser la technologie de rendu la mieux adaptée à leurs besoins. Cela donne aux applications la possibilité de continuer à afficher certaines parties de leur application via GDI et d’autres parties via Direct3D ou Direct2D. En fait, une application peut choisir de rendre DirectWrite via une pile de rendu propriétaire.

typographie High-Quality

DirectWrite tire parti des avancées de la technologie OpenType Font pour permettre une typographie de haute qualité dans une application Windows. Le système de polices DirectWrite fournit des services pour gérer l’énumération des polices, le secours de police et la mise en cache des polices, qui sont tous nécessaires aux applications pour gérer les polices.

La prise en charge d’OpenType fournie par DirectWrite permet aux développeurs d’ajouter à leurs applications des fonctionnalités typographiques avancées et de prendre en charge le texte international.

Prise en charge des fonctionnalités typographiques avancées

DirectWrite permet aux développeurs d’applications de déverrouiller les fonctionnalités des polices OpenType qu’ils n’ont pas pu utiliser dans WinForms ou GDI. L’objet IDWriteTypography DirectWrite expose de nombreuses fonctionnalités avancées des polices OpenType, telles que les variantes stylistiques et les lavages. Le Kit de développement logiciel (SDK) Microsoft Windows fournit un ensemble d’exemples de polices OpenType conçues avec des fonctionnalités enrichies, telles que les polices Pericles et Pescadero. Pour plus d’informations sur les fonctionnalités OpenType, consultez Fonctionnalités de police OpenType.

Prise en charge du texte international

DirectWrite utilise des polices OpenType pour permettre une prise en charge étendue du texte international. Les fonctionnalités Unicode telles que les substituts, BIDI, le saut de ligne et les UVS sont prises en charge. L’itemisation de script guidé par le langage, la substitution de nombres et la mise en forme des glyphes garantissent que le texte de tout script a la disposition et le rendu corrects.

Les scripts suivants sont pris en charge :

Notes

Pour les scripts marqués d’une *, il n’existe aucune police système par défaut. Les applications doivent installer des polices qui prennent en charge ces scripts.

 

• Arabe
• Arménien
• Bengala
• Bopomofo
• Braille*
• SYLLABE AUTOCHTONE CANADIENNE
• Cherokee
• Chinois (traditionnel simplifié & )
• Cyrillique
• Copte*
• Dévanâgarî
• Éthiopique
• Géorgien
• Glagolitique*
• Grec
• Goudjrati
• Gurmukhi
• Hébreu
• Japonais
• Kannada
• Khmer
• Coréen
• Lao
• Latin
• Malayalam
• Mongol
• Myanmar
• New Tai Lue
• Ogham*
• Odia
• 'Phags-pa
• Runiques*
• Cingalais
• Syriaque
• Taï Le
• Tamoul
• Télougou
• Tana
• Thaï
• Tibétain
• Yi

Plusieurs couches de fonctionnalités

DirectWrite fournit des couches factorielles de fonctionnalités, chaque couche interagissant en toute transparence avec la suivante. La conception de l’API offre aux développeurs d’applications la liberté et la flexibilité d’adopter des couches individuelles en fonction de leurs besoins et de leur planification. Le diagramme suivant montre la relation entre ces couches.

L’API de disposition de texte fournit les fonctionnalités de plus haut niveau disponibles à partir de DirectWrite. Il fournit des services permettant à l’application de mesurer, d’afficher et d’interagir avec des chaînes de texte au format enrichi. Cette API de texte peut être utilisée dans les applications qui utilisent actuellement le DrawText de Win32 pour créer une interface utilisateur moderne avec du texte au format enrichi.

Les applications gourmandes en texte qui implémentent leur propre moteur de disposition peuvent utiliser la couche suivante : le processeur de script. Le processeur de script décompose un morceau de texte en blocs de script et gère le mappage entre les représentations Unicode et la représentation de glyphe appropriée dans la police afin que le texte du script puisse être affiché correctement dans la langue appropriée. Le système de disposition utilisé par la couche d’API de disposition de texte est basé sur le système de traitement des polices et des scripts.

La couche de rendu des glyphes est la couche de fonctionnalités la plus faible et fournit des fonctionnalités de rendu de glyphe pour les applications qui implémentent leur propre moteur de disposition de texte. La couche de rendu de glyphe est également utile pour les applications qui implémentent un convertisseur personnalisé pour modifier le comportement du dessin de glyphes via la fonction de rappel dans l’API de mise en forme de texte DirectWrite.

Le système de polices DirectWrite est disponible pour toutes les couches fonctionnelles DirectWrite et permet à une application d’accéder aux informations de police et de glyphe. Il est conçu pour gérer les technologies de police et les formats de données courants. Le modèle de police DirectWrite suit la pratique typographique courante qui consiste à prendre en charge un nombre quelconque de poids, de styles et d’étirements dans la même famille de polices. Ce modèle, le même modèle que WPF et CSS, spécifie que les polices qui diffèrent uniquement par leur poids (gras, léger, etc.), le style (droit, italique ou oblique) ou l’étirement (étroit, condensé, large, etc.) sont considérés comme membres d’une seule famille de polices.

Rendu de texte amélioré avec ClearType

L’amélioration de la lisibilité à l’écran est une condition essentielle pour toutes les applications Windows. Les preuves de la recherche en psychologie cognitive indiquent que nous devons être en mesure de reconnaître chaque lettre avec précision et que même l’espacement entre les lettres est essentiel pour un traitement rapide. Les lettres et les mots qui ne sont pas symétriques sont perçus comme laids et dégradent l’expérience de lecture. Kevin Larson, groupe Microsoft Advanced Reading Technologies, a écrit un article sur le sujet qui a été publié dans Spectrum IEEE. L’article est intitulé « La technologie du texte ».

Le texte dans DirectWrite est rendu à l’aide de Microsoft ClearType, ce qui améliore la clarté et la lisibilité du texte. ClearType tire parti du fait que les écrans LCD modernes ont des bandes RVB pour chaque pixel qui peuvent être contrôlées individuellement. DirectWrite utilise les dernières améliorations apportées à ClearType, d’abord inclus avec Windows Vista avec Windows Presentation Foundation, ce qui lui permet d’évaluer non seulement les lettres individuelles, mais également l’espacement entre les lettres. Avant ces améliorations ClearType, le texte d’une taille de « lecture » de 10 ou 12 points était difficile à afficher : nous pouvions placer 1 pixel entre les lettres, ce qui était souvent trop petit, ou 2 pixels, ce qui était souvent trop. L’utilisation de la résolution supplémentaire dans les sous-pixels nous fournit un espacement fractionnaire, ce qui améliore l’équilibre et la symétrie de l’ensemble de la page.

Les deux illustrations suivantes montrent comment les glyphes peuvent commencer sur n’importe quelle limite de sous-pixel lorsque le positionnement sous-pixel est utilisé.

L’illustration suivante est rendue à l’aide de la version GDI du convertisseur ClearType, qui n’a pas utilisé le positionnement de sous-pixels.

L’illustration suivante est rendue à l’aide de la version DirectWrite du convertisseur ClearType, qui utilise le positionnement en sous-pixels.

Notez que l’espacement entre les lettres h et n est plus homogène dans la deuxième image et que la lettre o est espacée plus loin de la lettre n, plus même avec la lettre l. Notez également comment les tiges sur les lettres l sont d’aspect plus naturel.

Le positionnement ClearType du sous-pixel offre l’espacement le plus précis des caractères à l’écran, en particulier dans les petites tailles où la différence entre un sous-pixel et un pixel entier représente une proportion significative de la largeur du glyphe. Il permet de mesurer le texte dans un espace de résolution idéal et de le rendre à sa position naturelle sur la bande de couleur LCD, avec une granularité subpixel. Le texte mesuré et rendu à l’aide de cette technologie est, par définition, indépendant de la résolution, ce qui signifie que la même disposition de texte est obtenue sur la plage des différentes résolutions d’affichage.

Contrairement à l’un ou l’autre type de rendu GDI ClearType, le sous-pixel ClearType offre la largeur de caractères la plus précise.

L’API Chaîne de texte adopte le rendu de texte en sous-pixels par défaut, ce qui signifie qu’elle mesure le texte à sa résolution idéale, indépendamment de la résolution d’affichage actuelle, et produit le résultat du positionnement du glyphe en fonction des largeurs avancées du glyphe réellement mises à l’échelle et des décalages de positionnement.

Pour le texte de grande taille, DirectWrite permet également l’anti-aliasing le long de l’axe y pour rendre les bords plus lisses et rendre les lettres comme le concepteur de polices l’a prévu. L’illustration suivante montre l’anti-aliasing dans la direction y.

Bien que DirectWrite texte soit positionné et rendu à l’aide du sous-pixel ClearType par défaut, d’autres options de rendu sont disponibles. De nombreuses applications existantes utilisent GDI pour afficher la plupart de leur interface utilisateur, et certaines applications utilisent des contrôles d’édition système qui continuent d’utiliser GDI pour le rendu de texte. Lorsque vous ajoutez DirectWrite texte à ces applications, il peut être nécessaire de sacrifier les améliorations de l’expérience de lecture fournies par le sous-pixel ClearType afin que le texte ait une apparence cohérente dans l’application.

Pour répondre à ces exigences, DirectWrite prend également en charge les options de rendu suivantes :

• Sous-pixel ClearType (par défaut).
• Sous-pixel ClearType avec anti-aliasing dans les dimensions horizontales et verticales.
• Texte alias.
• Largeur naturelle GDI (utilisé par Microsoft Word Mode Lecture, par exemple).
• Largeur compatible GDI (y compris bitmap incorporée d’Asie de l’Est).

Chacun de ces modes de rendu peut être affiné via l’API DirectWrite et le nouveau tuner ClearType de la boîte de réception Windows 7.

Notes

À compter de Windows 8, vous devez utiliser l’anti-attirail de texte en nuances de gris dans la plupart des cas. Pour en savoir plus, consultez la section suivante.

 

Prise en charge de la disposition naturelle

La disposition naturelle étant indépendante de la résolution, l’espacement des caractères ne change pas au fur et à mesure que vous effectuez un zoom avant ou arrière, ou en fonction du ppp de l’affichage. Un avantage secondaire est que l’espacement est fidèle à la conception de la police. La disposition naturelle est rendue possible par la prise en charge par DirectWrite pour le rendu naturel, ce qui signifie que les glyphes individuels peuvent être positionnés sur une fraction d’un pixel.

Bien que la disposition naturelle soit la valeur par défaut, certaines applications doivent afficher le texte avec le même espacement et la même apparence que GDI. Pour de telles applications, DirectWrite fournit des modes de mesure GDI classiques et GDI naturels et des modes de rendu correspondants.

L’un des modes de rendu ci-dessus peut être combiné avec l’un des deux modes d’anti-ataliasing : ClearType ou nuances de gris. L’anticrénelage ClearType permet de simuler une résolution plus élevée en manipulant individuellement les valeurs de couleur rouge, verte et bleue de chaque pixel. L’anti-attirail à nuances de gris calcule une seule valeur de couverture (ou alpha) pour chaque pixel. ClearType est la valeur par défaut, mais l’anti-ataliasing en niveaux de gris est recommandé pour les applications du Windows Store, car il est plus rapide et compatible avec l’anticrénelage standard, tout en étant très lisible.

Présentation de l’API

L’interface IDWriteFactory est le point de départ de l’utilisation de DirectWrite fonctionnalité. La fabrique est l’objet racine qui crée un ensemble d’objets qui peuvent être utilisés ensemble.

L’opération de mise en forme et de disposition est un prérequis pour les opérations, car le texte doit être correctement mis en forme et disposé selon un ensemble de contraintes spécifié avant de pouvoir être dessiné ou testé. Deux objets clés que vous pouvez créer avec un IDWriteFactory à cet effet sont IDWriteTextFormat et IDWriteTextLayout. Un objet IDWriteTextFormat représente les informations de mise en forme d’un paragraphe de texte. La fonction IDWriteFactory::CreateTextLayout prend la chaîne d’entrée, les contraintes associées telles que la dimension de l’espace à remplir et l’objet IDWriteTextFormat , et place le résultat entièrement analysé et mis en forme dans IDWriteTextLayout à utiliser dans les opérations suivantes.

L’application peut ensuite restituer le texte à l’aide de la fonction DrawTextLayout fournie par Direct2D ou en implémentant une fonction de rappel qui peut utiliser GDI, Direct2D ou d’autres systèmes graphiques pour restituer les glyphes. Pour un texte de format unique, la fonction DrawText sur Direct2D offre un moyen plus simple de dessiner du texte sans avoir à créer d’abord un objet IDWriteTextLayout .

Mise en forme et dessin « Hello World » à l’aide de DirectWrite

L’exemple de code suivant montre comment une application peut mettre en forme un seul paragraphe à l’aide d’IDWriteTextFormat et le dessiner à l’aide de la fonction Direct2DDrawText .

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

Accès au système de polices

En plus de spécifier un nom de famille de polices pour la chaîne de texte à l’aide de l’interface IDWriteTextFormat dans l’exemple ci-dessus, DirectWrite offre aux applications davantage de contrôle sur la sélection des polices par le biais de l’énumération de polices et la possibilité de créer une collection de polices personnalisée basée sur des polices de documents incorporées.

L’objet IDWriteFontCollection est une collection de familles de polices. DirectWrite permet d’accéder à l’ensemble de polices installées sur le système via une collection de polices spéciale appelée collection de polices système. Pour cela, appelez la méthode GetSystemFontCollection de l’objet IDWriteFactory . Une application peut également créer une collection de polices personnalisées à partir d’un ensemble de polices énumérées par un rappel défini par l’application, c’est-à-dire des polices privées installées par une application ou des polices incorporées dans un document.

L’application peut ensuite appeler GetFontFamily pour accéder à un objet FontFamily spécifique au sein de la collection, puis appeler IDWriteFontFamily::GetFirstMatchingFont pour accéder à un objet IDWriteFont spécifique. L’objet IDWriteFont représente une police dans une collection de polices et expose des propriétés et quelques métriques de police de base.

IDWriteFontFace est un autre objet qui représente une police et expose un ensemble complet de métriques sur une police. L’IDWriteFontFace peut être créé directement à partir d’un nom de police ; une application n’a pas besoin d’obtenir une collection de polices pour y accéder. Il est utile pour une application de disposition de texte telle que Microsoft Word qui doit interroger les détails d’une police spécifique.

Le diagramme suivant illustre la relation entre ces objets.

IDWriteFontFace

L’objet IDWriteFontFace représente une police et fournit des informations plus détaillées sur la police que l’objet IDWriteFont. Les métriques de police et de glyphe d’IDWriteFontFace sont utiles pour les applications qui implémentent la disposition de texte.

La plupart des applications standard n’utilisent pas ces API directement, mais utilisent IDWriteFont ou spécifient directement le nom de la famille de polices.

Le tableau suivant récapitule les scénarios d’utilisation des deux objets.

Category	IDWriteFont	IDWriteFontFace
API pour prendre en charge les interactions utilisateur telles qu’une interface utilisateur de sélecteur de polices : description et autres API d’information	Oui	Non
API pour prendre en charge le mappage des polices : famille, style, poids, étirement, couverture des caractères	Oui	Non
DrawText API	Oui	Non
API utilisées pour le rendu	Non	Oui
API utilisées pour la disposition du texte : métriques de glyphe, et ainsi de suite	Non	Oui
API pour le contrôle de l’interface utilisateur et la disposition du texte : métriques à l’échelle de la police	Oui	Oui

 

Voici un exemple d’application qui énumère les polices dans la collection de polices système.

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

Rendu du texte

Les API de rendu de texte permettent aux glyphes d’une police DirectWrite d’être rendus sur une surface Direct2D ou dans une bitmap indépendante de l’appareil GDI, ou d’être convertis en contours ou bitmaps. Le rendu ClearType dans DirectWrite prend en charge le positionnement de sous-pixels avec une netteté et un contraste améliorés par rapport aux implémentations précédentes sur Windows. DirectWrite prend également en charge le texte en noir et blanc alias pour prendre en charge les scénarios impliquant des polices d’Asie de l’Est avec des bitmaps incorporées, ou lorsque l’utilisateur a désactivé le lissage des polices de tout type.

Toutes les options sont réglables par tous les boutons ClearType disponibles accessibles via les API DirectWrite, et également exposées via la nouvelle applet du panneau de configuration ClearType de Windows 7.

Deux API sont disponibles pour le rendu des glyphes, l’une fournissant un rendu accéléré par le matériel via Direct2D et l’autre fournissant un rendu logiciel sur une bitmap GDI. Une application utilisant IDWriteTextLayout et implémentant le rappel IDWriteTextRenderer peut appeler l’une de ces fonctions en réponse à un rappel DrawGlyphRun . En outre, les applications qui implémentent leur propre disposition ou traitent des données au niveau du glyphe peuvent utiliser ces API.

1. ID2DRenderTarget::D rawGlyphRun

   Les applications peuvent utiliser l’API Direct2DDrawGlyphRun pour fournir une accélération matérielle pour le rendu de texte à l’aide du GPU. L’accélération matérielle affecte toutes les phases du pipeline de rendu de texte, de la fusion des glyphes en exécutions de glyphes et du filtrage de l’image bitmap d’exécution de glyphes à l’application de l’algorithme de fusion ClearType à la sortie finale affichée. Il s’agit de l’API recommandée pour obtenir les meilleures performances de rendu.

2. IDWriteBitmapRenderTarget::D rawGlyphRun

   Les applications peuvent utiliser la méthode IDWriteBitmapRenderTarget::D rawGlyphRun pour effectuer un rendu logiciel d’une exécution de glyphes en bitmap 32 bpp. L’objet IDWriteBitmapRenderTarget encapsule une bitmap et un contexte de périphérique mémoire qui peuvent être utilisés pour le rendu des glyphes. Cette API est utile si vous souhaitez rester avec GDI, car vous disposez d’une base de code existante qui s’affiche dans GDI.

Si vous avez une application qui a un code de disposition de texte existant qui utilise GDI et que vous souhaitez conserver son code de disposition existant, mais que vous utilisez DirectWrite uniquement pour l’étape finale du rendu des glyphes, IDWriteGdiInterop::CreateFontFaceFromHdc fournit le pont entre les deux API. Avant d’appeler cette fonction, l’application utilise la fonction IDWriteGdiInterop::CreateFontFaceFromHdc pour obtenir une référence police-visage à partir d’un contexte d’appareil.

Notes

Dans la plupart des scénarios, les applications n’ont peut-être pas besoin d’utiliser ces API de rendu de glyphes. Une fois qu’une application a créé un objet IDWriteTextLayout , elle peut utiliser la méthode ID2D1RenderTarget::D rawTextLayout pour afficher le texte.

 

Modes de rendu personnalisés

Un certain nombre de paramètres affectent le rendu du texte, tels que le gamma, le niveau ClearType, la géométrie des pixels et le contraste amélioré. Les paramètres de rendu sont encapsulés par un objet qui implémente l’interface IDWriteRenderingParams publique. L’objet paramètres de rendu est initialisé automatiquement en fonction des propriétés matérielles et/ou des préférences utilisateur spécifiées par le biais de l’applet du panneau de configuration ClearType dans Windows 7. En règle générale, si un client utilise l’API de disposition DirectWrite, DirectWrite sélectionne automatiquement un mode de rendu qui correspond au mode de mesure spécifié.

Les applications qui veulent plus de contrôle peuvent utiliser IDWriteFactory::CreateCustomRenderingParams pour implémenter les différentes options de rendu. Cette fonction peut également être utilisée pour définir le gamma, la géométrie des pixels et le contraste amélioré.

Voici les différentes options de rendu disponibles :

• Anti-aliasing de sous-pixels

  L’application définit le paramètre renderingMode sur DWRITE_RENDERING_MODE_NATURAL pour spécifier le rendu avec anti-aliasing dans la dimension horizontale uniquement.

• Anti-aliasing de sous-pixels dans les dimensions horizontales et verticales.

  L’application définit le paramètre renderingMode sur DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC pour spécifier le rendu avec anti-aliasing dans les dimensions horizontales et verticales. Cela rend les courbes et les lignes diagonales plus lisses au détriment d’une certaine douceur, et est généralement utilisé à des tailles supérieures à 16 epim.

• Texte alias

  L’application définit le paramètre renderingMode sur DWRITE_RENDERING_MODE_ALIASED pour spécifier le texte alias.

• Texte en nuances de gris

  L’application définit le paramètre pixelGeometry sur DWRITE_PIXEL_GEOMETRY_FLAT pour spécifier le texte en nuances de gris.

• Largeur compatible GDI (y compris bitmap incorporée d’Asie de l’Est)

  L’application définit le paramètre renderingMode sur DWRITE_RENDERING_MODE_GDI_CLASSIC pour spécifier l’anti-aliasing de largeur compatible GDI.

• Largeur naturelle GDI

  L’application définit le paramètre renderingMode sur DWRITE_RENDERING_MODE_GDI_NATURAL pour spécifier un anti-alias compatible avec la largeur naturelle GDI.

• Texte du plan

  Pour le rendu de grandes tailles, un développeur d’applications peut préférer effectuer un rendu à l’aide du plan de police plutôt qu’en rastérisant dans une bitmap. L’application définit le paramètre renderingMode sur DWRITE_RENDERING_MODE_OUTLINE pour spécifier que le rendu doit contourner le rastériseur et utiliser directement les contours.

Interopérabilité GDI

L’interface IDWriteGdiInterop assure l’interopérabilité avec GDI. Cela permet aux applications de poursuivre leur investissement existant dans les bases de code GDI et d’utiliser de manière sélective DirectWrite pour le rendu ou la disposition.

Voici les API qui permettent à une application de migrer vers ou à partir du système de policeS GDI :

• CreateFontFromLOGFONT

  Crée un objet IDWriteFont qui correspond aux propriétés spécifiées par la structure LOGFONT .

• ConvertFontToLOGFONT

  Initialise une structure LOGFONT en fonction des propriétés compatibles GDI de l’IDWriteFont spécifié.

• ConvertFontFaceToLOGFONT

  Initialise une structure LOGFONT en fonction des propriétés compatibles GDI de l’IDWriteFontFace spécifié.

• CreateFontFaceFromHdc

  Crée un objet IDWriteFontFace qui correspond au HFONT actuellement sélectionné.

Conclusion

L’amélioration de l’expérience de lecture est d’une grande valeur pour les utilisateurs, que ce soit à l’écran ou sur papier. DirectWrite offre la facilité d’utilisation et le modèle de programmation en couches pour les développeurs d’applications afin d’améliorer l’expérience de texte de leurs applications Windows. Les applications peuvent utiliser DirectWrite pour afficher du texte richement mis en forme pour leur interface utilisateur et leurs documents avec l’API de disposition. Pour les scénarios plus complexes, une application peut utiliser directement des glyphes, accéder aux polices, etc., et exploiter la puissance de DirectWrite pour fournir une typographie de haute qualité.

Les fonctionnalités d’interopérabilité de DirectWrite permettent aux développeurs d’applications de transférer leurs codebases Win32 existants et d’adopter des DirectWrite de manière sélective au sein de leurs applications.