exit from while loop win32gui

Hawlong (120)
i have 2 button in my gui the first button name is "run" and secoud button name is "stop" when i click run button while loop runing, how to stop while loop when click stop button ?

My code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
#include <iostream>
#include <windows.h>

/* Declare Windows procedure */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/* Make the class name into a global variable */
char szClassName[ ] = "WindowsApp";
HBITMAP imgb;
void load(){

imgb = (HBITMAP)LoadImage(NULL, "11.bmp", IMAGE_BITMAP, 80, 50, LR_LOADFROMFILE);
}
int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nFunsterStil)

{
//ShowWindow(GetConsoleWindow(), SW_HIDE);
HWND hwnd; /* This is the handle for our window */
MSG messages; /* Here messages to the application are saved */
WNDCLASSEX wincl; /* Data structure for the windowclass */

/* The Window structure */
wincl.hInstance = hThisInstance;
wincl.lpszClassName = szClassName;
wincl.lpfnWndProc = WindowProcedure; /* This function is called by windows */
wincl.style = CS_DBLCLKS; /* Catch double-clicks */
wincl.cbSize = sizeof (WNDCLASSEX);

/* Use default icon and mouse-pointer */
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
wincl.lpszMenuName = NULL; /* No menu */
wincl.cbClsExtra = 0; /* No extra bytes after the window class */
wincl.cbWndExtra = 0; /* structure or the window instance */
/* Use Windows's default color as the background of the window */
wincl.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
// wincl.hbrBackground = CreateSolidBrush(RGB(64,64,64));

/* Register the window class, and if it fails quit the program */
if (!RegisterClassEx (&wincl))
return 0;

/* The class is registered, let's create the program*/
hwnd = CreateWindowEx (
0, /* Extended possibilites for variation */
szClassName, /* Classname */
"Windows App", /* Title Text */
WS_OVERLAPPEDWINDOW, /* default window */
CW_USEDEFAULT, /* Windows decides the position */
CW_USEDEFAULT, /* where the window ends up on the screen */
144, /* The programs width */
175, /* and height in pixels */
HWND_DESKTOP, /* The window is a child-window to desktop */
NULL, /* No menu */
hThisInstance, /* Program Instance handler */
NULL /* No Window Creation data */
);

/* Make the window visible on the screen */
ShowWindow (hwnd, nFunsterStil);

/* Run the message loop. It will run until GetMessage() returns 0 */
while (GetMessage (&messages, NULL, 0, 0))
{
/* Translate virtual-key messages into character messages */
TranslateMessage(&messages);
/* Send message to WindowProcedure */
DispatchMessage(&messages);
}

/* The program return-value is 0 - The value that PostQuitMessage() gave */
return messages.wParam;
}


/* This function is called by the Windows function DispatchMessage() */
#define button 1
#define text 0

HWND hwndtext;

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) /* handle the messages */
{
case WM_CREATE:{
//load();
/*
hwndtext = CreateWindow(TEXT("EDIT"), TEXT("change me"),
WS_VISIBLE | WS_CHILD | WS_BORDER | ES_AUTOHSCROLL,
10,10,100,20,
hwnd, HMENU(text), NULL, NULL);
*/
//WS_DISABLED


CreateWindow(TEXT("BUTTON"), TEXT(" stop"),
WS_VISIBLE | WS_CHILD | WS_BORDER ,
10, 40, 80, 20,
hwnd, HMENU(button), NULL, NULL);
CreateWindow(TEXT("BUTTON"), TEXT(" run"),
WS_VISIBLE | WS_CHILD | WS_BORDER,
10, 100, 80, 20,
hwnd, HMENU(2), NULL, NULL);
/*
HWND hButton = CreateWindow(TEXT("BUTTON"), NULL,
WS_VISIBLE | WS_CHILD | BS_BITMAP,
10, 100, 80, 20,
hwnd, HMENU(2), NULL, NULL);
//SendMessage(hButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hBmp);
SendMessage(hButton, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM)imgb);
*/
break;
}
case WM_COMMAND:{
if (LOWORD(wParam) == button){

MessageBox(hwnd, "zz", "hwndtext", MB_OK);

}
if (LOWORD(wParam) == 2){ // when press run button

while (1) {
std::cout<<"a"<<std::endl;
Sleep(1000);
}
//MessageBox(hwnd, "zzz", "hwndtext", MB_OK);
}
break;
}

case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
default: /* for messages that we don't deal with */
return DefWindowProc (hwnd, message, wParam, lParam);
}

return 0;
}


while loop start from line 127 ,
Last edited on
jonnin (11437)
the stop button could set a class variable (boolean) to false

then it becomes
while(classvariable)
malibor (660)
Your loop:

1
2
3
4
 
while (1) {
std::cout<<"a"<<std::endl;
Sleep(1000);
}


Problem with this loop is that it will stop the main thread for ever, that's why your window freezes for ever and is unable respond since the loop never finishes.

A possible solution is to run this loop on another thread or to run it asynchronously.

To run it asynchronously modify your button click code as follows and your button will start working...

