How do I create multiple windows to display different text.

[Juicej]

Good Day Good Men and Women,

I was tasked with creating a main window and three other windows. The main window is kind of like a trigger to create the three other windows.
The first window should show the time.
The second window shows the result of a calculation.
The third shows the result or another calculation but using the FPU instruction set.
These three windows should loop and update the screen with the results, but really the only visible change would be the first window showing the time.

Now the problem I am having is that, the time shows on each window, despite using a separate SetWindowText() function for each window.

I Have already made some progress, the code is long but i will paste it all. I never know what the Guru's really need to look at in their investigation.

I used alot of code from a stack over solution

///////////////// Function Prototypes ////////////////////
HWND wnd1TextBox, wnd2TextBox, wnd3TextBox;

/////////////// Global Variables: //////////////////////////////
bool openMainWnd, openchildWnd1, openchildWnd2, openchildWnd3 = false;
bool windowclass1registeredbefore, windowclass2registeredbefore, windowclass3registeredbefore, windowclass4registeredbefore = false;

enum windowtoopenenumt {none, ChildWindow1, ChildWindow2, ChildWindow3};

windowtoopenenumt windowtoopenenum=none;


int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR args, int nShowCmd )
{
	bool endprogram = false;	  
    WNDCLASSEXW childCls1;   
    WNDCLASSEXW childCls2;
    WNDCLASSEXW childCls3;
    
	HWND mainWndHnd;
    HWND childWndHnd1;
    HWND childWndHnd2;
    HWND childWndHnd3;

	// Creating Parent Window
	MSG msg;
	WNDCLASSEXW mainWnd;
	mainWnd.cbSize			;
	mainWnd.style													 
	mainWnd.hbrBackground 	
	mainWnd.hCursor 												 
	mainWnd.hInstance 																 
	mainWnd.lpszClassName 												 	
	mainWnd.lpszMenuName 	
	mainWnd.lpfnWndProc 	 												e	
	mainWnd.cbWndExtra 		= 0;
	mainWnd.cbClsExtra		= 0;
	mainWnd.hIcon			
	mainWnd.hIconSm			
	
	if(!RegisterClassExW(&mainWnd))
    {
    	int nResult=GetLastError();
        MessageBox(NULL, "Window class creation failed", "Window Class Failed", MB_ICONERROR);
        //return 0;
    }
	
	 
	RegisterDialogClass(hInst);				
	
	
	mainWndHnd = CreateWindowExW("Main Window); // removed to meet 9000 characters requirements
	
	
	if(!mainWndHnd)
    {
        int nResult=GetLastError();

        MessageBox(NULL, "Window creation failed", "Window Creation Failed", MB_ICONERROR);
    }
   	
	
	ShowWindow(mainWndHnd,nShowCmd);
    bool endloop=false;
    
    
    while (endloop == false) 
	{
        if (GetMessage(&msg,NULL,0,0));
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        if (windowtoopenenum != none) 
		{
            switch (windowtoopenenum) 
			{
                case ChildWindow1:
                	// Open first windows
                    if (openchildWnd1 == false) 
					{                                                 
                    	createChildWindow1(childCls1,childWndHnd1,hInst,nShowCmd);
                    	SetWindowText(wnd1TextBox, loopStartTime());
                       	cout << "child window 1 created" << endl;
                    
                    	// Open Second windows
                    	if (openchildWnd2 == false) 
						{   
	                       	createChildWindow2(childCls2,childWndHnd2,hInst,nShowCmd);
	                       	SetWindowText(wnd2TextBox, integerCal());
	                       	cout << "child window 2 created" << endl;
	                       	
	                       		// Open third windows
	                       		if (openchildWnd3 == false) 
								{   
									//windowtoopenenum = ChildWindow3;
			                       	createChildWindow3(childCls3,childWndHnd3,hInst,nShowCmd);
			                       	SetWindowText(wnd3TextBox, integerCal());
			                    	cout << "child window 3 created" << endl;
			                    }
			                    else
								{
									SetWindowText(wnd3TextBox, integerCal());
								UpdateWindow(childWndHnd3);
								}
	                    }
	                    else
						{
							SetWindowText(wnd3TextBox, integerCal());
							UpdateWindow(childWndHnd2);
						}
                    	
                    }
                    else			// if window is already open, then just update
					{
						SetWindowText(wnd1TextBox, loopStartTime());
						UpdateWindow(childWndHnd1);
					}
		
                    break;
						

                    }
                    break;
                    
                case ChildWindow3:               
                    if (openchildWnd3==false) 
					{               
                        createChildWindow3(childCls3,childWndHnd3,hInst,nShowCmd);
                        cout << "child window 2 created" << endl;
                    }
                    break;
                    
            }
        	
			windowtoopenenum = none;
    	}
		if (openMainWnd==false && openchildWnd1==false && openchildWnd2==false && openchildWnd3==false )
        	endloop=true;

    } // end while loop
    
    MessageBox(NULL, "All Windows are closed. Program will now close.", "Message", MB_ICONINFORMATION);
    
    return 0;
}



