Examples: A very simple example of High DPI changing handling for Win32

[Demonese]

High DPI changing handling

There are some key points:

• The application must High DPI aware.
• Remember to handling WM_DPICHANGED message.
• Once receiving the WM_DPICHANGED message, reload fonts and resize style metrics according to DPI scaling.
• Texture resources (font atlas textures) are also need to reload.
• Remember, our font atlas texture ID is invalid now. We should skip rendering untill next GUI frame update.

Updating and rendering during window resizing or moving

I also show another interesting thing: How to updating and rendering during window resizing or moving?
Microsift provide us a simple solution: updating and rendering in WM_PAINT.
Well, I don't think this is a good solution, because we don't know how WM_PAINT messages are generated and how often are they sent. Also, many apps/games have their own update loop via FPS limiter.
But if we don't want to write multithreaded applications and the requirement of update frequency is not high, this might be the best choise :)

Video

2021-03-16.15-50-01.mp4

Example application

Requirement:

• imgui
• imgui_impl_win32
• imgui_impl_dx9

// Dear ImGui: standalone example application for DirectX 9
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs

// This is a example of very simple High DPI supported and DPI changing handling:
//  - Resize Win32 window automatically (WM_DPICHANGED)
//  - Resize Dear ImGui font automatically
//  - Resize style metrics automatically

#include "imgui.h"
#include "imgui_impl_dx9.h"
#include "imgui_impl_win32.h"
#include <d3d9.h>

// Window data
static WNDCLASSEXW  g_WndCls  = {};
static ATOM         g_WndAtom = 0;
static HWND         g_hWnd    = NULL;

// Window functions
bool CreateWindowWin32();
void DestroyWindowWin32();
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

// D3D9 Data
static IDirect3D9*           g_pD3D       = NULL;
static IDirect3DDevice9*     g_pd3dDevice = NULL;
static D3DPRESENT_PARAMETERS g_d3dpp      = {};

// D3D9 functions
bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void ResetDevice();

// Dear ImGui data
static ImGuiContext* g_pUIContext         = NULL;
static bool          g_IsUITextureIDValid = false;

// Dear ImGui functions
bool CreateUI();
void DestroyUI();
bool UpdateUIScaling(float scale = 1.0f);

// Main Loop data
static bool   g_IsInitialized     = false;
static bool   show_demo_window    = true;
static ImVec4 clear_color         = ImVec4(0.94f, 0.94f, 0.94f, 1.00f);

// Main Loop
void Update()
{
    if (!g_IsInitialized)
        return;
    
    // Start the Dear ImGui frame
    ImGui_ImplDX9_NewFrame();
    ImGui_ImplWin32_NewFrame();
    g_IsUITextureIDValid = true;
    ImGui::NewFrame();
    
    // 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
    if (show_demo_window)
        ImGui::ShowDemoWindow(&show_demo_window);
    
    // 2. Show a simple window that we create ourselves. We use a Begin/End pair to created a named window.
    if (ImGui::Begin("High DPI changing handling"))
    {
        // Color style selector (auto change background color)
        if (ImGui::ShowStyleSelector("Colors##New Selector"))
            clear_color = ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
        
        ImGui::Checkbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
        ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
        ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
    }
    ImGui::End();
    
    // finish
    ImGui::EndFrame();
    ImGui::Render();
}
void Render()
{
    if (!g_IsInitialized)
        return;
    
    // Rendering
    g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
    g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
    g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
    D3DCOLOR clear_col_dx = D3DCOLOR_RGBA((int)(clear_color.x*clear_color.w*255.0f), (int)(clear_color.y*clear_color.w*255.0f), (int)(clear_color.z*clear_color.w*255.0f), (int)(clear_color.w*255.0f));
    g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, clear_col_dx, 1.0f, 0);
    if (g_pd3dDevice->BeginScene() >= 0)
    {
        if (g_IsUITextureIDValid)
        {
            ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
        }
        g_pd3dDevice->EndScene();
    }
    HRESULT result = g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
    
    // Handle loss of D3D9 device
    if (result == D3DERR_DEVICELOST && g_pd3dDevice->TestCooperativeLevel() == D3DERR_DEVICENOTRESET)
        ResetDevice();
}

