GDI

Question

我正在使用 Embarcadero RAD Studio（10.2 Tokyo starter）和 Windows GDI 创建一个 c++ 项目，通过 DrawText() 函数绘制文本。

我最近看到 Windows 10 提供了一种新的“Segoe UI Emoji”字体，它可能允许文本函数绘制彩色表情符号。我找到了几个使用 Direct2D 的示例，但是 none 具有纯 GDI 函数。

我也试过一个简单的代码，像这样：

HDC hDC = ::GetDC(Handle);

std::auto_ptr<TCanvas> pCanvas(new TCanvas());
pCanvas->Handle = hDC;

pCanvas->Brush->Color = clWhite;
pCanvas->Brush->Style = bsSolid;
pCanvas->FillRect(TRect(0, 0, ClientWidth, ClientHeight));

const std::wstring text = L"Test        ";

TRect textRect(10, 10, ClientWidth - 10, ClientHeight - 10);

hFont = ::CreateFont(-40,
                      0, 
                      0,
                      0,
                      FW_DONTCARE,
                      FALSE,
                      FALSE,
                      FALSE,
                      DEFAULT_CHARSET,
                      OUT_OUTLINE_PRECIS,
                      CLIP_DEFAULT_PRECIS,
                      CLEARTYPE_QUALITY,
                      VARIABLE_PITCH,
                      L"Segoe UI Emoji");

::SelectObject(hDC, hFont);

::DrawTextW(hDC,
            text.c_str(),
            text.length(),
            &textRect,
            DT_LEFT | DT_TOP | DT_SINGLELINE);

::DeleteObject(hFont);

输出结果在符号方面听起来不错，但它们是黑白绘制的，没有颜色，如下面的屏幕截图所示：

我找不到任何其他选项可以允许使用彩色符号而不是黑白符号来绘制文本。有没有一种方法可以激活 GDI DrawText() 函数中的颜色支持，如果可以，该怎么做？或者只有 Direct2D 可以绘制彩色表情符号？

编辑于 2017 年 10 月 30 日

由于 GDI 无法完成这项工作（不幸的是，正如我所想的那样）我在这里发布了上述代码的 Direct2D 版本，它对我有用。

const std::wstring text = L"Test        ";

HDC hDC = ::GetDC(Handle);

std::auto_ptr<TCanvas> pGDICanvas(new TCanvas());
pGDICanvas->Handle = hDC;

pGDICanvas->Brush->Color = clWhite;
pGDICanvas->Brush->Style = bsSolid;
pGDICanvas->FillRect(TRect(0, 0, ClientWidth, ClientHeight));

::D2D1_RECT_F textRect;
textRect.left   = 10;
textRect.top    = 10;
textRect.right  = ClientWidth  - 10;
textRect.bottom = ClientHeight - 10;

std::auto_ptr<TDirect2DCanvas> pCanvas(new TDirect2DCanvas(hDC, TRect(0, 0, ClientWidth, ClientHeight)));

// configure Direct2D font
pCanvas->Font->Size        = 40;
pCanvas->Font->Name        = L"Segoe UI Emoji";
pCanvas->Font->Orientation = 0;
pCanvas->Font->Pitch       = System::Uitypes::TFontPitch::fpVariable;
pCanvas->Font->Style       = TFontStyles();

// get DirectWrite text format object
_di_IDWriteTextFormat pFormat = pCanvas->Font->Handle;

if (!pFormat)
    return;

pCanvas->RenderTarget->SetTextAntialiasMode(D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE);

::D2D1_COLOR_F color;
color.r = 0.0f;
color.g = 0.0f;
color.b = 0.0f;
color.a = 1.0f;

::ID2D1SolidColorBrush* pBrush = NULL;

// create solid color brush, use pen color if rect is completely filled with outline
pCanvas->RenderTarget->CreateSolidColorBrush(color, &pBrush);

if (!pBrush)
    return;

// set horiz alignment
pFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING);

// set vert alignment
pFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR);

// set reading direction
pFormat->SetReadingDirection(DWRITE_READING_DIRECTION_LEFT_TO_RIGHT);

// set word wrapping mode
pFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);

IDWriteInlineObject* pInlineObject = NULL;

