Apresentando DirectWrite

As pessoas se comunicam com texto o tempo todo em suas vidas diárias. É a principal forma de as pessoas consumirem um volume crescente de informação. No passado, costumava ser através de conteúdo impresso, principalmente documentos, jornais, livros e assim por diante. Cada vez mais, é conteúdo on-line em seu PC com Windows. Um usuário típico do Windows passa muito tempo lendo a partir da tela do computador. Eles podem estar navegando na Web, digitalizando e-mails, compondo um relatório, preenchendo uma planilha ou escrevendo software, mas o que eles estão realmente fazendo é ler. Embora o texto e as fontes permeiem quase todas as partes da experiência do usuário no Windows, para a maioria dos usuários, ler na tela não é tão agradável quanto ler a saída impressa.

Para os desenvolvedores de aplicativos do Windows, escrever código de manipulação de texto é um desafio devido aos requisitos maiores para melhor legibilidade, formatação sofisticada e controle de layout, e suporte para os vários idiomas que o aplicativo deve exibir. Mesmo o sistema de manipulação de texto mais básico deve permitir a entrada de texto, layout, exibição, edição e cópia e colagem. Os usuários do Windows geralmente esperam ainda mais do que esses recursos básicos, exigindo até mesmo editores simples para suportar várias fontes, vários estilos de parágrafo, imagens incorporadas, verificação ortográfica e outros recursos. O design moderno da interface do usuário também não está mais confinado ao formato único, texto simples, mas precisa apresentar uma experiência melhor com fontes ricas e layouts de texto.

Esta é uma introdução a como DirectWrite permite que os aplicativos do Windows aprimorem a experiência de texto para interface do usuário e documentos.

Melhorar a experiência de texto

Os aplicativos modernos do Windows têm requisitos sofisticados para texto em sua interface do usuário e documentos. Isso inclui melhor legibilidade, suporte para uma grande variedade de linguagens e scripts e desempenho de renderização superior. Além disso, a maioria dos aplicativos existentes requer uma maneira de levar adiante os investimentos existentes na base de código WindowsWin32.

DirectWrite fornece os três recursos a seguir que permitem que os desenvolvedores de aplicativos do Windows melhorem a experiência de texto em seus aplicativos: independência do sistema de renderização, tipografia de alta qualidade e várias camadas de funcionalidade.

Rendering-System Independência

DirectWrite é independente de qualquer tecnologia gráfica específica. Os aplicativos são livres para usar a tecnologia de renderização mais adequada às suas necessidades. Isso dá aos aplicativos a flexibilidade de continuar renderizando algumas partes de seus aplicativos por meio de GDI e outras partes por meio de Direct3D ou Direct2D. Na verdade, um aplicativo pode optar por renderizar o DirectWrite por meio de uma pilha de renderização proprietária.

High-Quality Tipografia

DirectWrite aproveita os avanços na tecnologia OpenType Font para permitir tipografia de alta qualidade dentro de um aplicativo do Windows. O sistema de fontes DirectWrite fornece serviços para lidar com enumeração, fallback e cache de fontes, os quais são todos necessários para aplicações lidarem com fontes.

O suporte a OpenType fornecido pelo DirectWrite permite que os desenvolvedores adicionem aos seus aplicativos recursos tipográficos avançados e suporte para texto internacional.

Suporte para recursos tipográficos avançados

DirectWrite permite que os desenvolvedores de aplicativos desbloqueiem os recursos de fontes OpenType que eles não poderiam usar no WinForms ou GDI. O objeto DirectWrite IDWriteTypography expõe muitos dos recursos avançados das fontes OpenType, como alternativas estilísticas e swashes. O Microsoft Windows Software Development Kit (SDK) fornece um conjunto de exemplos fontes OpenType que são projetadas com recursos avançados, como as fontes Pericles e Pescadero. Para obter mais detalhes sobre os recursos do OpenType, consulte Recursos de fonte OpenType.

Suporte para Texto Internacional