// Main code
int WINAPI wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
{
    ImGui_ImplWin32_EnableDpiAwareness();
    
    // Create application window
    if (!CreateWindowWin32())
    {
        DestroyWindowWin32();
        return 1;
    }
    HWND hwnd = g_hWnd;
    
    // Initialize Direct3D
    if (!CreateDeviceD3D(hwnd))
    {
        CleanupDeviceD3D();
        DestroyWindowWin32();
        return 1;
    }
    
    // Initialize Dear ImGUI
    if (!CreateUI())
    {
        DestroyUI();
        CleanupDeviceD3D();
        DestroyWindowWin32();
        return 1;
    }
    
    // Show the window
    ::ShowWindow(hwnd, SW_SHOWDEFAULT);
    ::UpdateWindow(hwnd);
    
    // Main loop
    MSG msg = {};
    ZeroMemory(&msg, sizeof(MSG));
    g_IsInitialized = true;
    while (msg.message != WM_QUIT)
    {
        // Poll and handle messages (inputs, window resize, etc.)
        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
        if (::PeekMessageW(&msg, NULL, 0U, 0U, PM_REMOVE))
        {
            ::TranslateMessage(&msg);
            ::DispatchMessageW(&msg);
        }
    }
    g_IsInitialized = false;
    
    DestroyUI();
    CleanupDeviceD3D();
    DestroyWindowWin32();
    
    return 0;
}

// Window functions
bool CreateWindowWin32()
{
    ZeroMemory(&g_WndCls, sizeof(WNDCLASSEXW));
    g_WndCls.cbSize = sizeof(WNDCLASSEXW);
    g_WndCls.style = CS_HREDRAW | CS_VREDRAW;
    g_WndCls.lpfnWndProc = &WndProc;
    g_WndCls.hInstance = GetModuleHandleW(NULL);
    g_WndCls.lpszClassName = L"Window";
    
    g_WndAtom = ::RegisterClassExW(&g_WndCls);
    if (g_WndAtom == 0)
        return false;
    
    g_hWnd = ::CreateWindowExW(
        0, g_WndCls.lpszClassName, L"Dear ImGui DirectX9 Example", WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 1280, 800,
        //CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, g_WndCls.hInstance, NULL);
    return g_hWnd != NULL;
}
void DestroyWindowWin32()
{
    if (g_hWnd)
        ::DestroyWindow(g_hWnd);
    g_hWnd = NULL;
    if (g_WndAtom != 0)
        ::UnregisterClassW(g_WndCls.lpszClassName, g_WndCls.hInstance);
    g_WndAtom = 0;
}
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
    if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
        return true;
    
    #ifndef USER_DEFAULT_SCREEN_DPI
    #define USER_DEFAULT_SCREEN_DPI 96
    #endif
    #ifndef WM_DPICHANGED
    #define WM_DPICHANGED 0x02E0
    #endif
    
    switch (msg)
    {
    case WM_SIZE:
        if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED)
        {
            g_d3dpp.BackBufferWidth = LOWORD(lParam);
            g_d3dpp.BackBufferHeight = HIWORD(lParam);
            ResetDevice();
        }
        return 0;
    case WM_SYSCOMMAND:
        if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
            return 0;
        break;
    case WM_PAINT:
        Update();
        Render();
        return 0;
    case WM_DPICHANGED:
        {
            RECT* rect = (RECT*)lParam;
            IM_ASSERT(LOWORD(wParam) == HIWORD(wParam));
            ::SetWindowPos(hWnd, NULL, rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top, SWP_NOZORDER);
            UpdateUIScaling((float)LOWORD(wParam) / (float)USER_DEFAULT_SCREEN_DPI);
        }
        return 0;
    case WM_DESTROY:
        ::PostQuitMessage(0);
        return 0;
    }
    return ::DefWindowProcW(hWnd, msg, wParam, lParam);
}

