AutoShutdown: folder structure change

git-svn-id: http://svn.miranda-ng.org/main/trunk@767 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 576 insertions, 0 deletions

diff --git a/plugins/AutoShutdown/src/shutdownsvc.cpp b/plugins/AutoShutdown/src/shutdownsvc.cpp
new file mode 100644
index 0000000000..57c12c65a2
--- /dev/null
+++ b/plugins/AutoShutdown/src/shutdownsvc.cpp
@@ -0,0 +1,576 @@
+/*

+

+'AutoShutdown'-Plugin for Miranda IM

+

+Copyright 2004-2007 H. Herkenrath

+

+This program is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public License

+as published by the Free Software Foundation; either version 2

+of the License, or (at your option) any later version.

+

+This program is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+You should have received a copy of the GNU General Public License

+along with this program (Shutdown-License.txt); if not, write to the Free Software

+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

+*/

+

+#include "common.h"

+

+/* Shutdown Dialog */

+static HWND hwndShutdownDlg;

+extern HINSTANCE hInst;

+/* Services */

+static HANDLE hEventOkToShutdown,hEventShutdown;

+static HANDLE hServiceShutdown,hServiceIsTypeEnabled,hServiceGetTypeDesc;

+

+/************************* Utils **************************************/

+

+static BOOL WinNT_SetPrivilege(TCHAR *pszPrivName,BOOL bEnable)

+{

+	BOOL bReturn=FALSE;

+	HANDLE hToken;

+	TOKEN_PRIVILEGES tkp;

+	/* get a token for this process */

+	if(OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&hToken)) {

+		tkp.PrivilegeCount=1; /* one privilege is to set */   

+		/* get the LUID for the shutdown privilege */

+		if(LookupPrivilegeValue(NULL,pszPrivName,&tkp.Privileges[0].Luid)) {

+			tkp.Privileges[0].Attributes=bEnable?SE_PRIVILEGE_ENABLED:0;

+			/* get the shutdown privilege for this process */

+			bReturn=AdjustTokenPrivileges(hToken,FALSE,&tkp,0,(PTOKEN_PRIVILEGES)NULL,0);

+		}

+		CloseHandle(hToken);

+	}

+	return bReturn;

+}

+

+static void BroadcastEndSession(DWORD dwRecipients,LPARAM lParam)

+{

+	LONG (WINAPI *pfnBroadcastSystemMessage)(DWORD,DWORD*,UINT,WPARAM,LPARAM);

+	*(PROC*)&pfnBroadcastSystemMessage=GetProcAddress(GetModuleHandleA("USER32"),"BroadcastSystemMessageW");

+	if(pfnBroadcastSystemMessage)

+		pfnBroadcastSystemMessage(BSF_FORCEIFHUNG,&dwRecipients,WM_ENDSESSION,TRUE,lParam);

+}

+

+static BOOL WinNT_IsWorkStationLocked(void)

+{

+	HDESK hDesk;

+	TCHAR szName[8];

+	DWORD cbName;

+	BOOL bLocked;

+	hDesk=OpenInputDesktop(0,FALSE,DESKTOP_READOBJECTS);

+	if(hDesk==NULL) return TRUE;

+	bLocked=(!GetUserObjectInformation(hDesk,UOI_NAME,szName,SIZEOF(szName),&cbName) || lstrcmpi(szName,_T("default"))!=0);

+	CloseDesktop(hDesk);

+	return bLocked;

+} 

+

+/************************* Workers ************************************/

+static BOOL IsShutdownTypeEnabled(BYTE shutdownType)