First include required header file:
#include <future>

define variable in global scope as follows:

std::future<void> run;

then modify (line 127 - 130):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
if (LOWORD(wParam) == 2)
{ // when press run button

	run = std::async(std::launch::async, []()
	{
		while (1)
		{
			std::cout << "a" << std::endl;
			std::this_thread::sleep_for(std::chrono::seconds(10));
		}
	});

	//MessageBox(hwnd, "zzz", "hwndtext", MB_OK);
}


EDIT:
This will run the loop concurently until you use the result variable called run which will block the program from terminating because the loop never ends.

Another more effective solution would be to create a new thread, see example I posted here:

http://www.cplusplus.com/forum/beginner/279591/
Last edited on
Hawlong (120)
jonnin

Thanks for reply,Please Example

malibor

Thanks for reply
The first solution does not stop while loop
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
#include <iostream>
#include <windows.h>
#include <future>




/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "WindowsApp";
HBITMAP imgb;
void load(){

    imgb = (HBITMAP)LoadImage(NULL, "11.bmp", IMAGE_BITMAP, 80, 50, LR_LOADFROMFILE);
}
int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
   //ShowWindow(GetConsoleWindow(), SW_HIDE);
   std::future<void> run;
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
   // wincl.hbrBackground =  CreateSolidBrush(RGB(64,64,64));

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           144,                 /* The programs width */
           175,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nFunsterStil);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */
#define button 1
#define text 0

HWND hwndtext;

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
        case WM_CREATE:{
            //load();
            /*
            hwndtext = CreateWindow(TEXT("EDIT"), TEXT("change me"),
                           WS_VISIBLE | WS_CHILD | WS_BORDER | ES_AUTOHSCROLL,
                           10,10,100,20,
                           hwnd, HMENU(text), NULL, NULL);
             */
//WS_DISABLED


             CreateWindow(TEXT("BUTTON"), TEXT(" stop"),
                 WS_VISIBLE | WS_CHILD | WS_BORDER  ,
                 10, 40, 80, 20,
                 hwnd, HMENU(button), NULL, NULL);
             CreateWindow(TEXT("BUTTON"), TEXT(" run"),
                 WS_VISIBLE | WS_CHILD | WS_BORDER,
                 10, 100, 80, 20,
                 hwnd, HMENU(2), NULL, NULL);
          /*
            HWND hButton =  CreateWindow(TEXT("BUTTON"), NULL,
                 WS_VISIBLE | WS_CHILD | BS_BITMAP,
                 10, 100, 80, 20,
                 hwnd, HMENU(2), NULL, NULL);
          //SendMessage(hButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hBmp);
          SendMessage(hButton, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM)imgb);
          */
             break;
        }
        case WM_COMMAND:{
              if (LOWORD(wParam) == button){

                 MessageBox(hwnd, "zz", "hwndtext", MB_OK);

                 }
if (LOWORD(wParam) == 2)
{ // when press run button

	run = std::async(std::launch::async, []()
	{
		while (1)
		{
			std::cout << "a" << std::endl;
			std::this_thread::sleep_for(std::chrono::seconds(2));
		}
	});

	//MessageBox(hwnd, "zzz", "hwndtext", MB_OK);
}
              break;
              }

        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}


and http://www.cplusplus.com/forum/beginner/279591/

I didn't understand this example sorry I'm a beginner

malibor (660)
Following is your code with modifications, that runs the loop on another thread and notifies you every 2 seconds that the loop is running until you click the stop button.

Once you click stop button the loop will stop until you start it again.
Note that clicking run button twice won't start another loop.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 

#include <iostream>
#include <windows.h>
#include <future>
#include <thread>
#include <iostream>
#include <chrono>
#include <utility>

void MyLoop(std::future<bool>* condition)
{
	auto status = std::future_status::deferred;

	while (status != std::future_status::ready)
	{
		MessageBoxA(NULL, "Loop is running!", "Notice", MB_OK);
		status = condition->wait_for(std::chrono::seconds(2));
	}
}

std::thread loop_thread;
std::promise<bool>* promise = nullptr;
std::future<bool>* condition = nullptr;

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[] = "WindowsApp";
HBITMAP imgb;

void load()
{

	imgb = (HBITMAP)LoadImage(NULL, "11.bmp", IMAGE_BITMAP, 80, 50, LR_LOADFROMFILE);
}

int WINAPI WinMain(HINSTANCE hThisInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpszArgument,
	int nFunsterStil)

