//-----------------------------------------------------------------------------
// Name: 
// Desc:
//-----------------------------------------------------------------------------
HRESULT CFileWatch::Cleanup()
{
    if( m_hFileChangeThread )
    {
        PostThreadMessage( m_dwFileChangeThreadId, WM_QUIT, 0, 0 );
        WaitForSingleObject( m_hFileChangeThread, INFINITE );
        CloseHandle( m_hFileChangeThread );
        m_hFileChangeThread = NULL;
    }

    return S_OK;
}

// Called from the Java Swing dispatch thread
void
DesktopIndicatorHandler::enable
(JNIEnv *jniEnv)
{
    g_desktopIndicatorThread.MakeSureThreadIsUp(jniEnv);
    while (!PostThreadMessage(
            g_desktopIndicatorThread.getWinThreadId(),
            WM_DESKTOPINDICATOR, (WPARAM)enableCode,
            (LPARAM)this)) {
        Sleep(0); //Yield to other threads with any priority
    }
}

/* Signal to the main thread that we have file notifications for it to
   process.  */
static void
send_notifications (BYTE *info, DWORD info_size, void *desc,
                    volatile int *terminate)
{
    int done = 0;
    struct frame *f = SELECTED_FRAME ();

    /* A single buffer is used to communicate all notifications to the
       main thread.  Since both the main thread and several watcher
       threads could be active at the same time, we use a critical area
       and an "in-use" flag to synchronize them.  A watcher thread can
       only put its notifications in the buffer if it acquires the
       critical area and finds the "in-use" flag reset.  The main thread
       resets the flag after it is done processing notifications.

       FIXME: is there a better way of dealing with this?  */
    while (!done && !*terminate)
    {
        enter_crit ();
        if (!notification_buffer_in_use)
        {
            if (info_size)
                memcpy (file_notifications, info, info_size);
            notifications_size = info_size;
            notifications_desc = desc;
            /* If PostMessage fails, the message queue is full.  If that
               happens, the last thing they will worry about is file
               notifications.  So we effectively discard the
               notification in that case.  */
            if ((FRAME_TERMCAP_P (f)
                    /* We send the message to the main (a.k.a. "Lisp")
                    thread, where it will wake up MsgWaitForMultipleObjects
                      inside sys_select, causing it to report that there's
                      some keyboard input available.  This will in turn cause
                      w32_console_read_socket to be called, which will pick
                      up the file notifications.  */
                    && PostThreadMessage (dwMainThreadId, WM_EMACS_FILENOTIFY, 0, 0))
                    || (FRAME_W32_P (f)
                        && PostMessage (FRAME_W32_WINDOW (f),
                                        WM_EMACS_FILENOTIFY, 0, 0))
                    /* When we are running in batch mode, there's no one to
                    send a message, so we just signal the data is
                     available and hope sys_select will be called soon and
                     will read the data.  */
                    || (FRAME_INITIAL_P (f) && noninteractive))
                notification_buffer_in_use = 1;
            done = 1;
        }
        leave_crit ();
        if (!done)
            Sleep (5);
    }
}

void DspCloseLibrary()
#ifdef USE_A_THREAD
{
	if(!dspPluginEnabled) return ;

	PostThreadMessage(UpdateThreadId,WM_QUIT,0,0);
	running=false;
	if(WaitForSingleObject(hUpdateThread,1000)==WAIT_TIMEOUT)
	{
		TerminateThread(hUpdateThread,1);
	}
}

int CSound::Stop()
{
	if(!m_pSecondaryBuffer) return CS_E_NULL_SECONDARY;
	if( m_isStreamFile ){
		PostThreadMessage(m_dwThreadId, CSL_MSG_STOP, 0, 0);
		WaitForSingleObject(m_hThreadMessageDispatchEvent, INFINITE);
	}else{
		m_pSecondaryBuffer->Stop();
		this->StopDuplicatedBuffer();	//まさか複製バッファの音だけ残しておきたいとか無いでしょ・・・
	}
	return CS_E_OK;
}