void createChildWindow1(WNDCLASSEXW& wc,HWND& hwnd,HINSTANCE hInst,int nShowCmd)
{
	MSG Msg;
	
	if (windowclass1registeredbefore == false) 
	{
		// Creating Parent Window
	MSG msg;
	WNDCLASSEXW wc;
	wc.cbSize			;
	wc.style													 
	wc.hbrBackground 	
	wc.hCursor 												 
	wc.hInstance 																 
	wc.lpszClassName 												 	
	wc.lpszMenuName 	
	wc.lpfnWndProc 	 												e	
	wc.cbWndExtra 		= 0;
	wc.cbClsExtra		= 0;
	wc.hIcon			
	wc.hIconSm	

		if(!RegisterClassExW(&wc))
		{
			int nResult=GetLastError();
			MessageBox();
		}
		else
			windowclass1registeredbefore=true;
	} 
		
	CreateWindowExW(Wnd 1" ); // removed to meet 9000 characters requirements

    if(!hwnd)
    {
        int nResult=GetLastError();

        MessageBox();
    }
	
	ShowWindow(hwnd,nShowCmd);
	
}


void createChildWindow2()
{
	// Basically the same code as in createChildWindow1, but replace all 1's with 2
}

void createChildWindow3()
{
	// Basically the same code as in createChildWindow1, but replace all 1's with 3
}


//////////////////////////////////////////////////// WINDOW PROCEDURES ////////////////////////////////////////////////

LRESULT CALLBACK WindowProcedureMain(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
{
	switch (msg)
	{

		case WM_COMMAND:
			switch(wp)
			{
				case IDA_MENU_EXIT:
					DestroyWindow(hWnd);		
					break;
			
				case IDA_MENU_ABOUT:
					displayDialog(hWnd);
					break;
				
				case ID_OPEN_WINDOWS_BUTTON1:
					windowtoopenenum = ChildWindow1;								
					break;
					
				case ID_OPEN_WINDOWS_BUTTON2:
						windowtoopenenum = ChildWindow2;			
					break;

			 
			} // end inner switch
	        
		break;
		

		case WM_CREATE:	
				openMainWnd = true;
				CreateWindowW(L"Part 1");		// removed to meet 9000 characters requirements	
				CreateWindowW(L"Part 2"); 		 // removed to meet 9000 characters requirements		
				addMenu(hWnd);				
				break;
			
		// Sent when a window is being destroyed.
		case WM_DESTROY:
			openMainWnd = false;
			PostQuitMessage(0);
			break;
			
		default:
		
		return DefWindowProcW(hWnd,msg,wp,lp);
	
	} // end outer switch

} // end 


LRESULT CALLBACK WindowProcedureChild1(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{ 
	 
	 switch(msg) {
        case WM_CREATE:
            openchildWnd1 = true;
            addMenu(hwnd);
			wnd1TextBox = CreateWindowW(); 		 // removed to meet 9000 characters requirements
            break;
            
        case WM_DESTROY:
            openchildWnd1 = false;
            PostQuitMessage(0);
            break;
            
                
        case WM_COMMAND:
            switch LOWORD(wParam) 
			{
                case IDA_MENU_EXIT:
					DestroyWindow(hwnd);		
					break;
			
				case IDA_MENU_ABOUT:
					displayDialog(hwnd);
					break;
            }
    }
    return DefWindowProc(hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WindowProcedureChild2(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{ 	
		 // Basically the same code as in WindowProcedureChild1, but replace all 1's with 3  
}

LRESULT CALLBACK WindowProcedureChild3(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
             // Basically the same code as in WindowProcedureChild1, but replace all 1's with 3   
}

Thanks for helping I appreciate it.

[fewdiefie]

why don't your create the other windows as children of the main window by specifying WM_CHILD flag as follow

HWND window1 = CreateWindow(L"static", L"", WS_CHILD | WM_VISIBLE, posX, posY, 
    width, height, mainWindow, nullptr, nullptr, nullptr);

In the app loop yo ucan do something like this

while (WM_QUIT != msg.message)
{
    if (PeekMessage())
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    else
    {
        updateWindow(window1, deltaTime);
        updateWindow(window2, deltaTime);
        updateWindow(window3, deltaTime);
    }
}

updateWindow would look something like this

void updateWindow(HWND hWnd, float dt)
{
    CHAR time[32];
    // . . .

    SetWindowText(hWnd, time);
}

[Juicej]

I'm gonna try this now... if it works I'm SCREAM!!!... Thanks much though for replying.. I'll Let you know if it works

[Juicej]

So I tried it, not sure how the windows should come up though.

Can you please guide me on this?

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR args, int nShowCmd)
{
	HWND mainWndHnd;
	HWND childWndHnd1{};
	HWND childWndHnd2{};
	HWND childWndHnd3{};

	// Creating Parent Window
	MSG msg = {};
	WNDCLASSEXW mainWnd;
	mainWnd.cbSize = sizeof(WNDCLASSEX);
	mainWnd.style = CS_HREDRAW | CS_VREDRAW;;
	//wc.hbrBackground 		= (HBRUSH)(COLOR_WINDOW+1) ;										 // A handle to the class background brush
	mainWnd.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
	mainWnd.hCursor = LoadCursor(NULL, IDC_ARROW); 										 // A handle to the class cursor. This member must be a handle to a cursor resource. 
	mainWnd.hInstance = hInst;															 // A handle to the instance that contains the window procedure for the class.
	mainWnd.lpszClassName = L"Main Window";												 	// A pointer to a null-terminated string or is an atom
	mainWnd.lpszMenuName = MAKEINTRESOURCEW(IDR_SimpleMENU);
	mainWnd.lpfnWndProc = (WNDPROC)WindowProcedureMain; 												 // A pointer to the window procedure	
	mainWnd.cbWndExtra = 0;
	mainWnd.cbClsExtra = 0;
	mainWnd.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	mainWnd.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	if (!RegisterClassExW(&mainWnd))
	{
		int nResult = GetLastError();
		MessageBox(NULL, L"Window class creation failed", L"Window Class Failed", MB_ICONERROR);
		//MessageBox(NULL, "Window Registration Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK);
		//return 0;
	}


	RegisterDialogClass(hInst);														 // Registers any nonstandard window classes required by a screen saver's configuration dialog box.

	
	mainWndHnd = CreateWindowExW(WS_EX_CLIENTEDGE, mainWnd.lpszClassName, L"Main Window", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 2, 5, 700, 400, NULL, NULL, hInst, NULL);


	if (!mainWndHnd)
	{
		int nResult = GetLastError();

		MessageBox(NULL, L"Window creation failed", L"Window Creation Failed", MB_ICONERROR);
	}


	childWndHnd1 = CreateWindowExW(WS_EX_CLIENTEDGE, L"Child WIndow 1", L"Win 1", WS_VISIBLE | WS_CHILD, 800, 5, 700, 400, mainWndHnd, NULL, hInst, NULL);
	childWndHnd2 = CreateWindowExW(WS_EX_CLIENTEDGE, L"Child WIndow 2", L"Win 2", WS_VISIBLE | WS_CHILD, 2, 450, 700, 400, mainWndHnd, NULL, hInst, NULL);
	childWndHnd3 = CreateWindowExW(WS_EX_CLIENTEDGE, L"Child WIndow 3", L"Win 3", WS_VISIBLE | WS_CHILD, 800, 450, 700, 400, mainWndHnd, NULL, hInst, NULL);

	ShowWindow(mainWndHnd, nShowCmd);
	bool endloop = false;

	while (WM_QUIT != msg.message)
	{
		if (PeekMessage(&msg, mainWndHnd, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			updateWindow(childWndHnd1, loopStartTime());
			updateWindow(childWndHnd2, integerCal());
			updateWindow(childWndHnd3, loopStartTime());
		}
	}

	return 0;
}