DirectWrite usa fontes OpenType para permitir um amplo suporte para texto internacional. Recursos Unicode como substitutos, BIDI, quebra de linha e UVS são suportados. A itemização de script guiada por linguagem, a substituição de números e a formatação de glifos garantem que o texto em qualquer script tenha o layout e a renderização corretos.

Os seguintes scripts são suportados atualmente:

• Árabe
• Arménio
• Bengala
• Bopomofo
• Braille*
• Silábicos aborígenes canadenses
• Cherokee
• Chinês (simplificado & tradicional)
• Cirílico
• Copta*
• Devanagari
• Etíope
• Georgiano
• Glagolítico*
• Grego
• Guzerate
• Gurmukhi
• Hebraico
• Japonês
• Canarês
• Khmer
• Coreano
• Laos
• Latim
• Malaiala
• Mongol
• Mianmar
• Novo Tai Lue
• Ogham*
• Odia
• 'Phags-pa
• Rúnica*
• Cingalês
• Siríaco
• Tai Le
• Tâmil
• Telugu
• Thaana
• Tailandês
• Tibetano
• Yi

Várias camadas de funcionalidade

DirectWrite fornece camadas fatoradas de funcionalidade, com cada camada interagindo perfeitamente com a próxima. O design da API dá aos desenvolvedores de aplicativos a liberdade e a flexibilidade para adotar camadas individuais, dependendo de suas necessidades e cronograma. O diagrama a seguir mostra a relação entre essas camadas.

A API de layout de texto fornece a funcionalidade de mais alto nível disponível DirectWrite. Ele fornece serviços para o aplicativo medir, exibir e interagir com cadeias de texto ricamente formatadas. Essa API de texto pode ser usada em aplicativos que atualmente usam o DrawText do Win32 para criar uma interface do usuário moderna com texto ricamente formatado.

Aplicativos com uso intensivo de texto que implementam seu próprio mecanismo de layout podem usar a próxima camada para baixo: o processador de script. O processador de script divide um pedaço de texto em blocos de script e lida com o mapeamento entre representações Unicode para a representação de glifo apropriada na fonte para que o texto do script possa ser exibido corretamente na linguagem correta. O sistema de layout usado pela camada de API de layout de texto é construído sobre o sistema de processamento de fontes e scripts.

A camada de renderização de glifo é a camada mais baixa de funcionalidade e fornece funcionalidade de renderização de glifo para aplicativos que implementam seu próprio mecanismo de layout de texto. A camada de renderização de glifo também é útil para aplicativos que implementam um renderizador personalizado para modificar o comportamento de desenho de glifo por meio da função de retorno de chamada no DirectWrite API de formatação de texto.

O sistema de fontes DirectWrite está disponível para todas as camadas funcionais do DirectWrite e permite que um aplicativo acesse informações de fonte e glifo. Ele é projetado para lidar com tecnologias de fonte comuns e formatos de dados. O modelo de fonte DirectWrite segue a prática tipográfica comum de suportar qualquer número de pesos, estilos e alongamentos na mesma família de fontes. Este modelo, o mesmo modelo seguido por WPF e CSS, especifica que fontes diferentes apenas em peso (negrito, leve e assim por diante), estilo (vertical, itálico ou oblíquo) ou estiramento (estreito, condensado, largo e assim por diante) são consideradas membros de uma única família de fontes.

Renderização de texto melhorada com ClearType

Melhorar a legibilidade na tela é um requisito fundamental para todos os aplicativos do Windows. As evidências de pesquisas em psicologia cognitiva indicam que precisamos ser capazes de reconhecer cada letra com precisão e que até mesmo o espaçamento entre letras é fundamental para um processamento rápido. Letras e palavras que não são simétricas são percebidas como feias e degradam a experiência de leitura. Kevin Larson, grupo Microsoft Advanced Reading Technologies, escreveu um artigo sobre o assunto que foi publicado no Spectrum IEEE. O artigo chama-se "A Tecnologia do Texto".