+{

+	BOOL bReturn=FALSE;

+	switch(shutdownType) {

+		case SDSDT_HIBERNATE:

+		case SDSDT_STANDBY:

+			{	HMODULE hPowerDLL=LoadLibraryA("POWRPROF"); /* all ascii */

+				if(hPowerDLL!=NULL) {

+					BOOLEAN (STDAPICALLTYPE *pfnIsPwrModeAllowed)(void);

+					*(PROC*)&pfnIsPwrModeAllowed=GetProcAddress(hPowerDLL,(shutdownType==SDSDT_HIBERNATE)?"IsPwrHibernateAllowed":"IsPwrSuspendAllowed");

+					if(pfnIsPwrModeAllowed) bReturn=pfnIsPwrModeAllowed()!=0;

+					FreeLibrary(hPowerDLL);

+				}

+			}

+			/* test privilege */

+			if(bReturn && IsWinVerNT()) {

+				bReturn=WinNT_SetPrivilege(SE_SHUTDOWN_NAME,TRUE);

+				if(bReturn) WinNT_SetPrivilege(SE_SHUTDOWN_NAME,FALSE);

+			}

+			break;

+		case SDSDT_LOGOFF:

+			{	HKEY hKey;

+				DWORD dwSetting,dwSize;

+				/* NoLogOff is BINARY on Win9x/ME and DWORD on Win2000+ */

+				bReturn=TRUE;

+				if(RegOpenKeyEx(HKEY_CURRENT_USER,_T("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer"),0,KEY_QUERY_VALUE,&hKey)==ERROR_SUCCESS) {

+					dwSize=sizeof(dwSetting);

+					if(RegQueryValueEx(hKey, _T("NoLogOff"), 0, NULL, (LPBYTE)&dwSetting, &dwSize) == ERROR_SUCCESS)

+						if(dwSetting) bReturn=FALSE;

+					RegCloseKey(hKey);

+				}

+			}

+			break;

+		case SDSDT_LOCKWORKSTATION:

+			{	void (WINAPI *pfnLockWorkStation)(void);

+				*(PROC*)&pfnLockWorkStation=GetProcAddress(GetModuleHandleA("USER32"),"LockWorkStation");

+				if(pfnLockWorkStation) {

+					HKEY hKey;

+					DWORD dwSize,dwSetting;

+					/* DisableLockWorkstation is DWORD on Win2000+ */

+					bReturn=TRUE;

+					if(RegOpenKeyEx(HKEY_CURRENT_USER,_T("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System"),0,KEY_QUERY_VALUE,&hKey)==ERROR_SUCCESS) {

+						dwSize=sizeof(dwSetting);

+						if(!RegQueryValueEx(hKey, _T("DisableLockWorkstation"), 0, NULL, (LPBYTE)&dwSetting, &dwSize))

+							if(dwSetting) bReturn=FALSE;

+						RegCloseKey(hKey);

+					}

+				}

+				else if(IsWinVerNT()) /* for WinNT4 */

+					bReturn=SearchPath(NULL,_T("LOGIN.SCR"),NULL,0,NULL,NULL)!=0;

+			}

+			break;	

+		case SDSDT_CLOSERASCONNECTIONS:

+			/* check if RAS installed/available */

+			bReturn=SearchPath(NULL,_T("RASAPI32"),_T(".DLL"),0,NULL,NULL)!=0;

+			break;

+		case SDSDT_SETMIRANDAOFFLINE:

+		case SDSDT_CLOSEMIRANDA:

+			bReturn=TRUE; /* always possible */

+			break;

+		case SDSDT_REBOOT:

+		case SDSDT_SHUTDOWN: 

+			/* test privileges */

+			if(IsWinVerNT()) {

+				bReturn=WinNT_SetPrivilege(SE_SHUTDOWN_NAME,TRUE);

+				if(bReturn) WinNT_SetPrivilege(SE_SHUTDOWN_NAME,FALSE);

+			}

+			else bReturn=TRUE;

+			break;

+	}

+	return bReturn;

+}

+

+static DWORD ShutdownNow(BYTE shutdownType)

