Presentación de DirectWrite

Personas comunicarse con el texto todo el tiempo en sus vidas diarias. Es la forma principal de que los usuarios consuman un volumen creciente de información. En el pasado, solía ser a través de contenido impreso, principalmente documentos, periódicos, libros, etc. Cada vez más, es contenido en línea en su PC Windows. Un usuario típico de Windows pasa mucho tiempo leyendo desde su pantalla del equipo. Es posible que estén navegando por la Web, examinando el correo electrónico, redactando un informe, rellenando una hoja de cálculo o escribiendo software, pero lo que realmente hacen es leer. Aunque el texto y las fuentes permean casi todas las partes de la experiencia del usuario en Windows, para la mayoría de los usuarios, leer en la pantalla no es tan agradable como leer la salida impresa.

Para los desarrolladores de aplicaciones de Windows, escribir código de control de texto es un desafío debido al aumento de los requisitos para mejorar la legibilidad, el formato sofisticado y el control de diseño, y la compatibilidad con los varios idiomas que debe mostrar la aplicación. Incluso el sistema de control de texto más básico debe permitir la entrada de texto, el diseño, la visualización, la edición y la copia y el pegado. Normalmente, los usuarios de Windows esperan incluso más que estas características básicas, lo que requiere incluso editores simples para admitir varias fuentes, varios estilos de párrafo, imágenes incrustadas, revisión ortográfica y otras características. El diseño moderno de la interfaz de usuario ya no está limitado a un solo formato, texto sin formato, pero necesita presentar una mejor experiencia con fuentes enriquecidas y diseños de texto.

Se trata de una introducción a cómo DirectWrite permite a las aplicaciones de Windows mejorar la experiencia de texto para la interfaz de usuario y los documentos.

Mejora de la experiencia de texto

Las aplicaciones modernas de Windows tienen requisitos sofisticados para el texto en su interfaz de usuario y documentos. Esto incluye una mejor legibilidad, compatibilidad con una gran variedad de lenguajes y scripts, y un rendimiento de representación superior. Además, la mayoría de las aplicaciones existentes requieren una manera de llevar a cabo inversiones existentes en la base de código WindowsWin32.

DirectWrite proporciona las tres características siguientes que permiten a los desarrolladores de aplicaciones de Windows mejorar la experiencia de texto dentro de sus aplicaciones: independencia del sistema de representación, la tipografía de alta calidad y varias capas de funcionalidad.

independencia de Rendering-System

DirectWrite es independiente de cualquier tecnología gráfica concreta. Las aplicaciones son gratuitas para usar la tecnología de representación más adecuada para sus necesidades. Esto proporciona a las aplicaciones la flexibilidad de seguir representando algunas partes de su aplicación a través de GDI y otras partes a través de Direct3D o Direct2D. De hecho, una aplicación podría optar por representar DirectWrite a través de una pila de representación propietaria.

Tipografía de High-Quality

DirectWrite aprovecha los avances en la tecnología OpenType Font para habilitar la tipografía de alta calidad dentro de una aplicación Windows. El sistema de fuentes DirectWrite proporciona servicios para trabajar con la enumeración de fuentes, la reserva de fuentes y el almacenamiento en caché de fuentes, que todas las aplicaciones necesitan para controlar las fuentes.

La compatibilidad con OpenType proporcionada por DirectWrite permite a los desarrolladores agregar a sus aplicaciones características tipográficas avanzadas y compatibilidad con texto internacional.

Compatibilidad con características tipográficas avanzadas

DirectWrite permite a los desarrolladores de aplicaciones desbloquear las características de las fuentes OpenType que no pudieron usar en WinForms o GDI. El objeto IDWriteTypography DirectWrite expone muchas de las características avanzadas de las fuentes OpenType, como alternativas estilísticas y lavados. El Kit de desarrollo de software (SDK) de Microsoft Windows proporciona un conjunto de fuentes OpenType de ejemplo diseñadas con características enriquecidas, como las fuentes Pericles y Pescadero. Para obtener más detalles sobre las características de OpenType, consulte Características de las fuentes OpenType.

Compatibilidad con texto internacional

