Using C++ Magnification API (MagSetWindowTransform) shows both zoomed and normal window simultaneously

Question

Using C++ Magnification API (MagSetWindowTransform) shows both zoomed and normal window simultaneously

Pallavi Bhosale 0

I am trying to implement a feature similar to the Windows Magnifier using the Windows Magnification API in C++.

I am using MagSetWindowTransform to apply zoom (scaling) on a magnifier window. The magnification itself works, but I am facing an unexpected issue when zooming in.

Issue Description

When I apply a transform using MagSetWindowTransform:

The zoomed (magnified) content is displayed correctly

At the same time, the original 100% (non-zoomed) content is also visible

As a result, it looks like two windows are rendered:

One zoomed window

One normal-sized window

This is not the expected behavior. I want behavior similar to Windows Magnifier, where only the magnified content is visible, not both.

What I Expect

Only a single magnified view should be displayed

The original (non-magnified) content should not appear simultaneously

The magnifier window should fully replace the normal view when zoomed

What I Am Currently Doing

Creating a magnifier window using CreateWindow

Initializing Magnification API with MagInitialize

Applying scaling using MAGTRANSFORM and MagSetWindowTransform

Using a host window + magnifier child window

Despite this, the unscaled content is still visible behind or alongside the magnified content.

Questions

Is this dual rendering (zoomed + normal) expected behavior with MagSetWindowTransform?

Am I missing a required window style, clipping, or redraw setting to suppress the normal content?

Do I need to:

Hide or invalidate the host window?

Use MagSetWindowSource differently?

Apply specific extended window styles (WS_EX_LAYERED, WS_EX_TRANSPARENT, etc.)?

How does Windows Magnifier internally avoid showing the original unscaled content?

Is there a recommended architecture (fullscreen magnifier vs windowed magnifier) to avoid this issue?

Environment

Language: C++

API: Windows Magnification API

OS: Windows 10 / Windows 11

Magnification method: MagSetWindowTransform

Any guidance, sample code, or explanation of the correct window/magnifier setup would be greatly appreciated.

Pallavi Bhosale 0

Below is the standalone code. and attached is screenshot where we can see window twice

OSKDouble

#include <windows.h>

#include <algorithm> // std::sort, std::unique, std::remove_if, std::find

#include <string> // std::wstring

#include <magnification.h>

#include <iostream>

#include <mutex>

#include <vector>

#pragma comment(lib, "Magnification.lib")

HWND hwndHost = NULL;

HWND hwndMag = NULL;

float zoomLevel = 1.0f; // Start at 100%

bool zoomEnabled = false;

POINT lastCursorPos = { -1, -1 };

float lastZoomLevel = 1.0f;

std::mutex magMutex; // Mutex for thread safety

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {

switch (message) {

case WM_TIMER: {

    if (zoomLevel < 1.0f) {

        zoomLevel = 1.0f;

    }

    POINT pt;

    if (GetCursorPos(&pt)) {

        int screenWidth = GetSystemMetrics(SM_CXSCREEN);

        int screenHeight = GetSystemMetrics(SM_CYSCREEN);

        int halfWidth = static_cast<int>(screenWidth / (2 * zoomLevel));

        int halfHeight = static_cast<int>(screenHeight / (2 * zoomLevel));

        // Calculate the source rectangle centered around the cursor

        RECT sourceRect;

        sourceRect.left = max(0, pt.x - halfWidth);

        sourceRect.top = max(0, pt.y - halfHeight);

        sourceRect.right = sourceRect.left + 2 * halfWidth;

        sourceRect.bottom = sourceRect.top + 2 * halfHeight;

        // Clamp the rectangle to ensure it doesn't exceed screen boundaries

        if (sourceRect.right > screenWidth) {

            sourceRect.right = screenWidth;

            sourceRect.left = max(0, screenWidth - 2 * halfWidth);

        }

        if (sourceRect.bottom > screenHeight) {

            sourceRect.bottom = screenHeight;

            sourceRect.top = max(0, screenHeight - 2 * halfHeight);

        }

        // Ensure the source rectangle is valid

        if (sourceRect.left < sourceRect.right && sourceRect.top < sourceRect.bottom) {

            MagSetWindowSource(hwndMag, sourceRect);

            MAGTRANSFORM matrix = {

                zoomLevel, 0, 0,

                0, zoomLevel, 0,

                0, 0, 1

            };

            MagSetWindowTransform(hwndMag, &matrix);

        }

    }

    return 0;

}

case WM_KEYDOWN: {

    if (wParam == VK_OEM_COMMA) {  // ',' key to zoom in

        if (zoomLevel < 10.0f) {

            zoomLevel += 0.5f;

            zoomEnabled = true;

        }

    }

    else if (wParam == VK_OEM_PERIOD) {  // '.' key to zoom out

        if (zoomLevel > 1.0f) {

            zoomLevel -= 0.5f;

            zoomEnabled = true;

        }

        else {

            zoomLevel = 1.0f; // Clamp to minimum

            zoomEnabled = false;

        }

    }

    // Force an update to the magnifier

    RECT sourceRect;

    POINT pt;

    if (GetCursorPos(&pt)) {

        int screenWidth = GetSystemMetrics(SM_CXSCREEN);

        int screenHeight = GetSystemMetrics(SM_CYSCREEN);

        int halfWidth = static_cast<int>(screenWidth / (2 * zoomLevel));

        int halfHeight = static_cast<int>(screenHeight / (2 * zoomLevel));

        sourceRect.left = max(0, pt.x - halfWidth);

        sourceRect.top = max(0, pt.y - halfHeight);

        sourceRect.right = min(screenWidth, pt.x + halfWidth);

        sourceRect.bottom = min(screenHeight, pt.y + halfHeight);

        // Validate RECT dimensions

        if (sourceRect.left < sourceRect.right && sourceRect.top < sourceRect.bottom) {

            MagSetWindowSource(hwndMag, sourceRect);

            MAGTRANSFORM matrix = {

                zoomLevel, 0, 0,

                0, zoomLevel, 0,

                0, 0, 1

            };

            MagSetWindowTransform(hwndMag, &matrix);

        }

    }

    return 0;

}

case WM_DESTROY:

    PostQuitMessage(0);

    return 0;

default:

    return DefWindowProc(hwnd, message, wParam, lParam);

}

}