// D3D9 functions
bool CreateDeviceD3D(HWND hWnd)
{
    if ((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
        return false;
    
    // Create the D3DDevice
    ZeroMemory(&g_d3dpp, sizeof(g_d3dpp));
    g_d3dpp.Windowed = TRUE;
    g_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    g_d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; // Need to use an explicit format with alpha if needing per-pixel alpha composition.
    g_d3dpp.EnableAutoDepthStencil = TRUE;
    g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;           // Present with vsync
    //g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;   // Present without vsync, maximum unthrottled framerate
    if (g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &g_d3dpp, &g_pd3dDevice) < 0)
        return false;
    
    return true;
}
void CleanupDeviceD3D()
{
    if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; }
    if (g_pD3D) { g_pD3D->Release(); g_pD3D = NULL; }
}
void ResetDevice()
{
    g_IsUITextureIDValid = false;
    ImGui_ImplDX9_InvalidateDeviceObjects();
    HRESULT hr = g_pd3dDevice->Reset(&g_d3dpp);
    if (hr == D3DERR_INVALIDCALL)
        IM_ASSERT(0);
    ImGui_ImplDX9_CreateDeviceObjects();
}

// Dear ImGui functions
bool CreateUI()
{
    // Setup Dear ImGui context
    if (!IMGUI_CHECKVERSION())
        return false;
    g_pUIContext = ImGui::CreateContext();
    
    // Setup Dear ImGui flags
    ImGuiIO& io = ImGui::GetIO();
    IM_UNUSED(io);
    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
    ImGui::StyleColorsLight();
    clear_color = ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
    
    // Setup Platform/Renderer backends
    if (!ImGui_ImplWin32_Init(g_hWnd))
        return false;
    if (!ImGui_ImplDX9_Init(g_pd3dDevice))
        return false;
    float dpiscale = ImGui_ImplWin32_GetDpiScaleForHwnd(g_hWnd);
    if (!UpdateUIScaling(dpiscale > 1.0f ? dpiscale : 1.0f)) // Avoid floor to 0.0f scaling
        return false;
    
    return true;
}
void DestroyUI()
{
    g_IsUITextureIDValid = false;
    ImGui_ImplDX9_Shutdown();
    ImGui_ImplWin32_Shutdown();
    if (g_pUIContext)
        ImGui::DestroyContext(g_pUIContext);
    g_pUIContext = NULL;
}
bool UpdateUIScaling(float scale)
{
    ImGuiIO& io = ImGui::GetIO();
    
    g_IsUITextureIDValid = false;
    ImGui_ImplDX9_InvalidateDeviceObjects();
    
    // Setup Dear ImGui style
    ImGuiStyle& style = ImGui::GetStyle();
    ImGuiStyle styleold = style; // Backup colors
    style = ImGuiStyle(); // IMPORTANT: ScaleAllSizes will change the original size, so we should reset all style config
    style.WindowBorderSize = 1.0f;
    style.ChildBorderSize  = 1.0f;
    style.PopupBorderSize  = 1.0f;
    style.FrameBorderSize  = 1.0f;
    style.TabBorderSize    = 1.0f;
    style.WindowRounding    = 0.0f;
    style.ChildRounding     = 0.0f;
    style.PopupRounding     = 0.0f;
    style.FrameRounding     = 0.0f;
    style.ScrollbarRounding = 0.0f;
    style.GrabRounding      = 0.0f;
    style.TabRounding       = 0.0f;
    style.ScaleAllSizes(scale);
    CopyMemory(style.Colors, styleold.Colors, sizeof(style.Colors)); // Restore colors
    
    io.Fonts->Clear();
    
    // Load Fonts
    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
    // - If the file cannot be loaded, the function will return NULL. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
    // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
    // - Read 'docs/FONTS.md' for more instructions and details.
    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
    //io.Fonts->AddFontDefault();
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/ProggyTiny.ttf", 10.0f);
    //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
    //IM_ASSERT(font != NULL);
    ImFont* font = io.Fonts->AddFontFromFileTTF("C:\\Windows\\Fonts\\msyh.ttc", 16.0f * scale);
    if (font == NULL)
        font = io.Fonts->AddFontFromFileTTF("C:\\Windows\\Fonts\\msyh.ttf", 16.0f * scale); // Windows 7
    IM_ASSERT(font != NULL);
    if (font == NULL)
        return false;
    
    return ImGui_ImplDX9_CreateDeviceObjects();
}