Apresentando DirectWrite

As 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 por meio de conteúdo impresso, principalmente documentos, jornais, livros e assim por diante. Cada vez mais, é conteúdo online em seu computador Windows. Um usuário típico de Windows gasta muito tempo lendo da tela do computador. Eles podem estar navegando na Web, verificando emails, redigindo um relatório, preenchendo uma planilha ou escrevendo software, mas o que eles estão realmente fazendo é ler. Embora texto e fontes permeiem quase todas as partes da experiência do usuário em Windows, para a maioria dos usuários, a leitura na tela não é tão agradável quanto ler a saída impressa.

Para Windows desenvolvedores de aplicativos, escrever código de tratamento de texto é um desafio devido ao aumento dos requisitos de 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 tratamento de texto mais básico deve permitir entrada de texto, layout, exibição, edição e cópia e colagem. Windows usuários 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 limitado 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 à forma como DirectWrite permite que Windows aplicativos aprimorem a experiência de texto para interface do usuário e documentos.

Aprimorando a experiência de texto

Aplicativos Windows modernos 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 Windows desenvolvedores de aplicativos 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 gratuitos para usar a tecnologia de renderização mais adequada às suas necessidades. Isso oferece 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.

High-Quality Tipografia

DirectWrite aproveita os avanços na tecnologia fonte OpenType para habilitar a tipografia de alta qualidade em um aplicativo Windows. O sistema de fontes DirectWrite fornece serviços para lidar com enumeração de fontes, fallback de fonte e cache de fonte, que são todos necessários por aplicativos para lidar com fontes.

O suporte do 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 no GDI. O objeto DirectWrite IDWriteTypography expõe muitos dos recursos avançados de fontes OpenType, como alternativas estilísticas e lavagens. O Microsoft Windows Software Development Kit (SDK) fornece um conjunto de fontes OpenType de exemplo que são projetadas com recursos avançados, como as fontes Péricos e Pescadero. Para obter mais detalhes sobre os recursos do OpenType, consulte OpenType Font Features.

Suporte para Texto Internacional

DirectWrite usa fontes OpenType para habilitar um 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*
  • Syllabics aborígenes canadenses
  • 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 flexibilidade para adotar camadas individuais, dependendo de suas necessidades e agendamento. O diagrama a seguir mostra a relação entre essas camadas.

diagram of directwrite layers and how they communicate with an application or ui framework and the graphics api

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 o DrawText do Win32 para criar uma interface do usuário moderna com texto altamente 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 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 script e fonte.

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 que diferem apenas em peso (negrito, claro e assim por diante), estilo (vertical, itálico ou oblíquo) ou alongamento (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 Windows. As evidências da pesquisa em psicologia cognitiva indicam que precisamos ser capazes de reconhecer cada letra com precisão e que até mesmo o espaçamento entre as 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 aumenta a clareza e a legibilidade do texto. ClearType aproveita o fato de que as exibições LCD modernas têm listras RGB para cada pixel que podem ser controladas individualmente. DirectWrite usa os aprimoramentos mais recentes para ClearType, incluídos pela primeira vez com 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 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 do 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.

illustration of

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

illustration of

Observe que o espaçamento entre as letras h e n é mais uniforme na segunda imagem e a letra o está 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 em 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 em todo o intervalo de várias resoluções de exibição.

Ao contrário de qualquer tipo de renderização GDI ClearType, 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 independentemente da resolução de exibição atual e produz o resultado do posicionamento do glifo com base nas larguras avançadas de glifo verdadeiramente dimensionadas e 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 fontes pretendia. A ilustração a seguir mostra o anti-aliasing de direção y.

illustration of

Embora DirectWrite texto esteja 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 o 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 o 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 sub pixel (padrão).
  • ClearType de sub pixel com anti-aliasing em dimensões horizontais e verticais.
  • Texto aliased.
  • Largura natural do GDI (usada por Microsoft Word Modo de Exibição de Leitura, por exemplo).
  • Largura compatível com GDI (incluindo bitmap inserido no Leste Asiático).

Cada um desses modos de renderização pode ser ajustado pela API de DirectWrite e pelo novo ajuste clearType de caixa de entrada 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 muda à 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 é possível pelo suporte de 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 que o GDI. Para esses aplicativos, DirectWrite fornece modos de medição natural GDI e GDI clássicos 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. A anulação de ClearType simula uma resolução mais alta manipulando individualmente os valores de cor vermelho, verde e azul de cada pixel. A antíalia de escala de cinza calcula apenas um valor de cobertura (ou alfa) para cada pixel. ClearType é o padrão, mas a antaliasing 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 de ser desenhado ou testado. Dois objetos importantes 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 para usar em operações subsequentes.

Em seguida, o aplicativo pode renderizar o texto usando a função DrawTextLayout 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 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 personalizada 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 chegar a 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 Microsoft Word que precisa consultar os detalhes de uma fonte específica.

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

diagram of the relationship between a font collection, font family, and font face

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 fontes: 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 de 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 glifos em uma fonte DirectWrite sejam renderizados em uma superfície Direct2D ou em um bitmap independente do dispositivo GDI ou sejam convertidos em contornos ou bitmaps. A renderização ClearType no DirectWrite dá suporte ao posicionamento de sub pixel com nitidez e contraste aprimorados em comparação com implementações anteriores em Windows. DirectWrite também dá suporte ao texto em preto e branco 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 DirectWrite e também expostas por meio do novo Windows painel de controle do ajuste ClearType 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 o Direct2D API 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 combinação 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 pode ser usado para renderizar glifos. Essa API será útil se você quiser ficar com o GDI porque você tem uma base de código existente que é renderizada no 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 rosto 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 painel de controle ClearType no Windows 7. Geralmente, 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.

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 pixels e o contraste aprimorado.

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

  • Anti-aliasing 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-aliasing 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 em detrimento de alguma maciez e normalmente são usadas em tamanhos acima de 16 ppem.

  • Texto aliased

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

  • 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 antialiasing de largura compatível com GDI.

  • Largura natural do GDI

    O aplicativo define o parâmetro renderingMode como DWRITE_RENDERING_MODE_GDI_NATURAL para especificar o antialiasing 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 do 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.

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

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 Windows. Os aplicativos podem usar DirectWrite para renderizar texto com formatação avançada para a 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 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.