::DWRITE_TRIMMING trimming;
trimming.delimiter      = 0;
trimming.delimiterCount = 0;
trimming.granularity    = DWRITE_TRIMMING_GRANULARITY_NONE;

// set text trimming
pFormat->SetTrimming(&trimming, pInlineObject);

pCanvas->BeginDraw();

pCanvas->RenderTarget->DrawText(text.c_str(), text.length(), pFormat, textRect, pBrush,
            D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT);

pCanvas->EndDraw();

当然，此代码只会在 Windows 10 及更高版本的当前最新版本上绘制彩色表情符号。在以前的版本中，文本将如上所示绘制（并且代码可能无法编译）。

红利阅读

MSDN：Color Fonts with DirectWrite, Direct2D, and Win2D

Answer 1

GDI 不支持彩色字体（即使你走完整的 Uniscribe 路线），如果你想要彩色字体支持，你必须使用 Direct2D。更简单的 GDI API 不支持彩色字体是有道理的，因为彩色字体需要使用 OpenType 标签，而 none of DrawText/TextOut 提供了这种控制级别，Uniscribe 允许使用此类标签，但根本没有扩展支持彩色字体。

Answer 2

您可以使用 DirectWrite 将彩色表情符号绘制到内存 DC 中的位图上，然后 BitBlt() 到您的目标 DC。

基本上，您需要实现自定义 IDWriteTextRenderer class 并使用渲染器调用 IDWriteTextLayout::Draw()，然后复制结果。

在您的 class 中，您从 IDWriteFactory 中检索 IDWriteGdiInterop 并调用 IDWriteGdiInterop::CreateBitmapRenderTarget() 以获取位图渲染目标；调用 IDWriteFactory::CreateMonitorRenderingParams() 获取渲染参数，调用 IDWriteFactory::CreateTextFormat() 设置文本格式。

唯一重要的方法是 DrawGlyphRun()，其中您使用 IDWriteFactory2::TranslateColorGlyphRun() 和每种颜色运行得到 IDWriteColorGlyphRunEnumerator，调用 IDWriteBitmapRenderTarget::DrawGlyphRun() 来完成工作给你。

请记住在 window size/position 更改时更新渲染 target/parameters。

您可以参考这个 MSDN 文档：

渲染到 GDI 表面 https://msdn.microsoft.com/en-us/library/windows/desktop/ff485856(v=vs.85).aspx

Answer 3

如@SoronelHaetir's answer above, the win32 graphics device interface (GDI) that is used when working with static window components (via WC_STATIC所述）不支持彩色字体。为了显示彩色表情符号 and/or "fancier" 文本（即彩色文本等），您需要使用 Direct2D API.

以上由发帖者 (OP) @Jean-Milost Reymond 提供的示例并不是 reader 可以立即编译和试用的东西。此外，它使用 TCanvas class，在直接使用 Win32 API.

时并不是严格需要的

对于正在寻找适用于 bare-metal Win32 API 并且可以立即复制、粘贴和编译的完整示例的人，这里是将在 [=50= 中编译的代码]:

#define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers

// Windows Header Files
#include <windows.h>

// C RunTime Header Files
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <wchar.h>
#include <math.h>

#include <d2d1.h>
#include <d2d1helper.h>
#include <dwrite.h>
#include <wincodec.h>
#include <string>
#include <cassert>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "Dwrite.lib")

HWND WindowHandle                       = nullptr;
IDWriteFactory * DWriteFactory          = nullptr;
ID2D1Factory * Direct2dFactory          = nullptr;
ID2D1HwndRenderTarget * RenderTarget    = nullptr;
ID2D1SolidColorBrush * TextBlackBrush   = nullptr;

const std::wstring DISPLAY_TEXT         = L"Test        ";

template<class Interface>
inline void SafeRelease (Interface ** ppInterfaceToRelease);
LRESULT CALLBACK WndProc (HWND hwnd,
                          UINT message,
                          WPARAM wParam,
                          LPARAM lParam);
HRESULT CreateDeviceIndependentResources ();
HRESULT InitInstance (HINSTANCE hInstance, int nCmdShow);
void DiscardDeviceResources ();
HRESULT OnRender ();
HRESULT CreateDeviceResources ();