+{

+	DWORD dwErrCode=ERROR_SUCCESS;

+	switch(shutdownType) {

+		case SDSDT_CLOSEMIRANDA:

+			if(!Miranda_Terminated()) {

+				/* waiting for short until ready (but not too long...) */

+				DWORD dwLastTickCount=GetTickCount();

+				while(!CallService(MS_SYSTEM_OKTOEXIT,0,0)) {

+					/* infinite loop protection (max 5 sec) */

+					if(GetTickCount()-dwLastTickCount>=5000) { /* wraparound works */

+						OutputDebugStringA("Timeout (5 sec)\n"); /* tell others, all ascii */

+						break;

+					}

+					SleepEx(1000,TRUE);

+					if(Miranda_Terminated()) break; /* someone else did it */

+					OutputDebugStringA("Not ready to exit. Waiting...\n"); /* tell others, all ascii */

+				}

+				/* shutdown service must be called from main thread anyway */

+				if(!DestroyWindow((HWND)CallService(MS_CLUI_GETHWND,0,0)))

+					dwErrCode=GetLastError();

+			}

+			break;

+		case SDSDT_SETMIRANDAOFFLINE:

+			/* set global status mode to offline (is remembered by Miranda on exit) */

+			CallService(MS_CLIST_SETSTATUSMODE,(WPARAM)ID_STATUS_OFFLINE,(LPARAM)NULL);

+			break;

+		case SDSDT_STANDBY:

+		case SDSDT_HIBERNATE:

+			WinNT_SetPrivilege(SE_SHUTDOWN_NAME,TRUE);

+			if(!SetSystemPowerState(shutdownType==SDSDT_STANDBY,TRUE))

+				dwErrCode=GetLastError();

+			WinNT_SetPrivilege(SE_SHUTDOWN_NAME,FALSE);

+			break;

+		case SDSDT_LOCKWORKSTATION:

+			{	BOOL (WINAPI *pfnLockWorkStation)(void);

+				*(PROC*)&pfnLockWorkStation=GetProcAddress(GetModuleHandleA("USER32"),"LockWorkStation");

+				if(pfnLockWorkStation!=NULL) /* Win2000+ */

+					if(!pfnLockWorkStation() && !WinNT_IsWorkStationLocked())

+						dwErrCode=GetLastError();

+				else if(IsWinVerNT()) { /* WinNT4 */

+					HKEY hKey;

+					/* start LOGON.SCR screensaver (locks workstation on NT4) */

+					if(!SearchPath(NULL,_T("LOGIN.SCR"),NULL,0,NULL,NULL)) {

+						if(RegCreateKeyEx(HKEY_CURRENT_USER,_T("Control Panel\\Desktop"),0,NULL,REG_OPTION_VOLATILE,KEY_QUERY_VALUE|KEY_SET_VALUE,NULL,&hKey,NULL)==ERROR_SUCCESS) {

+							TCHAR szScreenSaveActive[2],szScreenSaverIsSecure[2],szScrnsaveExe[MAX_PATH];

+							DWORD dwSize;

+							/* save old settings */

+							dwSize=sizeof(szScreenSaveActive); /* in bytes */

+							ZeroMemory(&szScreenSaveActive,dwSize);

+							RegQueryValueEx(hKey, _T("ScreenSaveActive"), 0, NULL, (LPBYTE)szScreenSaveActive, &dwSize);

+							dwSize=sizeof(szScreenSaverIsSecure); /* in bytes */

+							ZeroMemory(&szScreenSaverIsSecure, dwSize);

+							RegQueryValueEx(hKey, _T("ScreenSaverIsSecure"), 0, NULL, (LPBYTE)szScreenSaverIsSecure, &dwSize);

+							dwSize=sizeof(szScrnsaveExe); /* in bytes */

+							ZeroMemory(&szScrnsaveExe, dwSize);

+							RegQueryValueEx(hKey, _T("SCRNSAVE.EXE"), 0, NULL, (LPBYTE)szScrnsaveExe, &dwSize);

+							/* set LOGON.SCR data */

+							if(!RegSetValueEx(hKey, _T("ScreenSaveActive"), 0, REG_SZ, (LPBYTE)_T("1"), 2) &&

+							   !RegSetValueEx(hKey, _T("ScreenSaverIsSecure"), 0, REG_SZ, (LPBYTE)"1", 2) &&

+							   !RegSetValueEx(hKey, _T("SCRNSAVE.EXE"), 0, REG_SZ, (LPBYTE)_T("LOGIN.SCR"), 10))

+									SendMessage(GetForegroundWindow(), WM_SYSCOMMAND, SC_SCREENSAVE, 0);

+							else dwErrCode=GetLastError();

+							/* restore old settings */

+							RegSetValueEx(hKey, _T("ScreenSaveActive"), 0, REG_SZ, (BYTE*)szScreenSaveActive, (lstrlen(szScreenSaveActive)+1)*sizeof(TCHAR));

+							RegSetValueEx(hKey, _T("ScreenSaverIsSecure"), 0, REG_SZ, (BYTE*)szScreenSaverIsSecure, (lstrlen(szScreenSaverIsSecure)+1)*sizeof(TCHAR));

+							RegSetValueEx(hKey, _T("SCRNSAVE.EXE"), 0, REG_SZ, (BYTE*)szScrnsaveExe, (lstrlen(szScrnsaveExe)+1)*sizeof(TCHAR));

+							RegCloseKey(hKey);

+						} else dwErrCode=GetLastError();

+					} else dwErrCode=GetLastError();

+				} else dwErrCode=GetLastError();

+			}

+			break;

+		case SDSDT_CLOSERASCONNECTIONS:

+			ShutdownNow(SDSDT_SETMIRANDAOFFLINE); /* set Miranda offline */

+			/* hang up all ras connections */

+			{	HMODULE hRasApiDLL=LoadLibrary(_T("RASAPI32")); /* all ascii */

+				if(hRasApiDLL!=NULL) {

+					DWORD (APIENTRY *pfnRasEnumConnections)(RASCONN*,DWORD*,DWORD*);

+					DWORD (APIENTRY *pfnRasHangUp)(HRASCONN);

+					DWORD (APIENTRY *pfnRasGetConnectStatus)(HRASCONN,RASCONNSTATUS*);

+					*(PROC*)&pfnRasEnumConnections=GetProcAddress(hRasApiDLL,"RasEnumConnectionsW");

+					*(PROC*)&pfnRasHangUp=GetProcAddress(hRasApiDLL,"RasHangUpW");

+					*(PROC*)&pfnRasGetConnectStatus=GetProcAddress(hRasApiDLL,"RasGetConnectStatusW");

+					if(pfnRasEnumConnections && pfnRasGetConnectStatus && pfnRasHangUp) {

+						RASCONN *paConn;

+						RASCONN *paConnBuf;

+						DWORD dwConnSize,dwConnItems,dwRetries;

+						RASCONNSTATUS rcs;

+						DWORD dw,dwLastTickCount;

+

+						dwConnSize=sizeof(RASCONN);

+						dwConnItems=0;

+						paConn=(RASCONN*)mir_alloc(dwConnSize);

+						dwErrCode=ERROR_NOT_ENOUGH_MEMORY;

+						if(paConn!=NULL)

+							for(dwRetries=5;dwRetries!=0;dwRetries--) { /* prevent infinite loop (rare) */

+								ZeroMemory(paConn,dwConnSize);

+								paConn[0].dwSize=sizeof(RASCONN);

+								dwErrCode=pfnRasEnumConnections(paConn,&dwConnSize,&dwConnItems);

+								if(dwErrCode!=ERROR_BUFFER_TOO_SMALL) break;

+								paConnBuf=(RASCONN*)mir_realloc(paConn,dwConnSize);

+								if(paConnBuf!=NULL) {

+									mir_free(paConn);

+									paConn=NULL;

+									dwErrCode=ERROR_NOT_ENOUGH_MEMORY;

+									break;

+								}

+								paConn=paConnBuf;

+							}

+						if(dwErrCode==ERROR_SUCCESS || dwErrCode==ERROR_BUFFER_TOO_SMALL) {

+							for(dw=0;dw<dwConnItems;++dw) {

+								if(dwErrCode) {

+									if(pfnRasHangUp(paConn[dw].hrasconn))

+										paConn[dw].hrasconn=NULL; /* do not wait for on error */

+								} else {

+									dwErrCode=pfnRasHangUp(paConn[dw].hrasconn);

+									if(!dwErrCode) paConn[dw].hrasconn=NULL; /* do not wait for on error */

+								}

+							}

+							/* RAS does not allow to quit directly after HangUp (see docs) */

+							dwLastTickCount=GetTickCount();

+							ZeroMemory(&rcs,sizeof(RASCONNSTATUS));

+							rcs.dwSize=sizeof(RASCONNSTATUS);

+							for(dw=0;dw<dwConnItems;++dw)

+								if(paConn[dw].hrasconn!=NULL)

+									while(pfnRasGetConnectStatus(paConn[dw].hrasconn, &rcs)!=ERROR_INVALID_HANDLE) {

+										Sleep(0); /* give rest of time silce to other threads with equal priority */

+										/* infinite loop protection (3000ms defined in docs) */

+										dwRetries=GetTickCount();

+										if(dwRetries-dwLastTickCount>3000) break; /* wraparound works */

+									}

+						}

+						mir_free(paConn); /* does NULL check */

+					} else dwErrCode=GetLastError();

+					FreeLibrary(hRasApiDLL);

+				} else dwErrCode=GetLastError();

+			}

+			/* set Miranda to offline again, to remain offline with reconnection plugins */

+			ShutdownNow(SDSDT_SETMIRANDAOFFLINE);

+			break;

+		case SDSDT_REBOOT:

+		case SDSDT_SHUTDOWN:

+			if(GetSystemMetrics(SM_SHUTTINGDOWN)) { /* Win2000+, 0 on error */

+				dwErrCode=ERROR_SHUTDOWN_IN_PROGRESS;

+				break;

+			}

+			/* WinNT4/2000/XP */

+			{	BOOL (WINAPI *pfnInitiateSystemShutdownEx)(const TCHAR*,const TCHAR*,DWORD,BOOL,BOOL,DWORD);

+				BOOL (WINAPI *pfnInitiateSystemShutdown)(const TCHAR*,const TCHAR*,DWORD,BOOL,BOOL);

+				*(PROC*)&pfnInitiateSystemShutdownEx=GetProcAddress(GetModuleHandleA("ADVAPI32"),"InitiateSystemShutdownExW");

+				*(PROC*)&pfnInitiateSystemShutdown=GetProcAddress(GetModuleHandleA("ADVAPI32"),"InitiateSystemShutdownW");

+				if(pfnInitiateSystemShutdownEx!=NULL || pfnInitiateSystemShutdown!=NULL) {

+					WinNT_SetPrivilege(SE_SHUTDOWN_NAME,TRUE);

+			

+					/* does not send out WM_ENDSESSION messages, so we do it manually to

+					 * give the applications the chance to save their data */

+					WinNT_SetPrivilege(SE_TCB_NAME,TRUE); /* for BSM_ALLDESKTOPS */

+					BroadcastEndSession(BSM_APPLICATIONS|BSM_ALLDESKTOPS,ENDSESSION_CLOSEAPP); /* app should close itself */

+					WinNT_SetPrivilege(SE_TCB_NAME,FALSE);

+

+					if(pfnInitiateSystemShutdownEx!=NULL) {

+						if(!pfnInitiateSystemShutdownEx(NULL,TranslateT("AutoShutdown"),0,TRUE,shutdownType==SDSDT_REBOOT,SHTDN_REASON_MAJOR_OTHER|SHTDN_REASON_MINOR_OTHER|SHTDN_REASON_FLAG_PLANNED))

+							dwErrCode=GetLastError();

+					} else if(!pfnInitiateSystemShutdown(NULL,TranslateT("AutoShutdown"),0,TRUE,shutdownType==SDSDT_REBOOT))

+						dwErrCode=GetLastError();

+

+					/* cleanly close Miranda */

+					if(!dwErrCode) ShutdownNow(SDSDT_CLOSEMIRANDA);

+					break;

+				}

+			}

+			/* fall through for Win9x */

+		case SDSDT_LOGOFF:

+			{	UINT flags;

+				switch(shutdownType) {

+					case SDSDT_LOGOFF: flags=EWX_LOGOFF; break;

+					case SDSDT_REBOOT: flags=EWX_REBOOT; break;

+					default:           flags=EWX_SHUTDOWN|EWX_POWEROFF;

+				}

+				if(shutdownType==SDSDT_LOGOFF && IsWinVer2000Plus() && !WinNT_IsWorkStationLocked())

+					flags|=EWX_FORCEIFHUNG; /* only considered for WM_ENDSESSION messages */

+				else flags|=EWX_FORCE; /* must be used when workstation locked */

+

+				if(flags&EWX_FORCE) {

+					/* EWX_FORCE does not send out WM_ENDSESSION messages, so we do it

+					 * manually to give the applications the chance to save their data */

+					BroadcastEndSession(BSM_APPLICATIONS,(shutdownType==SDSDT_LOGOFF)?ENDSESSION_LOGOFF:0);

+				

+					/* Windows Me/98/95 (msdn): Because of the design of the shell,

+					 * calling ExitWindowsEx with EWX_FORCE fails to completely log off

+					 * the user (the system terminates the applications and displays the

+					 * Enter Windows Password dialog box, however, the user's desktop remains.)

+					 * To log off the user forcibly, terminate the Explorer process before calling

+					 * ExitWindowsEx with EWX_LOGOFF and EWX_FORCE. */

+				}

+				if(!ExitWindowsEx(flags,SHTDN_REASON_MAJOR_OTHER|SHTDN_REASON_MINOR_OTHER|SHTDN_REASON_FLAG_PLANNED))

+					dwErrCode=GetLastError();

+				/* cleanly close Miranda */

+				if(!dwErrCode) ShutdownNow(SDSDT_CLOSEMIRANDA);

+			}

+			break;

+	}

+	return dwErrCode;

+}