DirectWrite usa fuentes OpenType para habilitar una amplia compatibilidad con el texto internacional. Se admiten características Unicode como suplentes, BIDI, saltos de línea y UVS. La creación de elementos de script guiados por lenguaje, la sustitución de números y la forma del glifo garantizan que el texto de cualquier script tenga el diseño y la representación correctos.

Actualmente se admiten los siguientes scripts:

Nota

En el caso de los scripts marcados con *, no hay fuentes del sistema predeterminadas. Las aplicaciones deben instalar fuentes que admitan estos scripts.

 

• Árabe
• Armenio
• Bengala
• Bopomofo
• Braille*
• Aylábicas canadienses
• Cheroqui
• Chino (tradicional simplificado & )
• Cirílico
• Copto*
• Devanagari
• Etíope
• Georgiano
• Glagolitic*
• Griego
• Gujarati
• Gurmukhi
• Hebreo
• Japonés
• Canarés
• Jemer
• Coreano
• Lao
• Latín
• Malayalam
• Mongol
• Myanmar
• Nuevo Tai Lue
• Ogham*
• Odia
• 'Phags-pa
• Rúnico*
• Cingalés
• Sirio
• Tai Le
• Tamil
• Telugu
• Thaana
• Tailandés
• Tibetano
• Yi

Varias capas de funcionalidad

DirectWrite proporciona capas factoradas de funcionalidad, con cada capa que interactúa sin problemas con la siguiente. El diseño de la API ofrece a los desarrolladores de aplicaciones la libertad y flexibilidad para adoptar capas individuales en función de sus necesidades y programación. En el diagrama siguiente se muestra la relación entre estas capas.

La API de diseño de texto proporciona la funcionalidad de nivel más alto disponible en DirectWrite. Proporciona servicios para que la aplicación mida, muestre e interactúe con cadenas de texto con formato enriquecido. Esta API de texto se puede usar en aplicaciones que actualmente usan DrawText de Win32 para crear una interfaz de usuario moderna con texto con formato enriquecido.

Las aplicaciones con uso intensivo de texto que implementan su propio motor de diseño pueden usar la siguiente capa hacia abajo: el procesador de scripts. El procesador de scripts divide un fragmento de texto en bloques de script y controla la asignación entre representaciones Unicode a la representación de glifo adecuada en la fuente para que el texto del script se pueda mostrar correctamente en el idioma correcto. El sistema de diseño usado por la capa de api de diseño de texto se basa en el sistema de procesamiento de fuentes y scripts.

La capa de representación de glifos es la capa más baja de funcionalidad y proporciona funcionalidad de representación de glifos para las aplicaciones que implementan su propio motor de diseño de texto. La capa de representación de glifos también es útil para las aplicaciones que implementan un representador personalizado para modificar el comportamiento de dibujo del glifo a través de la función de devolución de llamada en la API de formato de texto de DirectWrite.

El sistema de fuentes DirectWrite está disponible para todas las capas funcionales DirectWrite y permite a una aplicación acceder a la información de fuente y glifo. Está diseñado para controlar tecnologías comunes de fuentes y formatos de datos. El modelo de fuente DirectWrite sigue la práctica tipográfica común de admitir cualquier número de pesos, estilos y tramos en la misma familia de fuentes. Este modelo, el mismo modelo seguido de WPF y CSS, especifica que las fuentes solo difieren en peso (negrita, luz, etc.), estilo (vertical, cursiva o oblicuo) o stretch (estrecho, condensado, ancho, etc.) se consideran miembros de una sola familia de fuentes.

Representación de texto mejorada con ClearType

Mejorar la legibilidad en la pantalla es un requisito clave para todas las aplicaciones de Windows. La evidencia de la investigación en psicología cognitiva indica que es necesario poder reconocer cada letra con precisión y que incluso el espaciado entre letras es fundamental para un procesamiento rápido. Las letras y palabras que no son simétricas se perciben como feas y degradan la experiencia de lectura. Kevin Larson, grupo de Tecnologías avanzadas de lectura de Microsoft, escribió un artículo sobre el tema que se publicó en Spectrum IEEE. El artículo se denomina "La tecnología del texto".

