Apresentando DirectWrite

Pessoas se comunicam com texto o tempo todo em suas vidas diárias. É a principal maneira de as pessoas consumirem um volume crescente de informações. No passado, costumava ser através de conteúdo impresso, principalmente documentos, jornais, livros e assim por diante. Cada vez mais, ele é conteúdo online em seu computador Windows. Um usuário típico do Windows passa muito tempo lendo na tela do computador. Eles podem estar navegando na Web, digitalizando emails, redigindo 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, a leitura na tela não é tão agradável quanto ler a saída impressa.

Para desenvolvedores de aplicativos do Windows, escrever código de tratamento de texto é um desafio devido aos requisitos aumentados para melhor legibilidade, formatação sofisticada e controle de layout e suporte para os vários idiomas que o aplicativo deve exibir. Até mesmo o sistema de tratamento de texto mais básico deve permitir 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 dar suporte a várias fontes, vários estilos de parágrafo, imagens inseridas, verificação ortográfica e outros recursos. O design de interface do usuário moderno também não está mais restrito a formato único, texto sem formatação, mas precisa apresentar uma experiência melhor com fontes avançadas e layouts de texto.

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

Aprimorando 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 idiomas e scripts e desempenho de renderização superior. Além disso, a maioria dos aplicativos existentes exige uma maneira de levar adiante os investimentos existentes na base de código do 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.

Independência do Rendering-System

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 seu aplicativo por meio de GDI e outras partes por meio do Direct3D ou Direct2D. Na verdade, um aplicativo pode optar por renderizar DirectWrite por meio de uma pilha de renderização proprietária.

Tipografia High-Quality

DirectWrite aproveita os avanços na tecnologia Fonte OpenType para habilitar tipografia de alta qualidade em um aplicativo do Windows. O sistema de fontes DirectWrite fornece serviços para lidar com enumeração de fonte, fallback de fonte e cache de fontes, que são todos necessários para aplicativos para lidar 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 não puderam usar no WinForms ou na GDI. O objeto IDWriteTypography DirectWrite expõe muitos dos recursos avançados de fontes OpenType, como alternativas estilísticas e lavagens. O SDK (Software Development Kit) do Microsoft Windows fornece um conjunto de fontes OpenType de exemplo 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 habilitar amplo suporte para texto internacional. Há suporte para recursos Unicode, como substitutos, BIDI, quebra de linha e UVS. A itemização de script guiado por idioma, a substituição de números e a formatação de glifo garantem que o texto em qualquer script tenha o layout e a renderização corretos.

Os scripts a seguir tem suporte atualmente:

Observação

Para scripts marcados com um *, não há fontes padrão do sistema. Os aplicativos devem instalar fontes que dão suporte a esses scripts.

 

• Árabe
• Armênia
• Bengala
• Bopomofo
• Braille*
• Sílabica aborígene canadense
• Cherokee
• Chinês (tradicional simplificado & )
• Cirílico
• Copta*
• Devanagari
• Etíope
• Georgiano
• Glagolitic*
• Grego
• Guzerate
• Gurmukhi
• Hebraico
• Japonês
• canarim
• Khmer
• Coreano
• Lao
• Latim
• Malaiala
• Mongol
• Myanmar
• Tai Lue Novo
• Ogham*
• Oriá
• 'Phags-pa
• Runic*
• Sinhala
• Siríaco
• Tai Le
• Tâmil
• Télugo
• 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 agendamento. O diagrama a seguir mostra a relação entre essas camadas.

A API de layout de texto fornece a funcionalidade de nível mais alto disponível de DirectWrite. Ele fornece serviços para o aplicativo medir, exibir e interagir com cadeias de caracteres de texto ricamente formatadas. Essa API de texto pode ser usada em aplicativos que atualmente usam 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 uma parte do texto em blocos de script e manipula 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 no idioma correto. O sistema de layout usado pela camada de API de layout de texto é criado 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 na API de formatação de texto DirectWrite.

O sistema de fontes DirectWrite está disponível para todas as camadas funcionais DirectWrite e permite que um aplicativo acesse informações de fonte e glifo. Ele foi 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 dar suporte a qualquer número de pesos, estilos e alongamentos na mesma família de fontes. Esse modelo, o mesmo modelo seguido por WPF e CSS, especifica que fontes diferentes somente em peso (negrito, claro e assim por diante), estilo (vertical, itálico ou oblíquo) ou stretch (estreito, condensado, largo e assim por diante) são considerados membros de uma única família de fontes.

Renderização de texto aprimorada 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 o 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 é chamado de "A Tecnologia do Texto".

O texto em DirectWrite é renderizado usando o Microsoft ClearType, o que melhora a clareza e a legibilidade do texto. ClearType aproveita o fato de que as telas LCD modernas têm listras RGB para cada pixel que pode ser controlado individualmente. DirectWrite usa os aprimoramentos mais recentes para ClearType, incluídos primeiro no Windows Vista com Windows Presentation Foundation, que permite avaliar não apenas as letras individuais, mas também o espaçamento entre letras. Antes desses aprimoramentos do ClearType, o texto com um tamanho de "leitura" de 10 ou 12 pontos era difícil de exibir: poderíamos colocar um pixel entre letras, o que era muitas vezes muito pequeno, ou 2 pixels, o que muitas vezes era demais. O uso da resolução extra nos subpixels nos fornece espaçamento fracionário, o que melhora a paridade e a simetria de toda a página.

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

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

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

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