+

+/************************* Shutdown Dialog ****************************/

+

+#define M_START_SHUTDOWN    (WM_APP+111)

+#define M_UPDATE_COUNTDOWN  (WM_APP+112)

+static INT_PTR CALLBACK ShutdownDlgProc(HWND hwndDlg,UINT msg,WPARAM wParam,LPARAM lParam)

+{

+	BYTE shutdownType=(BYTE)GetWindowLongPtr(hwndDlg, DWLP_USER);

+	WORD countdown=(WORD)GetWindowLongPtr(GetDlgItem(hwndDlg, IDC_TEXT_HEADER), GWLP_USERDATA);

+	static BOOL (WINAPI *pfnLockSetForegroundWindow)(UINT);

+

+	switch(msg) {

+		case WM_INITDIALOG:

+			hwndShutdownDlg=hwndDlg;

+			SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG)lParam);

+			TranslateDialogDefault(hwndDlg);

+			

+			if(lParam==SDSDT_SHUTDOWN || lParam==SDSDT_REBOOT || lParam==SDSDT_LOGOFF)

+				ShowWindow(GetDlgItem(hwndDlg,IDC_TEXT_UNSAVEDWARNING),SW_SHOW);

+			SendDlgItemMessage(hwndDlg,IDC_ICON_HEADER,STM_SETIMAGE,IMAGE_ICON,(LPARAM)IcoLib_GetIcon("AutoShutdown_Header"));