O texto em DirectWrite é processado usando o Microsoft ClearType, o que melhora a clareza e a legibilidade do texto. A ClearType tira partido do facto de os ecrãs LCD modernos terem riscas RGB para cada pixel que podem ser controladas individualmente. O DirectWrite usa os aprimoramentos mais recentes do ClearType, incluídos pela primeira vez no Windows Vista com o Windows Presentation Foundation, que permitem avaliar não apenas as letras individuais, mas também o espaçamento entre letras. Antes dessas melhorias do ClearType, o texto com um tamanho de "leitura" de 10 ou 12 pontos era difícil de exibir: podíamos colocar 1 pixel entre letras, o que muitas vezes era muito pouco, ou 2 pixels, que muitas vezes era demais. Usar a resolução extra nos subpixels nos fornece espaçamento fracionado, o que melhora a uniformidade e simetria de toda a página.

As duas ilustrações a seguir mostram como os glifos podem começar em qualquer limite de subpixel quando o posicionamento de subpixel é usado.

A ilustração a seguir é renderizada usando a versão GDI do renderizador ClearType, que não empregava posicionamento de subpixel.

A ilustração a seguir é renderizada usando a versão DirectWrite do renderizador ClearType, que usa posicionamento de subpixel.

Note que o espaçamento entre as letras h e n é mais uniforme na segunda imagem, e a letra o está espaçada mais para longe da letra n, estando mais alinhada com a letra l. Observe também como as hastes nas letras l são mais naturais.

O posicionamento ClearType do subpixel oferece o espaçamento mais preciso de caracteres na tela, especialmente em tamanhos pequenos, onde a diferença entre um subpixel e um pixel inteiro representa uma proporção significativa da largura do glifo. Ele permite que o texto seja medido no espaço de resolução ideal e renderizado em sua posição natural na faixa de cores do LCD, com granularidade subpixel. O texto medido e processado usando esta tecnologia é, por definição, independente da resolução, o que significa que o mesmo layout exato do texto é alcançado em toda a gama de várias resoluções de exibição.

Ao contrário de qualquer tipo de renderização do GDI ClearType, o ClearType sub-pixel oferece a largura de caracteres mais precisa.

A API de cadeia de caracteres de texto adota renderização de texto de subpixel por padrão, o que significa que mede o texto em sua resolução ideal, independentemente da resolução de exibição atual, e produz o resultado de posicionamento do glifo com base nas larguras de avanço do glifo verdadeiramente dimensionadas e nos deslocamentos de posicionamento.

Para texto de tamanho grande, DirectWrite também possibilita a suavização das bordas ao longo do eixo y para tornar as bordas mais suaves e renderizar as letras como pretendido pelo designer da fonte. A ilustração a seguir mostra o antialiasing no eixo y.

Embora texto DirectWrite seja posicionado e renderizado usando ClearType de subpixel por padrão, outras opções de renderização estão disponíveis. Muitos aplicativos existentes usam GDI para renderizar a maior parte de sua interface do usuário, e alguns aplicativos usam controles de edição do sistema que continuam a usar GDI para renderização de texto. Ao adicionar texto DirectWrite a esses aplicativos, pode ser necessário sacrificar as melhorias na experiência de leitura fornecidas pelo subpixel ClearType para que o texto tenha uma aparência consistente em todo o aplicativo.

Para atender a esses requisitos, DirectWrite também oferece suporte às seguintes opções de renderização:

• Sub-pixel ClearType (padrão).
• Sub-pixel ClearType com suavização de serrilhado nas duas direções, horizontal e vertical.
• Texto com alias.
• GDI de largura natural (usado pelo Modo de Exibição de Leitura do Microsoft Word, por exemplo).
• Largura compatível com GDI (incluindo mapa de bits incorporado do Leste Asiático).

Cada um desses modos de renderização pode ser ajustado por meio da API DirectWrite e do novo sintonizador ClearType da caixa de entrada do Windows 7.

Suporte para Layout Natural

O layout natural é independente da resolução, portanto, o espaçamento dos caracteres não muda à medida que você aumenta ou diminui o zoom, ou dependendo do DPI da tela. Uma vantagem secundária é que o espaçamento é fiel ao design da fonte. O layout natural é possibilitado pelo suporte do DirectWrite para renderização natural, o que significa que glifos individuais podem ser posicionados em uma fração de pixel.