El texto de DirectWrite se representa mediante Microsoft ClearType, lo que mejora la claridad y la legibilidad del texto. ClearType aprovecha el hecho de que las pantallas LCD modernas tienen franjas RGB para cada píxel que se puede controlar individualmente. DirectWrite usa las últimas mejoras en ClearType, incluida primero con Windows Vista con Windows Presentation Foundation, lo que le permite evaluar no solo las letras individuales, sino también el espaciado entre letras. Antes de estas mejoras de ClearType, el texto con un tamaño de "lectura" de 10 o 12 puntos era difícil de mostrar: podríamos colocar 1 píxel entre letras, que a menudo era demasiado pequeño o 2 píxeles, que a menudo era demasiado. El uso de la resolución adicional en los subpíxeles nos proporciona espaciado fraccionado, lo que mejora la paridad y la simetría de toda la página.

En la ilustración siguiente se muestra cómo pueden comenzar los glifos en cualquier límite de sub píxeles cuando se usa el posicionamiento de sub píxeles.

La ilustración siguiente se representa mediante la versión GDI del representador ClearType, que no empleaba el posicionamiento de sub píxeles.

La ilustración siguiente se representa mediante la versión DirectWrite del representador ClearType, que usa el posicionamiento de sub píxeles.

Tenga en cuenta que el espaciado entre las letras h y n es más incluso en la segunda imagen y la letra o está espaciada más lejos de la letra n, más incluso con la letra l. Tenga en cuenta también cómo los tallos de las letras l son más naturales.

El posicionamiento de ClearType de subpixel ofrece el espaciado más preciso de caracteres en la pantalla, especialmente en tamaños pequeños donde la diferencia entre un sub píxel y un píxel entero representa una proporción significativa del ancho del glifo. Permite medir el texto en un espacio de resolución ideal y representarse en su posición natural en la franja de color LCD, con granularidad de subpíxel. El texto medido y representado mediante esta tecnología es, por definición, independiente de la resolución, lo que significa que el mismo diseño de texto se logra exactamente en el intervalo de diversas resoluciones de visualización.

A diferencia de cualquier tipo de representación de ClearType de GDI, ClearType de sub píxel ofrece el ancho más preciso de caracteres.

Text String API adopta la representación de texto de sub píxeles de forma predeterminada, lo que significa que mide el texto en su resolución ideal independiente de la resolución de pantalla actual y genera el resultado de posicionamiento del glifo en función de los anchos de avance y los desplazamientos de posición realmente escalados.

En el caso del texto de gran tamaño, DirectWrite también permite suavizar el alias a lo largo del eje Y para que los bordes sean más suaves y representen letras como el diseñador de fuentes previsto. En la ilustración siguiente se muestra el suavizado de contorno y-direction.

Aunque DirectWrite texto se coloca y se representa mediante ClearType de sub píxel de forma predeterminada, hay disponibles otras opciones de representación. Muchas aplicaciones existentes usan GDI para representar la mayor parte de su interfaz de usuario y algunas aplicaciones usan controles de edición del sistema que siguen usando GDI para la representación de texto. Al agregar DirectWrite texto a estas aplicaciones, puede ser necesario sacrificar las mejoras de la experiencia de lectura proporcionadas por ClearType de sub píxel para que el texto tenga una apariencia coherente en toda la aplicación.

Para cumplir estos requisitos, DirectWrite también admite las siguientes opciones de representación:

• ClearType de sub píxel (valor predeterminado).
• ClearType de sub píxel con suavizado de contorno en dimensiones horizontales y verticales.
• Texto con alias.
• Ancho natural de GDI (usado por Microsoft Word vista de lectura, por ejemplo).
• Ancho compatible con GDI (incluido el mapa de bits incrustado de Asia Oriental).

Cada uno de estos modos de representación se puede ajustar a través de la API de DirectWrite y a través del nuevo tuner ClearType de la bandeja de entrada de Windows 7.

Nota

A partir de Windows 8, debe usar el suavizado de contorno de texto de escala gris en la mayoría de los casos. Consulte la siguiente sección para más información.

 

Compatibilidad con el diseño natural

El diseño natural es independiente de la resolución, por lo que el espaciado de caracteres no cambia a medida que se acerca o se aleja, o dependiendo del ppp de la pantalla. Una ventaja secundaria es que el espaciado es verdadero para el diseño de la fuente. El diseño natural es posible gracias a la compatibilidad de DirectWrite con la representación natural, lo que significa que los glifos individuales se pueden colocar en una fracción de un píxel.