+			{	HFONT hBoldFont;

+				LOGFONT lf;

+				if(GetObject((HFONT)SendDlgItemMessage(hwndDlg,IDC_TEXT_HEADER,WM_GETFONT,0,0),sizeof(lf),&lf)) {

+					lf.lfWeight=FW_BOLD;

+					hBoldFont=CreateFontIndirect(&lf);

+				}

+				else hBoldFont=NULL;

+				SendDlgItemMessage(hwndDlg,IDC_TEXT_HEADER,WM_SETFONT,(WPARAM)hBoldFont,FALSE);

+				SetWindowLongPtr(GetDlgItem(hwndDlg, IDC_TEXT_HEADER), GWLP_USERDATA, (LONG)hBoldFont);

+			}

+			{	WORD countdown=DBGetContactSettingWord(NULL,"AutoShutdown","ConfirmDlgCountdown",SETTING_CONFIRMDLGCOUNTDOWN_DEFAULT);

+				if(countdown<3) countdown=SETTING_CONFIRMDLGCOUNTDOWN_DEFAULT;

+				SetWindowLongPtr(GetDlgItem(hwndDlg, IDC_TEXT_HEADER), GWLP_USERDATA, countdown);

+				SendMessage(hwndDlg,M_UPDATE_COUNTDOWN,0,countdown);

+			}

