reactos/rostests/apitests/user32/AttachThreadInput.c

682 lines
21 KiB
C
Raw Normal View History

/*
* PROJECT: ReactOS api tests
* LICENSE: GPL - See COPYING in the top level directory
* PURPOSE: Test for AttachThreadInput
* PROGRAMMERS: Giannis Adamopoulos
*/
#include <windows.h>
#include <stdio.h>
#include <wine/test.h>
#include "helper.h"
#include <undocuser.h>
#define DESKTOP_ALL_ACCESS 0x01ff
typedef struct {
DWORD tid;
HANDLE hThread;
HWND hWnd;
WCHAR* Desktop;
HANDLE StartEvent;
HANDLE QueueStatusEvent;
DWORD LastQueueStatus;
MSG_CACHE cache;
} THREAD_DATA;
DWORD tidMouseMove;
THREAD_DATA data[6];
HHOOK hMouseHookLL = NULL;
HHOOK hKbdHookLL = NULL;
#define EXPECT_FOREGROUND(expected) ok(GetForegroundWindow() == expected, \
"Expected hwnd%d at the foreground, got hwnd%d\n", \
get_iwnd(expected), get_iwnd(GetForegroundWindow()));
#define EXPECT_ACTIVE(expected) ok(GetActiveWindow() == expected, \
"Expected hwnd%d to be active, got hwnd%d\n", \
get_iwnd(expected), get_iwnd(GetActiveWindow()));
/*
* Helper functions
*/
static int get_iwnd(HWND hWnd)
{
if(hWnd == data[0].hWnd) return 0;
else if(hWnd == data[1].hWnd) return 1;
else if(hWnd == data[2].hWnd) return 2;
else if(hWnd == data[3].hWnd) return 3;
else if(hWnd == data[4].hWnd) return 4;
else return -1;
}
LRESULT CALLBACK TestProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int iwnd = get_iwnd(hWnd);
if(iwnd >= 0 && message > 0 && message < WM_APP && message != WM_TIMER)
record_message(&data[iwnd].cache, iwnd, message, SENT, wParam,0);
return DefWindowProc(hWnd, message, wParam, lParam);
}
static void FlushMessages()
{
MSG msg;
LRESULT res;
while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
{
int iwnd = get_iwnd(msg.hwnd);
if( iwnd >= 0 && msg.message > 0 && msg.message < WM_APP && msg.message != WM_TIMER)
record_message(&data[0].cache, iwnd, msg.message, POST, msg.wParam,0);
DispatchMessageA( &msg );
}
/* Use SendMessage to sync with the other queues */
res = SendMessageTimeout(data[1].hWnd, WM_APP, 0,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
res = SendMessageTimeout(data[2].hWnd, WM_APP, 0,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
res = SendMessageTimeout(data[3].hWnd, WM_APP, 0,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
res = SendMessageTimeout(data[4].hWnd, WM_APP, 0,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
}
static DWORD WINAPI thread_proc(void *param)
{
THREAD_DATA* current_data = (THREAD_DATA*)param;
MSG msg;
HDESK hdesk = NULL;
int iwnd;
if(current_data->Desktop)
{
hdesk = CreateDesktopW(current_data->Desktop, NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
SetThreadDesktop(hdesk);
}
/* create test window */
current_data->hWnd = CreateWindowW(L"TestClass", L"test", WS_OVERLAPPEDWINDOW,
100, 100, 500, 500, NULL, NULL, 0, NULL);
SetEvent( current_data->StartEvent );
iwnd = get_iwnd(current_data->hWnd);
/* Use MsgWaitForMultipleObjects to let the thread process apcs */
while( GetMessage(&msg, 0,0,0) )
{
if(msg.message > 0 && msg.message < WM_APP && msg.message != WM_TIMER )
record_message(&data[iwnd].cache, iwnd, msg.message, POST, msg.wParam,0);
DispatchMessage(&msg);
}
if(hdesk)
CloseDesktop(hdesk);
return 0;
}
BOOL CreateTestThread(int i, WCHAR* Desktop)
{
DWORD ret;
data[i].StartEvent = CreateEventW(NULL, 0, 0, NULL);
data[i].Desktop = Desktop;
data[i].hThread = CreateThread(NULL, 0, thread_proc, &data[i], 0, &data[i].tid);
if(!data[i].hThread) goto fail;
ret = WaitForSingleObject(data[i].StartEvent, 1000);
CloseHandle(data[i].StartEvent);
if(ret == WAIT_TIMEOUT)
{
fail:
win_skip("child thread failed to initialize\n");
return FALSE;
}
return TRUE;
}
static LRESULT CALLBACK MouseLLHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
LRESULT ret;
MSLLHOOKSTRUCT* params = (MSLLHOOKSTRUCT*) lParam;
ret = CallNextHookEx(hMouseHookLL, nCode, wParam, lParam);
if((params->flags & LLKHF_INJECTED) == 0)
return TRUE;
return ret;
}
LRESULT CALLBACK KbdLLHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
LRESULT ret;
KBDLLHOOKSTRUCT* params = (KBDLLHOOKSTRUCT*) lParam;
ret = CallNextHookEx(hMouseHookLL, nCode, wParam, lParam);
if((params->flags & LLKHF_INJECTED) == 0)
return TRUE;
return ret;
}
BOOLEAN InitThreads()
{
/* Create a LL hook that drops any physical keyboard and mouse action
and prevent the user from interfering with the test results */
if(!IsDebuggerPresent())
{
hMouseHookLL = SetWindowsHookExW(WH_MOUSE_LL, MouseLLHookProc, GetModuleHandleW( NULL ), 0);
ok(hMouseHookLL!=NULL,"failed to set hook\n");
hKbdHookLL = SetWindowsHookExW(WH_KEYBOARD_LL, KbdLLHookProc, GetModuleHandleW( NULL ), 0);
ok(hKbdHookLL!=NULL,"failed to set hook\n");
}
/* create test clases */
RegisterSimpleClass(TestProc, L"TestClass");
memset(&data[0], 0, sizeof(data[0]));
data[0].tid = GetCurrentThreadId();
/* create test window */
data[0].hWnd = CreateWindowW(L"TestClass", L"test", WS_OVERLAPPEDWINDOW,
100, 100, 500, 500, NULL, NULL, 0, NULL);
if(!data[0].hWnd)
{
win_skip("CreateWindowW failed\n");
return FALSE;
}
/* create thread1(same desktop) */
if(!CreateTestThread(1, NULL)) return FALSE;
/* create thread2(same desktop) */
if(!CreateTestThread(2, NULL)) return FALSE;
/* ugly ros hack to bypass desktop crapiness */
if(!CreateTestThread(6, L"ThreadTestDesktop")) return FALSE;
/* create thread3(different desktop) */
if(!CreateTestThread(3, L"ThreadTestDesktop")) return FALSE;
/* create thread4(different desktop) */
if(!CreateTestThread(4, L"ThreadTestDesktop")) return FALSE;
return TRUE;
}
static void cleanup_attachments()
{
int i,j;
BOOL ret;
for(i = 0; i< 4; i++);
{
for(j = 0; j< 4; j++);
{
ret = AttachThreadInput(data[i].tid,data[j].tid, FALSE);
ok(ret==0, "expected AttachThreadInput to fail\n");
}
}
}
/*
* The actual tests
*/
void Test_SimpleParameters()
{
BOOL ret;
/* FIXME: acording to msdn xp doesn't set last error but vista+ does*/
/* test wrong thread */
ret = AttachThreadInput( 0, 1, TRUE);
ok(ret==0, "expected AttachThreadInput to fail\n");
/* test same thread */
ret = AttachThreadInput( data[1].tid, data[1].tid, TRUE);
ok(ret==0, "expected AttachThreadInput to fail\n");
/* try to attach to a thread on another desktop*/
ret = AttachThreadInput( data[2].tid,data[3].tid, TRUE);
ok(ret==0, "expected AttachThreadInput to fail\n");
if(ret == 1 )
AttachThreadInput( data[2].tid,data[3].tid, FALSE);
/* test other desktop to this */
ret = AttachThreadInput( data[3].tid,data[2].tid, TRUE);
ok(ret==0, "expected AttachThreadInput to fail\n");
if(ret == 1 )
AttachThreadInput( data[3].tid,data[2].tid, FALSE);
/* attach two threads that are both in ThreadTestDesktop */
{
/* Attach thread 3 and 4 */
ret = AttachThreadInput( data[3].tid,data[4].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
/* cleanup previous attachment */
ret = AttachThreadInput( data[3].tid,data[4].tid, FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
{
/* Attach thread 1 and 2 */
ret = AttachThreadInput( data[1].tid,data[2].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
/* attach already attached*/
ret = AttachThreadInput( data[1].tid,data[2].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
/* attach in the opposite order */
ret = AttachThreadInput( data[2].tid,data[1].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
/* Now try to detach 0 from 1 */
ret = AttachThreadInput( data[0].tid,data[1].tid, FALSE);
ok(ret==0, "expected AttachThreadInput to fail\n");
/* also try to detach 3 from 2 */
ret = AttachThreadInput( data[3].tid,data[2].tid, FALSE);
ok(ret==0, "expected AttachThreadInput to fail\n");
/* cleanup previous attachment */
ret = AttachThreadInput( data[1].tid,data[2].tid, FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[2].tid,data[1].tid, FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[1].tid,data[2].tid, FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
/* test triple attach */
{
ret = AttachThreadInput( data[0].tid, data[1].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[1].tid, data[2].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
/* try to detach 2 and 0 */
ret = AttachThreadInput( data[0].tid, data[2].tid, FALSE);
ok(ret==0, "expected AttachThreadInput to fail\n");
ret = AttachThreadInput( data[2].tid, data[0].tid, FALSE);
ok(ret==0, "expected AttachThreadInput to fail\n");
/* try to to attach 0 to 2. it works! */
ret = AttachThreadInput( data[0].tid, data[2].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[0].tid, data[2].tid, FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
/* detach in inverse order */
ret = AttachThreadInput( data[0].tid, data[1].tid, FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[1].tid, data[2].tid, FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
/* test detaching in thread cleanup */
{
ret = AttachThreadInput( data[0].tid, data[1].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[0].tid, data[1].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[1].tid, data[2].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
ret = AttachThreadInput( data[1].tid, data[2].tid, TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
TerminateThread(data[1].hThread, 0);
ret = AttachThreadInput( data[0].tid, data[1].tid, FALSE);
ok(ret==0, "expected AttachThreadInput to fail\n");
ret = AttachThreadInput( data[1].tid, data[2].tid, FALSE);
ok(ret==0, "expected AttachThreadInput to fail\n");
/* Create Thread1 again */
CreateTestThread(1, NULL);
}
}
void Test_Focus() //Focus Active Capture Foreground Capture
{
BOOL ret;
/* Window 1 is in the foreground */
SetForegroundWindow(data[1].hWnd);
SetActiveWindow(data[0].hWnd);
FlushMessages();
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(data[0].hWnd);
/* attach thread 0 to 1 */
{
ret = AttachThreadInput( data[0].tid, data[1].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
FlushMessages();
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(data[1].hWnd);
ret = AttachThreadInput( data[0].tid, data[1].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(0);
SetForegroundWindow(data[1].hWnd);
SetActiveWindow(data[0].hWnd);
FlushMessages();
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(data[0].hWnd);
/* attach thread 1 to 0 */
{
ret = AttachThreadInput( data[1].tid, data[0].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
FlushMessages();
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(data[1].hWnd);
ret = AttachThreadInput( data[1].tid, data[0].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
/* Window 0 is in the foreground */
SetForegroundWindow(data[0].hWnd);
SetActiveWindow(data[1].hWnd);
FlushMessages();
EXPECT_FOREGROUND(data[0].hWnd);
EXPECT_ACTIVE(data[0].hWnd);
/* attach thread 0 to 1 */
{
ret = AttachThreadInput( data[0].tid, data[1].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
FlushMessages();
EXPECT_FOREGROUND(data[0].hWnd);
EXPECT_ACTIVE(data[0].hWnd);
SetForegroundWindow(data[0].hWnd);
SetActiveWindow(data[1].hWnd);
FlushMessages();
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(data[1].hWnd);
ret = AttachThreadInput( data[0].tid, data[1].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(0);
SetForegroundWindow(data[0].hWnd);
SetActiveWindow(data[1].hWnd);
FlushMessages();
EXPECT_FOREGROUND(data[0].hWnd);
EXPECT_ACTIVE(data[0].hWnd);
/* attach thread 1 to 0 */
{
ret = AttachThreadInput( data[1].tid, data[0].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
FlushMessages();
EXPECT_FOREGROUND(data[0].hWnd);
EXPECT_ACTIVE(data[0].hWnd);
SetForegroundWindow(data[0].hWnd);
SetActiveWindow(data[1].hWnd);
FlushMessages();
EXPECT_FOREGROUND(data[1].hWnd);
EXPECT_ACTIVE(data[1].hWnd);
ret = AttachThreadInput( data[1].tid, data[0].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
}
/* test some functions like PostMessage and SendMessage that shouldn't be affected */
void Test_UnaffectedMessages()
{
BOOL ret;
LRESULT res;
EMPTY_CACHE_(&data[0].cache);
EMPTY_CACHE_(&data[1].cache);
/* test that messages posted before and after attachment are unaffected
and that we don't receive a meassage from a window we shouldn't */
PostMessage(data[0].hWnd, WM_USER, 0,0);
PostMessage(data[1].hWnd, WM_USER, 1,0);
{
MSG_ENTRY Thread0_chain[]={
{0,WM_USER, POST, 0, 0},
{0,WM_USER, POST, 2, 0},
{0,0}};
MSG_ENTRY Thread1_chain[]={
{1,WM_USER, POST, 1, 0},
{1,WM_USER, POST, 3, 0},
{0,0}};
ret = AttachThreadInput( data[1].tid, data[0].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
PostMessage(data[0].hWnd, WM_USER, 2,0);
PostMessage(data[1].hWnd, WM_USER, 3,0);
FlushMessages();
Sleep(100);
COMPARE_CACHE_(&data[0].cache, Thread0_chain);
COMPARE_CACHE_(&data[1].cache, Thread1_chain);
ret = AttachThreadInput( data[1].tid, data[0].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
/* test messages send to the wrong thread */
res = SendMessageTimeout(data[0].hWnd, WM_USER, 0,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
res = SendMessageTimeout(data[1].hWnd, WM_USER, 1,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
{
MSG_ENTRY Thread0_chain[]={
{0,WM_USER, SENT, 0, 0},
{0,WM_USER, SENT, 2, 0},
{0,0}};
MSG_ENTRY Thread1_chain[]={
{1,WM_USER, SENT, 1, 0},
{1,WM_USER, SENT, 3, 0},
{1,WM_MOUSEMOVE, SENT, 0, 0},
{0,0}};
ret = AttachThreadInput( data[2].tid, data[1].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
res = SendMessageTimeout(data[0].hWnd, WM_USER, 2,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
res = SendMessageTimeout(data[1].hWnd, WM_USER, 3,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
/* Try to send a fake input message */
res = SendMessageTimeout(data[1].hWnd, WM_MOUSEMOVE, 0,0, SMTO_NORMAL, 1000, NULL);
ok (res != ERROR_TIMEOUT, "SendMessageTimeout timed out\n");
COMPARE_CACHE_(&data[0].cache, Thread0_chain);
COMPARE_CACHE_(&data[1].cache, Thread1_chain);
ret = AttachThreadInput( data[2].tid, data[1].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
/* todo: test keyboard layout that shouldn't be affected */
}
void Test_SendInput()
{
MSG_ENTRY Thread1_chain[]={
{1,WM_KEYDOWN, POST, VK_SHIFT, 0},
{1,WM_KEYUP, POST, VK_SHIFT, 0},
{0,0}};
MSG_ENTRY Thread0_chain[]={
{0,WM_KEYDOWN, POST, VK_SHIFT, 0},
{0,WM_KEYUP, POST, VK_SHIFT, 0},
{0,0}};
BOOL ret;
/* First try sending input without attaching. It will go to the foreground */
{
SetForegroundWindow(data[1].hWnd);
SetActiveWindow(data[0].hWnd);
ok(GetForegroundWindow() == data[1].hWnd, "wrong foreground\n");
ok(GetActiveWindow() == data[0].hWnd, "wrong active\n");
FlushMessages();
EMPTY_CACHE_(&data[0].cache);
EMPTY_CACHE_(&data[1].cache);
keybd_event(VK_SHIFT, 0,0,0);
keybd_event(VK_SHIFT, 0,KEYEVENTF_KEYUP,0);
Sleep(100);
FlushMessages();
COMPARE_CACHE_(&data[0].cache, empty_chain);
COMPARE_CACHE_(&data[1].cache, Thread1_chain);
}
/* Next attach and send input. It will go to the same thread as before */
{
ret = AttachThreadInput( data[1].tid, data[0].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
FlushMessages();
EMPTY_CACHE_(&data[0].cache);
EMPTY_CACHE_(&data[1].cache);
keybd_event(VK_SHIFT, 0,0,0);
keybd_event(VK_SHIFT, 0,KEYEVENTF_KEYUP,0);
Sleep(100);
FlushMessages();
COMPARE_CACHE_(&data[0].cache, empty_chain);
COMPARE_CACHE_(&data[1].cache, Thread1_chain);
}
/* Now set foregroung and active again. Input will go to thread 0 */
{
SetForegroundWindow(data[1].hWnd);
SetActiveWindow(data[0].hWnd);
FlushMessages();
EMPTY_CACHE_(&data[0].cache);
EMPTY_CACHE_(&data[1].cache);
keybd_event(VK_SHIFT, 0,0,0);
keybd_event(VK_SHIFT, 0,KEYEVENTF_KEYUP,0);
Sleep(100);
FlushMessages();
COMPARE_CACHE_(&data[0].cache, Thread0_chain);
COMPARE_CACHE_(&data[1].cache, empty_chain);
ret = AttachThreadInput( data[1].tid, data[0].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
/* Attach in the opposite order and send input */
{
ret = AttachThreadInput( data[0].tid, data[1].tid , TRUE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
FlushMessages();
EMPTY_CACHE_(&data[0].cache);
EMPTY_CACHE_(&data[1].cache);
keybd_event(VK_SHIFT, 0,0,0);
keybd_event(VK_SHIFT, 0,KEYEVENTF_KEYUP,0);
Sleep(100);
FlushMessages();
COMPARE_CACHE_(&data[0].cache, Thread0_chain);
COMPARE_CACHE_(&data[1].cache, empty_chain);
}
/* Now set foregroung and active again. Input will go to thread 0 */
{
SetForegroundWindow(data[1].hWnd);
SetActiveWindow(data[0].hWnd);
FlushMessages();
EMPTY_CACHE_(&data[0].cache);
EMPTY_CACHE_(&data[1].cache);
keybd_event(VK_SHIFT, 0,0,0);
keybd_event(VK_SHIFT, 0,KEYEVENTF_KEYUP,0);
Sleep(100);
FlushMessages();
COMPARE_CACHE_(&data[0].cache, Thread0_chain);
COMPARE_CACHE_(&data[1].cache, empty_chain);
ret = AttachThreadInput( data[0].tid, data[1].tid , FALSE);
ok(ret==1, "expected AttachThreadInput to succeed\n");
}
}
START_TEST(AttachThreadInput)
{
if(!InitThreads())
return;
win_skip("skip Test_SimpleParameters that crash ros\n");
//Test_SimpleParameters();
//cleanup_attachments();
Test_Focus();
cleanup_attachments();
Test_UnaffectedMessages();
cleanup_attachments();
Test_SendInput();
cleanup_attachments();
if(hMouseHookLL)
UnhookWindowsHookEx(hMouseHookLL);
if(hKbdHookLL)
UnhookWindowsHookEx(hKbdHookLL);
/* Stop all threads and exit gratefully */
PostThreadMessage(data[1].tid, WM_QUIT,0,0);
PostThreadMessage(data[2].tid, WM_QUIT,0,0);
PostThreadMessage(data[3].tid, WM_QUIT,0,0);
PostThreadMessage(data[4].tid, WM_QUIT,0,0);
}