Aunque el diseño natural es el valor predeterminado, algunas aplicaciones deben representar texto con el mismo espaciado y apariencia que GDI. Para estas aplicaciones, DirectWrite proporciona modos de medición natural GDI clásico y GDI y modos de representación correspondientes.

Cualquiera de los modos de representación anteriores se puede combinar con cualquiera de los dos modos de suavizado de contorno: ClearType o escala de grises. ClearType antialiasing simula una resolución superior manipulando individualmente los valores de color rojo, verde y azul de cada píxel. El suavizado de contorno de grises calcula solo un valor de cobertura (o alfa) para cada píxel. ClearType es el valor predeterminado, pero se recomienda el suavizado de contorno de escala de grises para las aplicaciones de la Tienda Windows, ya que es más rápido y es compatible con el suavizado de contorno estándar, mientras sigue siendo altamente legible.

Información general acerca de la API

La interfaz IDWriteFactory es el punto de partida para usar DirectWrite funcionalidad. El generador es el objeto raíz que crea un conjunto de objetos que se pueden usar juntos.

La operación de formato y diseño es un requisito previo para las operaciones, ya que el texto debe tener el formato correcto y diseñarse en un conjunto especificado de restricciones antes de que se pueda dibujar o probar. Dos objetos clave que se pueden crear con IDWriteFactory para este propósito son IDWriteTextFormat e IDWriteTextLayout. Un objeto IDWriteTextFormat representa la información de formato de un párrafo de texto. La función IDWriteFactory::CreateTextLayout toma la cadena de entrada, las restricciones asociadas, como la dimensión del espacio que se va a rellenar, y el objeto IDWriteTextFormat , y coloca el resultado completamente analizado y con formato en IDWriteTextLayout para usarlo en las operaciones posteriores.

Después, la aplicación puede representar el texto mediante la función DrawTextLayout proporcionada por Direct2D o mediante la implementación de una función de devolución de llamada que puede usar GDI, Direct2D u otros sistemas gráficos para representar los glifos. Para un texto de un solo formato, la función DrawText en Direct2D proporciona una manera más sencilla de dibujar texto sin tener que crear primero un objeto IDWriteTextLayout .

Aplicar formato y dibujar "Hola mundo" mediante DirectWrite

En el ejemplo de código siguiente se muestra cómo una aplicación puede dar formato a un único párrafo mediante IDWriteTextFormat y dibujarlo mediante la función DrawTextde 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;
}

Acceso al sistema de fuentes

Además de especificar un nombre de familia de fuentes para la cadena de texto mediante la interfaz IDWriteTextFormat del ejemplo anterior, DirectWrite proporciona a las aplicaciones más control sobre la selección de fuentes a través de la enumeración de fuentes y la capacidad de crear una colección de fuentes personalizada basada en fuentes de documento incrustadas.

El objeto IDWriteFontCollection es una colección de familias de fuentes. DirectWrite proporciona acceso al conjunto de fuentes instaladas en el sistema a través de una colección de fuentes especial denominada colección de fuentes del sistema. Esto se obtiene llamando al método GetSystemFontCollection del objeto IDWriteFactory . Una aplicación también puede crear una colección de fuentes personalizada a partir de un conjunto de fuentes enumeradas por una devolución de llamada definida por la aplicación, es decir, fuentes privadas instaladas por una aplicación o fuentes incrustadas en un documento.

A continuación, la aplicación puede llamar a GetFontFamily para obtener un objeto FontFamily específico dentro de la colección y, a continuación, llamar a IDWriteFontFamily::GetFirstMatchingFont para obtener un objeto IDWriteFont específico. El objeto IDWriteFont representa una fuente de una colección de fuentes y expone las propiedades y algunas métricas de fuente básicas.

IDWriteFontFace es otro objeto que representa una fuente y expone un conjunto completo de métricas en una fuente. IdWriteFontFace se puede crear directamente a partir de un nombre de fuente; Una aplicación no tiene que obtener una colección de fuentes para acceder a ella. Resulta útil para una aplicación de diseño de texto como Microsoft Word que necesita consultar los detalles de una fuente específica.

En el diagrama siguiente se muestra la relación entre estos objetos.

IDWriteFontFace

El objeto IDWriteFontFace representa una fuente y proporciona información más detallada sobre la fuente que el objeto IDWriteFont . Las métricas de fuente y glifo de IDWriteFontFace son útiles para las aplicaciones que implementan el diseño de texto.