int main(HINSTANCE hInstance, HINSTANCE, LPWSTR, int) {

SetProcessDPIAware();

if (!MagInitialize()) {

    MessageBox(NULL, L"Failed to initialize Magnification API.", L"Error", MB_ICONERROR);

    return -1;

}

const wchar_t CLASS_NAME[] = L"FullscreenMagnifierWindow";

WNDCLASS wc = {};

wc.lpfnWndProc = WndProc;

wc.hInstance = hInstance;

wc.lpszClassName = CLASS_NAME;

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH); // Safer option

RegisterClass(&wc);

int screenWidth = GetSystemMetrics(SM_CXSCREEN);

int screenHeight = GetSystemMetrics(SM_CYSCREEN);

hwndHost = CreateWindowEx(

    WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TRANSPARENT | WS_EX_TOOLWINDOW,

    CLASS_NAME, L"Magnifier Host", WS_POPUP,

    0, 0, screenWidth, screenHeight,

    NULL, NULL, hInstance, NULL);

if (!hwndHost) {

    MessageBox(NULL, L"Failed to create host window.", L"Error", MB_ICONERROR);

    MagUninitialize();

    return -1;

}

SetLayeredWindowAttributes(hwndHost, 0, 255, LWA_ALPHA);

// When creating the magnifier window, remove the MS_SHOWMAGNIFIEDCURSOR flag

hwndMag = CreateWindow(WC_MAGNIFIER, NULL,

    WS_CHILD | WS_VISIBLE,  // Removed MS_SHOWMAGNIFIEDCURSOR

    0, 0, screenWidth, screenHeight, hwndHost, NULL, hInstance, NULL);

if (!hwndMag) {

    MessageBox(NULL, L"Failed to create magnifier control.", L"Error", MB_ICONERROR);

    DestroyWindow(hwndHost);

    MagUninitialize();

    return -1;

}

MAGTRANSFORM matrix = {

    zoomLevel, 0, 0,

    0, zoomLevel, 0,

    0, 0, 1

};

MagSetWindowTransform(hwndMag, &matrix);



SetTimer(hwndHost, 1, 50, NULL);  // Update every 50ms

ShowWindow(hwndHost, SW_SHOW);

MSG msg;

while (GetMessage(&msg, NULL, 0, 0)) {

    TranslateMessage(&msg);

    DispatchMessage(&msg);

}

KillTimer(hwndHost, 1);

DestroyWindow(hwndMag);

DestroyWindow(hwndHost);

MagUninitialize();

return 0;

}

Viorel 126.1K Reputation points

2026-01-08T09:32:27.11+00:00

Maybe the magnifier does not actually show the un-zoomed window; the On Screen Keyboard is simply placed above the magnifier.
Pallavi Bhosale 0 Reputation points

2026-01-08T09:44:13.27+00:00

Yeah..Even tried to hide the normal sized window of OSK but couldn't do that. By any chance do u have any idea/suggestions here?

Your answer

Viorel 126.1K Reputation points

2026-01-08T09:32:27.11+00:00

Maybe the magnifier does not actually show the un-zoomed window; the On Screen Keyboard is simply placed above the magnifier.
Pallavi Bhosale 0 Reputation points

2026-01-08T09:44:13.27+00:00

Yeah..Even tried to hide the normal sized window of OSK but couldn't do that. By any chance do u have any idea/suggestions here?

Share via

Using C++ Magnification API (MagSetWindowTransform) shows both zoomed and normal window simultaneously

Your answer