O posicionamento ClearType de subpixel oferece o espaçamento mais preciso dos caracteres na tela, especialmente em tamanhos pequenos em que a diferença entre um sub pixel e um pixel inteiro representa uma proporção significativa de largura de 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 LCD, com granularidade de subpixel. O texto medido e renderizado usando essa tecnologia é, por definição, independente de resolução, o que significa que exatamente o mesmo layout de texto é obtido no intervalo de várias resoluções de exibição.

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

A API de Cadeia de Texto adota a renderização de texto de sub pixel por padrão, o que significa que ela mede o texto em sua resolução ideal independente da resolução de exibição atual e produz o resultado do posicionamento do glifo com base nas larguras de avanço de glifo verdadeiramente dimensionadas e nos deslocamentos de posicionamento.

Para texto de tamanho grande, DirectWrite também permite o anti-aliasing ao longo do eixo y para tornar as bordas mais suaves e renderizar letras como o designer de fonte pretendia. A ilustração a seguir mostra o anti-aliasing de direção y.

Embora DirectWrite texto seja posicionado e renderizado usando ClearType de sub pixel 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 de sistema que continuam a usar gDI para renderização de texto. Ao adicionar DirectWrite texto a esses aplicativos, pode ser necessário sacrificar as melhorias da experiência de leitura fornecidas pelo ClearType de sub pixel para que o texto tenha uma aparência consistente em todo o aplicativo.

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

• ClearType de sub pixel (padrão).
• ClearType de sub pixel com anti-aliasing em dimensões horizontais e verticais.
• Texto aliased.
• Largura natural da GDI (usada pela Exibição de Leitura do Microsoft Word, por exemplo).
• Largura compatível com GDI (incluindo bitmap inserido no Leste Asiático).

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

Observação

Começando com Windows 8, você deve usar a suavização de texto em escala de cinza na maioria dos casos. Para obter mais informações, confira a próxima seção.

 

Suporte para Layout Natural

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

Embora o layout natural seja o padrão, alguns aplicativos precisam renderizar texto com o mesmo espaçamento e aparência que a GDI. Para esses aplicativos, DirectWrite fornece modos de medição natural GDI clássicos e GDI e 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. As simulações de suavização ClearType têm uma resolução mais alta manipulando individualmente os valores de cor vermelho, verde e azul de cada pixel. A computação de suavização em escala de cinza calcula apenas um valor de cobertura (ou alfa) para cada pixel. ClearType é o padrão, mas a suavização em escala de cinza é recomendada para aplicativos da Windows Store porque é mais rápida e é compatível com a suavização padrão, embora ainda seja altamente legível.

Visão geral da API

A interface IDWriteFactory é o ponto de partida para usar DirectWrite funcionalidade. 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 as operações, pois o texto precisa ser formatado corretamente e disposto em um conjunto especificado de restrições antes que possa ser desenhado ou testado com clique. Dois objetos principais que você pode criar com um IDWriteFactory para essa finalidade são IDWriteTextFormat e IDWriteTextLayout. Um objeto IDWriteTextFormat 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 o objeto IDWriteTextFormat , e coloca o resultado totalmente analisado e formatado em IDWriteTextLayout a ser usado em operações subsequentes.

Em seguida, o aplicativo pode renderizar o texto usando a função DrawTextLayout fornecida por 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 texto de formato único, a função DrawText no Direct2D fornece uma maneira mais simples de desenhar texto sem precisar primeiro criar um objeto IDWriteTextLayout.

Formatação e desenho "Olá, Mundo" 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ção 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;
}

Acessando o sistema de fontes

Além de especificar um nome de família de fontes para a cadeia de caracteres de texto usando a interface IDWriteTextFormat no 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 personalizadas com base em fontes de documento inseridas.

O objeto IDWriteFontCollection é uma coleção de famílias de fontes. DirectWrite fornece acesso ao conjunto de fontes instaladas no sistema por meio de uma coleção de fontes especial chamada coleção de fontes do sistema. Isso é obtido chamando o método GetSystemFontCollection do objeto IDWriteFactory . 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 privadas instaladas por um aplicativo ou fontes inseridas em um documento.

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

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 objeto IDWriteFontFace representa uma fonte e fornece informações mais detalhadas sobre a fonte do que o objeto IDWriteFont . As métricas de fonte e glifo do IDWriteFontFace são úteis para aplicativos que implementam o layout de texto.

A maioria dos aplicativos tradicionais 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 dos dois objetos.

