int PropertySheetDialog::DoModal(int start_page)
{
PROPSHEETHEADER::ppsp = (LPCPROPSHEETPAGE) &_pages[0];
PROPSHEETHEADER::nPages = _pages.size();
PROPSHEETHEADER::nStartPage = start_page;
/*
Window* pwnd = Window::create_property_sheet(this, WINDOW_CREATOR(PropertySheetDlg), NULL);
if (!pwnd)
return -1;
HWND hwndPropSheet = *pwnd;
*/
int ret = PropertySheet(this);
if (ret == -1)
return -1;
HWND hwndPropSheet = (HWND) ret;
HWND hwndparent = GetParent(hwndPropSheet);
if (hwndparent)
EnableWindow(hwndparent, FALSE);
ret = 0;
MSG msg;
while(GetMessage(&msg, 0, 0, 0)) {
try {
if (Window::pretranslate_msg(&msg))
continue;
if (PropSheet_IsDialogMessage(hwndPropSheet, &msg))
continue;
if (Window::dispatch_dialog_msg(&msg))
continue;
TranslateMessage(&msg);
try {
DispatchMessage(&msg);
} catch(COMException& e) {
HandleException(e, 0);
}
if (!PropSheet_GetCurrentPageHwnd(hwndPropSheet)) {
ret = PropSheet_GetResult(hwndPropSheet);
break;
}
} catch(COMException& e) {
HandleException(e, 0);
}
}
if (hwndparent)
EnableWindow(hwndparent, TRUE);
DestroyWindow(hwndPropSheet);
return ret;
}
int PropertySheetUI::runModal(HINSTANCE hInstance, HWND hParent, LPWSTR pCaption)
{
MSG msg;
m_pages = _buildPageArray();
m_nRslt = IDCANCEL;
memset (&m_psh, 0, sizeof(PROPSHEETHEADER));
m_psh.dwSize = sizeof(PROPSHEETHEADER);
m_psh.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD;
m_psh.hwndParent = hParent;
m_psh.hInstance = hInstance;
m_psh.hIcon = NULL;
m_psh.pszIcon = NULL;
m_psh.nPages = m_vecPages.size();
m_psh.nStartPage = 0;
m_psh.ppsp = (LPCPROPSHEETPAGE) m_pages;
m_psh.pfnCallback = m_pCallback;
if (m_pCallback)
m_psh.dwFlags |= PSH_USECALLBACK;
if (!m_bApplyButton)
m_psh.dwFlags |= PSH_NOAPPLYNOW;
m_psh.pszCaption = pCaption;
m_psh.dwFlags |= PSH_MODELESS;
m_hWnd = (HWND)::PropertySheet(&m_psh);
EnableWindow(m_psh.hwndParent, FALSE);
// Set buttons for first page after creation
PropertyPageUI* pPage = m_vecPages.at(0);
pPage->_sendSetButtonsMessage();
/* Subclassing */
m_lpfnDefSheet = (WHICHPROC)GetWindowLong(m_hWnd, GWL_WNDPROC);
SetWindowLong(m_hWnd, GWL_USERDATA, (LONG)this);
SetWindowLong(m_hWnd, GWL_WNDPROC, (LONG)m_pfnDlgProc);
_onInitDialog();
while (GetMessage(&msg, NULL, 0, 0))
{
if(m_hWnd && PropSheet_IsDialogMessage(m_hWnd, &msg))
continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
destroy();
return m_nRslt;
}
int PASCAL WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
MSG msg;
g_hInst = hInstance;
//don't forget this
InitCommonControls();
if(!hPrevInstance)
if(!InitApplication(hInstance))
return FALSE;
if (!InitInstance(hInstance, nCmdShow))
return FALSE;
while(GetMessage(&msg, NULL, 0x00, 0x00))
{
// If the modeless guy is up and is ready to be destroyed
// (PropSheet_GetCurrentPageHwnd returns NULL) then destroy the dialog.
// PropSheet_GetCurrentPageHwnd will return NULL after the OK or Cancel
// button has been pressed and all of the pages have been notified. The
// Apply button doesn't cause this to happen.
if(g_hwndPropSheet && (NULL == PropSheet_GetCurrentPageHwnd(g_hwndPropSheet)))
{
//enable the parent first to prevent another window from becoming the foreground window
EnableWindow(g_hwndMain, TRUE);
DestroyWindow(g_hwndPropSheet);
g_hwndPropSheet = NULL;
}
//use PropSheet_IsDialogMessage instead of IsDialogMessage
if(!PropSheet_IsDialogMessage(g_hwndPropSheet, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int)msg.wParam;
}
/** Global Function to translate dialog messages.*/
VBOOL VTranslateDialogMessage(MSG const& msg)
{
HWND hWndTop = msg.hwnd;
/* Obtain the top level window. All dialogs are typically defined
as top level popups.*/
while ( hWndTop )
{
if ( GetWindowLong(hWndTop, GWL_STYLE) & WS_CHILD )
hWndTop = GetParent(hWndTop);
else
break;
}
/* Obtain the associated window pointer (if a VWCL window).*/
VWindow* pWindow = VWindow::GetVWindowFromHandle(hWndTop);
if ( !pWindow )
return VFALSE;
VBOOL bResult = VFALSE;
/* Is it a dialog box?*/
if ( pWindow->IsVDialogType() )
{
bResult = IsDialogMessage(hWndTop, (MSG*)&msg);
/* Is it a modeless property sheet?*/
if ( !bResult &&
pWindow->GetRTTI() == VWindow::VWCL_RTTI_PROPERTY_SHEET &&
!((VDialog*)pWindow)->IsModal() )
bResult = PropSheet_IsDialogMessage(hWndTop, &msg);
}
/* Return result.*/
return bResult;
}
//================================================================================================
//--------------------------------------------------==-+++--> Entry Point of Program Using WinMain:
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
WNDCLASS wndclass;
HWND hwndMain;
MSG msg;
int updated;
(void)hPrevInstance;
(void)nCmdShow;
#if defined(__GNUC__) && defined(_DEBUG)
# ifdef _WIN64
# define LoadExcHndl() LoadLibraryExA("dbg\\64\\exchndl", NULL, LOAD_WITH_ALTERED_SEARCH_PATH)
# else
# define LoadExcHndl() LoadLibraryExA("dbg\\exchndl", NULL, LOAD_WITH_ALTERED_SEARCH_PATH)
# endif
#else
# define LoadExcHndl()
#endif
LoadExcHndl(); // LOAD_WITH_ALTERED_SEARCH_PATH works :P At least since Win2k
g_instance = hInstance;
if(LoadClockAPI("misc/T-Clock" ARCH_SUFFIX, &api)){
MessageBox(NULL, "Error loading: T-Clock" ARCH_SUFFIX ".dll", "API error", MB_OK|MB_ICONERROR);
return 2;
}
chdir(api.root); // make sure we've got the right working directory
// Make sure we're running Windows 2000 and above
if(!api.OS) {
MessageBox(NULL,"T-Clock requires Windows 2000 or newer","old OS",MB_OK|MB_ICONERROR);
return 1;
}
// make sure ObjectBar isn't running -> From Original Code/Unclear if This is Still a Conflict. (test suggested not really.. no crash but no clock either :P)
if(FindWindow("ObjectBar Main","ObjectBar")) {
MessageBox(NULL,"ObjectBar and T-Clock can't be run together","ObjectBar detected!",MB_OK|MB_ICONERROR);
return 1;
}
// Load ALL of the Global Resources
g_hIconTClock = LoadIcon(api.hInstance, MAKEINTRESOURCE(IDI_MAIN));
g_hIconPlay = LoadImage(g_instance, MAKEINTRESOURCE(IDI_PLAY), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
g_hIconStop = LoadImage(g_instance, MAKEINTRESOURCE(IDI_STOP), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
g_hIconDel = LoadImage(g_instance, MAKEINTRESOURCE(IDI_DEL), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
// FindTrayServer(hwndMain);
// Make sure we're not running 32bit on 64bit OS / start the other one
#ifndef _WIN64
if(IsWow64()){
hwndMain = FindWindow(g_szClassName, NULL);
if(hwndMain) { // send commands to existing instance
ProcessCommandLine(hwndMain,lpCmdLine);
}else{ // start new instance
char clock64[MAX_PATH];
memcpy(clock64, api.root, api.root_len+1);
add_title(clock64,"Clock" ARCH_SUFFIX_64 ".exe");
api.Exec(clock64,lpCmdLine,NULL);
}
return 0;
}
#endif // _WIN64
// Do Not Allow the Program to Execute Twice!
updated = 25; /**< wait up to 5 sec in 1/5th seconds for other instance */
do{
HANDLE processlock=CreateMutex(NULL,FALSE,g_szClassName); // we leak handle here, but Windows closes on process exit anyway (so why do it manually?)
if(processlock && GetLastError()==ERROR_ALREADY_EXISTS){
CloseHandle(processlock);
hwndMain = FindWindow(g_szClassName, NULL);
if(hwndMain) { // This One Sends Commands to the Instance
ProcessCommandLine(hwndMain,lpCmdLine); // That is Currently Running.
return 0;
}
Sleep(200);
continue;
}
break;
}while(updated--);
// Update settings if required and setup defaults
if((updated=CheckSettings())<0){
return 1;
}
CancelAllTimersOnStartUp();
// Message of the taskbar recreating - Special thanks to Mr.Inuya
g_WM_TaskbarCreated = RegisterWindowMessage("TaskbarCreated");
// register a window class
wndclass.style = 0;
wndclass.lpfnWndProc = WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = g_instance;
wndclass.hIcon = g_hIconTClock;
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(intptr_t)(COLOR_WINDOW+1);
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = g_szClassName;
g_atomTClock = RegisterClass(&wndclass);
if(api.OS >= TOS_VISTA) { // allow non elevated processes to send control messages (eg, App with admin rights, explorer without)
#define MSGFLT_ADD 1
#define MSGFLT_REMOVE 2
typedef BOOL (WINAPI* ChangeWindowMessageFilter_t)(UINT message,DWORD dwFlag);
ChangeWindowMessageFilter_t ChangeWindowMessageFilter=(ChangeWindowMessageFilter_t)GetProcAddress(GetModuleHandle("user32"), "ChangeWindowMessageFilter");
if(ChangeWindowMessageFilter){
int msgid;
ChangeWindowMessageFilter(g_WM_TaskbarCreated,MSGFLT_ADD);
ChangeWindowMessageFilter(WM_COMMAND,MSGFLT_ADD);
for(msgid=WM_MOUSEFIRST; msgid<=WM_MOUSELAST; ++msgid)
ChangeWindowMessageFilter(msgid,MSGFLT_ADD);
for(msgid=MAINMFIRST; msgid<=MAINMLAST; ++msgid)
ChangeWindowMessageFilter(msgid,MSGFLT_ADD);
}
}
// create a hidden window
g_hwndTClockMain = hwndMain = CreateWindowEx(WS_EX_NOACTIVATE, MAKEINTATOM(g_atomTClock),NULL, 0, 0,0,0,0, NULL,NULL,g_instance,NULL);
// This Checks for First Instance Startup Options
ProcessCommandLine(hwndMain,lpCmdLine);
GetHotKeyInfo(hwndMain);
if(api.OS > TOS_2000) {
if(api.GetInt("Desktop", "MonOffOnLock", 0))
RegisterSession(hwndMain);
}
if(updated==1){
PostMessage(hwndMain,WM_COMMAND,IDM_SHOWPROP,0);
}
while(GetMessage(&msg, NULL, 0, 0)) {
if(!(g_hwndSheet && IsWindow(g_hwndSheet) && PropSheet_IsDialogMessage(g_hwndSheet,&msg))
&& !(g_hDlgTimer && IsWindow(g_hDlgTimer) && IsDialogMessage(g_hDlgTimer,&msg))
&& !(g_hDlgTimerWatch && IsWindow(g_hDlgTimerWatch) && IsDialogMessage(g_hDlgTimerWatch,&msg))
&& !(g_hDlgStopWatch && IsWindow(g_hDlgStopWatch) && IsDialogStopWatchMessage(g_hDlgStopWatch,&msg))){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
UnregisterHotKey(hwndMain, HOT_TIMER);
UnregisterHotKey(hwndMain, HOT_WATCH);
UnregisterHotKey(hwndMain, HOT_STOPW);
UnregisterHotKey(hwndMain, HOT_PROPR);
UnregisterHotKey(hwndMain, HOT_CALEN);
UnregisterHotKey(hwndMain, HOT_TSYNC);
UnregisterSession(hwndMain);
EndNewAPI(NULL);
return (int)msg.wParam;
}
//========================================================================================
// /exit exit T-Clock 2010
// /prop show T-Clock 2010 properties
// /SyncOpt SNTP options
// /Sync synchronize the system clock with an NTP server
// /start start the Stopwatch (open as needed)
// /stop stop (pause really) the Stopwatch
// /reset reset Stopwatch to 0 (stop as needed)
// /lap record a (the current) lap time
//================================================================================================
//---------------------------------------------//---------------+++--> T-Clock Command Line Option:
void ProcessCommandLine(HWND hwndMain,const char* cmdline) //-----------------------------+++-->
{
int justElevated = 0;
const char* p = cmdline;
if(g_hwndTClockMain != hwndMain){
g_hwndTClockMain = CreateWindow("STATIC",NULL,0,0,0,0,0,HWND_MESSAGE_nowarn,0,0,0);
SubclassWindow(g_hwndTClockMain, MsgOnlyProc);
}
while(*p != '\0') {
if(*p == '/') {
++p;
if(strncasecmp(p, "prop", 4) == 0) {
SendMessage(hwndMain, WM_COMMAND, IDM_SHOWPROP, 0);
p += 4;
} else if(strncasecmp(p, "exit", 4) == 0) {
SendMessage(hwndMain, MAINM_EXIT, 0, 0);
p += 4;
} else if(strncasecmp(p, "start", 5) == 0) {
SendMessage(hwndMain, WM_COMMAND, IDM_STOPWATCH_START, 0);
p += 5;
} else if(strncasecmp(p, "stop", 4) == 0) {
SendMessage(hwndMain, WM_COMMAND, IDM_STOPWATCH_STOP, 0);
p += 4;
} else if(strncasecmp(p, "reset", 5) == 0) {
SendMessage(hwndMain, WM_COMMAND, IDM_STOPWATCH_RESET, 0);
p += 5;
} else if(strncasecmp(p, "pause", 5) == 0) {
SendMessage(hwndMain, WM_COMMAND, IDM_STOPWATCH_PAUSE, 0);
p += 5;
} else if(strncasecmp(p, "resume", 6) == 0) {
SendMessage(hwndMain, WM_COMMAND, IDM_STOPWATCH_RESUME, 0);
p += 6;
} else if(strncasecmp(p, "lap", 3) == 0) {
SendMessage(hwndMain, WM_COMMAND, IDM_STOPWATCH_LAP, 0);
p += 3;
} else if(strncasecmp(p, "SyncOpt", 7) == 0) {
if(HaveSetTimePermissions()){
if(!SendMessage(hwndMain, WM_COMMAND, MAKEWPARAM(IDM_SNTP,1), 0)){
NetTimeConfigDialog(justElevated);
}
}else{
SendMessage(hwndMain, WM_COMMAND, IDM_SNTP, 0);
}
p += 7;
} else if(strncasecmp(p, "Sync", 4) == 0) {
p += 4;
SendMessage(hwndMain, WM_COMMAND, MAKEWPARAM(IDM_SNTP_SYNC,justElevated), 0);
if(g_hwndTClockMain == hwndMain)
SendMessage(hwndMain, MAINM_EXIT, 0, 0);
} else if(strncmp(p, "Wc", 2) == 0) { // Win10 calendar "restore"
if(p[2] == '1') // restore to previous
api.SetSystemInt(HKEY_LOCAL_MACHINE, kSectionImmersiveShell, kKeyWin32Tray, 1);
else // use the slow (new) one
api.DelSystemValue(HKEY_LOCAL_MACHINE, kSectionImmersiveShell, kKeyWin32Tray);
p += 2;
} else if(strncmp(p, "UAC", 3) == 0) {
justElevated = 1;
p += 3;
}
continue;
}
++p;
}
if(g_hwndTClockMain != hwndMain){
const DWORD kTimeout = 10000;
const DWORD kStartTicks = GetTickCount();
DWORD timeout;
MSG msg;
msg.message = 0;
for(;;){
int have_ui = IsWindow(g_hwndSheet) || IsWindow(g_hDlgTimer) || IsWindow(g_hDlgTimerWatch) || IsWindow(g_hDlgSNTP) || IsWindow(g_hDlgStopWatch);
if(have_ui)
timeout = INFINITE;
else if(IsPlaying())
timeout = 200;
else
break;
MsgWaitForMultipleObjectsEx(0, NULL, timeout, QS_ALLEVENTS, MWMO_INPUTAVAILABLE);
while(PeekMessage(&msg,NULL,0,0,PM_REMOVE)){
if(msg.message == WM_QUIT)
break;
if(!(g_hwndSheet && IsWindow(g_hwndSheet) && PropSheet_IsDialogMessage(g_hwndSheet,&msg))
&& !(g_hDlgTimer && IsWindow(g_hDlgTimer) && IsDialogMessage(g_hDlgTimer,&msg))
&& !(g_hDlgTimerWatch && IsWindow(g_hDlgTimerWatch) && IsDialogMessage(g_hDlgTimerWatch,&msg))
&& !(g_hDlgSNTP && IsWindow(g_hDlgSNTP) && IsDialogMessage(g_hDlgSNTP,&msg))
&& !(g_hDlgStopWatch && IsWindow(g_hDlgStopWatch) && IsDialogStopWatchMessage(g_hDlgStopWatch,&msg))){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if(msg.message == WM_QUIT)
break;
if(!have_ui) {
DWORD elapsed = GetTickCount() - kStartTicks;
if(elapsed >= kTimeout)
break;
}
}
DestroyWindow(g_hwndTClockMain);
g_hwndTClockMain = NULL;
}
}
static THREAD_ENTRY_DECLARE WINDOW_main(THREAD_ENTRY_PARAM)
{
/**************************************
*
* W I N D O W _ m a i n
*
**************************************
*
* Functional description
*
* This function is where the actual service code starts.
* Do all the window init stuff, then fork off a thread for starting
* the server.
*
**************************************/
// If we're a service, don't create a window
if (service_flag)
{
try
{
Thread::start(start_and_watch_server, 0, THREAD_medium, &watcher_thd);
}
catch (const Firebird::Exception&)
{
// error starting server thread
char szMsgString[256];
LoadString(hInstance_gbl, IDS_CANT_START_THREAD, szMsgString, 256);
gds__log(szMsgString);
}
return 0;
}
// Make sure that there is only 1 instance of the guardian running
HWND hWnd = FindWindow(GUARDIAN_CLASS_NAME, GUARDIAN_APP_NAME);
if (hWnd)
{
char szMsgString[256];
LoadString(hInstance_gbl, IDS_ALREADYSTARTED, szMsgString, 256);
MessageBox(NULL, szMsgString, GUARDIAN_APP_LABEL, MB_OK | MB_ICONSTOP);
gds__log(szMsgString);
return 0;
}
// initialize main window
WNDCLASS wcl;
wcl.hInstance = hInstance_gbl;
wcl.lpszClassName = GUARDIAN_CLASS_NAME;
wcl.lpfnWndProc = WindowFunc;
wcl.style = 0;
wcl.hIcon = LoadIcon(hInstance_gbl, MAKEINTRESOURCE(IDI_IBGUARD));
wcl.hCursor = LoadCursor(NULL, IDC_ARROW);
wcl.lpszMenuName = NULL;
wcl.cbClsExtra = 0;
wcl.cbWndExtra = 0;
wcl.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
if (!RegisterClass(&wcl))
{
char szMsgString[256];
LoadString(hInstance_gbl, IDS_REGERROR, szMsgString, 256);
MessageBox(NULL, szMsgString, GUARDIAN_APP_LABEL, MB_OK | MB_ICONSTOP);
return 0;
}
hWnd = CreateWindowEx(0,
GUARDIAN_CLASS_NAME,
GUARDIAN_APP_NAME,
WS_DLGFRAME | WS_SYSMENU | WS_MINIMIZEBOX,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
HWND_DESKTOP, NULL, hInstance_gbl, NULL);
// Save the window handle for the thread
hWndGbl = hWnd;
// begin a new thread for calling the start_and_watch_server
try
{
Thread::start(start_and_watch_server, 0, THREAD_medium, NULL);
}
catch (const Firebird::Exception&)
{
// error starting server thread
char szMsgString[256];
LoadString(hInstance_gbl, IDS_CANT_START_THREAD, szMsgString, 256);
MessageBox(NULL, szMsgString, GUARDIAN_APP_LABEL, MB_OK | MB_ICONSTOP);
gds__log(szMsgString);
DestroyWindow(hWnd);
return 0;
}
SendMessage(hWnd, WM_COMMAND, IDM_CANCEL, 0);
UpdateWindow(hWnd);
MSG message;
while (GetMessage(&message, NULL, 0, 0))
{
if (hPSDlg)
{
// If property sheet dialog is open
// Check if the message is property sheet dialog specific
BOOL bPSMsg = PropSheet_IsDialogMessage(hPSDlg, &message);
// Check if the property sheet dialog is still valid, if not destroy it
if (!PropSheet_GetCurrentPageHwnd(hPSDlg))
{
DestroyWindow(hPSDlg);
hPSDlg = NULL;
if (swap_icons_thd)
{
CloseHandle(swap_icons_thd);
swap_icons_thd = 0;
};
}
if (bPSMsg)
continue;
}
TranslateMessage(&message);
DispatchMessage(&message);
}
return message.wParam;
}
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
MSG msg;
HACCEL hAccelTable;
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
UNREFERENCED_PARAMETER(nCmdShow);
/*
* Initialize this instance of MSConfig. Quit if we have
* another instance already running.
*/
if (!Initialize(hInstance))
return -1;
// hInst = hInstance;
hMainWnd = CreatePropSheet(hInstance, NULL, szAppName);
if (!hMainWnd)
{
/* We failed, cleanup and bail out */
Cleanup();
return -1;
}
hAccelTable = LoadAcceleratorsW(hInstance, MAKEINTRESOURCEW(IDR_MSCONFIG));
/* Message loop */
while (IsWindow(hMainWnd) && GetMessageW(&msg, NULL, 0, 0))
{
/*
* PropSheet_GetCurrentPageHwnd returns NULL when the user clicks the OK or Cancel button
* and after all of the pages have been notified. Apply button doesn't cause this to happen.
* We can then use the DestroyWindow function to destroy the property sheet.
*/
if (PropSheet_GetCurrentPageHwnd(hMainWnd) == NULL)
break;
/* Process the accelerator table */
if (!TranslateAcceleratorW(hMainWnd, hAccelTable, &msg))
{
/*
* If e.g. an item on the tree view is being edited,
* we cannot pass the event to PropSheet_IsDialogMessage.
* Doing so causes the property sheet to be closed at Enter press
* (instead of completing edit operation).
*/
if (/*g_bDisableDialogDispatch ||*/ !PropSheet_IsDialogMessage(hMainWnd, &msg))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
}
// FIXME: Process the results of MSConfig !!
/* Destroy the accelerator table and the window */
if (hAccelTable != NULL)
DestroyAcceleratorTable(hAccelTable);
DestroyWindow(hMainWnd);
/* Finish cleanup and return */
Cleanup();
return (int)msg.wParam;
}
BOOLEAN PhModalPropertySheet(
_Inout_ PROPSHEETHEADER *Header
)
{
// PropertySheet incorrectly discards WM_QUIT messages in certain cases, so we will use our own
// message loop. An example of this is when GetMessage (called by PropertySheet's message loop)
// dispatches a message directly from kernel-mode that causes the property sheet to close.
// In that case PropertySheet will retrieve the WM_QUIT message but will ignore it because of
// its buggy logic.
// This is also a good opportunity to introduce an auto-pool.
PH_AUTO_POOL autoPool;
HWND oldFocus;
HWND topLevelOwner;
HWND hwnd;
BOOL result;
MSG message;
PhInitializeAutoPool(&autoPool);
oldFocus = GetFocus();
topLevelOwner = Header->hwndParent;
while (topLevelOwner && (GetWindowLong(topLevelOwner, GWL_STYLE) & WS_CHILD))
topLevelOwner = GetParent(topLevelOwner);
if (topLevelOwner && (topLevelOwner == GetDesktopWindow() || EnableWindow(topLevelOwner, FALSE)))
topLevelOwner = NULL;
Header->dwFlags |= PSH_MODELESS;
hwnd = (HWND)PropertySheet(Header);
if (!hwnd)
{
if (topLevelOwner)
EnableWindow(topLevelOwner, TRUE);
return FALSE;
}
while (result = GetMessage(&message, NULL, 0, 0))
{
if (result == -1)
break;
if (!PropSheet_IsDialogMessage(hwnd, &message))
{
TranslateMessage(&message);
DispatchMessage(&message);
}
PhDrainAutoPool(&autoPool);
// Destroy the window when necessary.
if (!PropSheet_GetCurrentPageHwnd(hwnd))
break;
}
if (result == 0)
PostQuitMessage((INT)message.wParam);
if (Header->hwndParent && GetActiveWindow() == hwnd)
SetActiveWindow(Header->hwndParent);
if (topLevelOwner)
EnableWindow(topLevelOwner, TRUE);
if (oldFocus && IsWindow(oldFocus))
SetFocus(oldFocus);
DestroyWindow(hwnd);
PhDeleteAutoPool(&autoPool);
return TRUE;
}
int WINAPI WinMain(HINSTANCE inst, HINSTANCE, LPTSTR cmdline, int cmdshow)
{
MSG msg;
BOOL ret;
HWND sheet, active;
HACCEL accelerators;
#ifdef MSVC_MEMLEAK_CHECK
_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF); //check for memory leaks
#endif
// These two methods are not the same
GetModuleFileName(NULL, global::exedir, MAX_PATH); // works
PathRemoveFileSpec(global::exedir);
//GetCurrentDirectory(_MAX_PATH, global::exedir); // doesn't work
//basic initializations
aokts = inst;
propdata.p = scen.players; //start pointing to first member
ret = setts.load();
if (*setts.logname) {
char logpath[_MAX_PATH];
//GetCurrentDirectory(_MAX_PATH, logpath);
strcpy(logpath, global::exedir);
strcat(logpath, "\\");
strcat(logpath, setts.logname);
freopen(logpath, "w", stdout);
printf_log("Opened log file %s.\n", logpath);
}
printf_log("TS Path: %s\n", global::exedir);
// Hint about whether to open as AOC or SGWB
if (setts.recent_first) {
scen.game = (Game)setts.recent_first->game;
printf_log("Last game was %s.\n", gameName(scen.game));
}
//process any compress/decompress requests
if ((*cmdline == '/' || *cmdline == '-') && ProcessCmdline(cmdline))
return 0;
//read genie data
try
{
switch (scen.game) {
case AOK:
case AOC:
case AOHD:
case AOF:
esdata.load(datapath_aok);
break;
case SWGB:
case SWGBCC:
esdata.load(datapath_swgb);
break;
default:
esdata.load(datapath_aok);
}
}
catch (std::exception& ex)
{
printf_log("Could not load data: %s\n", ex.what());
MessageBox(NULL,
"Could not read Genie Data from data.xml. Terminating...",
"Error", MB_ICONERROR);
return 0;
}
//create the property sheet & init misc data
InitCommonControls();
sheet = MakeSheet(inst);
propdata.tformat = RegisterClipboardFormat("AOKTS Trigger");
propdata.ecformat = RegisterClipboardFormat("AOKTS EC");
propdata.mcformat = RegisterClipboardFormat("AOKTS Mapcopy");
accelerators = LoadAccelerators(inst, (LPCTSTR)IDA_MAIN); //checked for err later
//give the sheet its own DialogProc
pproc = (DLGPROC)SetWindowLong(sheet, DWL_DLGPROC, (LONG)&MainDlgProc);
//check for errors down here, after we create the sheet
if (!accelerators)
{
MessageBox(sheet,
"Keyboard Accelerators failed to load. Keyboard shortcuts will not be available.",
"Warning", MB_ICONWARNING);
}
if (!propdata.tformat | !propdata.ecformat)
{
MessageBox(sheet,
"Could not register clipboard format. Clipboard operations will not function.",
"Warning", MB_ICONWARNING);
}
//if (!ret)
// MessageBox(sheet, warnNoAOEII, "Warning", MB_ICONWARNING);
//open mapview window
propdata.mapview = MakeMapView(sheet, cmdshow || SW_MAXIMIZE);
//check for, then open the scenario specified in command string
if (*cmdline != '\0')
{
if (*cmdline == '"')
{
cmdline++; //increment past first doublequote
*strrchr(cmdline, '"') = '\0'; //find last " and replace it
}
strcpy(setts.ScenPath, cmdline);
printf_log("cmdline scenpath: %s\n", setts.ScenPath);
FileOpen(sheet, false, -1);
}
//the message loop
while (ret = GetMessage(&msg, NULL, 0, 0))
{
if (ret < 0) //did GetMessage() fail?
{
MessageBox(sheet,
"Unable to retrieve messages from queue. Click OK to terminate.",
"AOKTS Fatal Error", MB_ICONERROR);
break;
}
// Give first dibs to keyboard accelerators and the propsheet.
if (TranslateAccelerator(sheet, accelerators, &msg) ||
PropSheet_IsDialogMessage(sheet, &msg))
continue;
// Usually active is the sheet. If it's not, it's a modeless dialog and
// it should get a crack, too.
if ((active = GetActiveWindow()) != sheet &&
IsDialogMessage(active, &msg))
continue;
// If we get here, it's just a normal message, so Translate and
// Dispatch.
TranslateMessage(&msg);
DispatchMessage(&msg);
}
//cleanup
if (setts.DelTempOnExit)
DeleteFile(setts.TempPath);
fclose(stdout);
return msg.wParam;
}