{
	//ShowWindow(GetConsoleWindow(), SW_HIDE);
	HWND hwnd;               /* This is the handle for our window */
	MSG messages;            /* Here messages to the application are saved */
	WNDCLASSEX wincl;        /* Data structure for the windowclass */

	/* The Window structure */
	wincl.hInstance = hThisInstance;
	wincl.lpszClassName = szClassName;
	wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
	wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
	wincl.cbSize = sizeof(WNDCLASSEX);

	/* Use default icon and mouse-pointer */
	wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
	wincl.hCursor = LoadCursor(NULL, IDC_ARROW);
	wincl.lpszMenuName = NULL;                 /* No menu */
	wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
	wincl.cbWndExtra = 0;                      /* structure or the window instance */
	/* Use Windows's default color as the background of the window */
	wincl.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
	// wincl.hbrBackground =  CreateSolidBrush(RGB(64,64,64));

	 /* Register the window class, and if it fails quit the program */
	if (!RegisterClassEx(&wincl))
		return 0;

	/* The class is registered, let's create the program*/
	hwnd = CreateWindowEx(
		0,                   /* Extended possibilites for variation */
		szClassName,         /* Classname */
		"Windows App",       /* Title Text */
		WS_OVERLAPPEDWINDOW, /* default window */
		CW_USEDEFAULT,       /* Windows decides the position */
		CW_USEDEFAULT,       /* where the window ends up on the screen */
		144,                 /* The programs width */
		175,                 /* and height in pixels */
		HWND_DESKTOP,        /* The window is a child-window to desktop */
		NULL,                /* No menu */
		hThisInstance,       /* Program Instance handler */
		NULL                 /* No Window Creation data */
	);

	/* Make the window visible on the screen */
	ShowWindow(hwnd, nFunsterStil);

	/* Run the message loop. It will run until GetMessage() returns 0 */
	while (GetMessage(&messages, NULL, 0, 0))
	{
		/* Translate virtual-key messages into character messages */
		TranslateMessage(&messages);
		/* Send message to WindowProcedure */
		DispatchMessage(&messages);
	}

	/* The program return-value is 0 - The value that PostQuitMessage() gave */
	return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */
#define button 1
#define text 0

HWND hwndtext;

LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)                  /* handle the messages */
	{
	case WM_CREATE:
	{
		//load();
		/*
		hwndtext = CreateWindow(TEXT("EDIT"), TEXT("change me"),
					   WS_VISIBLE | WS_CHILD | WS_BORDER | ES_AUTOHSCROLL,
					   10,10,100,20,
					   hwnd, HMENU(text), NULL, NULL);
		 */
		 //WS_DISABLED


		CreateWindow(TEXT("BUTTON"), TEXT(" stop"),
			WS_VISIBLE | WS_CHILD | WS_BORDER,
			10, 40, 80, 20,
			hwnd, HMENU(button), NULL, NULL);
		CreateWindow(TEXT("BUTTON"), TEXT(" run"),
			WS_VISIBLE | WS_CHILD | WS_BORDER,
			10, 100, 80, 20,
			hwnd, HMENU(2), NULL, NULL);
		/*
		  HWND hButton =  CreateWindow(TEXT("BUTTON"), NULL,
			   WS_VISIBLE | WS_CHILD | BS_BITMAP,
			   10, 100, 80, 20,
			   hwnd, HMENU(2), NULL, NULL);
		//SendMessage(hButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hBmp);
		SendMessage(hButton, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM)imgb);
		*/
		break;
	}
	case WM_COMMAND:
	{
		if (LOWORD(wParam) == button)
		{
			if (loop_thread.joinable())
			{
				promise->set_value(true);
				loop_thread.join();

				delete promise;
				delete condition;

				promise = nullptr;
				condition = nullptr;

				MessageBox(hwnd, "zz", "hwndtext", MB_OK);
			}
			else
			{
				MessageBox(NULL, "Loop was not started!", "Notice", MB_OK);
			}
		}
		if (LOWORD(wParam) == 2)
		{ // when press run button

			if (promise == nullptr && condition == nullptr)
			{
				condition = new std::future<bool>;
				promise = new std::promise<bool>;

				*condition = promise->get_future();
				loop_thread = std::thread(MyLoop, condition);
			}

			//MessageBox(hwnd, "zzz", "hwndtext", MB_OK);
		}
		break;
	}

	case WM_DESTROY:
		if (loop_thread.joinable())
		{
			promise->set_value(true);
			loop_thread.join();

			delete promise;
			delete condition;

			promise = nullptr;
			condition = nullptr;
		}

		PostQuitMessage(0);       /* send a WM_QUIT to the message queue */
		break;
	default:                      /* for messages that we don't deal with */
		return DefWindowProc(hwnd, message, wParam, lParam);
	}

	return 0;
}


EDIT:
I modified code again so that you can normally close and press stop multiple times.
Last edited on
Hawlong (120)
malibor

thanks so much ,working <3
malibor (660)
good, but to get most out of it, next step is to understand what the code does.

I suggest you to read about std::thread here:
https://www.cplusplus.com/reference/thread/thread/

and also here:
https://en.cppreference.com/w/cpp/thread/thread

Also understanding what is promise and future
https://www.cplusplus.com/reference/future/future/
https://www.cplusplus.com/reference/future/promise/

Most notably, try to memorize individual class functions and what they do, write few samples to test them and to verify what you learn.

This should also help to understand:
https://stackoverflow.com/questions/11004273/what-is-stdpromise
Last edited on
Hawlong (120)
malibor <3

Thank you very much, you helped me a lot
Topic archived. No new replies allowed.