学步园

// WaitDlg.h

#pragma once

#include "resource.h"

#include <afxmt.h>
#include "WaitDlgThread.h"

class CWaitDlg : public CDialog
{
public:
    enum { IDD = IDD_WAITING_DIALOG };

public:
    CWaitDlg(CWnd* pParent = NULL);

protected:
    virtual void DoDataExchange(CDataExchange* pDX);
    virtual BOOL OnInitDialog();

protected:
    afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
    afx_msg void OnTimer(UINT nIDEvent);
    DECLARE_MESSAGE_MAP()

public:
    CWaitDlgThread* m_pcWaitDlgThread;
    CString m_strWaitTipText;
};

// WaitDlg.cpp

#include "stdafx.h"
#include "WaitDlg.h"

CWaitDlg::CWaitDlg(CWnd* pParent /*=NULL*/)
    : CDialog(CWaitDlg::IDD, pParent)
{
    m_pcWaitDlgThread = NULL;
    m_strWaitTipText = "";
}

void CWaitDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CWaitDlg, CDialog)
    ON_WM_SETCURSOR()
    ON_WM_TIMER()
END_MESSAGE_MAP()

BOOL CWaitDlg::OnInitDialog() 
{
    CDialog::OnInitDialog();

    if ( m_strWaitTipText.GetLength() > 0 )
    {
        GetDlgItem(IDC_STATIC_WAIT_TIP)->SetWindowText(m_strWaitTipText);
    }

    SetTimer(1, 500, NULL);

    return TRUE;
}

BOOL CWaitDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
	return TRUE;
}

void CWaitDlg::OnTimer(UINT nIDEvent) 
{
    static int nCount = 0;

    CString strMsg = m_strWaitTipText;

    for ( int i = 0; i < nCount; ++i )
    {
        strMsg += ".";
    }

    GetDlgItem(IDC_STATIC_WAIT_TIP)->SetWindowText(strMsg);

    if ( ++nCount > 3 )
    {
        nCount = 0;
    }

    CSingleLock cSingleLock(m_pcWaitDlgThread->m_pcEvent, FALSE);
    if ( cSingleLock.Lock(IGNORE) )
    {
        KillTimer(1);
        CDialog::OnOK();
    }
}

// WaitDlgThread.h

#pragma once

#include <afxmt.h>

class CWaitDlgThread : public CWinThread
{
    DECLARE_DYNCREATE(CWaitDlgThread)

public:
    CWaitDlgThread();

public:
    // CWinThread
    virtual BOOL InitInstance();
    virtual int ExitInstance();

public:    
    CString m_strEventName;
    CString m_strWaitTipText;

public:
    CEvent* m_pcEvent;
};

// WaitDlgThread.cpp

#include "stdafx.h"
#include "WaitDlgThread.h"
#include "WaitDlg.h"

IMPLEMENT_DYNCREATE(CWaitDlgThread, CWinThread)

CWaitDlgThread::CWaitDlgThread()
{
    m_strEventName = "";
    m_strWaitTipText = "";

    m_pcEvent = NULL;
}

BOOL CWaitDlgThread::InitInstance()
{
    CWaitDlg cWaitDlg;
    cWaitDlg.m_pcWaitDlgThread = this;
    cWaitDlg.m_strWaitTipText = m_strWaitTipText;

    m_pMainWnd = &cWaitDlg;

    m_pcEvent = new CEvent(FALSE, TRUE, m_strEventName);
    cWaitDlg.DoModal();
    delete m_pcEvent;

    return CWinThread::InitInstance();
}

int CWaitDlgThread::ExitInstance()
{
    return CWinThread::ExitInstance();
}

// WaitTip.h

#pragma once

#include "WaitDlgThread.h"

class CWaitTip : public CCmdTarget
{
public:
    CWaitTip();

public:
    void BeginWait(LPCSTR lpszWaitTipText);
    void EndWait();

private:
    CString m_strEventName;
    HANDLE m_hEvent;
    CWaitDlgThread* m_pcWaitDlgThread;
};

// WaitTip.cpp

#include "stdafx.h"
#include "WaitTip.h"

#define WAIT_TIP_EVENT_NAME "WaitTipEventName"

CWaitTip::CWaitTip()
{
    m_strEventName = WAIT_TIP_EVENT_NAME;
    m_hEvent = NULL;
    m_pcWaitDlgThread = NULL;
}

void CWaitTip::BeginWait(LPCSTR lpszWaitTipText)
{
    m_hEvent = CreateEvent(NULL, TRUE, FALSE, m_strEventName);
    if ( m_hEvent == NULL )
    {
        EndWait();
    }

    m_pcWaitDlgThread = (CWaitDlgThread*)AfxBeginThread(
        RUNTIME_CLASS(CWaitDlgThread),
        THREAD_PRIORITY_NORMAL,
        0,
        CREATE_SUSPENDED
    );
    if ( m_pcWaitDlgThread == NULL )
    {
        EndWait();
    }

    m_pcWaitDlgThread->m_strEventName = m_strEventName;
    m_pcWaitDlgThread->m_strWaitTipText = lpszWaitTipText;
    m_pcWaitDlgThread->ResumeThread();
}

void CWaitTip::EndWait()
{
    if ( m_pcWaitDlgThread != NULL )
    {
        while (true)
        {
            CEvent* pcEvent = m_pcWaitDlgThread->m_pcEvent;
            if ( pcEvent )
            {
                pcEvent->SetEvent();
                break;
            }
            else
            {
                Sleep(10);
                continue;
            }
        }
    }

    if ( m_hEvent != NULL )
    {
        CloseHandle(m_hEvent);
    }
}