Este artículo proviene de un motor de traducción automática.

El factor DirectX

¿Quién teme glifo funciona?

Charles Petzold

Descargar el código de ejemplo

Primero encontré el concepto de glifos de caracteres en Windows Presentation Foundation (WPF) algunos años atrás. En tipografía, "glifo" se refiere a la representación gráfica de un carácter más bien su función en una determinada lengua escrita, que es indicada por el valor Unicode de los personajes. Sabía que el elemento de WPF glifos y GlyphRun clase representó una forma alternativa para mostrar el texto, pero parecían añadir una capa de complejidad innecesaria. La mayor rareza había involucrado hace referencia a un tipo de letra deseada no por un nombre de familia de fuentes, sino por la ruta del archivo del archivo fuente real. Yo había estado codificando para Windows desde las versiones beta de 1.0, y nunca antes había necesitaba hacer referencia a un tipo de letra por el nombre de archivo. Simplemente no es cómo se hace.

Rápidamente llegué a la conclusión que glifos y GlyphRun eran mucho demasiado esotérico para los programadores como yo. Sólo años después cuando comencé a trabajar con la especificación de papel XML de Microsoft (XPS) hicieron el fundamento glifos llegan a ser evidentes.

La distinción fundamental

Normalmente cuando un programa solicita una fuente de Windows, lo hace mediante un nombre de familia de fuentes tales como Century Schoolbook y atributos tales como cursiva o negrita. En tiempo de ejecución Windows encuentra un archivo de fuente en el sistema del usuario con un tipo de letra que coincida con el nombre de familia. Cursiva y negrita tampoco puede ser intrínseco a este tipo de letra o sintetizada por el sistema. Para colocar texto, Windows o la aplicación accede a información métrica de fuentes que describe los tamaños de los caracteres de la fuente.

¿Qué sucede si dos usuarios distintos tienen dos archivos de diferentes fuentes en sus sistemas que contienen un tipo de letra con el nombre de familia Century Schoolbook, pero con métricas de fuente diferente? Eso no es un problema real. Porque el texto formateado y establecida en tiempo de ejecución, la representación real de estas dos fuentes podría ser ligeramente diferente, pero realmente no importa. Programas de aplicación están diseñados para ser flexibles en ese sentido.

Documentos XPS son diferentes, sin embargo. Como PDF, XPS describe un documento fijo. Todo el texto en cada página es ya establecido y colocado precisamente. Si dicho documento se procesa con una fuente que es ligeramente diferente de la fuente utilizada para diseñar la página, no se verá bien. Es por eso documentos XPS a menudo contienen archivos de fuentes incrustadas, y las páginas XPS utilizan el elemento Glyphs para referencia a estos archivos fuente y representar el texto. Cualquier ambigüedad es eliminado totalmente.

Normalmente nos referimos a los caracteres de texto de códigos de caracteres. Normalmente no necesitamos saber nada sobre el glifo preciso que le pasa a mostrarse como consecuencia de ese código de caracteres con una fuente particular. Pero a veces es importante tener más control sobre los glifos ellos mismos.

Usted podría asumir hay una correspondencia biunívoca entre códigos de caracteres y glifos de una fuente determinada, y que suele ser el caso. Pero hay excepciones muy importantes: Algunos ficheros contienen ligaduras, que son solos glifos correspondientes a pares de caracteres como fi, fl. Algunos conjuntos de caracteres no latinos requieren múltiples pictogramas para representar un carácter único. Además, algunos ficheros contienen pictogramas alternativos para algunos personajes — por ejemplo, un cero con una barra atravesada, pequeñas mayúsculas utilizados para mayúsculas o Letras con caracteres decorativos estilísticos. Estas alternativas estilísticas son característicos de un archivo de fuente particular en lugar de una fuente. Por eso el fichero adecuado es crucial.