+			SkinPlaySound("AutoShutdown_Countdown");

+			if(!SetTimer(hwndDlg,1,1000,NULL)) PostMessage(hwndDlg,M_START_SHUTDOWN,0,0);

+			Utils_RestoreWindowPositionNoSize(hwndDlg,NULL,"AutoShutdown","ConfirmDlg_");

+			

+			/* disallow foreground window changes (WinMe/2000+) */

+			SetForegroundWindow(hwndDlg);

+			*(PROC*)&pfnLockSetForegroundWindow=GetProcAddress(GetModuleHandleA("USER32"),"LockSetForegroundWindow");

+			if(pfnLockSetForegroundWindow!=NULL)

+				pfnLockSetForegroundWindow(LSFW_LOCK);

+

+			SendMessage(hwndDlg,WM_NEXTDLGCTL,(WPARAM)GetDlgItem(hwndDlg,IDCANCEL),TRUE);

+			return FALSE; /* focus set on cancel */

+		case WM_DESTROY:

+		{	HFONT hFont;

+			HICON hIcon;

+			hwndShutdownDlg=NULL;

+			ShowWindow(hwndDlg,SW_HIDE);

+			/* reallow foreground window changes (WinMe/2000+) */

+			if(pfnLockSetForegroundWindow) pfnLockSetForegroundWindow(LSFW_UNLOCK);

+			Utils_SaveWindowPosition(hwndDlg,NULL,"AutoShutdown","ConfirmDlg_");

+			hIcon=(HICON)SendDlgItemMessage(hwndDlg,IDC_ICON_HEADER,STM_SETIMAGE,IMAGE_ICON,(LPARAM)NULL);

+			IcoLib_ReleaseIcon(hIcon); /* does NULL check */

+			hFont=(HFONT)SendDlgItemMessage(hwndDlg,IDC_TEXT_HEADER,WM_GETFONT,0,0);

+			SendDlgItemMessage(hwndDlg,IDC_TEXT_HEADER,WM_SETFONT,(WPARAM)NULL,FALSE); /* no return value */

+			if(hFont!=NULL) DeleteObject(hFont);

+			return TRUE;

+		}

+		case M_START_SHUTDOWN:

+			if(IsWindowEnabled(GetDlgItem(hwndDlg,IDC_BUTTON_SHUTDOWNNOW))) {

+				DWORD dwErrCode;

+				EnableWindow(GetDlgItem(hwndDlg,IDC_BUTTON_SHUTDOWNNOW),FALSE);

+				ShowWindow(hwndDlg,SW_HIDE);  /* get rid of the dialog immediately */

+				dwErrCode=ShutdownNow(shutdownType);

+				if(dwErrCode!=ERROR_SUCCESS) {

+					char *pszErr;

+					pszErr=GetWinErrorDescription(dwErrCode);

+					ShowInfoMessage(NIIF_ERROR,Translate("Automatic Shutdown Error"),Translate("The shutdown process failed!\nReason: %s"),(pszErr!=NULL)?pszErr:Translate("Unknown"));

+					if(pszErr!=NULL) LocalFree(pszErr);

+				}

+				DestroyWindow(hwndDlg);

+			}