LPTIMECALLBACK setitimer_timeout(UINT uTimerID, UINT info, DWORD dwUser, DWORD dw1, DWORD dw2)
{
	struct timer_msg *msg = (struct timer_msg *) info;

	if (msg) {
		raise((int) msg->signal);
		PostThreadMessage(msg->threadid,
						  WM_NOTIFY, msg->signal, 0);
		free(msg);
	}
	return 0;
}

int clear_hook(void)
{
    if(mouse_ll_hook == NULL) {
        return 1;
    }

    PostThreadMessage(hook_thread_id, HOOK_THREAD_END, 0, 0);
    WaitForSingleObject(hook_thread_end_evt, INFINITE);
    CloseHandle(hook_thread_end_evt);

    return 1;
}

void wimfilecleanup(JSContext * cx, JSObject * obj)
{
    HANDLE wimHandle = JS_GetPrivate(cx, obj);
    if(wimHandle == NULL)
        return;
    if(threadID != 0)
    {
        while(!PostThreadMessage(threadID, WM_APP + 2, 0, (LPARAM)wimHandle))
            Sleep(200);
    }
    WIMUnregisterMessageCallback(wimHandle, NULL);
    WIMCloseHandle(wimHandle);
}

CCoFAHost::~CCoFAHost()
{
    TRY_CATCH
    Log.Add(_MESSAGE_,_T("CCoFAHost::~CCoFAHost()"));

    PostThreadMessage(GetTid(), WM_QUIT, 0, 0);
    m_brokerEvents.Revoke();

//	if( m_server.get() )
//		m_server->Stop();

    CATCH_LOG()
}

LIBNOTIFY_API gboolean notify_notification_close(
	NotifyNotification *notification, GError **error)
{
	UNREFERENCED_PARAMETER(error);

	if(notification_thread && notification)
		return PostThreadMessage(notification_thread_id,
								 WM_LIBNOTIFYCLOSE,
								 0,
								 (LPARAM) notification);

	return FALSE;
}

int d3d::EnterMsgLoop()
{
	MSG msg;
	::ZeroMemory(&msg, sizeof(MSG));

	timeBeginPeriod(1);
	unsigned int thid;

	g_ThreadCnt++;
	_beginthreadex(NULL, 0, GameLoop,NULL,0,&thid);
	while(msg.message != WM_QUIT)
	{
		if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
		{
			if(msg.message == WM_KEYDOWN || msg.message == WM_CHAR || (msg.message == WM_KEYUP && (msg.wParam == VK_SHIFT || msg.wParam == VK_CONTROL)))
				PostThreadMessage(thid,msg.message,msg.wParam,msg.lParam);
			::TranslateMessage(&msg);
			::DispatchMessage(&msg);
		}
		Sleep(16);	
		if(!Display(0))
		{
			::MessageBox(0, "디스플레이 에러", 0, 0);
		}
		if(!g_ThreadCnt)
			break;
		//if(0)
		//{
		//	PostQuitMessage(0);
		//}
    }
	PostThreadMessage(thid,WM_QUIT,msg.wParam,msg.lParam);
	int i=0;
	while(g_ThreadCnt > 0 && i++ <= 50)
		Sleep(200);
	if(i>50)
		::MessageBox(0, "쓰레드 종료 실패", 0, 0);
	return msg.wParam;
}

BOOL WINAPI ConsoleEventHandler(DWORD dwCtrlType)
{
	switch(dwCtrlType)
	{
		case CTRL_C_EVENT:
		case CTRL_CLOSE_EVENT:
			PostThreadMessage(dwMainThread, WM_QUIT, NULL, NULL);
			return TRUE;

		default:
			return FALSE;
	}
}

void DspCloseLibrary()
#ifdef USE_A_THREAD
{
	if(!dspPluginEnabled) return ;

	PostThreadMessage(UpdateThreadId,WM_QUIT,0,0);
	running=false;
	if(WaitForSingleObject(hUpdateThread,1000)==WAIT_TIMEOUT)
	{
		ConLog("SPU2-X: WARNING: DSP Thread did not close itself in time. Assuming hung. Terminating.\n");
		TerminateThread(hUpdateThread,1);
	}
}