template<class Interface>
inline void SafeRelease (Interface ** ppInterfaceToRelease)
{
    if (*ppInterfaceToRelease != NULL)
    {
        (*ppInterfaceToRelease)->Release ();

        (*ppInterfaceToRelease) = NULL;
    }
}

HRESULT OnRender ()
{
    HRESULT Result                  = S_OK;
    D2D1_SIZE_F RenderCanvasArea    = { 0 };
    IDWriteTextFormat * TextFormat  = nullptr;
    D2D1_RECT_F TextCanvasArea      = { 0 };

    Result = CreateDeviceResources ();

    if (SUCCEEDED (Result))
    {
        RenderTarget->BeginDraw ();

        RenderCanvasArea = RenderTarget->GetSize ();

        RenderTarget->Clear (D2D1::ColorF (D2D1::ColorF::White));

        if (SUCCEEDED (Result))
        {
            Result = DWriteFactory->CreateTextFormat (L"Segoe UI",
                                                      nullptr,
                                                      DWRITE_FONT_WEIGHT_REGULAR,
                                                      DWRITE_FONT_STYLE_NORMAL,
                                                      DWRITE_FONT_STRETCH_NORMAL,
                                                      25.0f,
                                                      L"en-us",
                                                      &TextFormat);

            TextFormat->SetTextAlignment (DWRITE_TEXT_ALIGNMENT_LEADING);
            TextFormat->SetParagraphAlignment (DWRITE_PARAGRAPH_ALIGNMENT_NEAR);
            TextFormat->SetReadingDirection (DWRITE_READING_DIRECTION_LEFT_TO_RIGHT);
            TextFormat->SetWordWrapping (DWRITE_WORD_WRAPPING_WRAP);

            if (SUCCEEDED (Result) &&
                TextFormat != nullptr)
            {
                TextCanvasArea = D2D1::RectF (0,
                                              0,
                                              RenderCanvasArea.width,
                                              RenderCanvasArea.height);

                RenderTarget->DrawTextW (DISPLAY_TEXT.c_str (),
                                         static_cast <UINT32> (DISPLAY_TEXT.size ()),
                                         TextFormat,
                                         TextCanvasArea,
                                         TextBlackBrush,
                                         D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT);
            }
        }

        Result = RenderTarget->EndDraw ();
    }

    if (Result == D2DERR_RECREATE_TARGET)
    {
        DiscardDeviceResources ();

        Result = S_OK;
    }

    return Result;
}

HRESULT CreateDeviceResources ()
{
    HRESULT Result  = S_OK;
    RECT rc         = { 0 };

    if (!RenderTarget)
    {
        GetClientRect (WindowHandle,
                       &rc);

        D2D1_SIZE_U size = D2D1::SizeU (rc.right - rc.left,
                                        rc.bottom - rc.top);

        // Create a Direct2D render target.
        Result = Direct2dFactory->CreateHwndRenderTarget (D2D1::RenderTargetProperties (),
                                                          D2D1::HwndRenderTargetProperties (WindowHandle, size),
                                                          &RenderTarget);

        if (SUCCEEDED (Result))
        {
            // Create a blue brush.
            Result = RenderTarget->CreateSolidColorBrush (D2D1::ColorF (D2D1::ColorF::Black),
                                                          &TextBlackBrush);
        }
    }

    return Result;
}

void DiscardDeviceResources ()
{
    SafeRelease (&RenderTarget);
    SafeRelease (&TextBlackBrush);
}

HRESULT InitInstance (HINSTANCE hInstance,
                      int nCmdShow)
{
    HRESULT Result = S_OK;

    // Create the window.
    WindowHandle = CreateWindow (L"D2DTextDemo",
                                 L"Direct2D Text Demo Application",
                                 WS_OVERLAPPEDWINDOW,
                                 CW_USEDEFAULT,
                                 CW_USEDEFAULT,
                                 600,
                                 200,
                                 nullptr,
                                 nullptr,
                                 hInstance,
                                 nullptr);

    if (WindowHandle == nullptr)
    {
        Result = E_POINTER;
    }
    else
    {
        ShowWindow (WindowHandle,
                    nCmdShow);
        UpdateWindow (WindowHandle);
    }

    return Result;
}