+			return TRUE;

+		case WM_TIMER:

+			if(countdown) {

+				--countdown;

+				SetWindowLongPtr(GetDlgItem(hwndDlg, IDC_TEXT_HEADER), GWLP_USERDATA, countdown);

+				if(countdown==27 || countdown==24 || countdown==21 || countdown==19 ||

+				   countdown==17 || countdown==15 || countdown==13 || countdown==11 ||

+				   countdown<=10)

+					SkinPlaySound("AutoShutdown_Countdown");

+			}

+			else KillTimer(hwndDlg,wParam);  /* countdown finished */

+			PostMessage(hwndDlg,M_UPDATE_COUNTDOWN,0,countdown);

+			return TRUE;

+		case M_UPDATE_COUNTDOWN:  /* lParam=(WORD)countdown */

+		{	TCHAR szText[256];

+			TCHAR *desc[]={_T("Miranda IM is going to be automatically closed in %u second(s)."),

+			               _T("All Miranda IM protocols are going to be set to offline in %u second(s)."),

+			               _T("You will be logged off automatically in %u second(s)."),

+			               _T("The computer will automatically be restarted in %u second(s)."),

+			               _T("The computer will automatically be set to standby mode in %u second(s)."),

+			               _T("The computer will automatically be set to hibernate mode in %u second(s)."),

+			               _T("The workstation will automatically get locked in %u second(s)."),

+			               _T("All dialup connections will be closed in %u second(s)."),

+			               _T("The computer will automatically be shut down in %u second(s).")};

+			mir_sntprintf(szText,SIZEOF(szText),TranslateTS(desc[shutdownType-1]),lParam);

+			SetDlgItemText(hwndDlg,IDC_TEXT_HEADER,szText);

+			/* countdown finished */

+			if(!lParam) PostMessage(hwndDlg,M_START_SHUTDOWN,0,0);

+			return TRUE;

+		}

+		case WM_COMMAND:

+			switch(LOWORD(wParam)) {

+				case IDC_BUTTON_SHUTDOWNNOW:

+					KillTimer(hwndDlg,1);

+					SetWindowLongPtr(GetDlgItem(hwndDlg, IDC_TEXT_HEADER), GWLP_USERDATA, 0);

+					SendMessage(hwndDlg,M_UPDATE_COUNTDOWN,0,(LONG)0);

+					PostMessage(hwndDlg,M_START_SHUTDOWN,0,0);

+					return TRUE;

+				case IDCANCEL: /* WM_CLOSE */

+					if(countdown) {

+						KillTimer(hwndDlg,1);

+						DestroyWindow(hwndDlg);

+					}

+					return TRUE;

+			}

+			break;

+	}

+	return FALSE;

+}

+

+/************************* Services ***********************************/

+

+INT_PTR ServiceShutdown(WPARAM wParam,LPARAM lParam)

+{

+	/* passing 0 as wParam is only to be used internally, undocumented */

+	if(!wParam) wParam=DBGetContactSettingByte(NULL,"AutoShutdown","ShutdownType",SETTING_SHUTDOWNTYPE_DEFAULT);

+	if(!IsShutdownTypeEnabled((BYTE)wParam)) return 1; /* does shutdownType range check */

+	if((BOOL)lParam && hwndShutdownDlg!=NULL) return 2;

+

+	/* ask others if allowed */

+	if(NotifyEventHooks(hEventOkToShutdown,wParam,lParam)) {

+		OutputDebugStringA("automatic shutdown denied by event hook\n"); /* all ascii */

+		return 3;

+	}

+	/* tell others */

+	NotifyEventHooks(hEventShutdown,wParam,lParam);

+	/* show dialog */

+	if(lParam && DBGetContactSettingByte(NULL,"AutoShutdown","ShowConfirmDlg",SETTING_SHOWCONFIRMDLG_DEFAULT))

+		if(CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_SHUTDOWNNOW), NULL, ShutdownDlgProc, (LPARAM)(BYTE)wParam) != NULL)

+			return 0;

+	/* show error */