Categoria	IDWriteFont	IDWriteFontFace
APIs para dar suporte à interação do usuário, como uma interface do usuário do seletor de fontes: descrição e outras APIs informativas	Sim	Não
APIs para dar suporte ao mapeamento de fonte: família, estilo, peso, alongamento, cobertura de caracteres	Sim	Não
DrawText API	Sim	Não
APIs usadas para renderização	Não	Sim
APIs usadas para layout de texto: métricas de glifo e assim por diante	Não	Sim
APIs para controle de interface do usuário e layout de texto: métricas em toda a fonte	Sim	Sim

 

Veja a seguir 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 os glifos em uma fonte DirectWrite sejam renderizados em uma superfície de Direct2D ou em um bitmap independente do dispositivo GDI ou sejam convertidos em estruturas de tópicos ou bitmaps. A renderização ClearType no DirectWrite dá suporte ao posicionamento de sub pixel com nitidez e contraste aprimorados em comparação com as implementações anteriores no Windows. DirectWrite também dá suporte a texto em preto e branco com alias para dar suporte a cenários que envolvem fontes do Leste Asiático com bitmaps inseridos ou em que 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 por meio das APIs de DirectWrite e também expostos por meio do novo miniaplicativo do painel de controle ClearType do Windows 7.

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

1. ID2DRenderTarget::D rawGlyphRun

   Os aplicativos podem usar a API Direct2D 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 mesclar glifos em execuções de glifo e filtrar o bitmap de execução de glifo até aplicar o algoritmo de mesclagem ClearType à saída final exibida. Essa é a API recomendada para obter o melhor desempenho de renderização.

2. IDWriteBitmapRenderTarget::D rawGlyphRun

   Os aplicativos podem usar o método IDWriteBitmapRenderTarget::D rawGlyphRun para executar uma renderização de software de uma execução de glifos em um bitmap de 32 bpp. O objeto IDWriteBitmapRenderTarget encapsula um bitmap e um contexto de dispositivo de memória que podem ser usados para renderizar glifos. Essa API será útil se você quiser permanecer com a GDI porque você tem uma base de código existente que é renderizada na GDI.

Se você tiver um aplicativo que tenha um código de layout de texto existente que use 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 fornecerá a ponte entre as duas APIs. Antes de chamar essa função, o aplicativo usará a função IDWriteGdiInterop::CreateFontFaceFromHdc para obter uma referência de face de fonte de um contexto de dispositivo.

Observação

Para a maioria dos cenários, talvez os aplicativos não precisem usar essas APIs de renderização de glifo. Depois que um aplicativo tiver criado um objeto IDWriteTextLayout , ele poderá usar o método ID2D1RenderTarget::D rawTextLayout para renderizar o texto.

 

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 IDWriteRenderingParams pública. O objeto de parâmetros de renderização é inicializado automaticamente com base em propriedades de hardware e/ou preferências de usuário especificadas por meio do miniaplicativo do painel de controle ClearType no Windows 7. Em geral, se um cliente usar a API de layout DirectWrite, 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. Essa função também pode ser usada para definir o gama, a geometria de pixel e o contraste aprimorado.

Estas são as várias opções de renderização disponíveis:

• Anti-alias de sub-pixel

  O aplicativo define o parâmetro renderingMode como DWRITE_RENDERING_MODE_NATURAL para especificar a renderização com anti-aliasing somente na dimensão horizontal.

• Anti-alias de sub-pixel em dimensões horizontais e verticais.

  O aplicativo define o parâmetro renderingMode como DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC para especificar a renderização com anti-aliasing em dimensões horizontais e verticais. Isso faz com que as curvas e linhas diagonais pareçam mais suaves às custas de alguma suavidade e normalmente é usada em tamanhos acima de 16 ppem.

• Texto com alias

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

• Texto em escala de cinza

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

• Largura compatível com GDI (incluindo bitmap inserido no Leste Asiático)

  O aplicativo define o parâmetro renderingMode como DWRITE_RENDERING_MODE_GDI_CLASSIC para especificar o anti-aliasing de largura compatível com GDI.

• Largura natural da GDI

  O aplicativo define o parâmetro renderingMode como DWRITE_RENDERING_MODE_GDI_NATURAL para especificar o anti-aliasing compatível com largura natural GDI.

• Texto da estrutura de tópicos

  Para renderização em tamanhos grandes, um desenvolvedor de aplicativos pode preferir renderizar usando a estrutura de tópicos 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 as estruturas de tópicos diretamente.

Interoperabilidade de GDI

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

Veja a seguir as APIs que permitem que um aplicativo migre de ou para o sistema de fontes GDI:

• CreateFontFromLOGFONT

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

• ConvertFontToLOGFONT

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

• ConvertFontFaceToLOGFONT

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

• CreateFontFaceFromHdc

  Cria um objeto IDWriteFontFace que corresponde ao HFONT selecionado no momento.

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 os desenvolvedores de aplicativos melhorarem a experiência de texto para seus aplicativos do Windows. Os aplicativos podem usar DirectWrite para renderizar texto com formatação avançada 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, acessar fontes e assim por diante e aproveitar o poder de 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 DirectWrite seletivamente em seus aplicativos.