HRESULT CreateDeviceIndependentResources ()
{
    HRESULT Result = S_OK;

    Result = D2D1CreateFactory (D2D1_FACTORY_TYPE_SINGLE_THREADED,
                                &Direct2dFactory);

    if (SUCCEEDED (Result))
    {
        Result = DWriteCreateFactory (DWRITE_FACTORY_TYPE_SHARED,
                                      __uuidof (IDWriteFactory),
                                      reinterpret_cast <IUnknown **> (&DWriteFactory));
    }

    return Result;
}

LRESULT CALLBACK WndProc (HWND hwnd,
                          UINT message,
                          WPARAM wParam,
                          LPARAM lParam)
{
    LRESULT Result = 0;

    switch (message)
    {
        case WM_SIZE:
        {
            UINT width = LOWORD (lParam);
            UINT height = HIWORD (lParam);

            if (RenderTarget != nullptr)
            {
                // Note: This method can fail, but it's okay to ignore the
                // error here, because the error will be returned again
                // the next time EndDraw is called.
                RenderTarget->Resize (D2D1::SizeU (width,
                                                    height));
            }
        }
        break;

        case WM_DISPLAYCHANGE:
        {
            InvalidateRect (hwnd, nullptr, FALSE);
        }
        break;

        case WM_PAINT:
        {
            OnRender ();
            ValidateRect (hwnd,
                            nullptr);
        }
        break;

        case WM_DESTROY:
        {
            PostQuitMessage (0);
            Result = 1;
        }
        break;

        default:
        {
            Result = DefWindowProc (hwnd,
                                    message,
                                    wParam,
                                    lParam);
        }
        break;
    }

    return Result;
}

int APIENTRY wWinMain (_In_ HINSTANCE hInstance,
                       _In_opt_ HINSTANCE hPrevInstance,
                       _In_ LPWSTR lpCmdLine,
                       _In_ int nCmdShow)
{
    UNREFERENCED_PARAMETER (hInstance);
    UNREFERENCED_PARAMETER (hPrevInstance);
    UNREFERENCED_PARAMETER (lpCmdLine);
    UNREFERENCED_PARAMETER (nCmdShow);

    HRESULT ExitCode    = S_OK;
    MSG NextMessage     = { 0 };
    WNDCLASSEX wcex     = { 0 };
    ATOM WindowClassId  = 0;

    wcex.cbSize         = sizeof (WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = sizeof (LONG_PTR);
    wcex.hInstance      = hInstance;
    wcex.hbrBackground  = nullptr;
    wcex.lpszMenuName   = nullptr;
    wcex.hCursor        = LoadCursor (nullptr, IDI_APPLICATION);
    wcex.lpszClassName  = L"D2DTextDemo";

    if (SUCCEEDED (CoInitialize (nullptr)))
    {
        WindowClassId = RegisterClassEx (&wcex);

        if (WindowClassId == 0)
        {
            ExitCode = HRESULT_FROM_WIN32 (GetLastError ());
        }

        if (SUCCEEDED (ExitCode))
        {
            ExitCode = CreateDeviceIndependentResources ();
        }

        if (SUCCEEDED (ExitCode))
        {
            ExitCode = InitInstance (hInstance,
                                     nCmdShow);
        }

        if (SUCCEEDED (ExitCode))
        {
            while (GetMessage (&NextMessage,
                                nullptr,
                                0,
                                0))
            {
                TranslateMessage (&NextMessage);
                DispatchMessage (&NextMessage);
            }
        }

        CoUninitialize ();

        SafeRelease (&Direct2dFactory);
        SafeRelease (&DWriteFactory);
        SafeRelease (&RenderTarget);
    }

    return ExitCode;
}

(上面的示例没有完美的错误处理，因此如果 reader 正在处理的任何项目中使用了以下代码，请务必审核此示例代码。)

在 Visual Studio 中尝试编译之前，请确保您的项目将“SubSystem”链接器选项设置为 Windows /SUBSYSTEM:WINDOWS。

编译成功后，会出现如下应用window：

我在 Visual Studio 2022 Community Edition 中于 Windows 11 成功测试了此编码示例。

参考文献：

GDI - 我可以在 DrawText 中使用新的 Windows 10 Segoe UI Emoji 彩色字体吗？

GDI - Can I use the new Windows 10 Segoe UI Emoji colored font with DrawText?

winapi

colors

emoji

红利阅读