La mayoría de las aplicaciones estándar no usarán estas API directamente y, en su lugar, usarán IDWriteFont o especificarán el nombre de familia de fuentes directamente.

En la tabla siguiente se resumen los escenarios de uso de los dos objetos.

Category	IDWriteFont	IDWriteFontFace
API para admitir la interacción del usuario, como una interfaz de usuario del selector de fuentes: descripción y otras API informativas	Sí	No
API para admitir la asignación de fuentes: familia, estilo, peso, stretch, cobertura de caracteres	Sí	No
DrawText API	Sí	No
API usadas para la representación	No	Sí
API usadas para el diseño de texto: métricas de glifo, etc.	No	Sí
API para el control de la interfaz de usuario y el diseño de texto: métricas para toda la fuente	Sí	Sí

 

A continuación se muestra una aplicación de ejemplo que enumera las fuentes de la colección de fuentes del 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);
}

Representación de texto

Las API de representación de texto permiten representar glifos en una fuente de DirectWrite en una superficie direct2D o en un mapa de bits independiente del dispositivo GDI, o convertirse en esquemas o mapas de bits. La representación de ClearType en DirectWrite admite el posicionamiento de sub píxeles con mayor nitidez y contraste en comparación con las implementaciones anteriores en Windows. DirectWrite también admite texto con alias negro y blanco para admitir escenarios que impliquen fuentes del Este asiático con mapas de bits incrustados o donde el usuario haya deshabilitado el suavizado de fuentes de cualquier tipo.

Todas las opciones son ajustables por todos los botones ClearType disponibles accesibles a través de las API de DirectWrite, y también se exponen a través del nuevo applet del panel de control de tuner de ClearType de Windows 7.

Hay dos API disponibles para representar glifos, uno que proporciona representación acelerada por hardware a través de Direct2D y el otro que proporciona representación de software a un mapa de bits GDI. Una aplicación que usa IDWriteTextLayout e implementa la devolución de llamada IDWriteTextRenderer puede llamar a cualquiera de estas funciones en respuesta a una devolución de llamada DrawGlyphRun . Además, las aplicaciones que implementan su propio diseño o tratan con los datos de nivel de glifo pueden usar estas API.

1. ID2DRenderTarget::D rawGlyphRun

   Las aplicaciones pueden usar DrawGlyphRun de la API de Direct2D para proporcionar aceleración de hardware para la representación de texto mediante la GPU. La aceleración de hardware afecta a todas las fases de la canalización de representación de texto, desde la combinación de glifos en ejecuciones de glifos y el filtrado del mapa de bits de ejecución del glifo hasta aplicar el algoritmo de combinación ClearType a la salida final mostrada. Esta es la API recomendada para obtener el mejor rendimiento de representación.

2. IDWriteBitmapRenderTarget::D rawGlyphRun

   Las aplicaciones pueden usar el método IDWriteBitmapRenderTarget::D rawGlyphRun para realizar una representación de software de una ejecución de glifos en un mapa de bits de 32 bpp. El objeto IDWriteBitmapRenderTarget encapsula un mapa de bits y un contexto de dispositivo de memoria que se puede usar para representar glifos. Esta API es útil si desea permanecer con GDI porque tiene una base de código existente que se representa en GDI.

Si tiene una aplicación que tiene código de diseño de texto existente que usa GDI y desea conservar su código de diseño existente, pero use DirectWrite solo para el último paso de representación de glifos, IDWriteGdiInterop::CreateFontFaceFromHdc proporciona el puente entre las dos API. Antes de llamar a esta función, la aplicación usará la función IDWriteGdiInterop::CreateFontFaceFromHdc para obtener una referencia de cara de fuente de un contexto de dispositivo.

Nota

En la mayoría de los escenarios, es posible que las aplicaciones no necesiten usar estas API de representación de glifos. Una vez que una aplicación ha creado un objeto IDWriteTextLayout , puede usar el método ID2D1RenderTarget::D rawTextLayout para representar el texto.

 

Modos de representación personalizados