/**
 * Send a message to the async window thread and wait for a reply
 *
 * @returns VBox status code.
 * @param   pWindowThread   Thread handle
 * @param   WndRequestSem   Semaphore handle for waiting
 * @param   msg             Message id
 * @param   wParam          First parameter
 * @param   lParam          Second parameter
 */
int vmsvga3dSendThreadMessage(RTTHREAD pWindowThread, RTSEMEVENT WndRequestSem, UINT msg, WPARAM wParam, LPARAM lParam)
{
    int  rc;
    BOOL ret;

    ret = PostThreadMessage(RTThreadGetNative(pWindowThread), msg, wParam, lParam);
    AssertMsgReturn(ret, ("PostThreadMessage %x failed with %d\n", RTThreadGetNative(pWindowThread), GetLastError()), VERR_INTERNAL_ERROR);

    rc = RTSemEventWait(WndRequestSem, RT_INDEFINITE_WAIT);
    Assert(RT_SUCCESS(rc));

    return rc;
}

void NotifyApplication(char *buffer)
{
	WORD msgSize, command;

	msgSize = *(WORD*)&buffer[0];
	command = *(WORD*)&buffer[2];

	if (blockingMode)
		PostThreadMessage (applProcID, WM_FL_ARRIVED, MAKELONG(command,msgSize), (LPARAM)(buffer+4));
	else
		SendMessage (hMom, WM_FL_ARRIVED, MAKELONG(command,msgSize), (LPARAM)(buffer+4));
	remRecvItems++;
}

void DesktopIndicatorHandler::update( jint image, const char *tooltip )
{
	m_icon = (HICON) image;

	// Free string
	if( m_tooltip )
		delete m_tooltip;

	// Copy string
	m_tooltip = strdup( tooltip );

	PostThreadMessage( g_DesktopIndicatorThread, WM_DESKTOPINDICATOR, updateCode, (LPARAM) this );
}

UIOHOOK_API int hook_stop() {
	int status = UIOHOOK_FAILURE;

	// Try to exit the thread naturally.
	if (PostThreadMessage(hook_thread_id, WM_QUIT, (WPARAM) NULL, (LPARAM) NULL)) {
		status = UIOHOOK_SUCCESS;
	}

	logger(LOG_LEVEL_DEBUG,	"%s [%u]: Status: %#X.\n",
			__FUNCTION__, __LINE__, status);

	return status;
}

/*
    WaveInProc

    Posts a message to 'CaptureThreadProc' everytime a WaveIn Buffer is completed and
    returns to the application (with more data)
*/
static void CALLBACK WaveInProc(HWAVEIN hDevice,UINT uMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)
{
    ALCdevice *pDevice = (ALCdevice*)dwInstance;
    WinMMData *pData = pDevice->ExtraData;

    (void)hDevice;
    (void)dwParam2;

    if(uMsg != WIM_DATA)
        return;

    InterlockedDecrement(&pData->lWaveBuffersCommitted);
    PostThreadMessage(pData->ulWaveThreadID,uMsg,0,dwParam1);
}

void wmmSoundSuspend(WmmSound* wmmSound) 
{
    if(wmmSound->hThread == NULL) {
        return;
    }

    while (0 == PostThreadMessage(wmmSound->sndThreadId, WM_USER + 1, 0, 0)) {
        Sleep(100);
    }

    WaitForSingleObject(wmmSound->hThread, INFINITE);
    CloseHandle(wmmSound->hThread);
    wmmSound->hThread = NULL;
}

VOID EndProcess(int ProcessIndex)
{
	if(ProcessIndex >=0 && ProcessIndex <= MAX_NUM_OF_PROCESS)
	{
		if(pProcInfo[ProcessIndex].hProcess)
		{
			// post a WM_QUIT message first
			PostThreadMessage(pProcInfo[ProcessIndex].dwThreadId, WM_QUIT, 0, 0);
			Sleep(1000);
			// terminate the process by force
			TerminateProcess(pProcInfo[ProcessIndex].hProcess, 0);
		}
	}
}