How does a single wndproc let each window know its serial number?

Question

0.00/5 (No votes)

See more:

C++

int Num = 0;
LRESULT CALLBACK TestWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    RECT rc;
    GetClientRect(hWnd, &rc);
    RECT Winrc;
    GetWindowRect(hWnd, &Winrc);
    SYSTEMTIME time;
    GetLocalTime(&time);
    static const wchar_t* BoxTxt = L"";
    static int MeIs = Num;
    switch (message)
    {

    case WM_CREATE:
    {
        SetWindowLong(hWnd, GWL_EXSTYLE,
            GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED);
        SetLayeredWindowAttributes(hWnd, RGB(255, 255, 255), 220, LWA_ALPHA);
        //GhWnd = hWnd;
        break;
    }
    case WM_LBUTTONUP:
    {
            wchar_t meChar[20] = L"";
            _itow(MeIs, meChar, 10);
            MessageBox(0, meChar, meChar, 0);
    }
    case WM_SIZE:
    {
        InvalidateRect(hWnd, &rc, 1);
        break;
    }
    case WM_NCLBUTTONDBLCLK:
    {
        break;
    }
    case WM_COMMAND:
    {
        int wmId = LOWORD(wParam);
        switch (wmId)
        {

        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
    }
    break;
    case WM_CLOSE:
    {
        Num -= 1;
        DestroyWindow(hWnd);
    }
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
int CreateTestWindow()
{
//Call testwndproc. To reduce the length of the problem description, omit these codes
Num+=1;
return 0;
}

In the above code, when I create multiple windows and click it, it should pop up "1", "2", "3"... But actually all pop up "1".

What I have tried:

static int MeIs = 0;
case WM_CREATE:
{
MeIs = Num;
}
Change to the above code and the serial number of the last window will pop up. For example, when the fourth window is created, all windows will pop up "4"
In practical application, each window has its own settings and is stored in the vector. Each window finds its own settings according to its own serial number
Any idea?thank you!

Posted 27-Nov-21 21:14pm

EnderMo233

Updated 29-Nov-21 11:00am

v2

Add a Solution

3 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Rick York · Accepted Answer · 2021-11-27T21:46:00

Solution 1

The problem is you have one instance of the variables of interest. If you want each window to have a unique number then they each have to a unique variable. There are several ways this could be implemented. Among them are a map that associates a number with a window handle.

Another possibility is to call the SetWindowLongPtr function and set the GWLP_USERDATA property to the identifier you want to give that window. Documentation can be found here : SetWindowLongPtrA function (winuser.h) - Win32 apps | Microsoft Docs[^].

When the window wants to display the value it can call GetWindowLongPtr as described here : GetWindowLongPtrA function (winuser.h) - Win32 apps | Microsoft Docs[^]. The value returned will be the identifier you assigned to it previously.

Posted 27-Nov-21 21:46pm

Rick York

Comments

EnderMo233 28-Nov-21 5:01am

Actually, I want to use it like this:
struct Data
{
int x;
int y;
int width;
int height;
const wchar_t* text;
}
std::vector<data>UserData(32);//Max:32
//then read them from file,But the window must know which window it is:UserData[i].
For example,the first window will set their coordinates to UserData[1].x and UserData[1].y,also need to save the file when closing.

Rick York 29-Nov-21 12:06pm

OK, so use the data like that. A window can get its index into that vector as I showed you. I would make a class to contain the data and a method to get an index and/or pointer to a window's data. Here is a prototype you could use : Data * GetWindowData( HWND hwnd ); You can wrap all of this stuff up into one easy method call. There could be a corresponding SetWindowData method also.

merano99 28-Nov-21 17:03pm

Numbering the windows with SetWindowLongPtr () seems to be a good solution if you write a consecutive number after creating the window. It is unclear which information should be stored in data.

merano99 · Accepted Answer · 2021-11-28T14:21:00

As Rick York suggested numbering the windows with SetWindowLongPtr () seems to be a good solution if you write a consecutive number after creating the window.

Insted of using a MessageBox it is better to use the StatusBar:

C++

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Instanzenhandle in der globalen Variablen speichern

   HWND hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
	  CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd) {
	  return FALSE;
   }

   statusbar = CreateStatusWindow(WS_CHILD | WS_VISIBLE, _T("x"), hWnd, IDM_STATUS);

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

C++

void ShowWindowNumber(HWND hWnd)
{
	size_t x = GetWindowLongPtr(hWnd, GWLP_USERDATA);
	if ((x>=0) && (x < UserData.size())) {
		wchar_t meChar[20] = L"";
		wsprintf(meChar, _T("%ld"), x);
		SendMessageW(statusbar, SB_SETTEXT, 0, (LPARAM)meChar); 
	}
}

case WM_CREATE:
	{
		SetWindowLong(hWnd, GWL_EXSTYLE,
			GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED);
		SetLayeredWindowAttributes(hWnd, RGB(255, 255, 255), 220, LWA_ALPHA);

		Data mydata;
		LONG_PTR chk, wn;

		// fill mydata for mainwindow here
		UserData.push_back(mydata);
		wn = (LONG_PTR)UserData.size() - 1;				  // get idx of last data
		chk = SetWindowLongPtrA(hWnd, GWLP_USERDATA, wn); // write idx of data

		but1 = CreateWindowW(L"BUTTON", L"OK",
			WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,  // Styles 
			10, 10, 100, 100, hWnd, (HMENU)IDC_BUTTON1, 
			(HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE), NULL);

		// fill mydata for every subwindow here
		UserData.push_back(mydata);
		wn = (LONG_PTR)UserData.size() - 1;				  // get idx of last data
		chk = SetWindowLongPtrA(but1, GWLP_USERDATA, wn); // write idx of data
	}

merano99 · Accepted Answer · 2021-11-29T11:00:00

Based on my first suggestion, here is another solution if you have to close windows in between.

C++

case WM_CREATE:
	{
		SetWindowLong(hWnd, GWL_EXSTYLE,
			GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED);
		SetLayeredWindowAttributes(hWnd, RGB(255, 255, 255), 220, LWA_ALPHA);

		Data mydata;

		// fill mydata for mainwindow here
		mydata.hwnd = hWnd;
		UserData.push_back(mydata);

		HWND but1 = CreateWindowW(L"BUTTON", L"OK",
			WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,  // Styles 
			10, 10, 100, 100, hWnd, (HMENU)IDC_BUTTON1,
			(HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE), NULL);

		// fill mydata for every subwindow here
		mydata.hwnd = but1;
		UserData.push_back(mydata);
	}

The vector element with the date can also be safely deleted shortly before the window is closed. With multithreading, however, it would make sense to secure searches and deletions with a mutex.

Here is the revised function to find the index:

C++

int FindWindowNumber(HWND hWnd)
{
	size_t x;     
	for (x = 0; x < UserData.size(); x++) {
		if (UserData[x].hwnd == hWnd)
			break;
	}
	
	if (x >= UserData.size())
		return -1;
	
	wchar_t meChar[20] = L"";
	wsprintf(meChar, _T("%ld"), x);
	SendMessageW(statusbar, SB_SETTEXT, 0, (LPARAM)meChar); 
	return (int)x;
}

How does a single wndproc let each window know its serial number?

3 solutions

Solution 1

Solution 2

Solution 3

Add your solution here

Preview 0