Window appears with old-style UI and no text in titlebar.

László Szerémi 15

I'm developing a middleware for D that is quite similar to SDL/SFML, here's an exempt from the window creation code:

class OSWindow {
[...]
this(io_str_t title, io_str_t name, int x, int y, int w, int h, ulong flags,
			WindowBitmap icon = null, OSWindow parent = null) {
registeredClass.cbSize = WNDCLASSEXW.sizeof;
registeredClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC ;
registeredClass.hInstance = mainInst;
registeredClass.lpfnWndProc = &wndprocCallback;
registeredClass.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
registeredClass.hCursor = LoadCursor(null, IDC_ARROW);
registeredClass.hIcon = LoadIcon(null, IDI_APPLICATION);
classname = toUTF16z(name);
registeredClass.lpszClassName = classname;
regClResult = RegisterClassExW(&registeredClass);
if (!regClResult) {
	auto errorCode = GetLastError();
	throw new WindowCreationException("Failed to register window class!", errorCode);
}
DWORD dwStyle = WS_OVERLAPPEDWINDOW | WS_VISIBLE;
if (x <= 0) x = CW_USEDEFAULT;
if (y <= 0) y = CW_USEDEFAULT;
if (w <= 0) w = CW_USEDEFAULT;
if (h <= 0) h = CW_USEDEFAULT;
windowname = toUTF16z(title);
HWND parentHndl = null;
if (parent !is null)
	parentHndl = parent.getHandle();
windowHandle = CreateWindowW(classname, windowname, dwStyle, x, y, w, h, parentHndl, null, mainInst, 
		null);
if (!windowHandle) {
	auto errorCode = GetLastError();
	throw new WindowCreationException("Failed to create window!", errorCode);
}
refCount ~= this;
ShowWindow(windowHandle, SW_RESTORE);
UpdateWindow(windowHandle);
}
}

Given this code, I'm getting a Win7 style GUI and no titlebar. Some other oddities is that if I don't include the WS_VISIBLE enum in dwStyle, I get a completely blank white window. In my wndCallback function, every event is dispatched to DefWindowProcW. In my event polling loop, I use Raw Input.

I've heard that I should add a manifest file, but I don't really know how to do with my own toolchain (DMD/LDC + MSVC linker and resource compiler), where I need to include the resource.o file, etc. Visual-C++ does it automatically, so there's little to no documentation, others instead suggest to use other, preexisting middleware like SDL, which has it's own issues, or even some GUI-oriented library that's not too ideal for my primary application (gaming, GUI that draws its own elements, etc.). In general I get little to no documentation and/or help besides of what Microsoft offers due to the aforementioned issues.

Viorel 114K Reputation points

2024-05-25T18:30:32.24+00:00
In C++, the appearance can be changed by #pragma comment directive:

https://learn.microsoft.com/en-us/windows/win32/controls/cookbook-overview#using-manifests-or-directives-to-ensure-that-visual-styles-can-be-applied-to-applications
RLWA32 42,161 Reputation points

2024-05-25T22:16:47.6033333+00:00

A window created by the Windows API functions (CreateWindow, etc.) will be displayed using visual styles without the need to use a manifest. This is built into Windows. The purpose of the manifest is so that any controls contained in the window will also use visual styles that are available in the common controls V6 dll.

As far as I know, removing visual styles from a window (e.g., the parent window or main window) requires the user to call API functions like the SetThemeAppProperties function
RLWA32 42,161 Reputation points

2024-05-26T08:28:46.03+00:00

I'm not familiar with the programming language or its tools. Having said that, I suggest that you verify that the code produces the proper sizes for Windows structures like WNDCLASSEXW and that it has the correct alignment. Also, you should ensure that the members of the structure that are not initialized in the code default to valid values. These should be done for both 32-bit and/or 64-bit builds. And do you really need the CS_OWNDC style?

Perhaps you should first start by using the conventional message pump functions like GetMessageW, TranslateMessage, and DispatchMessageW before introducing raw input.

For a newly created window the value passed to ShowWindow as the nCmdShow parameter would usually be SW_SHOW or the nShowCmd parameter that was passed to WinMain or wWinMain.
Xiaopo Yang - MSFT 12,066 Reputation points Microsoft Vendor

2024-05-31T06:32:50.1+00:00

@László Szerémi, any update about this question?
László Szerémi 15 Reputation points

2024-06-02T14:49:24.1933333+00:00

I took another look at my code.