Varios parámetros afectan a la representación de texto, como gamma, nivel ClearType, geometría de píxeles y contraste mejorado. Los parámetros de representación se encapsulan mediante un objeto , que implementa la interfaz pública IDWriteRenderingParams . El objeto de parámetros de representación se inicializa automáticamente en función de las propiedades de hardware o las preferencias de usuario especificadas a través del applet del panel de control ClearType en Windows 7. Por lo general, si un cliente usa la API de diseño de DirectWrite, DirectWrite seleccionará automáticamente un modo de representación que corresponda al modo de medición especificado.

Las aplicaciones que quieran más control pueden usar IDWriteFactory::CreateCustomRenderingParams para implementar las distintas opciones de representación. Esta función también se puede usar para establecer la gamma, la geometría de píxeles y el contraste mejorado.

A continuación se muestran las distintas opciones de representación disponibles:

• Suavizado de alias de sub píxeles

  La aplicación establece el parámetro renderingMode en DWRITE_RENDERING_MODE_NATURAL para especificar la representación con suavizado de alias solo en la dimensión horizontal.

• Suavizado de contorno de sub píxeles en dimensiones horizontales y verticales.

  La aplicación establece el parámetro renderingMode en DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC especificar la representación con suavizado de alias tanto en dimensiones horizontales como verticales. Esto hace que las curvas y las líneas diagonales parezcan más suaves a costa de cierta suavidad, y normalmente se usan con tamaños superiores a 16 eppm.

• Texto con alias

  La aplicación establece el parámetro renderingMode en DWRITE_RENDERING_MODE_ALIASED especificar texto con alias.

• Texto de escala de grises

  La aplicación establece el parámetro pixelGeometry en DWRITE_PIXEL_GEOMETRY_FLAT especificar texto de escala de grises.

• Ancho compatible con GDI (incluido el mapa de bits incrustado de Asia Oriental)

  La aplicación establece el parámetro renderingMode en DWRITE_RENDERING_MODE_GDI_CLASSIC para especificar el suavizado de contorno de ancho compatible con GDI.

• Ancho natural de GDI

  La aplicación establece el parámetro renderingMode en DWRITE_RENDERING_MODE_GDI_NATURAL para especificar el suavizado de contornos compatibles con el ancho natural GDI.

• Texto de esquema

  Para la representación en tamaños grandes, un desarrollador de aplicaciones podría preferir representar mediante el esquema de fuente en lugar de rasterizar en un mapa de bits. La aplicación establece el parámetro renderingMode en DWRITE_RENDERING_MODE_OUTLINE para especificar que la representación debe omitir el rasterizador y usar los esquemas directamente.

Interoperabilidad de GDI

La interfaz IDWriteGdiInterop proporciona interoperabilidad con GDI. Esto permite a las aplicaciones continuar su inversión existente en bases de código GDI y usar selectivamente DirectWrite para la representación o el diseño.

A continuación se muestran las API que permiten que una aplicación migre a o desde el sistema de fuentes GDI:

• CreateFontFromLOGFONT

  Crea un objeto IDWriteFont que coincide con las propiedades especificadas por la estructura LOGFONT .

• ConvertFontToLOGFONT

  Inicializa una estructura LOGFONT basada en las propiedades compatibles con GDI del IDWriteFont especificado.

• ConvertFontFaceToLOGFONT

  Inicializa una estructura LOGFONT basada en las propiedades compatibles con GDI del IDWriteFontFace especificado.

• CreateFontFaceFromHdc

  Crea un objeto IDWriteFontFace que corresponde al HFONT seleccionado actualmente.

Conclusión

Mejorar la experiencia de lectura es de gran valor para los usuarios, ya sea en la pantalla o en papel. DirectWrite proporciona la facilidad de uso y el modelo de programación por capas para los desarrolladores de aplicaciones a fin de mejorar la experiencia de texto para sus aplicaciones Windows. Las aplicaciones pueden usar DirectWrite para representar texto con formato enriquecido para su interfaz de usuario y documentos con la API de diseño. En escenarios más complejos, una aplicación puede trabajar directamente con glifos, fuentes de acceso, etc., y aprovechar la potencia de DirectWrite para ofrecer tipografía de alta calidad.

Las funcionalidades de interoperabilidad de DirectWrite permiten a los desarrolladores de aplicaciones llevar a cabo sus códigos base win32 existentes y adoptar DirectWrite selectivamente dentro de sus aplicaciones.