Embora o layout natural seja o padrão, alguns aplicativos precisam renderizar texto com o mesmo espaçamento e aparência do GDI. Para tais aplicações, o DirectWrite fornece os modos de medição GDI classic e GDI natural e os modos de renderização correspondentes.

Qualquer um dos modos de renderização acima pode ser combinado com qualquer um dos dois modos de suavização: ClearType ou escala de cinza. O antialiasing ClearType simula uma resolução mais alta manipulando individualmente os valores de cor vermelho, verde e azul de cada pixel. A suavização em tons de cinza calcula apenas um valor de cobertura (ou alfa) para cada pixel. ClearType é o padrão, mas a suavização em tons de cinza é recomendada para aplicações da Windows Store porque é mais rápida e compatível com a suavização de serrilhado padrão, embora ainda seja altamente legível.

Visão geral da API

A interface IDWriteFactory é o ponto de partida para usar a funcionalidade DirectWrite. A fábrica é o objeto raiz que cria um conjunto de objetos que podem ser usados juntos.

A operação de formatação e layout é um pré-requisito para outras operações, pois o texto precisa ser formatado corretamente e disposto em um conjunto especificado de restrições antes de poder ser desenhado ou submetido a testes de acertos. Dois objetos principais que você pode criar com um IDWriteFactory para essa finalidade são IDWriteTextFormat e IDWriteTextLayout. Um IDWriteTextFormat objeto representa as informações de formatação de um parágrafo de texto. A função IDWriteFactory::CreateTextLayout usa a cadeia de caracteres de entrada, as restrições associadas, como a dimensão do espaço a ser preenchido e a IDWriteTextFormat objeto, e coloca o resultado totalmente analisado e formatado em IDWriteTextLayout para usar em operações subsequentes.

O aplicativo pode então renderizar o texto usando a funçãoDrawTextLayout fornecida pelo Direct2D ou implementando uma função de retorno de chamada que pode usar GDI, Direct2D ou outros sistemas gráficos para renderizar os glifos. Para um único formato de texto, a funçãoDrawText no Direct2D fornece uma maneira mais simples de desenhar texto sem ter que criar primeiro um IDWriteTextLayout objeto.

Formatação e desenho "Hello World" usando DirectWrite

O exemplo de código a seguir mostra como um aplicativo pode formatar um único parágrafo usando IDWriteTextFormat e desenhá-lo usando a funçãoDirect2DDrawText.

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

Acesso ao sistema de fontes

Além de especificar um nome de família de fontes para a cadeia de caracteres de texto usando a interfaceIDWriteTextFormatno exemplo acima, DirectWrite fornece aos aplicativos mais controle sobre a seleção de fontes por meio da enumeração de fontes e a capacidade de criar uma coleção de fontes personalizada com base em fontes de documentos incorporadas.

O objeto IDWriteFontCollection é uma coleção de famílias de fontes. DirectWrite fornece acesso ao conjunto de fontes instaladas no sistema através de uma coleção de fontes especial chamada coleção de fontes do sistema. Isso é obtido chamando o GetSystemFontCollection método do IDWriteFactory objeto. Um aplicativo também pode criar uma coleção de fontes personalizada a partir de um conjunto de fontes enumeradas por um retorno de chamada definido pelo aplicativo, ou seja, fontes particulares instaladas por um aplicativo ou fontes incorporadas em um documento.

O aplicativo pode então chamar GetFontFamily para chegar a um objeto FontFamily específico dentro da coleção e, em seguida, chamar IDWriteFontFamily::GetFirstMatchingFont para chegar a um objetoIDWriteFontespecífico. O objeto IDWriteFont representa uma fonte em uma coleção de fontes e expõe propriedades e algumas métricas básicas de fonte.

O IDWriteFontFace é outro objeto que representa uma fonte e expõe um conjunto completo de métricas em uma fonte. O IDWriteFontFace pode ser criado diretamente a partir de um nome de fonte; Um aplicativo não precisa obter uma coleção de fontes para acessá-lo. É útil para um aplicativo de layout de texto, como o Microsoft Word, que precisa consultar os detalhes de uma fonte específica.