Changed stuff about the WNDCLASSEXW, didn't change anything. Even the removal of CS_OWNDC doesn't change it, which I'll be needing for OpenGL. Changed it to a pointer, and allocated it with both the D's own GC and C's malloc, same story. Even added an InitCommonControlsEx call, nothing changed. Someone on the D forum told me how I can include the resource file, was exactly the same as mine save for a different extension, adjusted to that, nothing changed.

I'll try to look into alternative ways to ensure comctl32.dll is properly loaded.
László Szerémi 15 Reputation points

2024-06-02T19:14:02.8266667+00:00

Well, I've been poking around in the build system, it might just completely ignore the resource file.

RLWA32 42,161

The following minimal C/C++ code will create a Windows desktop application. It can build without a resource file and in my test the executable did not contain a manifest or any resources. The application's window looks like this on Win10 22H2 -

Minimal

The code to create the application is -

#include <Windows.h>

#include <stdio.h>
#include <tchar.h>

#define IDC_EXIT 101

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPTSTR lpCommandline, _In_ int nShow)
{
    WNDCLASS wc = { 0 };
    MSG msg;

    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = TEXT("MinimalExample");

    if (!RegisterClass(&wc))
    {
        MessageBox(NULL, TEXT("Error registering window class"), TEXT("Error"), MB_ICONERROR | MB_OK);
        return 1;
    }

    HMENU hMenu = CreateMenu();
    HMENU h = CreatePopupMenu();
    AppendMenu(hMenu, MF_POPUP, (UINT_PTR)h, TEXT("File"));
    AppendMenu(h, MF_STRING, (UINT_PTR)IDC_EXIT, TEXT("Exit"));

    HWND hwnd = CreateWindow(TEXT("MinimalExample"), TEXT("Minimal Example"), WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 400, 300, NULL, hMenu, hInstance, NULL);

    if (!hwnd)
    {
        MessageBox(NULL, TEXT("Wndow Creation Failed"), TEXT("Error"), MB_ICONERROR | MB_OK);
        return 1;
    }

    ShowWindow(hwnd, nShow);
    UpdateWindow(hwnd);

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_COMMAND:
    {
        switch (LOWORD(wParam))
        {
            case IDC_EXIT:
                DestroyWindow(hwnd);
                break;

            default:
                return DefWindowProc(hwnd, msg, wParam, lParam);
        }
    }
    break;

    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        BeginPaint(hwnd, &ps);
        EndPaint(hwnd, &ps);
    }
    break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }

    return 0;
}

RLWA32 42,161 Reputation points

2024-06-02T20:10:16.1766667+00:00

And the image below from Process Explorer displays the DLLs that are loaded into the MinimalExample process. You can see that there are no common controls DLLs loaded even though the Windows was created with visual styles.

I don't know the cause of your issue, but I doubt that resource files and manifests are the issue.

If I deliberately insert code to turn off visual styles then I can get the MinimalExample window to look like this -
László Szerémi 15 Reputation points

2024-06-02T21:39:06.9633333+00:00

Okay, I think I found the issue.

I was using Windres instead of rc.exe, since I cannot find that file anywhere on my PC despite I just reinstalled it.
László Szerémi 15 Reputation points

2024-06-03T19:33:20.4866667+00:00

I did some digging, and the text on the titlebar appears once alt+tab is pressed. I wonder if there are any events passed to the wndprocCallback, that do not have a window handle.
RLWA32 42,161 Reputation points

2024-06-03T20:02:37.8033333+00:00

We haven't seen any code for your implementation of a message loop. Have you tried simplifying it as I previously suggested? Perhaps this is where your problem resides.

1 answer

László Szerémi 15

Well, the actual solution was a missing DefWindowProcW call.

static extern (Windows) LRESULT wndprocCallback(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) nothrow @system {
	//return DefWindowProcW(hWnd, msg, wParam, lParam);
	switch (msg) {
		case WM_CREATE, WM_NCCREATE:
			return DefWindowProcW(hWnd, msg, wParam, lParam);
		default:
			foreach (OSWindow key; refCount) {
				if (key.getHandle() == hWnd)
					return key.wndCallback(msg, wParam, lParam);
			}
			return DefWindowProcW(hWnd, msg, wParam, lParam);
	}
}

Tutorials only talked about the importance of WM_CREATE and WM_NCCREATE, the rest wasn't talked as much about. My solution uses OOP solutions, and essentially each class creates a mostly OS-agnostic window.

Share via

Window appears with old-style UI and no text in titlebar.

1 answer