1563 lines
32 KiB
C++
1563 lines
32 KiB
C++
//+--------------------------------------------------------------------------
|
|
//
|
|
// Copyright (C) DreamWorks Interactive, 1996.
|
|
//
|
|
// File: uidlgs.cpp
|
|
//
|
|
// Contents:
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 23-Nov-96 SHernd Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include "tpassglobals.h"
|
|
#include "supportfn.hpp"
|
|
#include "resource.h"
|
|
#include "dialogs.h"
|
|
#include "main.h"
|
|
#include "uiwnd.h"
|
|
#include "uidlgs.h"
|
|
#include "video.h"
|
|
#include "token.h"
|
|
#include "..\Lib\Sys\reg.h"
|
|
#include "..\lib\sys\reginit.hpp"
|
|
#include "keyremap.h"
|
|
|
|
|
|
#define FIRST_LEVEL_NAME "BE.SCN"
|
|
|
|
extern HINSTANCE g_hInst;
|
|
extern HWND g_hwnd;
|
|
extern CMainWnd * g_pMainWnd;
|
|
|
|
UINT g_uiRandom = (UINT)-1;
|
|
|
|
|
|
|
|
#define COUNT_LEVEL_IMAGES 1
|
|
struct
|
|
{
|
|
char szSCN[20];
|
|
char szImage[20];
|
|
} g_aszSCNImage[] =
|
|
{
|
|
{ "as.scn", "menu\\li_a1" },
|
|
{ "as2.scn", "menu\\li_a2" },
|
|
{ "be.scn", "menu\\li_be" },
|
|
{ "ij.scn", "menu\\li_ij" },
|
|
{ "it.scn", "menu\\li_it" },
|
|
{ "jr.scn", "menu\\li_jr" },
|
|
{ "lab.scn", "menu\\li_lab" },
|
|
{ "pv.scn", "menu\\li_pv" },
|
|
{ "sum.scn", "menu\\li_sum" },
|
|
{ "", "menu\\li_other" },
|
|
};
|
|
|
|
|
|
void LoadDDFIntoListbox(HANDLE hFile, CUIListbox * plistbox)
|
|
{
|
|
|
|
WNDFILETOKEN wft;
|
|
BOOL bFinished;
|
|
BOOL bRet;
|
|
|
|
bFinished = FALSE;
|
|
while (!bFinished)
|
|
{
|
|
bRet = ReadWndFileToken(hFile, &wft);
|
|
if (!bRet || wft.TokenType == LFTT_EOF)
|
|
{
|
|
bFinished = TRUE;
|
|
}
|
|
else
|
|
{
|
|
plistbox->AddItem(wft.val.sz, 0, -1, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void InitRandom()
|
|
{
|
|
if (g_uiRandom == (UINT)-1)
|
|
{
|
|
g_uiRandom = SetTimer(g_pMainWnd->m_pUIMgr->m_hwnd, IDTIMER_MAINRANDOM, 10000, NULL);
|
|
}
|
|
}
|
|
|
|
|
|
void KillRandom()
|
|
{
|
|
KillTimer(g_pMainWnd->m_pUIMgr->m_hwnd, g_uiRandom);
|
|
g_uiRandom = (UINT)-1;
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
CUIDlg::CUIDlg(CUIManager * puimgr) : CUIWnd(puimgr)
|
|
{
|
|
m_bKeyStyle = KEYSTYLE_ESCAPE;
|
|
}
|
|
|
|
|
|
CUIDlg::~CUIDlg()
|
|
{
|
|
}
|
|
|
|
|
|
BOOL CUIDlg::OnCreate()
|
|
{
|
|
if (!CUIWnd::OnCreate())
|
|
{
|
|
TraceError(("CUIDlg::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CUIDlg::OnDestroy()
|
|
{
|
|
CUIWnd::OnDestroy();
|
|
}
|
|
|
|
|
|
BOOL CUIDlg::UIButtonAudioCmd(CUIButton * pbutton, BUTTONCMD bc)
|
|
{
|
|
if (bc == BC_DOWN)
|
|
{
|
|
g_CTPassGlobals.PlayButtonAudio();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool CMainScreenWnd::m_fAMDShowLogoOnce = FALSE;
|
|
|
|
CMainScreenWnd::CMainScreenWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
m_uiInitial = (UINT)-1;
|
|
m_pUIMgr->m_bDrawMouse = TRUE;
|
|
m_pctrlAMDLogo = NULL;
|
|
}
|
|
|
|
CMainScreenWnd::~CMainScreenWnd()
|
|
{
|
|
g_CTPassGlobals.StopBackgroundAudio();
|
|
g_CTPassGlobals.FreeMenuAudio();
|
|
|
|
if (m_uiInitial != (UINT)-1)
|
|
{
|
|
KillTimer(m_pUIMgr->m_hwnd, m_uiInitial);
|
|
}
|
|
|
|
KillRandom();
|
|
}
|
|
|
|
|
|
BOOL CMainScreenWnd::OnCreate()
|
|
{
|
|
CUICtrl * pctrl;
|
|
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CMainScreenWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
CenterUIWindow(this);
|
|
|
|
g_CTPassGlobals.CreateMenuAudioDatabase();
|
|
g_CTPassGlobals.SetupMenuAudio();
|
|
|
|
m_uiInitial = SetTimer(m_pUIMgr->m_hwnd, IDTIMER_MAININIT, 2000, NULL);
|
|
|
|
m_pctrlAMDLogo = GetUICtrl(1005);
|
|
if (m_pctrlAMDLogo && m_fAMDShowLogoOnce)
|
|
{
|
|
m_pctrlAMDLogo->SetVisible(FALSE);
|
|
}
|
|
else
|
|
{
|
|
m_fAMDShowLogoOnce = TRUE;
|
|
}
|
|
|
|
#if BUILDVER_MODE == MODE_FINAL
|
|
pctrl = GetUICtrl(1004);
|
|
if (pctrl)
|
|
{
|
|
pctrl->SetActive(FALSE);
|
|
}
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CMainScreenWnd::OnKey(UINT vk, BOOL fDown, int cRepeat, UINT flags)
|
|
{
|
|
if (fDown)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (vk)
|
|
{
|
|
case 'W':
|
|
if (IsKeyDown('Q') && IsKeyDown(VK_SHIFT) && IsKeyDown(VK_CONTROL))
|
|
{
|
|
if (m_pctrlAMDLogo)
|
|
{
|
|
m_fAMDShowLogoOnce = TRUE;
|
|
m_pctrlAMDLogo->SetVisible(FALSE);
|
|
}
|
|
|
|
DirectLoad();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CMainScreenWnd::OnTimer(UINT uiID)
|
|
{
|
|
switch (uiID)
|
|
{
|
|
case IDTIMER_MAININIT:
|
|
KillTimer(m_pUIMgr->m_hwnd, m_uiInitial);
|
|
g_CTPassGlobals.StartBackgroundAudio();
|
|
InitRandom();
|
|
break;
|
|
|
|
case IDTIMER_MAINRANDOM:
|
|
g_CTPassGlobals.PlayRandomAudio();
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CMainScreenWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "mainscreen.ddf");
|
|
}
|
|
|
|
|
|
void CMainScreenWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
if (m_pctrlAMDLogo)
|
|
{
|
|
m_fAMDShowLogoOnce = TRUE;
|
|
m_pctrlAMDLogo->SetVisible(FALSE);
|
|
}
|
|
|
|
switch (pbutton->GetID())
|
|
{
|
|
case 1000:
|
|
{
|
|
int iRet;
|
|
|
|
g_CTPassGlobals.FreeMenuAudio();
|
|
|
|
CVideoWnd video(m_pUIMgr);
|
|
|
|
video.Play("menu\\newgame");
|
|
|
|
iRet = g_CTPassGlobals.LoadLevel(FIRST_LEVEL_NAME);
|
|
|
|
if (iRet >= 0)
|
|
{
|
|
EndUIWnd(2);
|
|
}
|
|
else
|
|
{
|
|
DisplayLoadingFileError(iRet);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// Load Game
|
|
case 1001:
|
|
{
|
|
CLoadGameWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
|
|
// A Level was loaded so now we start the game
|
|
if (dlg.m_dwExitValue == 1)
|
|
{
|
|
EndUIWnd(2);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// configure
|
|
case 1002:
|
|
{
|
|
COptionsWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
if (dlg.m_dwExitValue == 3)
|
|
{
|
|
// Restart The game with the render
|
|
// dialog
|
|
EndUIWnd(3);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 1003:
|
|
{
|
|
CYesNoMsgDlg dlgExit(IDS_EXIT_TRESPASSER, m_pUIMgr);
|
|
|
|
dlgExit.StartUIWnd();
|
|
|
|
if (dlgExit.m_dwExitValue == 1)
|
|
{
|
|
EndUIWnd((DWORD)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 1004:
|
|
DirectLoad();
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CMainScreenWnd::DirectLoad()
|
|
{
|
|
CDirectLoadWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
|
|
// A Level was loaded so now we start the game
|
|
if (dlg.m_dwExitValue == 1)
|
|
{
|
|
EndUIWnd(2);
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
CLoaderWnd::CLoaderWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
InitializeCriticalSection(&m_cs);
|
|
|
|
m_puitext = NULL;
|
|
m_iCycle = 0;
|
|
|
|
iLoadPercent = 0;
|
|
iLastLoadPercent = -1;
|
|
iCopyPercent = 0;
|
|
iLastCopyPercent = -1;
|
|
|
|
dwCopyTotal = 1;
|
|
}
|
|
|
|
|
|
CLoaderWnd::~CLoaderWnd()
|
|
{
|
|
DeleteCriticalSection(&m_cs);
|
|
}
|
|
|
|
|
|
BOOL CLoaderWnd::SetupUIWnd()
|
|
{
|
|
BOOL bRet;
|
|
MSG msg;
|
|
|
|
if (!m_pUIMgr->Attach(this))
|
|
{
|
|
TraceError(("CLoaderWnd::SetupUIWnd() -- "
|
|
"Unable to attach window"));
|
|
goto Error;
|
|
}
|
|
|
|
if (!OnCreate())
|
|
{
|
|
TraceError(("CLoaderWnd::SetupUIWnd() -- "
|
|
"UIWnd creation failed"));
|
|
goto Error;
|
|
}
|
|
|
|
// Suck off all the mouse and keyboard Messages that are
|
|
// in the message queue
|
|
while (PeekMessage(&msg,NULL,WM_MOUSEFIRST, WM_MOUSELAST,PM_REMOVE))
|
|
{
|
|
;
|
|
}
|
|
while (PeekMessage(&msg,NULL,WM_KEYFIRST, WM_KEYLAST,PM_REMOVE))
|
|
{
|
|
;
|
|
}
|
|
|
|
m_uiTimer = SetTimer(g_hwnd, 54, 100, NULL);
|
|
|
|
bRet = TRUE;
|
|
|
|
Cleanup:
|
|
return bRet;
|
|
|
|
Error:
|
|
TraceError(("CLoaderWnd::SetupUIWnd"));
|
|
bRet = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
void CLoaderWnd::DestroyUIWnd()
|
|
{
|
|
MSG msg;
|
|
|
|
m_pUIMgr->m_iMouse = 0;
|
|
|
|
KillTimer(g_hwnd, 54);
|
|
|
|
OnDestroy();
|
|
|
|
m_pUIMgr->Detach(this);
|
|
|
|
// Suck off all Messages that are in the message queue
|
|
while (PeekMessage(&msg,NULL,WM_MOUSEFIRST, WM_MOUSELAST,PM_REMOVE))
|
|
{
|
|
;
|
|
}
|
|
while (PeekMessage(&msg,NULL,WM_KEYFIRST, WM_KEYLAST,PM_REMOVE))
|
|
{
|
|
;
|
|
}
|
|
}
|
|
|
|
|
|
void CLoaderWnd::OnTimer(UINT uiID)
|
|
{
|
|
int iIndex;
|
|
|
|
if (uiID != 54 || !m_puitext)
|
|
{
|
|
return;
|
|
}
|
|
|
|
COLORREF acr[10] =
|
|
{
|
|
RGB(255, 255, 255),
|
|
RGB(255, 255, 227),
|
|
RGB(255, 255, 199),
|
|
RGB(255, 255, 171),
|
|
RGB(255, 255, 143),
|
|
RGB(255, 255, 114),
|
|
RGB(255, 255, 85),
|
|
RGB(255, 255, 56),
|
|
RGB(255, 255, 27),
|
|
RGB(255, 255, 0),
|
|
};
|
|
|
|
if (++m_iCycle >= 20)
|
|
{
|
|
m_iCycle = 0;
|
|
}
|
|
|
|
if (m_iCycle >= 10)
|
|
{
|
|
iIndex = 9 - (m_iCycle - 10);
|
|
}
|
|
else
|
|
{
|
|
iIndex = m_iCycle;
|
|
}
|
|
|
|
m_puitext->SetFGColor(acr[iIndex]);
|
|
}
|
|
|
|
|
|
void CLoaderWnd::InnerWindowLoop(bool bPaint)
|
|
{
|
|
IDirectDrawSurface * pSurface;
|
|
HRESULT hr;
|
|
CUIWnd * puiwnd;
|
|
DDBLTFX ddfx;
|
|
|
|
PreLoopCall();
|
|
|
|
CheckMessages();
|
|
|
|
if (m_pUIMgr->m_bActive && !m_bExitWnd && bPaint)
|
|
{
|
|
DoUIHandling();
|
|
InnerLoopCall();
|
|
|
|
// Draw everything to the back buffer
|
|
puiwnd = m_pUIMgr->GetActiveUIWnd();
|
|
puiwnd->DrawIntoSurface(prasMainScreen.ptPtrRaw(), &m_pUIMgr->m_rcInvalid);
|
|
|
|
memset(&ddfx, 0, sizeof(ddfx));
|
|
ddfx.dwSize = sizeof(ddfx);
|
|
|
|
ddfx.dwROP = SRCCOPY;
|
|
ddfx.dwDDFX = DDBLTFX_NOTEARING;
|
|
|
|
// Now draw everthing from the back buffer to the front buffer
|
|
pSurface = prasMainScreen->GetPrimarySurface();
|
|
hr = pSurface->Blt(&m_pUIMgr->m_rcInvalid,
|
|
prasMainScreen->pddsDraw,
|
|
&m_pUIMgr->m_rcInvalid,
|
|
DDBLT_WAIT | DDBLT_ROP,
|
|
&ddfx);
|
|
|
|
// Reset the invalid rect
|
|
SetRect(&m_pUIMgr->m_rcInvalid, 0, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CLoaderWnd::OnCreate()
|
|
{
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CMainScreenWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
CenterUIWindow(this);
|
|
|
|
SetRect(&m_pUIMgr->m_rcInvalid,
|
|
0,
|
|
0,
|
|
prasMainScreen->iWidthFront,
|
|
prasMainScreen->iHeightFront);
|
|
|
|
m_rc.left = 0;
|
|
m_rc.top = 0;
|
|
m_rc.right = prasMainScreen->iWidthFront;
|
|
m_rc.bottom = prasMainScreen->iHeightFront;
|
|
|
|
m_pUIMgr->m_iMouse = 1;
|
|
|
|
m_puitext = (CUITextbox *)GetUICtrl(102);
|
|
|
|
SetupBackgroundImage();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
// look for the proper SCN matches from the currently loading
|
|
// level and the SCN Image match array
|
|
void CLoaderWnd::SetupBackgroundImage()
|
|
{
|
|
int icSCNs = sizeof(g_aszSCNImage)/sizeof(g_aszSCNImage[0]);
|
|
int i;
|
|
bool bFound;
|
|
int iFoundAt;
|
|
CRaster * pras;
|
|
RECT rcMain;
|
|
RECT rcImage;
|
|
int xDst;
|
|
int yDst;
|
|
char szName[_MAX_PATH];
|
|
|
|
// Identify the image we want to load as the background. This is
|
|
// determined by the SCN name. If the scn is not known we will use
|
|
// an "other" generic image.
|
|
|
|
for (i = 0, bFound = false; i < icSCNs && !bFound; i++)
|
|
{
|
|
if (strcmpi(g_CTPassGlobals.m_szSCN, g_aszSCNImage[i].szSCN) == 0)
|
|
{
|
|
bFound = true;
|
|
iFoundAt = i;
|
|
}
|
|
}
|
|
|
|
if (!bFound)
|
|
{
|
|
iFoundAt = icSCNs - 1;
|
|
}
|
|
|
|
// now that we have identified the image that we want to load,
|
|
// We must create the background to draw from.
|
|
|
|
// Create the primary background image.
|
|
SetRect(&rcMain, 0, 0, prasMainScreen->iWidthFront, prasMainScreen->iHeightFront);
|
|
m_pRaster = new CRasterMem(rcMain.right, rcMain.bottom, 16, 0);
|
|
|
|
// Fill the background with black
|
|
MyFillRect(&rcMain, 0, m_pRaster);
|
|
|
|
// Create The image name
|
|
wsprintf(szName,
|
|
"%s_%i.tga",
|
|
g_aszSCNImage[iFoundAt].szImage,
|
|
rand() % COUNT_LEVEL_IMAGES);
|
|
|
|
// Load the image.
|
|
pras = ReadAndConvertBMP(szName, false);
|
|
|
|
SetRect(&rcImage, 0, 0, pras->iWidth, pras->iHeight);
|
|
|
|
// Determine the blitting area
|
|
xDst = (rcMain.right / 2) - (rcImage.right / 2);
|
|
yDst = (rcMain.bottom / 2) - (rcImage.bottom / 2);
|
|
|
|
// now blit this image into the center of the background.
|
|
RasterBlt(pras,
|
|
&rcImage,
|
|
m_pRaster,
|
|
xDst,
|
|
yDst,
|
|
false,
|
|
0);
|
|
|
|
delete pras;
|
|
}
|
|
|
|
|
|
void CLoaderWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "loader.ddf");
|
|
}
|
|
|
|
|
|
DWORD CLoaderWnd::HandleNotify(DWORD dwParam1,
|
|
DWORD dwParam2,
|
|
DWORD dwParam3)
|
|
{
|
|
bool bPaint = false;
|
|
|
|
//EnterCriticalSection(&m_cs);
|
|
|
|
switch (dwParam1)
|
|
{
|
|
case 0:
|
|
// Just update (if there are any changes) no actual messages
|
|
bPaint = true;
|
|
break;
|
|
|
|
case 1:
|
|
// Percent complete dialog update.
|
|
{
|
|
CUIProgressBar * pprog;
|
|
|
|
// Compute load percent complete.
|
|
iLoadPercent = (int)((dwParam2 * 100) / dwParam3);
|
|
|
|
// Update progress bar.
|
|
pprog = (CUIProgressBar *)GetUICtrl(100);
|
|
Assert(pprog);
|
|
pprog->SetPos(iLoadPercent);
|
|
|
|
bPaint = true;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
// Copy progress complete dialog update.
|
|
{
|
|
CUIProgressBar * pprog;
|
|
|
|
// Compute copy percent complete.
|
|
iCopyPercent = (int)((dwParam2 * 100) / dwCopyTotal);
|
|
|
|
// Update progress bar.
|
|
pprog = (CUIProgressBar *)GetUICtrl(101);
|
|
Assert(pprog);
|
|
pprog->SetPos(dwParam2);
|
|
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
// Copy progress complete dialog range.
|
|
{
|
|
CUIProgressBar * pprog;
|
|
|
|
pprog = (CUIProgressBar *)GetUICtrl(101);
|
|
Assert(pprog);
|
|
|
|
pprog->SetRange(dwParam2, dwParam3, NULL, NULL);
|
|
|
|
// Save total.
|
|
dwCopyTotal = dwParam3;
|
|
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
// Begin loading D3D surfaces.
|
|
{
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
// Loading D3D surfaces (update iLoadPercent).
|
|
{
|
|
if (iLoadPercent < 100)
|
|
{
|
|
// Increment percentage.
|
|
iLoadPercent++;
|
|
|
|
// Update progress bar.
|
|
CUIProgressBar* pprog = (CUIProgressBar *)GetUICtrl(100);
|
|
Assert(pprog);
|
|
pprog->SetPos(iLoadPercent);
|
|
|
|
bPaint = true;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
{
|
|
CenterUIWindow(this);
|
|
InvalidateRect(NULL);
|
|
|
|
// Force paint.
|
|
iLastCopyPercent = -1;
|
|
iLastLoadPercent = -1;
|
|
bPaint = true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (bPaint && (iCopyPercent > iLastCopyPercent || iLoadPercent > iLastLoadPercent))
|
|
{
|
|
iLastCopyPercent = iCopyPercent;
|
|
iLastLoadPercent = iLoadPercent;
|
|
|
|
InnerWindowLoop(bPaint);
|
|
}
|
|
|
|
//LeaveCriticalSection(&m_cs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
CDirectLoadWnd::CDirectLoadWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
}
|
|
|
|
CDirectLoadWnd::~CDirectLoadWnd()
|
|
{
|
|
}
|
|
|
|
|
|
BOOL CDirectLoadWnd::OnCreate()
|
|
{
|
|
CUIListbox * puilist;
|
|
HANDLE hfind;
|
|
WIN32_FIND_DATA finddata;
|
|
char szFile[_MAX_PATH];
|
|
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CDirectLoadWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
GetRegString("Data Drive", szFile, sizeof(szFile), "");
|
|
strcat(szFile, "data\\");
|
|
strcat(szFile, "*.scn");
|
|
|
|
puilist = (CUIListbox*)GetUICtrl(1002);
|
|
|
|
hfind = FindFirstFile(szFile, &finddata);
|
|
if (hfind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
puilist->AddItem(finddata.cFileName, 0, -1, 0);
|
|
}
|
|
while (FindNextFile(hfind, &finddata));
|
|
|
|
FindClose(hfind);
|
|
}
|
|
|
|
CUIButton * pbutton;
|
|
|
|
pbutton = (CUIButton*)GetUICtrl(1001);
|
|
Assert(pbutton);
|
|
pbutton->SetActive(FALSE);
|
|
|
|
CenterUIWindow(this);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CDirectLoadWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "directload.ddf");
|
|
}
|
|
|
|
|
|
void CDirectLoadWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
switch (pbutton->GetID())
|
|
{
|
|
case 1000:
|
|
EndUIWnd(0);
|
|
break;
|
|
|
|
case 1001:
|
|
{
|
|
char szName[50];
|
|
DWORD dwParam;
|
|
WORD wFlags;
|
|
CUIListbox * pctrl;
|
|
int iIndex;
|
|
|
|
pctrl = (CUIListbox *)GetUICtrl(1002);
|
|
iIndex = pctrl->GetCurrSel();
|
|
|
|
pctrl->GetItem(szName,
|
|
sizeof(szName),
|
|
dwParam,
|
|
wFlags,
|
|
iIndex);
|
|
|
|
g_CTPassGlobals.FreeMenuAudio();
|
|
iIndex = g_CTPassGlobals.LoadLevel(szName);
|
|
|
|
if (iIndex < 0)
|
|
{
|
|
DisplayLoadingFileError(iIndex);
|
|
}
|
|
else
|
|
{
|
|
EndUIWnd(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CDirectLoadWnd::UIListboxClick(CUICtrl * pctrl, int iIndex)
|
|
{
|
|
(GetUICtrl(1001))->SetActive(TRUE);
|
|
}
|
|
|
|
|
|
void CDirectLoadWnd::UIListboxDblClk(CUICtrl * pctrl, int iIndex)
|
|
{
|
|
char szName[50];
|
|
DWORD dwParam;
|
|
WORD wFlags;
|
|
|
|
((CUIListbox *)pctrl)->GetItem(szName,
|
|
sizeof(szName),
|
|
dwParam,
|
|
wFlags,
|
|
iIndex);
|
|
|
|
g_CTPassGlobals.FreeMenuAudio();
|
|
g_CTPassGlobals.LoadLevel(szName);
|
|
EndUIWnd(1);
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
CNewGameWnd::CNewGameWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
}
|
|
|
|
CNewGameWnd::~CNewGameWnd()
|
|
{
|
|
}
|
|
|
|
|
|
BOOL CNewGameWnd::OnCreate()
|
|
{
|
|
CUIListbox * puilist;
|
|
HANDLE hFile;
|
|
char szFile[_MAX_PATH];
|
|
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CDirectLoadWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
GetRegString("Data Drive", szFile, sizeof(szFile), "");
|
|
strcat(szFile, "data\\menu\\ngi.ddf");
|
|
|
|
puilist = (CUIListbox*)GetUICtrl(1002);
|
|
|
|
hFile = CreateFile(szFile,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
LoadDDFIntoListbox(hFile, puilist);
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
|
|
CenterUIWindow(this);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CNewGameWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "newgame.ddf");
|
|
}
|
|
|
|
|
|
void CNewGameWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
switch (pbutton->GetID())
|
|
{
|
|
case 1000:
|
|
EndUIWnd(0);
|
|
break;
|
|
|
|
case 1001:
|
|
EndUIWnd(1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
CQuitWnd::CQuitWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
}
|
|
|
|
CQuitWnd::~CQuitWnd()
|
|
{
|
|
}
|
|
|
|
|
|
BOOL CQuitWnd::OnCreate()
|
|
{
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CQuitWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
CenterUIWindow(this);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CQuitWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "quit.ddf");
|
|
}
|
|
|
|
|
|
void CQuitWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
switch (pbutton->GetID())
|
|
{
|
|
// Cancel
|
|
case 1000:
|
|
EndUIWnd(0);
|
|
break;
|
|
|
|
// Quit Game
|
|
case 1001:
|
|
EndUIWnd(1);
|
|
break;
|
|
|
|
// Quit Menu
|
|
case 1002:
|
|
EndUIWnd(2);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
COptionsWnd::COptionsWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
}
|
|
|
|
COptionsWnd::~COptionsWnd()
|
|
{
|
|
}
|
|
|
|
|
|
BOOL COptionsWnd::OnCreate()
|
|
{
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("COptionsWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
CenterUIWindow(this);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void COptionsWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
if (g_CTPassGlobals.bInGame)
|
|
{
|
|
strcpy(psz, "options2.ddf");
|
|
}
|
|
else
|
|
{
|
|
strcpy(psz, "options.ddf");
|
|
}
|
|
}
|
|
|
|
|
|
void COptionsWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
switch (pbutton->GetID())
|
|
{
|
|
// Controls
|
|
case 1000:
|
|
{
|
|
CControlsWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
}
|
|
break;
|
|
|
|
// Rendering
|
|
case 1001:
|
|
{
|
|
CRenderWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
if (dlg.m_dwExitValue != 0)
|
|
{
|
|
EndUIWnd(dlg.m_dwExitValue);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// Audio
|
|
case 1002:
|
|
{
|
|
CAudioWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
}
|
|
break;
|
|
|
|
// Credits
|
|
case 1003:
|
|
{
|
|
// Pause the background audio
|
|
g_CTPassGlobals.StopBackgroundAudio();
|
|
KillRandom();
|
|
|
|
// Play the credits video
|
|
CVideoWnd video(m_pUIMgr);
|
|
|
|
video.Play("menu\\credits");
|
|
|
|
// Start the background audio
|
|
g_CTPassGlobals.StartBackgroundAudio();
|
|
InitRandom();
|
|
}
|
|
break;
|
|
|
|
// Return
|
|
case 1004:
|
|
EndUIWnd(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
CInGameOptionsWnd::CInGameOptionsWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
}
|
|
|
|
CInGameOptionsWnd::~CInGameOptionsWnd()
|
|
{
|
|
g_CTPassGlobals.FreeMenuAudio();
|
|
}
|
|
|
|
|
|
BOOL CInGameOptionsWnd::OnCreate()
|
|
{
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CInGameOptionsWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
g_CTPassGlobals.CreateMenuAudioDatabase();
|
|
g_CTPassGlobals.SetupButtonAudio();
|
|
|
|
CenterUIWindow(this);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CInGameOptionsWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "ingameopt.ddf");
|
|
}
|
|
|
|
|
|
void CInGameOptionsWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
switch (pbutton->GetID())
|
|
{
|
|
// Quit
|
|
case 1000:
|
|
EndUIWnd((DWORD)-1);
|
|
break;
|
|
|
|
// Resume
|
|
case 1001:
|
|
EndUIWnd(0);
|
|
break;
|
|
|
|
// Restart
|
|
case 1002:
|
|
{
|
|
CYesNoMsgDlg dlg(IDS_RESTARTLEVEL, m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
if (dlg.m_dwExitValue == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_CTPassGlobals.LoadLastScene();
|
|
EndUIWnd(0);
|
|
}
|
|
break;
|
|
|
|
case 1003:
|
|
{
|
|
CSaveGameWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
}
|
|
break;
|
|
|
|
case 1004:
|
|
{
|
|
CLoadGameWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
if (dlg.m_dwExitValue == 1)
|
|
{
|
|
EndUIWnd(0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 1005:
|
|
{
|
|
COptionsWnd dlg(m_pUIMgr);
|
|
|
|
dlg.StartUIWnd();
|
|
|
|
switch (dlg.m_dwExitValue)
|
|
{
|
|
case 0:
|
|
break;
|
|
|
|
case 1:
|
|
case 2:
|
|
g_CTPassGlobals.ResetScreen(dlg.m_dwExitValue == 2);
|
|
CenterUIWindow(this);
|
|
break;
|
|
|
|
case 3:
|
|
EndUIWnd(3);
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
CAudioWnd::CAudioWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
}
|
|
|
|
CAudioWnd::~CAudioWnd()
|
|
{
|
|
}
|
|
|
|
|
|
BOOL CAudioWnd::OnCreate()
|
|
{
|
|
CUICheckbox * pcheck;
|
|
CUISlider * pslider;
|
|
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CAudioWnd::OnCreate() -- base create failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
CenterUIWindow(this);
|
|
|
|
// Fill In the defaults for changed
|
|
m_uiVolume = (UINT)CAudio::pcaAudio->GetVolume();
|
|
pslider = (CUISlider *)GetUICtrl(1004);
|
|
pslider->SetCurrUnit(m_uiVolume);
|
|
|
|
m_bSFX = GetRegValue(REG_KEY_AUDIO_EFFECT, DEFAULT_AUDIO_EFFECT);
|
|
pcheck = (CUICheckbox *)GetUICtrl(1020);
|
|
pcheck->SetDown(m_bSFX);
|
|
|
|
m_bAmbient = GetRegValue(REG_KEY_AUDIO_AMBIENT, DEFAULT_AUDIO_AMBIENT);
|
|
pcheck = (CUICheckbox *)GetUICtrl(1021);
|
|
pcheck->SetDown(m_bAmbient);
|
|
|
|
m_bVO = GetRegValue(REG_KEY_AUDIO_VOICEOVER, DEFAULT_AUDIO_VOICEOVER);
|
|
pcheck = (CUICheckbox *)GetUICtrl(1022);
|
|
pcheck->SetDown(m_bVO);
|
|
|
|
m_bMusic = GetRegValue(REG_KEY_AUDIO_MUSIC, DEFAULT_AUDIO_MUSIC);
|
|
pcheck = (CUICheckbox *)GetUICtrl(1023);
|
|
pcheck->SetDown(m_bMusic);
|
|
|
|
m_bSubtitles = GetRegValue(REG_KEY_AUDIO_SUBTITLES, DEFAULT_AUDIO_SUBTITLES);
|
|
pcheck = (CUICheckbox *)GetUICtrl(1024);
|
|
pcheck->SetDown(m_bSubtitles);
|
|
|
|
m_bEnable3D = GetRegValue(REG_KEY_AUDIO_ENABLE3D, DEFAULT_AUDIO_ENABLE3D);
|
|
pcheck = (CUICheckbox *)GetUICtrl(1025);
|
|
pcheck->SetDown(m_bEnable3D);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CAudioWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "audio.ddf");
|
|
}
|
|
|
|
|
|
void CAudioWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
switch (pbutton->GetID())
|
|
{
|
|
// cancel
|
|
case 1000:
|
|
OnCancel();
|
|
EndUIWnd((DWORD)-1);
|
|
break;
|
|
|
|
// ok
|
|
case 1001:
|
|
OnOk();
|
|
EndUIWnd(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CAudioWnd::UIHotspotClick(CUIHotspot * pctrl, BOOL bDown)
|
|
{
|
|
int iCmdSrc;
|
|
CUICheckbox * pcheck;
|
|
|
|
if (!bDown)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Convert the control ID to a command #
|
|
iCmdSrc = pctrl->GetID() - 1100;
|
|
|
|
pcheck = (CUICheckbox*)GetUICtrl(iCmdSrc + 1020);
|
|
if (!pcheck)
|
|
{
|
|
return;
|
|
}
|
|
|
|
pcheck->SetDown(!pcheck->GetDown());
|
|
}
|
|
|
|
|
|
void CAudioWnd::UISliderChange(CUISlider * pslider, int iNewValue)
|
|
{
|
|
CUICheckbox * pcheck;
|
|
|
|
if (iNewValue == 0)
|
|
{
|
|
pcheck = (CUICheckbox *)GetUICtrl(1024);
|
|
pcheck->SetDown(TRUE);
|
|
|
|
pcheck = (CUICheckbox *)GetUICtrl(1022);
|
|
pcheck->SetDown(TRUE);
|
|
}
|
|
}
|
|
|
|
|
|
void CAudioWnd::OnOk()
|
|
{
|
|
CUISlider * pslider;
|
|
CUICheckbox * pcheck;
|
|
|
|
// Update the items
|
|
pslider = (CUISlider *)GetUICtrl(1004);
|
|
m_uiVolume = pslider->GetCurrUnit();
|
|
//pass value from 0 to 100
|
|
CAudio::pcaAudio->SetVolume((float)m_uiVolume);
|
|
|
|
pcheck = (CUICheckbox *)GetUICtrl(1020);
|
|
m_bSFX = pcheck->GetDown();
|
|
SetRegValue(REG_KEY_AUDIO_EFFECT, m_bSFX);
|
|
|
|
pcheck = (CUICheckbox *)GetUICtrl(1021);
|
|
m_bAmbient = pcheck->GetDown();
|
|
SetRegValue(REG_KEY_AUDIO_AMBIENT, m_bAmbient);
|
|
|
|
pcheck = (CUICheckbox *)GetUICtrl(1022);
|
|
m_bVO = pcheck->GetDown();
|
|
SetRegValue(REG_KEY_AUDIO_VOICEOVER, m_bVO);
|
|
|
|
pcheck = (CUICheckbox *)GetUICtrl(1023);
|
|
m_bMusic = pcheck->GetDown();
|
|
SetRegValue(REG_KEY_AUDIO_MUSIC, m_bMusic);
|
|
|
|
pcheck = (CUICheckbox *)GetUICtrl(1024);
|
|
m_bSubtitles = pcheck->GetDown();
|
|
SetRegValue(REG_KEY_AUDIO_SUBTITLES, m_bSubtitles);
|
|
|
|
pcheck = (CUICheckbox *)GetUICtrl(1025);
|
|
m_bEnable3D = pcheck->GetDown();
|
|
SetRegValue(REG_KEY_AUDIO_ENABLE3D, m_bEnable3D);
|
|
|
|
RefreshAudioSettings();
|
|
}
|
|
|
|
|
|
void CAudioWnd::OnCancel()
|
|
{
|
|
// Set the items to their orignal values
|
|
SetRegValue(REG_KEY_AUDIO_EFFECT, m_bSFX);
|
|
SetRegValue(REG_KEY_AUDIO_AMBIENT, m_bAmbient);
|
|
SetRegValue(REG_KEY_AUDIO_VOICEOVER, m_bVO);
|
|
SetRegValue(REG_KEY_AUDIO_MUSIC, m_bMusic);
|
|
SetRegValue(REG_KEY_AUDIO_SUBTITLES, m_bSubtitles);
|
|
SetRegValue(REG_KEY_AUDIO_ENABLE3D, m_bEnable3D);
|
|
|
|
RefreshAudioSettings();
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
CHintWnd::CHintWnd(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
}
|
|
|
|
CHintWnd::~CHintWnd()
|
|
{
|
|
}
|
|
|
|
BOOL CHintWnd::OnCreate()
|
|
{
|
|
BOOL bRet;
|
|
char sz[1024];
|
|
CUITextbox * ptextbox;
|
|
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CHintWnd::OnCreate() -- base class create failed"));
|
|
goto Error;
|
|
}
|
|
|
|
// We are going to literally translate the Hint ID into a string
|
|
// resource ID.
|
|
|
|
ptextbox = (CUITextbox *)GetUICtrl(1002);
|
|
Assert(ptextbox != NULL);
|
|
|
|
LoadString(g_hInst, IDS_STR_HINTS + CSetHintAction::iCurrentHint, sz, sizeof(sz));
|
|
|
|
ptextbox->SetText(sz);
|
|
|
|
bRet = TRUE;
|
|
|
|
Cleanup:
|
|
CenterUIWindow(this);
|
|
return bRet;
|
|
|
|
Error:
|
|
TraceError(("CHintWnd::OnCreate"));
|
|
bRet = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
void CHintWnd::GetWndFile(LPSTR psz, int ic)
|
|
{
|
|
strcpy(psz, "hint.ddf");
|
|
}
|
|
|
|
void CHintWnd::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
DWORD dwID;
|
|
|
|
dwID = pbutton->GetID();
|
|
|
|
switch (dwID)
|
|
{
|
|
case 1000:
|
|
EndUIWnd(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
CMsgDlg::CMsgDlg(CUIManager * puimgr) : CUIDlg(puimgr)
|
|
{
|
|
m_bKeyStyle = 0;
|
|
}
|
|
|
|
CMsgDlg::~CMsgDlg()
|
|
{
|
|
}
|
|
|
|
BOOL CMsgDlg::OnCreate()
|
|
{
|
|
BOOL bRet;
|
|
char sz[1024];
|
|
int iStmt;
|
|
CUITextbox * ptextbox;
|
|
|
|
if (!CUIDlg::OnCreate())
|
|
{
|
|
TraceError(("CMsgDlg::OnCreate() -- base class create failed"));
|
|
goto Error;
|
|
}
|
|
|
|
ptextbox = (CUITextbox *)GetUICtrl(1002);
|
|
Assert(ptextbox != NULL);
|
|
|
|
iStmt = JustStatement();
|
|
if (iStmt != -1)
|
|
{
|
|
LoadString(g_hInst, iStmt, sz, sizeof(sz));
|
|
}
|
|
else if (!GetText(sz, sizeof(sz)))
|
|
{
|
|
TraceError(("CMsgDlg::OnCreate() -- getting text to place in dialog failed"));
|
|
goto Error;
|
|
}
|
|
|
|
ptextbox->SetText(sz);
|
|
|
|
bRet = TRUE;
|
|
|
|
Cleanup:
|
|
CenterUIWindow(this);
|
|
return bRet;
|
|
|
|
Error:
|
|
TraceError(("CMsgDlg::OnCreate"));
|
|
bRet = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
void CMsgDlg::UIButtonUp(CUIButton * pbutton)
|
|
{
|
|
DWORD dwID;
|
|
|
|
dwID = pbutton->GetID();
|
|
|
|
switch (dwID)
|
|
{
|
|
case 1000:
|
|
OnEnter();
|
|
break;
|
|
|
|
case 1001:
|
|
OnEscape();
|
|
}
|
|
}
|
|
|
|
|