O diagrama a seguir ilustra a relação entre esses objetos.

IDWriteFontFace

O IDWriteFontFace objeto representa uma fonte e fornece informações mais detalhadas sobre a fonte do que o IDWriteFont objeto. As métricas de fonte e glifo do IDWriteFontFace são úteis para aplicativos que implementam layout de texto.

A maioria dos aplicativos principais não usará essas APIs diretamente e, em vez disso, usará IDWriteFont ou especificará o nome da família de fontes diretamente.

A tabela a seguir resume os cenários de uso para os dois objetos.

A seguir está um aplicativo de exemplo que enumera as fontes na coleção de fontes do 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);
}

Renderização de texto

As APIs de renderização de texto permitem que glifos em uma fonte DirectWrite sejam renderizados em uma superfície Direct2D ou em um bitmap independente de dispositivo GDI, ou sejam convertidos em contornos ou bitmaps. A renderização ClearType no DirectWrite suporta o posicionamento de subpixels com nitidez e contraste aprimorados em comparação com implementações anteriores no Windows. O DirectWrite também suporta texto em preto e branco com alias para suportar cenários que envolvem fontes do Leste Asiático com bitmaps incorporados ou onde o usuário desabilitou a suavização de fontes de qualquer tipo.

Todas as opções são ajustáveis por todos os botões ClearType disponíveis acessíveis através do DirectWrite APIs, e também expostas através do novo miniaplicativo do painel de controle do sintonizador ClearType do Windows 7.

Há duas APIs disponíveis para renderização de glifos, uma fornecendo renderização acelerada por hardware por meio de Direct2D e a outra fornecendo renderização de software para um bitmap GDI. Um aplicativo usando IDWriteTextLayout e implementando o retorno de chamada IDWriteTextRenderer pode chamar qualquer uma dessas funções em resposta a um retorno de chamadaDrawGlyphRun. Além disso, os aplicativos que implementam seu próprio layout ou lidam com dados no nível do glifo podem usar essas APIs.

1. ID2DRenderTarget::DrawGlyphRun

   Os aplicativos podem usar a API Direct2Do DrawGlyphRun para fornecer aceleração de hardware para renderização de texto usando a GPU. A aceleração de hardware afeta todas as fases do pipeline de renderização de texto — desde a junção de glifos em corridas de glifos e a filtragem do bitmap das corridas de glifos até à aplicação do algoritmo de mistura ClearType ao resultado final exibido. Esta é a API recomendada para obter o melhor desempenho de renderização.

2. IDWriteBitmapRenderTarget::DrawGlyphRun

   As aplicações podem usar o método IDWriteBitmapRenderTarget::DrawGlyphRun para executar uma renderização por software de uma sequência de glifos para um bitmap de 32 bits por pixel. O objeto IDWriteBitmapRenderTarget encapsula um bitmap e um contexto de dispositivo de memória que pode ser usado para renderizar glifos. Essa API é útil se você quiser permanecer com o GDI porque você tem uma base de código existente que renderiza no GDI.

Se você tiver um aplicativo que tenha código de layout de texto existente que usa GDI e quiser preservar seu código de layout existente, mas usar DirectWrite apenas para a etapa final de renderização de glifos, IDWriteGdiInterop::CreateFontFaceFromHdc fornece a ponte entre as duas APIs. Antes de chamar esta função, o aplicativo usará a função IDWriteGdiInterop::CreateFontFaceFromHdc para obter uma referência de tipo de letra de um contexto de dispositivo.

Modos de renderização personalizados

Vários parâmetros afetam a renderização de texto, como gama, nível ClearType, geometria de pixel e contraste aprimorado. Os parâmetros de renderização são encapsulados por um objeto que implementa a interface pública IDWriteRenderingParams. O objeto de parâmetros de renderização é inicializado automaticamente com base nas propriedades de hardware e/ou preferências do usuário especificadas através do miniaplicativo do painel de controle ClearType no Windows 7. Geralmente, se um cliente usar a API de layout DirectWrite, o DirectWrite selecionará automaticamente um modo de renderização que corresponda ao modo de medição especificado.