Si escribes una aplicación Windows Store de Windows 8, usted puede hacer uso de estas alternativas estilísticas a través de la API de tiempo de ejecución de Windows. Capítulo 16 de "Programación Windows, 6ª edición" (o ' Reilly Media, 2012) tiene un programa llamado TypographyDemo que muestra cómo hacer justamente eso. Pero el soporte subyacente para los glifos en Windows 8 se implementa en DirectX y el poder de glifos que ellos mismos se revela más en ese ambiente.

El soporte de DirectX glifo

Explorar cómo se muestra glifos en DirectX consiste en trazar un camino a través de varias interfaces, métodos y estructuras.

Comencemos con la interfaz ID2D1RenderTarget, que contiene los métodos básicos para mostrar texto y gráficos 2D. Esta interfaz define un método DrawGlyphRun. Este método requiere una estructura de tipo DWRITE_GLYPH_RUN que describe los glifos que se muestra, y también las referencias de un objeto de tipo IDWriteFontFace.

Una forma de obtener un objeto IDWriteFontFace es a través del método CreateFontFace de IDWriteFactory. Este método requiere un objeto IDWriteFontFile, que se obtiene mediante el método CreateFontFileReference de IDWriteFactory.

El método CreateFontFileReference hace referencia a un archivo fuente utilizando una ruta y un nombre de archivo. Sin embargo, si estás usando DirectX en una aplicación Windows Store, su aplicación probablemente no tendrá pleno y libre acceso al disco duro del usuario, y generalmente no puede acceder a fuentes de esa manera. Cualquier archivo fuente de que referencia con CreateFontFileReference es probable que se definirá como un recurso de aplicación y obligarse en el paquete de la aplicación.

Sin embargo, usted no puede incluir cualquier archivo de fuente en el paquete de aplicación. Si una fuente es parte de su aplicación, debe tener una licencia para distribuir esa fuente. Afortunadamente, Microsoft ha autorizado varios ficheros de ascendente Corp. con el propósito expreso de permitir que repartirlos con su aplicación. Estos ficheros se han utilizado principalmente para aplicaciones de XNA, pero también son interesantes desde una perspectiva de glifos.

Entre el código descargable para esta columna es un programa llamado GlyphDump que he creado basado en la plantilla de aplicación DirectX (XAML) en Visual Studio Express 2013 escuchar. Esta plantilla crea una aplicación que procesa gráficos DirectX en un SwapChainPanel.

Que crea un nuevo filtro (y la carpeta correspondiente) en el proyecto de GlyphDump llamado Fonts y agrega los archivos 10 fuente bajo licenciados de ascendente Corp. Un control ListBox en DirectXPage.xaml enumera explícitamente los nombres de familia de estas fuentes, con propiedades de etiqueta hace referencia a los nombres de archivo. Cuando uno es seleccionado, el programa construye la ruta y el nombre del archivo fuente como sigue:

Package::Current->InstalledLocation->Path +
  "\\Fonts\\" + filename;

La clase GlyphDumpRenderer utiliza ese camino para crear un objeto IDWriteFontFile y un objeto IDWriteFontFace.

El resto del trabajo se produce en el método Render, como se muestra en la figura 1.

Figura 1 el método Render en GlyphDump

bool GlyphDumpRenderer::Render()
{
  if (!m_needsRedraw)
      return false;
  ID2D1DeviceContext* context = m_deviceResources->GetD2DDeviceContext();
  context->SaveDrawingState(m_stateBlock.Get());
  context->BeginDraw();
  context->Clear(ColorF(ColorF::White));
  context->SetTransform(m_deviceResources->GetOrientationTransform2D());
  if (m_fontFace != nullptr)
  {
    Windows::Foundation::Size outputBounds = m_deviceResources->GetOutputBounds();
    uint16 glyphCount = m_fontFace->GetGlyphCount();
    int rows = (glyphCount + 16) / 16;
    float boxHeight = outputBounds.Height / (rows + 1);
    float boxWidth = outputBounds.Width / 17;
    // Define entire structure except glyphIndices
    DWRITE_GLYPH_RUN glyphRun;
    glyphRun.fontFace = m_fontFace.Get();
    glyphRun.fontEmSize = 0.75f * min(boxHeight, boxWidth);
    glyphRun.glyphCount = 1;
    glyphRun.glyphAdvances = nullptr;
    glyphRun.glyphOffsets = nullptr;
    glyphRun.isSideways = false;
    glyphRun.bidiLevel = 0;
    for (uint16 index = 0; index < glyphCount; index++)
    {
      glyphRun.glyphIndices = &index;
      context->DrawGlyphRun(Point2F(((index) % 16 + 0.5f) * boxWidth,
                                    ((index) / 16 + 1) * boxHeight),
                                    &glyphRun,
                                    m_blackBrush.Get());
    }
  }
  // We ignore D2DERR_RECREATE_TARGET here.
This error indicates
  // that the device is lost.
It will be handled during
  // the next call to Present.
HRESULT hr = context->EndDraw();
  if (hr != D2DERR_RECREATE_TARGET)
  {
    DX::ThrowIfFailed(hr);
  }
  context->RestoreDrawingState(m_stateBlock.Get());
  m_needsRedraw = false;
  return true;
}

Este método Render muestra todos los glifos en el fichero seleccionado en filas de 16 glifos cada uno, así que intenta calcular un valor fontEmSize lo suficientemente pequeño para esa pantalla. (Para algunas fuentes con glifos muchos, esto no funcionará bien.) Normalmente el campo glyphIndices de la estructura DWRITE_GLYPH_RUN es un conjunto de índices de glifo. Aquí sólo estoy mostrando un glifo en un momento.

El método DrawGlyphRun requiere un punto de coordenadas, la estructura DWRITE_GLYPH_RUN y un cepillo. La coordenada indica donde el borde izquierdo de la base del glifo colocarse. Note que dije "inicial". Esto es diferente de la mayoría métodos de visualización de texto, que requieren la especificación de la esquina superior izquierda del primer carácter.

Figura 2 muestra quizá la fuente más interesante de este lote, que tiene un apellido de Pescadero y archivo fuente de Pesca.ttf.

Figura 2 el programa de GlyphDump mostrando la fuente Pescadero

Antes de escribir este programa, nunca había visto una pantalla como esta. Empieza buscando algo así como una tabla ASCII tradicional, pero hay un montón de glifos para subscripting numérico y poner toda una colección de ligaduras de varias clases, además de letras mayúsculas con caracteres decorativos decorativos.

Obviamente, el campo glyphIndices de la DWRITE_GLYPH_RUN no es lo mismo que un código de caracteres. Estos son los índices que hacen referencia a los glifos reales dentro del archivo fuente, y estos glifos incluso no necesitan estar en cualquier tipo de orden racional.

Texto con glifos

Ya se puede ver alguna utilidad en ser capaz de Mostrar texto utilizando un archivo de fuente específica con índices de glifo en lugar de códigos de caracteres. Puede especificar exactamente qué glifos que quieras.

El proyecto puestoelegante demuestra esto. La idea aquí es que tienes un programa que es mayormente basada en XAML, pero quieres un título fantasia utilizando algunas ligaduras y caracteres decorativos de la fuente Pescadero. El proyecto incluye el archivo Pesca.ttf, y el archivo XAML define el SwapChainPanel para tener una anchura de 778 y una altura de 54, valores que elegí empírico basados en el tamaño del texto representado.

Porque los requisitos de exhibición de este proyecto son simples, me quitaron la clase FancyTitleMain y las clases de representación, dejando la clase DirectXPage para representar a la SwapChainPanel. (Sin embargo, tuve que modificar ligeramente para hacer IDeviceNotify una interfaz de clase ref para que DirectXPage podría implementar IDevice DeviceResources­notificar y ser notificado cuando el dispositivo de salida está perdido y recreado.)

La salida de texto que se muestra en la figura 3 tiene 24 caracteres, pero sólo 22 glifos. Reconocerás las ligaduras y los caracteres decorativos de figura 2.

Figura 3 la salida de puestoelegante

He hecho el fondo DirectX Alice Blue así se puede ver que el SwapChainPanel es apenas más grande que el texto. Por supuesto, es posible anticipar el tamaño de la salida, precisamente porque el archivo fuente es parte de la aplicación y los glifos se está accediendo directamente.

Puedes ligaduras y pictogramas alternativos sin utilizar DrawGlyphRun. También puedes obtenerlos con menos precisión utilizando el elemento TextBlock en el tiempo de ejecución de Windows, como la tipografía­se muestra el programa de demostración de mi libro de Windows 8. En DirectWrite, puede utilizar el método SetTypography de IDWriteTextLayout con un objeto IDWriteTypography, que en definitiva hace referencia a un miembro de la enumeración DWRITE_FONT_FEATURE_TAG extensa. Pero estas técnicas no son tan segura como especificar precisamente los glifos.

¿Cómo consigues cursiva y negrita con DrawGlyphRun? En muchos casos, archivos de diferentes fuentes contendrá las variaciones negritas y cursiva de una fuente. Entre las fuentes incluidas en el programa de GlyphDump son un par de fuente en negritas y una fuente de luz. Sin embargo, también tiene la opción para simular oblicuas y audaces caracteres usando los parámetros DWRITE_FONT_SIMULATIONS en CreateFontFace.

Avances y desvíos

Tanto GlyphDump y puestoelegante han decidido dos de los campos en DWRITE_GLYPH_RUN nullptr. Estos dos campos se denominan glyphAdvances y glyphOffsets.

Cuando visualiza un conjunto de pictogramas, se especifica el origen de la base izquierda del primer carácter. Para cada personaje sucesiva, la coordenada horizontal del origen aumenta automáticamente basándose en el ancho del personaje. (Un proceso similar ocurre cuando muestre texto lateral). Este aumento es conocido como un "avance".

Usted puede obtener los avances que DirectX utiliza para espacio entre caracteres llamando al método GetDesignGlyphMetrics de IDWriteFontFace. El resultado es una matriz de estructuras DWRITE_GLYPH_METRICS, uno para cada índice de glifo en el cual estás interesado. El campo advanceWidth de esa estructura indica el avance en relación al campo de designUnitsPerEm de la estructura DWRITE_FONT_METRICS obtenido por el método de GetMetrics de IDWriteFontFace, y que también incluye verticales métricas aplicables a glifos todos dentro de una fuente determinada.

O, puede llamar al método GetDesignGlyphAdvances de IDWriteFontFace1, que también ofrece avances en relación con el valor designUnitsPerEm. Los valores se dividen por designUnitsPerEm (que es a menudo un buen valor ronda como 2.048) y luego multiplicar por el em el tamaño especificado en DWRITE_GLYPH_RUN.

La matriz glyphAdvances se utiliza comúnmente para espacio personajes más juntos o más separados que indican los parámetros de diseño. Si usted decide utilizarla, necesitará establecer glyphAdvances en una matriz de valores que es por lo menos el tamaño de la matriz de índices de glifo, menos uno. No es necesario un adelanto sobre el glifo final porque no se muestra nada más allá de eso.

El campo glyphOffsets es una matriz de estructuras DWRITE_GLYPH_OFFSET, uno para cada personaje. Los dos campos son advanceOffset y ascenderOffset, que indican un desplazamiento deseado (a la derecha y arriba, respectivamente) en relación a la situación normal del personaje. Esta instalación se utiliza a menudo en archivos XPS para colocar varios glifos de una fuente particular en toda la página.

El programa CenteredGlyphDump muestra cómo utilizar el campo glyphOffsets para mostrar la matriz completa de glifos de un archivo fuente particular con una sola llamada DrawGlyphRun:

context->DrawGlyphRun(Point2F(), &m_glyphRun, m_blackBrush.Get());

La coordenada pasada a DrawGlyphRun es (0, 0), y glyphAdvances se establece en una matriz de valores cero para inhibir el avance de glifos sucesivas. La posición de cada glifo es gobernada enteramente por glyphOffsets. Esta posición se basa en métricas de glifo al centro cada glifo en su columna. Figura 4 muestra el resultado.

Figura 4 el programa de CenteredGlyphDump

Proporcionar su propia fuente cargadora

Si un archivo de fuente es parte de un paquete de aplicaciones, es bastante fácil derivar una ruta de archivo que se puede utilizar con CreateFontReference. Pero ¿qué pasa si usted tiene una fuente que se encuentra en un paquete XPS o EPUB, tal vez en almacenamiento aislado o en la nube?

Mientras se puede escribir código que tiene acceso el archivo fuente, DirectX puede acceder a él. Usted necesitará proporcionar dos clases, una que implementa IDWriteFontFileLoader y otra que implementa IDWriteFontFileStream. Generalmente, la clase que implementa IDWriteFontFileLoader es un singleton que tiene acceso a todos los archivos fuente su aplicación va a necesitar y asigna a cada uno de ellos una llave. El método CreateStreamFromKey en la implementación de IDWriteFontFileLoader devuelve una instancia de IDWriteFontStream para cada archivo fuente.

Para utilizar estas dos clases, primero crear una instancia de una sola instancia de la clase que implementa IDWriteFontFileLoader y pasar a la RegisterFontFileLoader del objeto IDWriteFactory. Entonces, en lugar de llamar a CreateFontFileReference para obtener un objeto IDWriteFontFile, llame CreateCustomFontFileReference con esta instancia de IDWriteFontFileLoader y una clave identificar el fichero especial que quieras.

Esta técnica se demuestra en el programa CenteredGlyphDump. El proyecto incluye dos clases: PrivateFontFileLoader y PrivateFontFileStream — que implementan las dos interfaces. Las clases de fuente de acceso a archivos en el paquete de la aplicación, pero podrían ser adaptados para otros fines.

Es probable su implementación IDWriteFontFileLoader tendrá que hacer llamadas archivo I/O, y en una aplicación Windows Store, estas llamadas deben ser asincrónicas. Hace mucho sentido para la clase IDWriteFontFileLoader definir un método asincrónico que carga todas las fuentes en la memoria y para la IDWriteFontFileStream volver simplemente punteros a estos bloques de memoria. Este es el enfoque que tomé con PrivateFontFileLoader y PrivateFontFileStream, después de examinar de cerca la Direct2D revista App muestra entre el código de ejemplo de Microsoft para Windows 8.1.

Para que la clave para identificar cada archivo, he utilizado el nombre de archivo. Una vez terminado el método de carga asincrónica en PrivateFontFileLoader, el programa CenteredGlyphDump obtiene estos nombres de archivo para el control ListBox. Por eso sólo los nombres de archivo se muestran en figura 4. El programa es ignorante de los nombres de familia font asociados con cada archivo.

De caracteres de glifos

¿Por supuesto, Mostrar texto mediante una referencia a glifos está bien si sabes exactamente qué glifos que necesita, pero usted puede mostrar caracteres Unicode normales usando DrawGlyphRun?

Puedes, porque IDWriteFontFace tiene un método GetGlyphIndices que se convierte códigos de caracteres en los índices de glifo para el archivo de fuente particular. Al hacer esto, recoge el glifo predeterminado para cada código de carácter, así que no tendrás ninguna de las alternativas de lujosa.

Pero los códigos de caracteres que se pasa a GetGlyphIndices en una forma tal vez única en todas ventanas. En lugar de caracteres de 16 bits códigos (como es el caso cuando se trabaja normalmente con cadenas de caracteres Unicode), necesitas crear un array de códigos de caracteres de 32 bits. Como sabrás, Unicode es en realidad un personaje 21 bits, pero caracteres comúnmente se almacenan como valores de 16 bits (llamados UTF-16), que significa que algunos caracteres componen de dos valores de 16 bits. Pero quiere que GetGlyphIndices los valores de 32 bits. A menos que su cadena de caracteres tenga caracteres con códigos arriba 0xFFFF, simplemente puede transferir los valores de una matriz a otra.

Si estás tratando con caracteres normales del alfabeto latino, también puede suponer que existe una correspondencia biunívoca entre personajes y glifos. De lo contrario, necesitará crear una matriz de salida más grande para recibir a los índices.

Esta técnica simple queda demostrada por el proyecto HelloGlyphRun. Figura 5 muestra el código que carga un archivo de fuente y establece una estructura DWRITE_GLYPH_RUN. El método Update ajusta las glifo compensaciones para lograr una especie de efecto del texto de ondulación.

Figura 5 definir un DWRITE_GLYPH_RUN de una cadena de caracteres

// Convert string to glyph indices
std::wstring str = L"Hello, Glyph Run!";
uint32 glyphCount = str.length();
std::vector<uint32> str32(glyphCount);
for (uint32 i = 0; i < glyphCount; i++)
     str32[i] = str[i];
m_glyphIndices = std::vector<uint16>(glyphCount);
m_fontFace->GetGlyphIndices(str32.data(), glyphCount, m_glyphIndices.data());
// Allocate array for offsets (set during Update)
m_glyphOffsets = std::vector<DWRITE_GLYPH_OFFSET>(glyphCount);
// Get output bounds
Windows::Foundation::Size outputBounds = m_deviceResources->GetOutputBounds();
// Define fields of DWRITE_GLYPH_RUN structure
m_glyphRun.fontFace = m_fontFace.Get();
m_glyphRun.fontEmSize = outputBounds.Width / 8; // Empirical
m_glyphRun.glyphCount = glyphCount;
m_glyphRun.glyphIndices = m_glyphIndices.data();
m_glyphRun.glyphAdvances = nullptr;
m_glyphRun.glyphOffsets = m_glyphOffsets.data();
m_glyphRun.isSideways = false;
m_glyphRun.bidiLevel = 0;

Aunque usted probablemente utilizará DrawGlyphRun sólo con archivos de fuentes con que está íntimamente familiarizado, es posible determinar qué tipo de glifos están contenidos en un archivo de fuente particular en tiempo de ejecución. IDWriteFontFace define un método TryGetFontTable que tiene acceso a las tablas en el archivo OpenFont. Utilice una etiqueta de "cmap" para el personaje-a-glifo mesa y "GSUB" de la tabla de sustitución de glifo, pero esté preparado para pasar muchas horas insoportables con la especificación de OpenType leer estas tablas con éxito.

Glifo funciona utilizando fuentes del sistema

DrawGlyphRun sólo sirve para archivos de fuentes que usted mismo suministra. Al principio parece que sí, pero usted puede utilizarlo con fuentes del sistema también. Aquí es el proceso: Utilice el método GetSystemFontCollection de IDWriteFactory para obtener un objeto IDWriteFontCollection. Ese objeto le permite encontrar todos los nombres de familia asociados con las fuentes instaladas en el sistema. El método GetFontFamily de IDWriteFontCollection devuelve un objeto de tipo IDWriteFontFamily. De eso, puede llamar a GetMatchingFonts o GetFirstMatchingFont para la familia de fuentes se combinan con atributos cursiva, negritas y estiramiento para obtener un IDWriteFont.

Una vez que tiene un objeto IDWriteFont, llame a CreateFontFace para obtener un objeto IDWriteFontFace. Es el mismo tipo de objeto Obtenido de CreateFontFace en los programas anteriores. De ese objeto puede empezar a establecer una estructura DWRITE_GLYPH_RUN para DrawGlyphRun.

Esto se demuestra en el proyecto SystemFontGlyphs. El proyecto utiliza el GetSystemFontCollection en su clase DirectXPage para llenar un ListBox con los nombres de familia de fuentes de sistema. Cuando se selecciona un elemento, un objeto IDWriteFontFace que se pasa al renderizador se deriva.

La clase SystemFontGlyphsRenderer construye una estructura DWRITE_GLYPH_RUN basada en el texto "Molestos vibrante efecto de texto." El método Update entonces está obligado a establecer los valores de la matriz de las compensaciones de glifo de números al azar entre -3 y 3, haciendo parecer como si todos los caracteres de la cadena de texto independiente vibran.

No parece que mucha diferencia conceptual entre IDWriteFont y IDWriteFontFace, excepto que IDWriteFont siempre representa una fuente que no es parte de una colección de fuentes (por ejemplo, la colección de fuentes del sistema) mientras que la necesidad de IDWriteFontFace. IDWriteFontCollection tiene un método GetFontFromFontFace que acepta un IDWriteFontFace y devuelve el IDWriteFont correspondiente, pero funciona sólo si el archivo fuente asociado con el IDWriteFontFace es parte de la colección de fuentes.

Colecciones personalizadas Font

Ya has visto cómo se puede utilizar DrawGlyphRun con archivos de fuentes que se carga la aplicación, así como con fuentes del sistema. ¿Es posible utilizar los métodos de salida de texto normales (DrawText y DrawTextLayout) con sus propios archivos de fuente?

Sí. Usted podrá recordar que tanto DrawText y DrawTextLayout requieren un objeto IDWriteTextFormat. Esto se crea utilizando el método CreateTextFormat de IDWriteFactory especificando un nombre de familia font y una colección de fuentes.

Normalmente se establece ese argumento colección fuente nullptr para indicar fuentes del sistema. Pero también puede crear una colección de fuentes personalizadas llamando al método CreateCustomFontCollection de IDWriteFactory. Usted necesitará suministrar su propia clase que implementa la interfaz IDWriteFontCollectionLoader y otra clase que implementa IDWriteFontFileEnumerator.

Esto se demuestra en el programa ResourceFontLayout. El programa también incluye la implementación de las interfaces IDWriteFontFileLoader y IDWriteFontFileStream de centrado­GlyphDump. Cuando usted obtener la lista de familias de fuentes de esta colección de fuentes personalizadas, usted notará esa fuente múltiples archivos a veces se consolidan en una sola familia.

El premio en la parte inferior de la caja

En este punto, la importancia de la IDWriteFontFace debe ser evidente. Puede crear un objeto IDWriteFontFace desde dos direcciones: o directamente desde un archivo fuente, eligiendo una fuente particular de una colección de fuentes. Entonces usted esta IDWriteFontFace en una estructura DWRITE_GLYPH_RUN de referencia o usarlo para obtener métricas de glifo o para acceder a tablas en el archivo fuente.

IDWriteFontFace también define un método denominado GetGlyphRun­contorno. Los argumentos de este método son muy parecidos como los campos de la estructura DWRITE_GLYPH_RUN, pero un argumento adicional es un IDWriteGeometrySink, que es lo mismo que un ID2D1SimplifiedGeometrySink.

Esto significa que puede convertir una cadena de texto a un ID2D1PathGeometry, representar y manipular esa geometría en la forma que quieras. Figura 6 es una captura de pantalla del programa OutlinedCharacters que muestra una geometría de carácter que ha acariciado y llenos; la misma geometría prestada con un estilo punteado (que se anima a hacer los puntos alrededor de los personajes de viajes); y la geometría se amplió y se señala, en efecto, delineando los contornos.

Figura 6 el programa de OutlinedCharacters

Y apenas estoy empezando.

Charles Petzold es desde hace mucho tiempo colaborador de MSDN Magazine y el autor de "Programación Windows, 6ª edición" (o ' Reilly Media, 2012), un libro acerca de cómo escribir aplicaciones para Windows 8. Su sitio Web es charlespetzold.com.

Gracias a los siguientes expertos técnicos de Microsoft por su ayuda en la revisión de este artículo: Jim Galasyn y Justin Panian