+	{	DWORD dwErrCode;

+		dwErrCode=ShutdownNow((BYTE)wParam);

+		if(dwErrCode!=ERROR_SUCCESS) {

+			char *pszErr;

+			pszErr=GetWinErrorDescription(dwErrCode);

+			ShowInfoMessage(NIIF_ERROR,Translate("Automatic Shutdown Error"),Translate("Inititiating the shutdown process failed!\nReason: %s"),(pszErr!=NULL)?pszErr:Translate("Unknown"));

+			if(pszErr!=NULL) LocalFree(pszErr);

+			return 4;

+		}

+	}

+	return 0;

+}

+

+INT_PTR ServiceIsTypeEnabled(WPARAM wParam,LPARAM lParam)

+{

+	return IsShutdownTypeEnabled((BYTE)wParam); /* does shutdownType range check */

+}

+

+INT_PTR ServiceGetTypeDescription(WPARAM wParam,LPARAM lParam)

+{

+	TCHAR *pszDesc;

+	const TCHAR *apszShort[]={_T("Close Miranda IM"),_T("Set Miranda IM offline"),_T("Log off user"),

+	                          _T("Restart computer"),_T("Shutdown computer"),_T("Standby mode"),_T("Hibernate mode"),

+	                          _T("Lock workstation"),_T("Hang up dialup connections"),_T("Close Miranda IM"),

+	                          _T("Set Miranda IM offline"),_T("Log off user"),_T("Restart computer"),_T("Shutdown computer"),

+	                          _T("Standby mode"),_T("Hibernate mode"),_T("Lock workstation"),_T("Hang up dialup connections")};

+	const TCHAR *apszLong[]={_T("Sets all Miranda IM protocols to offline and closes Miranda IM."),

+	                         _T("Sets all Miranda IM protocols to offline."),

+	                         _T("Logs the current Windows user off so that another user can log in."),

+	                         _T("Shuts down Windows and then restarts Windows."),

+	                         _T("Closes all running programs and shuts down Windows to a point at which it is safe to turn off the power."),

+	                         _T("Saves the current Windows session in memory and sets the system to suspend mode."),

+	                         _T("Saves the current Windows session on harddisc, so that the power can be turned off."),

+	                         _T("Locks the computer. To unlock the computer, you must log in."),

+			                 _T("Sets all protocols to offline and closes all RAS connections.")};

+	/* shutdownType range check */

+	if(!wParam || (BYTE)wParam>SDSDT_MAX) return (int)NULL;

+	/* select description */

+	pszDesc=(TCHAR*)((lParam&GSTDF_LONGDESC)?apszLong:apszShort)[wParam-1];

+	if(!(lParam&GSTDF_UNTRANSLATED)) pszDesc=TranslateTS(pszDesc);

+	/* convert as needed */

+	if(!(lParam&GSTDF_UNICODE)) {

+		static char szConvBuf[128];

+		char *buf=u2a(pszDesc);

+		if(buf==NULL) return (int)NULL;

+		lstrcpynA(szConvBuf,buf,sizeof(szConvBuf));

+		mir_free(buf);

+		return (int)szConvBuf;

+	}

+	return (int)pszDesc;

+}

+

+/************************* Misc ***************************************/

+

+void InitShutdownSvc(void)

+{

+	/* Shutdown Dialog */

+	hwndShutdownDlg=NULL;

+	SkinAddNewSoundBundled("AutoShutdown_Countdown",Translate("Alerts"),Translate("Automatic Shutdown Countdown"),"Sounds\\","countdown.wav");

+	/* Services */

+	hEventOkToShutdown=CreateHookableEvent(ME_AUTOSHUTDOWN_OKTOSHUTDOWN);

+	hEventShutdown=CreateHookableEvent(ME_AUTOSHUTDOWN_SHUTDOWN);

+	hServiceShutdown = CreateServiceFunction(MS_AUTOSHUTDOWN_SHUTDOWN, ServiceShutdown);

+	hServiceIsTypeEnabled = CreateServiceFunction(MS_AUTOSHUTDOWN_ISTYPEENABLED, ServiceIsTypeEnabled);

+	hServiceGetTypeDesc = CreateServiceFunction(MS_AUTOSHUTDOWN_GETTYPEDESCRIPTION, ServiceGetTypeDescription);

+}

+

+void UninitShutdownSvc(void)

+{

+	/* Shutdown Dialog */

+	if(hwndShutdownDlg!=NULL) DestroyWindow(hwndShutdownDlg);

+	/* Services */

+	DestroyServiceFunction(hServiceShutdown);

+	DestroyServiceFunction(hServiceIsTypeEnabled);

+	DestroyServiceFunction(hServiceGetTypeDesc);

+	DestroyHookableEvent(hEventOkToShutdown);

+	DestroyHookableEvent(hEventShutdown);

+}