Os aplicativos que desejam mais controle podem usar IDWriteFactory::CreateCustomRenderingParams para implementar as diferentes opções de renderização. Esta função também pode ser usada para definir a gama, geometria de pixel e contraste aprimorado.

A seguir estão as várias opções de renderização disponíveis:

• Anti-aliasing de subpixels

  A aplicação define o parâmetro renderingMode como DWRITE_RENDERING_MODE_NATURAL para especificar a renderização com anti-aliasing apenas na dimensão horizontal.

• Anti-aliasing de subpixel em dimensões horizontais e verticais.

  A aplicação define o parâmetro renderingMode para DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC para especificar a renderização com suavização de borda nas dimensões horizontal e vertical. Isso faz com que as curvas e linhas diagonais pareçam mais suaves em detrimento de alguma suavidade, e normalmente é usado em tamanhos acima de 16 ppem.

• Texto com alias

  O aplicativo define o renderingMode parâmetro para DWRITE_RENDERING_MODE_ALIASED para especificar texto com alias.

• Texto em tons de cinza

  O aplicativo define o parâmetro pixelGeometry como DWRITE_PIXEL_GEOMETRY_FLAT para especificar texto em tons de cinza.

• Largura compatível com GDI (incluindo bitmap incorporado do Leste Asiático)

  A aplicação define o parâmetro renderingMode como DWRITE_RENDERING_MODE_GDI_CLASSIC para especificar o anti-aliasing de largura compatível com GDI.

• GDI largura natural

  A aplicação define o parâmetro renderingMode como DWRITE_RENDERING_MODE_GDI_NATURAL para especificar a suavização de serrilhado compatível com a largura natural do GDI.

• Texto de esquema

  Para renderizar em tamanhos grandes, um desenvolvedor de aplicativos pode preferir renderizar usando o contorno da fonte em vez de rasterizar em um bitmap. O aplicativo define o parâmetro renderingMode como DWRITE_RENDERING_MODE_OUTLINE para especificar que a renderização deve ignorar o rasterizador e usar os contornos diretamente.

Interoperabilidade GDI

A interface IDWriteGdiInterop fornece interoperabilidade com GDI. Isso permite que os aplicativos continuem seu investimento existente em bases de código GDI e usem seletivamente DirectWrite para renderização ou layout.

A seguir estão as APIs que permitem que um aplicativo migre de ou para o sistema de fontes GDI:

• CreateFontFromLOGFONT

  Cria um IDWriteFont objeto que corresponde às propriedades especificadas pela estruturaLOGFONT.

• ConvertFontToLOGFONT

  Inicializa uma estrutura LOGFONT com base nas propriedades compatíveis com GDI do IDWriteFont especificado.

• ConvertFontFaceToLOGFONT

  Inicializa uma estrutura de LOGFONT com base nas propriedades compatíveis com GDI doIDWriteFontFace especificadoIDWriteFontFace.

• CreateFontFaceFromHdc

  Cria um objeto IDWriteFontFace que corresponde ao HFONT atualmente selecionado.

Conclusão

Melhorar a experiência de leitura é de grande valor para os usuários, seja na tela ou no papel. DirectWrite fornece a facilidade de uso e o modelo de programação em camadas para desenvolvedores de aplicativos melhorarem a experiência de texto para seus aplicativos do Windows. Os aplicativos podem usar o DirectWrite para renderizar texto ricamente formatado para sua interface do usuário e documentos com a API de layout. Para cenários mais complexos, um aplicativo pode trabalhar diretamente com glifos, fontes de acesso e assim por diante, e aproveitar o poder do DirectWrite para fornecer tipografia de alta qualidade.

Os recursos de interoperabilidade do DirectWrite permitem que os desenvolvedores de aplicativos levem adiante suas bases de código Win32 existentes e adotem o DirectWrite seletivamente em seus aplicativos.