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

#if !defined(AFX_SPLASHWND_H__18C1CB0F_1CFF_483B_872E_E5A78BC1239E__INCLUDED_)
#define AFX_SPLASHWND_H__18C1CB0F_1CFF_483B_872E_E5A78BC1239E__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// SplashWnd.h : header file
//

/
// CSplashWnd window

class CSplashWnd : public CWnd
{
    DECLARE_DYNAMIC(CSplashWnd)  
  
public:  
    CSplashWnd();  
    virtual ~CSplashWnd();  
  
protected:  
    virtual void PostNcDestroy();  
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);  
    afx_msg void OnTimer(UINT_PTR nIDEvent);  
    afx_msg void OnPaint();  
    BOOL Create(CWnd* pParentWnd=NULL);  
    void HideSplashScreen(void);  
    DECLARE_MESSAGE_MAP()  
  
protected:  
    CBitmap m_bitmap;  
    static CSplashWnd* c_pSplashWnd;  
    static BOOL c_bShowSplashWnd;  
  
public:  
    static void EnableSplashScreen(BOOL bEnable=TRUE);  
    static void ShowSplashScreen(CWnd* pParentWnd=NULL);  
    static BOOL PreTranslateAppMessage(MSG* pMsg); 
};

/

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_SPLASHWND_H__18C1CB0F_1CFF_483B_872E_E5A78BC1239E__INCLUDED_)

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

// SplashWnd.cpp : implementation file
//
#include "stdafx.h"  
#include "SplashWnd.h"  
#include "resource.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif  
  
/
// CSplashWnd
CSplashWnd* CSplashWnd::c_pSplashWnd;  
BOOL CSplashWnd::c_bShowSplashWnd;  
IMPLEMENT_DYNAMIC(CSplashWnd, CWnd)  
  
CSplashWnd::CSplashWnd()  
{  
  
}  
  
CSplashWnd::~CSplashWnd()  
{  
    ASSERT(c_pSplashWnd == this);  
    c_pSplashWnd = NULL;  
}  
  
  
BEGIN_MESSAGE_MAP(CSplashWnd, CWnd)  
    ON_WM_CREATE()  
    ON_WM_TIMER()  
    ON_WM_PAINT()  
END_MESSAGE_MAP()  
  
  
  
// CSplashWnd Message handler 
  
void CSplashWnd::EnableSplashScreen(BOOL bEnable)  
{  
    c_bShowSplashWnd = bEnable;  
}  
  
void CSplashWnd::ShowSplashScreen(CWnd* pParentWnd)  
{  
    if ( !c_bShowSplashWnd || c_pSplashWnd != NULL )  
    {  
        return;  
    }  
  
    c_pSplashWnd = new CSplashWnd;  
    if ( !c_pSplashWnd->Create(pParentWnd) )  
    {  
        delete c_pSplashWnd;  
    }  
    else  
    {  
        c_pSplashWnd->UpdateWindow();  
    }  
}  
  
BOOL CSplashWnd::PreTranslateAppMessage(MSG* pMsg)  
{  
    if ( c_pSplashWnd == NULL )  
    {  
        return FALSE;  
    }  
      
    if ( pMsg->message == WM_KEYDOWN  
        || pMsg->message == WM_SYSKEYDOWN  
        || pMsg->message == WM_LBUTTONDOWN  
        || pMsg->message == WM_RBUTTONDOWN  
        || pMsg->message == WM_MBUTTONDOWN  
        || pMsg->message == WM_NCLBUTTONDOWN  
        || pMsg->message == WM_NCRBUTTONDOWN  
        || pMsg->message == WM_NCMBUTTONDOWN)  
    {  
        c_pSplashWnd->HideSplashScreen();  
        return TRUE;  
    }  
  
    return FALSE;  
}  
  
void CSplashWnd::PostNcDestroy()  
{  
    delete this;  
}  
  
int CSplashWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)  
{  
    if ( CWnd::OnCreate(lpCreateStruct) == -1 )  
    {  
        return -1;  
    }  
  
    CenterWindow();  
    SetTimer(1, 3000, NULL);  
  
    return 0;  
}  
  
void CSplashWnd::OnTimer(UINT_PTR nIDEvent)  
{  
    if ( nIDEvent == 1 )  
    {  
        HideSplashScreen();  
    }  
}  
  
void CSplashWnd::OnPaint()  
{  
    CPaintDC dc(this);  
    CDC dcImg;  
    if ( !dcImg.CreateCompatibleDC(&dc) )  
    {  
        return;  
    }  
  
    BITMAP bm;  
    m_bitmap.GetBitmap(&bm);  
  
    CBitmap* pOldBit = dcImg.SelectObject(&m_bitmap);  
    dc.BitBlt(0, 0, bm.bmWidth, bm.bmHeight, &dcImg, 0, 0, SRCCOPY);  
    dcImg.SelectObject(pOldBit);  
}  
  
BOOL CSplashWnd::Create(CWnd* pParentWnd)  
{  
    if ( !m_bitmap.LoadBitmap(IDB_BITMAP_SPLASH) )  
    {  
        return FALSE;  
    }  
  
    BITMAP bm;  
    m_bitmap.GetBitmap(&bm);  
    return CreateEx(0,  
        AfxRegisterWndClass(0, AfxGetApp()->LoadStandardCursor(IDC_ARROW)),  
        NULL,  
        WS_POPUP | WS_VISIBLE,  
        0, 0,  
        bm.bmWidth,  
        bm.bmHeight,  
        pParentWnd->GetSafeHwnd(),  
        NULL);  
}  
  
void CSplashWnd::HideSplashScreen()  
{  
    DestroyWindow();  
    AfxGetMainWnd()->UpdateWindow();  
}

1
2
3
4

CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
// add EnableSplashScreen
CSplashWnd::EnableSplashScreen(cmdInfo.m_bShowSplash);

1
2

// Show Splash Window 
CSplashWnd::ShowSplashScreen(this);