KeepStatus, StartupStatus and AdvanceAutoAway merged into one plugin

20 files changed, 6541 insertions, 0 deletions

diff --git a/plugins/StatusManager/src/aaa_msgoptions.cpp b/plugins/StatusManager/src/aaa_msgoptions.cpp
new file mode 100644
index 0000000000..7bf788aa9b
--- /dev/null
+++ b/plugins/StatusManager/src/aaa_msgoptions.cpp
@@ -0,0 +1,179 @@
+/*
+    AdvancedAutoAway Plugin for Miranda-IM (www.miranda-im.org)
+    Copyright 2003-2006 P. Boon
+
+    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; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+extern char *StatusModeToDbSetting(int status,const char *suffix);
+
+void DisableDialog(HWND hwndDlg)
+{
+	EnableWindow(GetDlgItem(hwndDlg, IDC_STATUS), FALSE);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_STATUSMSG), FALSE);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), FALSE);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_RADUSECUSTOM), FALSE);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_RADUSEMIRANDA), FALSE);
+}
+
+INT_PTR CALLBACK DlgProcAutoAwayMsgOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static AAMSGSETTING** settings;
+	static int last, count;
+
+	switch( msg ) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault( hwndDlg );
+		{
+			ShowWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), ServiceExists(MS_VARS_SHOWHELP)?SW_SHOW:SW_HIDE);
+			count = 0;
+			last = -1;
+		
+			PROTOACCOUNT** proto;
+			int protoCount = 0;
+			Proto_EnumAccounts(&protoCount, &proto);
+			if (protoCount <= 0)
+			{
+				DisableDialog(hwndDlg);
+				break;
+			}
+
+			DWORD protoModeMsgFlags = 0;
+			for (int i=0; i < protoCount; i++)
+				if (CallProtoService(proto[i]->szModuleName, PS_GETCAPS, PFLAGNUM_1, 0) & PF1_MODEMSGSEND & ~PF1_INDIVMODEMSG)
+					protoModeMsgFlags |= CallProtoService( proto[i]->szModuleName, PS_GETCAPS, PFLAGNUM_3, 0 );
+
+			if (protoModeMsgFlags == 0)
+			{
+				DisableDialog(hwndDlg);
+				break;
+			}
+
+			settings = ( AAMSGSETTING** )malloc(sizeof(AAMSGSETTING*));
+			count = 0;
+			for (int i=0; i < _countof(statusModeList); i++ ) {
+				if ( !( protoModeMsgFlags & Proto_Status2Flag( statusModeList[i] )))
+					continue;
+
+				int j = SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_ADDSTRING, 0, (LPARAM)pcli->pfnGetStatusModeDescription(statusModeList[i], 0));
+				SendDlgItemMessage( hwndDlg, IDC_STATUS, CB_SETITEMDATA, j, statusModeList[i] );
+				settings = ( AAMSGSETTING** )realloc(settings, (count+1)*sizeof(AAMSGSETTING*));
+				settings[count] = ( AAMSGSETTING* )malloc(sizeof(AAMSGSETTING));
+				settings[count]->status = statusModeList[i];
+
+				DBVARIANT dbv;
+				if ( !db_get(NULL, AAAMODULENAME, StatusModeToDbSetting(statusModeList[i],SETTING_STATUSMSG), &dbv)) {
+					settings[count]->msg = ( char* )malloc(mir_strlen(dbv.pszVal) + 1);
+					mir_strcpy(settings[count]->msg, dbv.pszVal);
+					db_free(&dbv);
+				}
+				else settings[count]->msg = NULL;
+
+				settings[count]->useCustom = db_get_b(NULL, AAAMODULENAME, StatusModeToDbSetting(statusModeList[i], SETTING_MSGCUSTOM), FALSE);
+				count += 1;
+			}
+			SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_SETCURSEL,0,0);
+			SendMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDC_STATUS,CBN_SELCHANGE),0);
+		}
+		break;
+
+	case WM_COMMAND:
+		if ( ((HIWORD(wParam) == EN_CHANGE) || (HIWORD(wParam) == BN_CLICKED)) && ((HWND)lParam == GetFocus()))
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+		
+		switch(LOWORD(wParam)) {
+		case IDC_RADUSEMIRANDA:
+			CheckDlgButton(hwndDlg, IDC_RADUSECUSTOM, BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_RADUSEMIRANDA) ? BST_CHECKED : BST_UNCHECKED);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_STATUSMSG), IsDlgButtonChecked(hwndDlg, IDC_RADUSECUSTOM));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), IsDlgButtonChecked(hwndDlg, IDC_RADUSECUSTOM));
+			settings[SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_GETCURSEL,0,0)]->useCustom = IsDlgButtonChecked(hwndDlg, IDC_RADUSECUSTOM);
+			break;
+
+		case IDC_RADUSECUSTOM:
+			CheckDlgButton(hwndDlg, IDC_RADUSEMIRANDA, BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_RADUSECUSTOM) ? BST_CHECKED : BST_UNCHECKED);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_STATUSMSG), IsDlgButtonChecked(hwndDlg, IDC_RADUSECUSTOM));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), IsDlgButtonChecked(hwndDlg, IDC_RADUSECUSTOM));
+			settings[SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_GETCURSEL,0,0)]->useCustom = IsDlgButtonChecked(hwndDlg, IDC_RADUSECUSTOM);
+			break;
+
+		case IDC_STATUS:
+			if ( HIWORD( wParam ) == CBN_SELCHANGE ) {
+				int i = SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_GETCURSEL,0,0);
+				int len = SendDlgItemMessage(hwndDlg, IDC_STATUSMSG, WM_GETTEXTLENGTH, 0, 0);
+				if ( last != -1 ) {
+					if (settings[last]->msg == NULL)
+						settings[last]->msg = ( char* )malloc(len+1);
+					else
+						settings[last]->msg = (char*)realloc(settings[last]->msg, len+1);
+					GetDlgItemTextA(hwndDlg, IDC_STATUSMSG, settings[last]->msg, (len+1));
+				}
+
+				if (i != -1) {
+					if (settings[i]->msg != NULL)
+						SetDlgItemTextA(hwndDlg, IDC_STATUSMSG, settings[i]->msg);
+					else {
+						ptrW msg((wchar_t*)CallService(MS_AWAYMSG_GETSTATUSMSGW, settings[i]->status, 0));
+						SetDlgItemText(hwndDlg, IDC_STATUSMSG, (msg != NULL) ? msg : L"");
+					}
+
+					if (settings[i]->useCustom) {
+						EnableWindow(GetDlgItem(hwndDlg, IDC_STATUSMSG), TRUE);
+						EnableWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), TRUE);
+						CheckDlgButton(hwndDlg, IDC_RADUSECUSTOM, BST_CHECKED);
+						CheckDlgButton(hwndDlg, IDC_RADUSEMIRANDA, BST_UNCHECKED);
+					}
+					else {
+						EnableWindow(GetDlgItem(hwndDlg, IDC_STATUSMSG), FALSE);
+						EnableWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), FALSE);
+						CheckDlgButton(hwndDlg, IDC_RADUSEMIRANDA, BST_CHECKED);
+						CheckDlgButton(hwndDlg, IDC_RADUSECUSTOM, BST_UNCHECKED);
+					}
+				}
+				last = i;
+			}
+			break;
+
+		case IDC_VARIABLESHELP:
+			CallService(MS_VARS_SHOWHELP, (WPARAM)GetDlgItem(hwndDlg, IDC_STATUSMSG), 0);
+			break;
+		}
+		break;
+
+	case WM_NOTIFY:
+		switch (((LPNMHDR)lParam)->code) {
+		case PSN_APPLY:
+			SendMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDC_STATUS,CBN_SELCHANGE),0);
+			for (int i=0; i < count; i++ ) {
+				db_set_b(NULL, AAAMODULENAME, StatusModeToDbSetting(settings[i]->status,SETTING_MSGCUSTOM), (BYTE)settings[i]->useCustom);
+				if ( (settings[i]->useCustom) && (settings[i]->msg != NULL) && (settings[i]->msg[0] != '\0'))
+					db_set_s(NULL, AAAMODULENAME, StatusModeToDbSetting(settings[i]->status,SETTING_STATUSMSG), settings[i]->msg);
+			}
+			break;
+		}
+		break;
+	
+	case WM_DESTROY:
+		for (int i=0; i < count; i++ ) {
+			free(settings[i]->msg);
+			free(settings[i]);
+		}
+		free(settings);
+		break;
+	}
+	
+	return FALSE;
+}
diff --git a/plugins/StatusManager/src/aaa_options.cpp b/plugins/StatusManager/src/aaa_options.cpp
new file mode 100644
index 0000000000..88c02a1d1f
--- /dev/null
+++ b/plugins/StatusManager/src/aaa_options.cpp
@@ -0,0 +1,523 @@
+/*
+AdvancedAutoAway Plugin for Miranda-IM (www.miranda-im.org)
+Copyright 2003-2006 P. Boon
+
+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; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+int LoadAutoAwaySetting(TAAAProtoSetting &autoAwaySetting, char* protoName);
+
+INT_PTR CALLBACK DlgProcAutoAwayMsgOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
+
+static BOOL bSettingSame = FALSE;
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Dialog service functions
+
+static int WriteAutoAwaySetting(TAAAProtoSetting &autoAwaySetting, char *protoName)
+{
+	char setting[128];
+	mir_snprintf(setting, "%s_OptionFlags", protoName);
+	db_set_w(NULL, AAAMODULENAME, setting, (WORD)autoAwaySetting.optionFlags);
+	mir_snprintf(setting, "%s_AwayTime", protoName);
+	db_set_w(NULL, AAAMODULENAME, setting, (WORD)autoAwaySetting.awayTime);
+	mir_snprintf(setting, "%s_NATime", protoName);
+	db_set_w(NULL, AAAMODULENAME, setting, (WORD)autoAwaySetting.naTime);
+	mir_snprintf(setting, "%s_StatusFlags", protoName);
+	db_set_w(NULL, AAAMODULENAME, setting, (WORD)autoAwaySetting.statusFlags);
+	mir_snprintf(setting, "%s_Lv1Status", protoName);
+	db_set_w(NULL, AAAMODULENAME, setting, (WORD)autoAwaySetting.lv1Status);
+	mir_snprintf(setting, "%s_Lv2Status", protoName);
+	db_set_w(NULL, AAAMODULENAME, setting, (WORD)autoAwaySetting.lv2Status);
+
+	return 0;
+}
+
+static void SetDialogItems(HWND hwndDlg, TAAAProtoSetting *setting)
+{
+	bool bIsTimed = (setting->optionFlags & FLAG_ONMOUSE) != 0;
+	bool bSetNA = (setting->optionFlags & FLAG_SETNA) != 0;
+	bool bSaver = (setting->optionFlags & FLAG_ONSAVER) != 0;
+	bool bFullScr = (setting->optionFlags & FLAG_FULLSCREEN) != 0;
+
+	CheckDlgButton(hwndDlg, IDC_FULLSCREEN, bFullScr ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_SCREENSAVE, bSaver ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_ONLOCK, (setting->optionFlags & FLAG_ONLOCK) != 0 ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_TIMED, bIsTimed ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_SETNA, bSetNA ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_CONFIRM, (setting->optionFlags & FLAG_CONFIRM) != 0 ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_RESETSTATUS, (setting->optionFlags & FLAG_RESET) != 0 ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_MONITORMIRANDA, (setting->optionFlags & FLAG_MONITORMIRANDA) != 0 ? BST_CHECKED : BST_UNCHECKED);
+	CheckDlgButton(hwndDlg, IDC_LV2ONINACTIVE, (setting->optionFlags & FLAG_LV2ONINACTIVE) != 0 ? BST_CHECKED : BST_UNCHECKED);
+
+	SetDlgItemInt(hwndDlg, IDC_AWAYTIME, setting->awayTime, FALSE);
+	SetDlgItemInt(hwndDlg, IDC_NATIME, setting->naTime, FALSE);
+
+	EnableWindow(GetDlgItem(hwndDlg, IDC_SETNA), bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_LV2ONINACTIVE), bIsTimed && bSetNA);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_MONITORMIRANDA), bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_AWAYTIME), bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_LV1AFTERSTR), bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_LV1STATUS), bIsTimed || bSaver || bFullScr);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_STATUSLIST), bIsTimed || bSaver || bFullScr);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_RESETSTATUS), (bIsTimed || bSaver || bFullScr) && IsDlgButtonChecked(hwndDlg, IDC_LV2ONINACTIVE));
+	EnableWindow(GetDlgItem(hwndDlg, IDC_CONFIRM), (bIsTimed || bSaver || bFullScr) && IsDlgButtonChecked(hwndDlg, IDC_LV2ONINACTIVE) && IsDlgButtonChecked(hwndDlg, IDC_RESETSTATUS));
+	EnableWindow(GetDlgItem(hwndDlg, IDC_NATIME), bSetNA && bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_SETNASTR), bSetNA && bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_SETNASTR), bSetNA && bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_LV2STATUS), bSetNA && bIsTimed);
+	EnableWindow(GetDlgItem(hwndDlg, IDC_PROTOCOL), !bSettingSame);
+}
+
+static TAAAProtoSetting* GetSetting(HWND hwndDlg, TAAAProtoSetting *sameSetting)
+{
+	if (bSettingSame)
+		return sameSetting;
+
+	int iItem = SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, CB_GETCURSEL, 0, 0);
+	if (iItem == -1)
+		return NULL;
+
+	INT_PTR iData = (INT_PTR)SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, CB_GETITEMDATA, iItem, 0);
+	return (iData == -1) ? NULL : (TAAAProtoSetting*)iData;
+}
+
+static void SetDialogStatus(HWND hwndDlg, TAAAProtoSetting *sameSetting)
+{
+	TAAAProtoSetting *setting = GetSetting(hwndDlg, sameSetting);
+	if (setting == NULL)
+		return;
+
+	// create columns
+	HWND hList = GetDlgItem(hwndDlg, IDC_STATUSLIST);
+	ListView_SetExtendedListViewStyleEx(hList, LVS_EX_FULLROWSELECT | LVS_EX_CHECKBOXES, LVS_EX_FULLROWSELECT | LVS_EX_CHECKBOXES);
+
+	LVCOLUMN lvCol = { 0 };
+	lvCol.mask = LVCF_WIDTH | LVCF_TEXT;
+	lvCol.pszText = TranslateT("Status");
+	lvCol.cx = 118;
+	ListView_InsertColumn(hList, 0, &lvCol);
+
+	// get pointer to settings
+	SetDialogItems(hwndDlg, setting);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Rules dialog window procedure
+
+static TAAAProtoSettingList optionSettings(10, CompareSettings);
+
+static INT_PTR CALLBACK DlgProcAutoAwayRulesOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static TAAAProtoSetting* sameSetting;
+	TAAAProtoSetting *setting;
+	static int init;
+
+	switch (msg) {
+	case WM_INITDIALOG:
+		init = TRUE;
+		TranslateDialogDefault(hwndDlg);
+
+		// copy the settings
+		optionSettings = autoAwaySettings;
+
+		sameSetting = (TAAAProtoSetting*)malloc(sizeof(TAAAProtoSetting));
+		LoadAutoAwaySetting(*sameSetting, SETTING_ALL);
+
+		// fill list from currentProtoSettings
+		{
+			for (int i = 0; i < optionSettings.getCount(); i++) {
+				TAAAProtoSetting &p = optionSettings[i];
+				int item = SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, CB_ADDSTRING, 0, (LPARAM)p.tszAccName);
+				SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, CB_SETITEMDATA, item, (LPARAM)&p);
+			}
+		}
+		// set cursor to first protocol
+		SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, CB_SETCURSEL, 0, 0);
+
+		// status list
+		SetDialogStatus(hwndDlg, sameSetting);
+
+		SendMessage(hwndDlg, WM_COMMAND, (WPARAM)IDC_PROTOCOL, (LPARAM)0x11111111);
+		init = FALSE;
+		break;
+
+	case WM_COMMAND:
+		if ((HIWORD(wParam) == EN_CHANGE || HIWORD(wParam) == BN_CLICKED) && (HWND)lParam == GetFocus())
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+
+		setting = GetSetting(hwndDlg, sameSetting);
+		if (!setting)
+			break;
+
+		switch (LOWORD(wParam)) {
+		case IDC_PROTOCOL:
+			// status listview
+			init = TRUE;
+			{
+				HWND hList = GetDlgItem(hwndDlg, IDC_STATUSLIST);
+				ListView_DeleteAllItems(hList);
+
+				int flags = 0;
+				if (!bSettingSame)
+					flags = CallProtoService(setting->szName, PS_GETCAPS, PFLAGNUM_2, 0)&~CallProtoService(setting->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_5, 0);
+
+				LVITEM lvItem = { 0 };
+				lvItem.mask = LVIF_TEXT | LVIF_PARAM;
+				lvItem.iItem = 0;
+				lvItem.iSubItem = 0;
+				for (int i = 0; i < _countof(statusModeList); i++) {
+					if ((flags & statusModePf2List[i]) || (statusModePf2List[i] == PF2_OFFLINE) || (bSettingSame)) {
+						lvItem.pszText = pcli->pfnGetStatusModeDescription(statusModeList[i], 0);
+						lvItem.lParam = (LPARAM)statusModePf2List[i];
+						ListView_InsertItem(hList, &lvItem);
+						ListView_SetCheckState(hList, lvItem.iItem, setting->statusFlags & statusModePf2List[i] ? TRUE : FALSE);
+						lvItem.iItem++;
+					}
+				}
+			}
+			init = FALSE;
+			// status dropdown boxes
+			{
+				int flags = 0;
+				if (!bSettingSame)
+					flags = CallProtoService(setting->szName, PS_GETCAPS, PFLAGNUM_2, 0)&~CallProtoService(setting->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_5, 0);
+
+				// clear box and add new status, loop status and check if compatible with proto
+				SendDlgItemMessage(hwndDlg, IDC_LV1STATUS, CB_RESETCONTENT, 0, 0);
+				SendDlgItemMessage(hwndDlg, IDC_LV2STATUS, CB_RESETCONTENT, 0, 0);
+				for (int i=0; i < _countof(statusModeList); i++) {
+					if ((flags & statusModePf2List[i]) || statusModePf2List[i] == PF2_OFFLINE || bSettingSame) {
+						wchar_t *statusMode = pcli->pfnGetStatusModeDescription(statusModeList[i], 0);
+						int item = SendDlgItemMessage(hwndDlg, IDC_LV1STATUS, CB_ADDSTRING, 0, (LPARAM)statusMode);
+						SendDlgItemMessage(hwndDlg, IDC_LV1STATUS, CB_SETITEMDATA, item, (LPARAM)statusModeList[i]);
+						item = SendDlgItemMessage(hwndDlg, IDC_LV2STATUS, CB_ADDSTRING, 0, (LPARAM)statusMode);
+						SendDlgItemMessage(hwndDlg, IDC_LV2STATUS, CB_SETITEMDATA, item, (LPARAM)statusModeList[i]);
+						if (statusModeList[i] == setting->lv1Status) {
+							SendDlgItemMessage(hwndDlg, IDC_LV1STATUS, CB_SETCURSEL, (WPARAM)item, 0);
+							SetDlgItemText(hwndDlg, IDC_SETNASTR, CMStringW(FORMAT, TranslateT("minutes of %s mode"), statusMode));
+						}
+						if (statusModeList[i] == setting->lv2Status)
+							SendDlgItemMessage(hwndDlg, IDC_LV2STATUS, CB_SETCURSEL, (WPARAM)item, 0);
+					}
+				}
+			}
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_LV1STATUS:
+			if (HIWORD(wParam) == CBN_SELCHANGE)
+				SendMessage(GetParent(hwndDlg),PSM_CHANGED,0,0);
+
+			setting->lv1Status = (int)SendDlgItemMessage(hwndDlg, IDC_LV1STATUS, CB_GETITEMDATA, SendDlgItemMessage(hwndDlg, IDC_LV1STATUS, CB_GETCURSEL, 0, 0), 0);
+			SetDlgItemText(hwndDlg, IDC_SETNASTR, CMStringW(FORMAT, TranslateT("minutes of %s mode"), pcli->pfnGetStatusModeDescription(setting->lv1Status, 0)));
+			break;
+
+		case IDC_LV2STATUS:
+			if (HIWORD(wParam) == CBN_SELCHANGE)
+				SendMessage(GetParent(hwndDlg),PSM_CHANGED,0,0);
+
+			setting->lv2Status = (int)SendDlgItemMessage(hwndDlg, IDC_LV2STATUS, CB_GETITEMDATA, SendDlgItemMessage(hwndDlg, IDC_LV2STATUS, CB_GETCURSEL, 0, 0), 0);
+			break;
+
+		case IDC_FULLSCREEN:
+			setting->optionFlags ^= FLAG_FULLSCREEN;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_SCREENSAVE:
+			setting->optionFlags ^= FLAG_ONSAVER;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_ONLOCK:
+			setting->optionFlags ^= FLAG_ONLOCK;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_TIMED:
+			setting->optionFlags ^= FLAG_ONMOUSE;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_SETNA:
+			setting->optionFlags ^= FLAG_SETNA;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_AWAYTIME:
+			setting->awayTime = GetDlgItemInt(hwndDlg,IDC_AWAYTIME, NULL, FALSE);
+			break;
+
+		case IDC_NATIME:
+			setting->naTime = GetDlgItemInt(hwndDlg,IDC_NATIME, NULL, FALSE);
+			break;
+
+		case IDC_LV2ONINACTIVE:
+			setting->optionFlags^=FLAG_LV2ONINACTIVE;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_CONFIRM:
+			setting->optionFlags^=FLAG_CONFIRM;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_RESETSTATUS:
+			setting->optionFlags^=FLAG_RESET;
+			SetDialogItems(hwndDlg, setting);
+			break;
+
+		case IDC_MONITORMIRANDA:
+			setting->optionFlags^=FLAG_MONITORMIRANDA;
+			SetDialogItems(hwndDlg, setting);
+			break;
+		}
+		break;
+
+	case WM_SHOWWINDOW:
+		init = TRUE;
+
+		if (setting = GetSetting(hwndDlg, sameSetting))
+			SetDialogItems(hwndDlg, setting);
+
+		SendMessage(hwndDlg, WM_COMMAND, (WPARAM)IDC_PROTOCOL, (LPARAM)0x11111111);
+		init = FALSE;
+		break;
+
+	case WM_NOTIFY:
+		switch(((NMHDR*)lParam)->idFrom) {
+		case IDC_STATUSLIST:
+			if (init)
+				break;
+
+			switch(((NMHDR*)lParam)->code) {
+			case LVN_ITEMCHANGED:
+				NMLISTVIEW *nmlv = (NMLISTVIEW*)lParam;
+				if (IsWindowVisible(GetDlgItem(hwndDlg, IDC_STATUSLIST)) && ((nmlv->uNewState ^ nmlv->uOldState) & LVIS_STATEIMAGEMASK)) {
+					SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+
+					if (setting = GetSetting(hwndDlg, sameSetting)) {
+						HWND hList = GetDlgItem(hwndDlg, IDC_STATUSLIST);
+						LVITEM lvItem = { 0 };
+						lvItem.mask = LVIF_PARAM;
+						lvItem.iItem = nmlv->iItem;
+						ListView_GetItem(hList, &lvItem);
+						int pf2Status = lvItem.lParam;
+						if (ListView_GetCheckState(hList, lvItem.iItem))
+							setting->statusFlags |= pf2Status;
+						else
+							setting->statusFlags &= ~pf2Status;
+					}
+				}
+				break;
+			}
+			break;
+		}
+
+		switch (((LPNMHDR)lParam)->code) {
+		case PSN_APPLY:
+			if (bSettingSame)
+				WriteAutoAwaySetting(*sameSetting, SETTING_ALL);
+			else {
+				for (int i=0; i < optionSettings.getCount(); i++ )
+					WriteAutoAwaySetting(optionSettings[i], optionSettings[i].szName);
+			}
+			LoadOptions(autoAwaySettings, FALSE);
+		}
+		break;
+
+	case WM_DESTROY:
+		optionSettings.destroy();
+		free(sameSetting);
+		break;
+	}
+	return FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// General options window procedure
+
+static INT_PTR CALLBACK DlgProcAutoAwayGeneralOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch (msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+		CheckDlgButton(hwndDlg, IDC_IGNLOCK, db_get_b(NULL, AAAMODULENAME, SETTING_IGNLOCK, FALSE) != 0 ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_IGNSYSKEYS, db_get_b(NULL, AAAMODULENAME, SETTING_IGNSYSKEYS, FALSE) != 0 ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_IGNALTCOMBO, db_get_b(NULL, AAAMODULENAME, SETTING_IGNALTCOMBO, FALSE) != 0 ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_MONITORMOUSE, db_get_b(NULL, AAAMODULENAME, SETTING_MONITORMOUSE, BST_CHECKED) != 0 ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_MONITORKEYBOARD, db_get_b(NULL, AAAMODULENAME, SETTING_MONITORKEYBOARD, BST_CHECKED) != 0 ? BST_CHECKED : BST_UNCHECKED);
+		SetDlgItemInt(hwndDlg, IDC_AWAYCHECKTIMEINSECS, db_get_w(NULL, AAAMODULENAME, SETTING_AWAYCHECKTIMEINSECS, 5), FALSE);
+		SetDlgItemInt(hwndDlg, IDC_CONFIRMDELAY, db_get_w(NULL, AAAMODULENAME, SETTING_CONFIRMDELAY, 5), FALSE);
+		CheckDlgButton(hwndDlg, bSettingSame ? IDC_SAMESETTINGS : IDC_PERPROTOCOLSETTINGS, BST_CHECKED);
+		ShowWindow(GetDlgItem(hwndDlg, IDC_IDLEWARNING), db_get_b(NULL, "Idle", "AAEnable", 0));
+		break;
+
+	case WM_SHOWWINDOW:
+		ShowWindow(GetDlgItem(hwndDlg, IDC_IDLEWARNING), (db_get_b(NULL, "Idle", "AAEnable", 0)));
+		break;
+	
+	case WM_COMMAND:
+		if (( HIWORD(wParam) == EN_CHANGE || HIWORD(wParam) == BN_CLICKED ) && (HWND)lParam == GetFocus())
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+
+		switch(LOWORD(wParam)) {
+		case IDC_MONITORMOUSE:
+			CheckDlgButton(hwndDlg, IDC_MONITORMOUSE, (((BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_MONITORMOUSE))&&(BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_MONITORKEYBOARD)))||(IsDlgButtonChecked(hwndDlg, IDC_MONITORMOUSE)) ? BST_CHECKED : BST_UNCHECKED));
+			break;
+
+		case IDC_MONITORKEYBOARD:
+			CheckDlgButton(hwndDlg, IDC_MONITORKEYBOARD, (((BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_MONITORMOUSE))&&(BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_MONITORKEYBOARD)))||(IsDlgButtonChecked(hwndDlg, IDC_MONITORKEYBOARD)) ? BST_CHECKED : BST_UNCHECKED));
+			break;
+
+		case IDC_SAMESETTINGS:
+		case IDC_PERPROTOCOLSETTINGS:
+			bSettingSame = IsDlgButtonChecked(hwndDlg, IDC_SAMESETTINGS);
+			break;
+		}
+		break;
+
+	case WM_NOTIFY:
+		if (((LPNMHDR)lParam)->code == PSN_APPLY ) {
+			db_set_b(NULL, AAAMODULENAME, SETTING_IGNLOCK, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_IGNLOCK));
+			db_set_b(NULL, AAAMODULENAME, SETTING_IGNSYSKEYS, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_IGNSYSKEYS));
+			db_set_b(NULL, AAAMODULENAME, SETTING_IGNALTCOMBO, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_IGNALTCOMBO));
+			db_set_b(NULL, AAAMODULENAME, SETTING_SAMESETTINGS, (BYTE)bSettingSame);
+			db_set_w(NULL, AAAMODULENAME, SETTING_AWAYCHECKTIMEINSECS, (WORD)GetDlgItemInt(hwndDlg, IDC_AWAYCHECKTIMEINSECS, NULL, FALSE));
+			db_set_w(NULL, AAAMODULENAME, SETTING_CONFIRMDELAY, (WORD)GetDlgItemInt(hwndDlg, IDC_CONFIRMDELAY, NULL, FALSE));
+			db_set_b(NULL, AAAMODULENAME, SETTING_MONITORMOUSE, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_MONITORMOUSE));
+			db_set_b(NULL, AAAMODULENAME, SETTING_MONITORKEYBOARD, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_MONITORKEYBOARD));
+			LoadOptions(autoAwaySettings, FALSE);
+		}
+		break;
+	}
+	return FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Tab window procedure
+
+static INT_PTR CALLBACK DlgProcAutoAwayTabs(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch(msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+		{
+			RECT rcTabs, rcOptions, rcPage;
+			bSettingSame = db_get_b(NULL, AAAMODULENAME, SETTING_SAMESETTINGS, FALSE);
+
+			// set tabs
+			int tabCount = 0;
+			HWND hTab = GetDlgItem(hwndDlg, IDC_TABS);
+			GetWindowRect(hTab, &rcTabs);
+			GetWindowRect(hwndDlg, &rcOptions);
+
+			// general tab
+			TCITEM tci = { 0 };
+			tci.mask = TCIF_TEXT | TCIF_PARAM;
+			tci.pszText = TranslateT("General");
+			HWND hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_OPT_GENAUTOAWAY), hwndDlg, DlgProcAutoAwayGeneralOpts, (LPARAM)GetParent(hwndDlg));
+			EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
+
+			tci.lParam = (LPARAM)hPage;
+			GetClientRect(hPage, &rcPage);
+			MoveWindow(hPage, (rcTabs.left - rcOptions.left) + ((rcTabs.right-rcTabs.left)-(rcPage.right-rcPage.left))/2, 10 + (rcTabs.top - rcOptions.top) + ((rcTabs.bottom-rcTabs.top)-(rcPage.bottom-rcPage.top))/2, rcPage.right-rcPage.left, rcPage.bottom-rcPage.top, TRUE);
+			ShowWindow(hPage, SW_HIDE);
+			TabCtrl_InsertItem(hTab, tabCount++, &tci);
+			HWND hShow = hPage;
+
+			// rules tab
+			tci.mask = TCIF_TEXT|TCIF_PARAM;
+			tci.pszText = TranslateT("Rules");
+			hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_OPT_AUTOAWAY), hwndDlg, DlgProcAutoAwayRulesOpts, (LPARAM)GetParent(hwndDlg));
+			EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
+
+			tci.lParam = (LPARAM)hPage;
+			GetClientRect(hPage, &rcPage);
+			MoveWindow(hPage, (rcTabs.left - rcOptions.left) + ((rcTabs.right-rcTabs.left)-(rcPage.right-rcPage.left))/2, 10 + (rcTabs.top - rcOptions.top) + ((rcTabs.bottom-rcTabs.top)-(rcPage.bottom-rcPage.top))/2, rcPage.right-rcPage.left, rcPage.bottom-rcPage.top, TRUE);
+			ShowWindow(hPage, SW_HIDE);
+			TabCtrl_InsertItem(hTab, tabCount++, &tci);
+
+			// messages tab
+			tci.mask = TCIF_TEXT|TCIF_PARAM;
+			tci.pszText = TranslateT("Status messages");
+			hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_OPT_AUTOAWAYMSG), hwndDlg, DlgProcAutoAwayMsgOpts, (LPARAM)GetParent(hwndDlg));
+			EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
+
+			tci.lParam = (LPARAM)hPage;
+			GetClientRect(hPage, &rcPage);
+			MoveWindow(hPage, (rcTabs.left - rcOptions.left) + ((rcTabs.right-rcTabs.left)-(rcPage.right-rcPage.left))/2, 10 + (rcTabs.top - rcOptions.top) + ((rcTabs.bottom-rcTabs.top)-(rcPage.bottom-rcPage.top))/2, rcPage.right-rcPage.left, rcPage.bottom-rcPage.top, TRUE);
+			ShowWindow(hPage, SW_HIDE);
+			TabCtrl_InsertItem(hTab, tabCount++, &tci);
+
+			ShowWindow(hShow, SW_SHOW);			
+		}
+		break;
+
+	case PSM_CHANGED:
+		SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+		break;
+
+	case WM_NOTIFY:
+		if ((((NMHDR*)lParam)->idFrom == IDC_TABS)) {
+			if (((NMHDR*)lParam)->code == TCN_SELCHANGING) {
+				TCITEM tci;
+
+				tci.mask = TCIF_PARAM;
+				TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_TABS)), &tci);
+				ShowWindow((HWND)tci.lParam, SW_HIDE);
+			}
+			else if (((NMHDR*)lParam)->code == TCN_SELCHANGE) {
+				TCITEM tci;
+
+				tci.mask = TCIF_PARAM;
+				TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_TABS)), &tci);
+				ShowWindow((HWND)tci.lParam, SW_SHOW);
+			}
+		}
+		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
+			TCITEM tci;
+			tci.mask = TCIF_PARAM;
+			int count = TabCtrl_GetItemCount(GetDlgItem(hwndDlg, IDC_TABS));
+			for (int i = 0; i < count; i++) {
+				TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), i, &tci);
+				SendMessage((HWND)tci.lParam, WM_NOTIFY, 0, lParam);
+			}
+		}
+		break;
+	}
+
+	return FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Options initialization procedure
+
+int AutoAwayOptInitialise(WPARAM wParam,LPARAM lParam)
+{
+	OPTIONSDIALOGPAGE odp = { 0 };
+	odp.position = 1000000000;
+	odp.hInstance = hInst;
+	odp.pszTemplate = MAKEINTRESOURCEA(IDD_OPT_TABS);
+	odp.pszTitle = LPGEN("Auto Away");
+	odp.pszGroup = LPGEN("Status");
+	odp.pfnDlgProc = DlgProcAutoAwayTabs;
+	odp.flags = ODPF_BOLDGROUPS;
+	Options_AddPage(wParam, &odp);
+	return 0;
+}
diff --git a/plugins/StatusManager/src/advancedautoaway.cpp b/plugins/StatusManager/src/advancedautoaway.cpp
new file mode 100644
index 0000000000..3c4e58efd4
--- /dev/null
+++ b/plugins/StatusManager/src/advancedautoaway.cpp
@@ -0,0 +1,590 @@
+/*
+    AdvancedAutoAway Plugin for Miranda-IM (www.miranda-im.org)
+    Copyright 2003-2006 P. Boon
+
+    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; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	
+	Some code is copied from Miranda's AutoAway module
+*/
+
+#include "stdafx.h"
+
+#ifdef _DEBUG
+	#define SECS_PER_MINUTE		20 /* speedup */
+#else
+	#define SECS_PER_MINUTE		60 /* default I believe */
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+int CompareSettings(const TAAAProtoSetting *p1, const TAAAProtoSetting *p2)
+{
+	return mir_strcmp(p1->szName, p2->szName);
+}
+
+TAAAProtoSettingList autoAwaySettings(10, CompareSettings);
+
+TAAAProtoSetting::TAAAProtoSetting(PROTOACCOUNT *pa)
+{
+	cbSize = sizeof(PROTOCOLSETTINGEX);
+	szName = pa->szModuleName;
+	tszAccName = pa->tszAccountName;
+	lastStatus = status = originalStatusMode = ID_STATUS_CURRENT;
+	szMsg = NULL;
+	curState = ACTIVE;
+	mStatus = FALSE;
+}
+
+TAAAProtoSetting::~TAAAProtoSetting()
+{
+	free(szMsg);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+extern HANDLE hStateChangedEvent;
+
+static BOOL ignoreLockKeys = FALSE;
+static BOOL ignoreSysKeys = FALSE;
+static BOOL ignoreAltCombo = FALSE;
+static BOOL monitorMouse = TRUE;
+static BOOL monitorKeyboard = TRUE;
+static HWND confirmDialog;
+static int mouseStationaryTimer;
+HHOOK hMirandaMouseHook = NULL;
+HHOOK hMirandaKeyBoardHook = NULL;
+#pragma data_seg("Shared")
+DWORD lastInput = 0;
+POINT lastMousePos = {0};
+HHOOK hMouseHook = NULL;
+HHOOK hKeyBoardHook = NULL;
+#pragma data_seg()
+#pragma comment(linker, "/section:Shared,rws")
+DWORD lastMirandaInput = 0;
+static UINT_PTR hAutoAwayTimer;
+// prototypes
+extern DWORD StatusModeToProtoFlag(int status);
+static int HookWindowsHooks(int hookMiranda, int hookAll);
+static int UnhookWindowsHooks();
+static LRESULT CALLBACK MouseHookFunction(int code, WPARAM wParam, LPARAM lParam);
+static LRESULT CALLBACK KeyBoardHookFunction(int code, WPARAM wParam, LPARAM lParam);
+static LRESULT CALLBACK MirandaMouseHookFunction(int code, WPARAM wParam, LPARAM lParam);
+static LRESULT CALLBACK MirandaKeyBoardHookFunction(int code, WPARAM wParam, LPARAM lParam);
+BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved);
+
+static VOID CALLBACK AutoAwayTimer(HWND hwnd,UINT message,UINT_PTR idEvent,DWORD dwTime);
+extern int AutoAwayOptInitialise(WPARAM wParam,LPARAM lParam);
+extern int AutoAwayMsgOptInitialise(WPARAM wParam,LPARAM lParam);
+extern int SetStatus(WPARAM wParam, LPARAM lParam);
+extern int ShowConfirmDialog(WPARAM wParam, LPARAM lParam);
+extern char *StatusModeToDbSetting(int status,const char *suffix);
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Load from DB
+
+void LoadOptions(TAAAProtoSettingList &loadSettings, BOOL override)
+{
+	// if override is enabled, samesettings will be ignored (for options loading)
+	int monitorMiranda = FALSE; // use windows hooks?
+	int monitorAll = FALSE; // use windows hooks?
+
+	if (!override)
+		UnhookWindowsHooks();
+	if (hAutoAwayTimer != 0)
+		KillTimer(NULL, hAutoAwayTimer);
+
+	ignoreLockKeys = db_get_b(NULL, AAAMODULENAME, SETTING_IGNLOCK, FALSE);
+	ignoreSysKeys = db_get_b(NULL, AAAMODULENAME, SETTING_IGNSYSKEYS, FALSE);
+	ignoreAltCombo = db_get_b(NULL, AAAMODULENAME, SETTING_IGNALTCOMBO, FALSE);
+	monitorMouse = db_get_b(NULL, AAAMODULENAME, SETTING_MONITORMOUSE, TRUE);
+	monitorKeyboard = db_get_b(NULL, AAAMODULENAME, SETTING_MONITORKEYBOARD, TRUE);
+	lastInput = lastMirandaInput = GetTickCount();
+
+	for (int i = 0; i < loadSettings.getCount(); i++) {
+		char* protoName;
+		if ((db_get_b(NULL, AAAMODULENAME, SETTING_SAMESETTINGS, 0)) && !override)
+			protoName = SETTING_ALL;
+		else
+			protoName = loadSettings[i].szName;
+		LoadAutoAwaySetting(loadSettings[i], protoName);
+		if (!override) {
+			if (loadSettings[i].optionFlags & FLAG_MONITORMIRANDA)
+				monitorMiranda = TRUE;
+			else if (ignoreLockKeys || ignoreSysKeys || ignoreAltCombo || (monitorMouse != monitorKeyboard))
+				monitorAll = TRUE;
+		}
+	}
+
+	if (db_get_b(NULL, "Idle", "AAEnable", 0))
+		return;
+
+	HookWindowsHooks(monitorMiranda, monitorAll);
+	hAutoAwayTimer = SetTimer(NULL, 0, db_get_w(NULL, AAAMODULENAME, SETTING_AWAYCHECKTIMEINSECS, 5) * 1000, AutoAwayTimer);
+}
+
+int LoadAutoAwaySetting(TAAAProtoSetting &autoAwaySetting, char* protoName)
+{
+	char setting[128];
+	mir_snprintf(setting, "%s_OptionFlags", protoName);
+	autoAwaySetting.optionFlags = db_get_w(NULL, AAAMODULENAME, setting, FLAG_LV2ONINACTIVE | FLAG_RESET);
+	mir_snprintf(setting, "%s_AwayTime", protoName);
+	autoAwaySetting.awayTime = db_get_w(NULL, AAAMODULENAME, setting, SETTING_AWAYTIME_DEFAULT);
+	mir_snprintf(setting, "%s_NATime", protoName);
+	autoAwaySetting.naTime = db_get_w(NULL, AAAMODULENAME, setting, SETTING_NATIME_DEFAULT);
+	mir_snprintf(setting, "%s_StatusFlags", protoName);
+	autoAwaySetting.statusFlags = db_get_w(NULL, AAAMODULENAME, setting, StatusModeToProtoFlag(ID_STATUS_ONLINE) | StatusModeToProtoFlag(ID_STATUS_FREECHAT));
+
+	int flags;
+	if (db_get_b(NULL, AAAMODULENAME, SETTING_SAMESETTINGS, 0))
+		flags = 0xFFFFFF;
+	else
+		flags = CallProtoService(protoName, PS_GETCAPS, PFLAGNUM_2, 0)&~CallProtoService(protoName, PS_GETCAPS, (WPARAM)PFLAGNUM_5, 0);
+	mir_snprintf(setting, "%s_Lv1Status", protoName);
+	autoAwaySetting.lv1Status = db_get_w(NULL, AAAMODULENAME, setting, (flags&StatusModeToProtoFlag(ID_STATUS_AWAY)) ? ID_STATUS_AWAY : ID_STATUS_OFFLINE);
+	mir_snprintf(setting, "%s_Lv2Status", protoName);
+	autoAwaySetting.lv2Status = db_get_w(NULL, AAAMODULENAME, setting, (flags&StatusModeToProtoFlag(ID_STATUS_NA)) ? ID_STATUS_NA : ID_STATUS_OFFLINE);
+
+	return 0;
+}
+
+static int ProcessProtoAck(WPARAM wParam, LPARAM lParam)
+{
+	ACKDATA *ack = (ACKDATA*)lParam;
+	if (ack->type != ACKTYPE_STATUS || ack->result != ACKRESULT_SUCCESS)
+		return 0;
+
+	log_debugA("ProcessProtoAck: ack->szModule: %s", ack->szModule);
+	for (int i = 0; i < autoAwaySettings.getCount(); i++) {
+		TAAAProtoSetting &p = autoAwaySettings[i];
+		log_debugA("chk: %s", p.szName);
+		if (!mir_strcmp(p.szName, ack->szModule)) {
+			log_debugA("ack->szModule: %s p.statusChanged: %d", ack->szModule, p.statusChanged);
+			if (!p.statusChanged)
+				p.mStatus = TRUE;
+
+			p.statusChanged = FALSE;
+		}
+	}
+
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Account control event
+
+int OnAAAAccChanged(WPARAM wParam, LPARAM lParam)
+{
+	PROTOACCOUNT *pa = (PROTOACCOUNT*)lParam;
+	switch (wParam) {
+	case PRAC_ADDED:
+		autoAwaySettings.insert(new TAAAProtoSetting(pa));
+		break;
+
+	case PRAC_REMOVED:
+		for (int i = 0; i < autoAwaySettings.getCount(); i++) {
+			if (!mir_strcmp(autoAwaySettings[i].szName, pa->szModuleName)) {
+				autoAwaySettings.remove(i);
+				break;
+			}
+		}
+		break;
+	}
+
+	return 0;
+}
+
+static char* status2descr(int status)
+{
+	switch (status) {
+		case ACTIVE:        return "ACTIVE";
+		case STATUS1_SET:   return "STATUS1_SET";
+		case STATUS2_SET:   return "STATUS2_SET";
+		case SET_ORGSTATUS: return "SET_ORGSTATUS";
+		case HIDDEN_ACTIVE: return "HIDDEN_ACTIVE";
+	}
+	return "ERROR";
+}
+
+static int changeState(TAAAProtoSetting &setting, STATES newState)
+{
+	if (setting.curState == newState)
+		return 0;
+
+	setting.oldState = setting.curState;
+	setting.curState = newState;
+
+	log_debugA("%s state change: %s -> %s", setting.szName, status2descr(setting.oldState), status2descr(setting.curState));
+
+	NotifyEventHooks(hStateChangedEvent, 0, (LPARAM)&setting);
+	if (setting.curState != SET_ORGSTATUS && setting.curState != ACTIVE && setting.statusChanged) {
+		/* change the awaymessage */
+		if (setting.szMsg != NULL) {
+			free(setting.szMsg);
+			setting.szMsg = NULL;
+		}
+
+		if (db_get_b(NULL, AAAMODULENAME, StatusModeToDbSetting(setting.status, SETTING_MSGCUSTOM), FALSE)) {
+			DBVARIANT dbv;
+			if (!db_get_ws(NULL, AAAMODULENAME, StatusModeToDbSetting(setting.status, SETTING_STATUSMSG), &dbv)) {
+				setting.szMsg = wcsdup(dbv.ptszVal);
+				db_free(&dbv);
+			}
+		}
+	}
+	else if (setting.szMsg != NULL) {
+		free(setting.szMsg);
+		setting.szMsg = NULL;
+	}
+
+	return 0;
+}
+
+static VOID CALLBACK AutoAwayTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime)
+{
+	int statusChanged = FALSE;
+	int confirm = FALSE;
+
+	for (int i = 0; i < autoAwaySettings.getCount(); i++) {
+		TAAAProtoSetting& aas = autoAwaySettings[i];
+		aas.status = ID_STATUS_DISABLED;
+
+		BOOL bTrigger = false;
+
+		if (aas.optionFlags & FLAG_MONITORMIRANDA)
+			mouseStationaryTimer = (GetTickCount() - lastMirandaInput) / 1000;
+		else {
+			LASTINPUTINFO ii = { sizeof(ii) };
+			GetLastInputInfo(&ii);
+			mouseStationaryTimer = (GetTickCount() - ii.dwTime) / 1000;
+		}
+
+		int sts1Time = aas.awayTime * SECS_PER_MINUTE;
+		int sts2Time = aas.naTime * SECS_PER_MINUTE;
+		int sts1setTime = aas.sts1setTimer == 0 ? 0 : (GetTickCount() - aas.sts1setTimer) / 1000;
+		int currentMode = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+
+		if (aas.optionFlags & FLAG_ONSAVER)
+			bTrigger |= IsScreenSaverRunning();
+		if (aas.optionFlags & FLAG_ONLOCK)
+			bTrigger |= IsWorkstationLocked();
+		if (aas.optionFlags & FLAG_FULLSCREEN)
+			bTrigger |= IsFullScreen();
+
+		/* check states */
+		if (aas.curState == ACTIVE) {
+			if (((mouseStationaryTimer >= sts1Time && (aas.optionFlags & FLAG_ONMOUSE)) || bTrigger) && currentMode != aas.lv1Status && aas.statusFlags&StatusModeToProtoFlag(currentMode)) {
+				/* from ACTIVE to STATUS1_SET */
+				aas.lastStatus = aas.originalStatusMode = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+				aas.status = aas.lv1Status;
+				aas.sts1setTimer = GetTickCount();
+				sts1setTime = 0;
+				aas.statusChanged = statusChanged = TRUE;
+				changeState(aas, STATUS1_SET);
+			}
+			else if (mouseStationaryTimer >= sts2Time && currentMode == aas.lv1Status && currentMode != aas.lv2Status && (aas.optionFlags & FLAG_SETNA) && (aas.statusFlags & StatusModeToProtoFlag(currentMode))) {
+				/* from ACTIVE to STATUS2_SET */
+				aas.lastStatus = aas.originalStatusMode = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+				aas.status = aas.lv2Status;
+				aas.statusChanged = statusChanged = TRUE;
+				changeState(aas, STATUS2_SET);
+			}
+		}
+
+		if (aas.curState == STATUS1_SET) {
+			if ((mouseStationaryTimer < sts1Time && !bTrigger) && !(aas.optionFlags & FLAG_RESET)) {
+				/* from STATUS1_SET to HIDDEN_ACTIVE */
+				changeState(aas, HIDDEN_ACTIVE);
+				aas.lastStatus = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+			}
+			else if (((mouseStationaryTimer < sts1Time) && !bTrigger) &&
+						((aas.optionFlags & FLAG_LV2ONINACTIVE) || (!(aas.optionFlags&FLAG_SETNA))) &&
+						(aas.optionFlags & FLAG_RESET)) {
+				/* from STATUS1_SET to SET_ORGSTATUS */
+				changeState(aas, SET_ORGSTATUS);
+			}
+			else if ((aas.optionFlags & FLAG_SETNA) && sts1setTime >= sts2Time) {
+				/* when set STATUS2, currentMode doesn't have to be in the selected status list (statusFlags) */
+				/* from STATUS1_SET to STATUS2_SET */
+				aas.lastStatus = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+				aas.status = aas.lv2Status;
+				aas.statusChanged = statusChanged = TRUE;
+				changeState(aas, STATUS2_SET);
+			}
+		}
+
+		if (aas.curState == STATUS2_SET) {
+			if (mouseStationaryTimer < sts2Time && !bTrigger && (aas.optionFlags & FLAG_RESET)) {
+				/* from STATUS2_SET to SET_ORGSTATUS */
+				changeState(aas, SET_ORGSTATUS);
+			}
+			else if (mouseStationaryTimer < sts2Time && !bTrigger && !(aas.optionFlags & FLAG_RESET)) {
+				/* from STATUS2_SET to HIDDEN_ACTIVE */
+				/* Remember: after status1 is set, and "only on inactive" is NOT set, it implies !reset. */
+				changeState(aas, HIDDEN_ACTIVE);
+				aas.lastStatus = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+			}
+		}
+
+		if (aas.curState == HIDDEN_ACTIVE) {
+			if (aas.mStatus) {
+				/* HIDDEN_ACTIVE to ACTIVE */
+				//aas.statusChanged = FALSE;
+				changeState(aas, ACTIVE);
+				aas.sts1setTimer = 0;
+				aas.mStatus = FALSE;
+			}
+			else if ((aas.optionFlags & FLAG_SETNA) && currentMode == aas.lv1Status &&
+						currentMode != aas.lv2Status && (aas.statusFlags & StatusModeToProtoFlag(currentMode)) &&
+						(mouseStationaryTimer >= sts2Time || (sts1setTime >= sts2Time && !(aas.optionFlags & FLAG_LV2ONINACTIVE)))) {
+				/* HIDDEN_ACTIVE to STATUS2_SET */
+				aas.lastStatus = aas.originalStatusMode = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+				aas.status = aas.lv2Status;
+				aas.statusChanged = statusChanged = TRUE;
+				changeState(aas, STATUS2_SET);
+			}
+		}
+		if (aas.curState == SET_ORGSTATUS) {
+			/* SET_ORGSTATUS to ACTIVE */
+			aas.lastStatus = CallProtoService(aas.szName, PS_GETSTATUS, 0, 0);
+			aas.status = aas.originalStatusMode;
+			confirm = (aas.optionFlags&FLAG_CONFIRM) ? TRUE : confirm;
+			aas.statusChanged = statusChanged = TRUE;
+			changeState(aas, ACTIVE);
+			aas.sts1setTimer = 0;
+		}
+		autoAwaySettings[i].mStatus = FALSE;
+	}
+
+	if (confirm || statusChanged) {
+		TAAAProtoSettingList ps = autoAwaySettings;
+		for (int i = 0; i < ps.getCount(); i++) {
+			if (ps[i].szMsg)
+				ps[i].szMsg = wcsdup(ps[i].szMsg);
+
+			if (ps[i].status == ID_STATUS_DISABLED)
+				ps[i].szName = "";
+		}
+
+		if (confirm)
+			confirmDialog = (HWND)CallService(MS_CS_SHOWCONFIRMDLGEX, (WPARAM)&ps, db_get_w(NULL, AAAMODULENAME, SETTING_CONFIRMDELAY, 5));
+		else if (statusChanged)
+			CallService(MS_CS_SETSTATUSEX, (WPARAM)&ps, 0);
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Windows hooks 
+
+static int HookWindowsHooks(int hookMiranda, int hookAll)
+{
+	if (hookMiranda) {
+		if (monitorKeyboard && hMirandaKeyBoardHook == NULL)
+			hMirandaKeyBoardHook = SetWindowsHookEx(WH_KEYBOARD, MirandaKeyBoardHookFunction, NULL, GetCurrentThreadId());
+		if (monitorMouse && hMirandaMouseHook == NULL)
+			hMirandaMouseHook = SetWindowsHookEx(WH_MOUSE, MirandaMouseHookFunction, NULL, GetCurrentThreadId());
+	}
+	if (hookAll) {
+		if (monitorKeyboard && hKeyBoardHook == NULL)
+			hKeyBoardHook = SetWindowsHookEx(WH_KEYBOARD, KeyBoardHookFunction, 0, GetCurrentThreadId());
+		if (monitorMouse && hMouseHook == NULL)
+			hMouseHook = SetWindowsHookEx(WH_MOUSE, MouseHookFunction, 0, GetCurrentThreadId());
+	}
+
+	return 0;
+}
+
+static int UnhookWindowsHooks()
+{
+	UnhookWindowsHookEx(hMouseHook);
+	UnhookWindowsHookEx(hKeyBoardHook);
+	UnhookWindowsHookEx(hMirandaMouseHook);
+	UnhookWindowsHookEx(hMirandaKeyBoardHook);
+
+	hMouseHook = hKeyBoardHook = hMirandaMouseHook = hMirandaKeyBoardHook = NULL;
+	return 0;
+}
+
+static LRESULT CALLBACK MirandaMouseHookFunction(int code, WPARAM wParam, LPARAM lParam)
+{
+	if (code >= 0) {
+		PMOUSEHOOKSTRUCT mouseInfo = (PMOUSEHOOKSTRUCT)lParam;
+		POINT pt = mouseInfo->pt;
+
+		/* TioDuke's KeyBoardNotifyExt: only update if a Miranda window is focused */
+		DWORD pid;
+		GetWindowThreadProcessId(GetForegroundWindow(), &pid);
+		if (pid != GetCurrentProcessId())
+			return CallNextHookEx(hMirandaMouseHook, code, wParam, lParam);
+
+		if (pt.x != lastMousePos.x || pt.y != lastMousePos.y) {
+			lastMousePos = pt;
+			lastMirandaInput = GetTickCount();
+		}
+	}
+
+	return CallNextHookEx(hMirandaMouseHook, code, wParam, lParam);
+}
+
+static LRESULT CALLBACK MirandaKeyBoardHookFunction(int code, WPARAM wParam, LPARAM lParam)
+{
+	if (code >= 0) {
+		if (ignoreAltCombo) {
+			if (((GetKeyState(VK_MENU) < 0) || (wParam == VK_MENU)) ||
+				 ((GetKeyState(VK_TAB) < 0) || (wParam == VK_TAB)) ||
+				 ((GetKeyState(VK_SHIFT) < 0) || (wParam == VK_SHIFT)) ||
+				 ((GetKeyState(VK_CONTROL) < 0) || (wParam == VK_CONTROL)) ||
+				 ((GetKeyState(VK_ESCAPE) < 0) || (wParam == VK_ESCAPE)) ||
+				 ((GetKeyState(VK_LWIN) < 0) || (wParam == VK_LWIN)) ||
+				((GetKeyState(VK_RWIN) < 0) || (wParam == VK_RWIN)))
+			{
+				return CallNextHookEx(hMirandaKeyBoardHook, code, wParam, lParam);
+			}
+		}
+
+		switch (wParam) {
+		case VK_NUMLOCK:
+		case VK_CAPITAL:
+		case VK_SCROLL:
+			if (!ignoreLockKeys)
+				lastMirandaInput = GetTickCount();
+			break;
+
+		case VK_TAB:
+		case VK_SHIFT:
+		case VK_CONTROL:
+		case VK_MENU:
+		case VK_ESCAPE:
+		case VK_LWIN:
+		case VK_RWIN:
+			if (!ignoreSysKeys)
+				lastMirandaInput = GetTickCount();
+			break;
+
+		default:
+			lastMirandaInput = GetTickCount();
+			break;
+		}
+	}
+
+	return CallNextHookEx(hMirandaKeyBoardHook, code, wParam, lParam);
+}
+
+static LRESULT CALLBACK MouseHookFunction(int code, WPARAM wParam, LPARAM lParam)
+{
+	if (code >= 0) {
+		PMOUSEHOOKSTRUCT mouseInfo = (PMOUSEHOOKSTRUCT)lParam;
+		POINT pt = mouseInfo->pt;
+
+		/* TioDuke's KeyBoardNotifyExt: also grab clicks */
+		if ((wParam >= WM_NCLBUTTONDOWN && wParam <= WM_NCXBUTTONDBLCLK && wParam != 0x00AA) || (wParam >= WM_LBUTTONDOWN && wParam <= WM_XBUTTONDBLCLK))
+			lastInput = GetTickCount();
+
+		if (pt.x != lastMousePos.x || pt.y != lastMousePos.y) {
+			lastMousePos = pt;
+			lastInput = GetTickCount();
+		}
+	}
+
+	return CallNextHookEx(hMouseHook, code, wParam, lParam);
+}
+
+static LRESULT CALLBACK KeyBoardHookFunction(int code, WPARAM wParam, LPARAM lParam)
+{
+	if (code >= 0) {
+		if (ignoreAltCombo) {
+			if (((GetKeyState(VK_MENU) < 0) || (wParam == VK_MENU)) ||
+				 ((GetKeyState(VK_TAB) < 0) || (wParam == VK_TAB)) ||
+				 ((GetKeyState(VK_SHIFT) < 0) || (wParam == VK_SHIFT)) ||
+				 ((GetKeyState(VK_CONTROL) < 0) || (wParam == VK_CONTROL)) ||
+				 ((GetKeyState(VK_ESCAPE) < 0) || (wParam == VK_ESCAPE)) ||
+				 ((GetKeyState(VK_LWIN) < 0) || (wParam == VK_LWIN)) ||
+				((GetKeyState(VK_RWIN) < 0) || (wParam == VK_RWIN)))
+			{
+				return CallNextHookEx(hKeyBoardHook, code, wParam, lParam);
+			}
+		}
+
+		switch (wParam) {
+		case VK_NUMLOCK:
+		case VK_CAPITAL:
+		case VK_SCROLL:
+			if (!ignoreLockKeys)
+				lastInput = GetTickCount();
+			break;
+
+		case VK_TAB:
+		case VK_SHIFT:
+		case VK_CONTROL:
+		case VK_MENU:
+		case VK_ESCAPE:
+		case VK_LWIN:
+		case VK_RWIN:
+			if (!ignoreSysKeys)
+				lastInput = GetTickCount();
+			break;
+
+		default:
+			lastInput = GetTickCount();
+			break;
+		}
+	}
+
+	return CallNextHookEx(hKeyBoardHook, code, wParam, lParam);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Inits & stuff
+
+static int AutoAwayShutdown(WPARAM wParam, LPARAM lParam)
+{
+	KillTimer(NULL, hAutoAwayTimer);
+
+#ifdef TRIGGERPLUGIN
+	DeInitTrigger();
+#endif
+	UnhookWindowsHooks();
+	DestroyHookableEvent(hStateChangedEvent);
+
+	autoAwaySettings.destroy();
+	return 0;
+}
+
+int AAACSModuleLoaded(WPARAM wParam, LPARAM lParam)
+{
+	HookEvent(ME_PROTO_ACCLISTCHANGED, OnAAAAccChanged);
+	HookEvent(ME_OPT_INITIALISE, AutoAwayOptInitialise);
+	HookEvent(ME_SYSTEM_PRESHUTDOWN, AutoAwayShutdown);
+	HookEvent(ME_PROTO_ACK, ProcessProtoAck);
+	mouseStationaryTimer = 0;
+	lastInput = lastMirandaInput = GetTickCount();
+
+	////////////////////////////////////////////////////////////////////////////////////////
+
+	protoList = (OBJLIST<PROTOCOLSETTINGEX>*)&autoAwaySettings;
+
+	int count;
+	PROTOACCOUNT** protos;
+	Proto_EnumAccounts(&count, &protos);
+
+	for (int i = 0; i < count; i++)
+		if (IsSuitableProto(protos[i]))
+			autoAwaySettings.insert(new TAAAProtoSetting(protos[i]));
+
+	////////////////////////////////////////////////////////////////////////////////////////
+
+	LoadOptions(autoAwaySettings, FALSE);
+	return 0;
+}
diff --git a/plugins/StatusManager/src/advancedautoaway.h b/plugins/StatusManager/src/advancedautoaway.h
new file mode 100644
index 0000000000..a8177c2a77
--- /dev/null
+++ b/plugins/StatusManager/src/advancedautoaway.h
@@ -0,0 +1,90 @@
+/*
+    AdvancedAutoAway Plugin for Miranda-IM (www.miranda-im.org)
+    Copyright 2003-2006 P. Boon
+
+    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; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+#ifndef __ADVANCED_AUTOAWAY_HEADER
+#define __ADVANCED_AUTOAWAY_HEADER
+
+#define AAAMODULENAME        "AdvancedAutoAway"
+#define SETTING_IGNLOCK      "IgnoreLockKeys"
+#define SETTING_IGNSYSKEYS   "IgnoreSysKeys"
+#define SETTING_IGNALTCOMBO  "IgnoreAltCombo"
+#define SETTING_SAMESETTINGS "SameAutoAwaySettings"
+#define SETTING_ALL          "ALLPROTOS"
+#define SETTING_MSGCUSTOM    "Custom"
+#define SETTING_STATUSMSG    "Msg"
+#define SETTING_CONFIRMDELAY "ConfirmTimeout"
+
+#define SETTING_AWAYTIME_DEFAULT 5
+#define SETTING_NATIME_DEFAULT  20
+#define SETTING_AWAYCHECKTIMEINSECS "CheckInterval"
+
+#define STATUS_RESET    1
+#define STATUS_AUTOAWAY 2
+#define STATUS_AUTONA   3
+
+#define SETTING_MONITORMOUSE    "MonitorMouse"
+#define SETTING_MONITORKEYBOARD "MonitorKeyboard"
+
+#define FLAG_ONSAVER        0x0001 // db: set lv1 status on screensaver ?
+#define FLAG_ONMOUSE        0x0002 // db: set after inactivity ?
+#define FLAG_SETNA          0x0004 // db: set NA after xx of away time ?
+#define FLAG_CONFIRM        0x0008 // db: show confirm dialog ?
+#define FLAG_RESET          0x0010 // db: restore status ?
+#define FLAG_LV2ONINACTIVE  0x0020 // db: set lv2 only on inactivity
+#define FLAG_MONITORMIRANDA 0x0040 // db: monitor miranda activity only
+#define FLAG_ONLOCK         0x0080 // db: on work station lock
+#define FLAG_FULLSCREEN     0x0100 // db: on full screen
+
+struct TAAAProtoSetting : public PROTOCOLSETTINGEX, public MZeroedObject
+{
+	TAAAProtoSetting(PROTOACCOUNT *pa);
+	~TAAAProtoSetting();
+
+	int originalStatusMode;
+	STATES
+		oldState,
+		curState;
+	BOOL statusChanged; // AAA changed the status, don't update mStatus
+	BOOL mStatus; // status changed manually or not ?
+	int optionFlags, // db: see above
+		 awayTime, // db: time to wait for inactivity
+		 naTime, // db: time to wait after away is set
+		 statusFlags; // db: set lv1 status if this is original status
+	WORD lv1Status, // db
+		  lv2Status; // db
+	unsigned int sts1setTimer;
+};
+
+struct AAMSGSETTING
+{
+	short useCustom;
+	int   status;
+	char* msg;
+};
+
+extern HINSTANCE hInst;
+
+int CompareSettings( const TAAAProtoSetting *p1, const TAAAProtoSetting *p2 );
+
+typedef OBJLIST<TAAAProtoSetting> TAAAProtoSettingList;
+extern TAAAProtoSettingList autoAwaySettings;
+
+int  LoadAutoAwaySetting(TAAAProtoSetting &autoAwaySetting, char *protoName);
+void LoadOptions(TAAAProtoSettingList &settings, BOOL override);
+
+#endif
diff --git a/plugins/StatusManager/src/commonstatus.cpp b/plugins/StatusManager/src/commonstatus.cpp
new file mode 100644
index 0000000000..1dca15ceff
--- /dev/null
+++ b/plugins/StatusManager/src/commonstatus.cpp
@@ -0,0 +1,328 @@
+/*
+	AdvancedAutoAway Plugin for Miranda-IM (www.miranda-im.org)
+	KeepStatus Plugin for Miranda-IM (www.miranda-im.org)
+	StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+// handles for hooks and other Miranda thingies
+static HANDLE hCSStatusChangedExEvent;
+
+OBJLIST<PROTOCOLSETTINGEX> *protoList;
+
+// prototypes
+char* StatusModeToDbSetting(int status, const char *suffix);
+DWORD StatusModeToProtoFlag(int status);
+INT_PTR SetStatusEx(WPARAM wParam, LPARAM lParam);
+int InitCommonStatus();
+int GetProtoCount();
+
+// extern
+extern INT_PTR ShowConfirmDialogEx(WPARAM wParam, LPARAM lParam);
+
+// some helpers from awaymsg.c ================================================================
+char *StatusModeToDbSetting(int status, const char *suffix)
+{
+	char *prefix;
+	static char str[64];
+
+	switch (status) {
+	case ID_STATUS_AWAY: prefix = "Away";	break;
+	case ID_STATUS_NA: prefix = "Na";	break;
+	case ID_STATUS_DND: prefix = "Dnd"; break;
+	case ID_STATUS_OCCUPIED: prefix = "Occupied"; break;
+	case ID_STATUS_FREECHAT: prefix = "FreeChat"; break;
+	case ID_STATUS_ONLINE: prefix = "On"; break;
+	case ID_STATUS_OFFLINE: prefix = "Off"; break;
+	case ID_STATUS_INVISIBLE: prefix = "Inv"; break;
+	case ID_STATUS_ONTHEPHONE: prefix = "Otp"; break;
+	case ID_STATUS_OUTTOLUNCH: prefix = "Otl"; break;
+	default: return NULL;
+	}
+	mir_strcpy(str, prefix); mir_strcat(str, suffix);
+	return str;
+}
+
+DWORD StatusModeToProtoFlag(int status)
+{
+	// *not* the same as in core, <offline>
+	switch (status) {
+	case ID_STATUS_ONLINE: return PF2_ONLINE;
+	case ID_STATUS_OFFLINE: return PF2_OFFLINE;
+	case ID_STATUS_INVISIBLE: return PF2_INVISIBLE;
+	case ID_STATUS_OUTTOLUNCH: return PF2_OUTTOLUNCH;
+	case ID_STATUS_ONTHEPHONE: return PF2_ONTHEPHONE;
+	case ID_STATUS_AWAY: return PF2_SHORTAWAY;
+	case ID_STATUS_NA: return PF2_LONGAWAY;
+	case ID_STATUS_OCCUPIED: return PF2_LIGHTDND;
+	case ID_STATUS_DND: return PF2_HEAVYDND;
+	case ID_STATUS_FREECHAT: return PF2_FREECHAT;
+	}
+	return 0;
+}
+
+int GetActualStatus(PROTOCOLSETTINGEX *protoSetting)
+{
+	if (protoSetting->status == ID_STATUS_LAST) {
+		if ((protoSetting->lastStatus < MIN_STATUS) || (protoSetting->lastStatus > MAX_STATUS))
+			return CallProtoService(protoSetting->szName, PS_GETSTATUS, 0, 0);
+		return protoSetting->lastStatus;
+	}
+	if (protoSetting->status == ID_STATUS_CURRENT)
+		return CallProtoService(protoSetting->szName, PS_GETSTATUS, 0, 0);
+
+	if ((protoSetting->status < ID_STATUS_OFFLINE) || (protoSetting->status > ID_STATUS_OUTTOLUNCH)) {
+		log_debugA("invalid status detected: %d", protoSetting->status);
+		return 0;
+	}
+	return protoSetting->status;
+}
+
+// helper, from core
+static wchar_t* GetDefaultMessage(int status)
+{
+	switch (status) {
+	case ID_STATUS_AWAY:       return TranslateT("I've been away since %time%.");
+	case ID_STATUS_NA:         return TranslateT("Give it up, I'm not in!");
+	case ID_STATUS_OCCUPIED:   return TranslateT("Not right now.");
+	case ID_STATUS_DND:        return TranslateT("Give a guy some peace, would ya?");
+	case ID_STATUS_FREECHAT:   return TranslateT("I'm a chatbot!");
+	case ID_STATUS_ONLINE:     return TranslateT("Yep, I'm here.");
+	case ID_STATUS_OFFLINE:    return TranslateT("Nope, not here.");
+	case ID_STATUS_INVISIBLE:  return TranslateT("I'm hiding from the mafia.");
+	case ID_STATUS_ONTHEPHONE: return TranslateT("That'll be the phone.");
+	case ID_STATUS_OUTTOLUNCH: return TranslateT("Mmm... food.");
+	case ID_STATUS_IDLE:       return TranslateT("idleeeeeeee");
+	}
+	return NULL;
+}
+
+wchar_t* GetDefaultStatusMessage(PROTOCOLSETTINGEX *ps, int newstatus)
+{
+	if (ps->szMsg != NULL) {// custom message set
+		log_infoA("CommonStatus: Status message set by calling plugin");
+		return mir_wstrdup(ps->szMsg);
+	}
+
+	wchar_t *tMsg = (wchar_t*)CallService(MS_AWAYMSG_GETSTATUSMSGW, newstatus, (LPARAM)ps->szName);
+	log_debugA("CommonStatus: Status message retrieved from general awaysys: %S", tMsg);
+	return tMsg;
+}
+
+static int equalsGlobalStatus(PROTOCOLSETTINGEX **ps)
+{
+
+	int i, j, pstatus = 0, gstatus = 0;
+
+	for (i = 0; i < protoList->getCount(); i++)
+		if (ps[i]->szMsg != NULL && GetActualStatus(ps[i]) != ID_STATUS_OFFLINE)
+			return 0;
+
+	int count;
+	PROTOACCOUNT **protos;
+	Proto_EnumAccounts(&count, &protos);
+
+	for (i = 0; i < count; i++) {
+		if (!IsSuitableProto(protos[i]))
+			continue;
+
+		pstatus = 0;
+		for (j = 0; j < protoList->getCount(); j++)
+			if (!mir_strcmp(protos[i]->szModuleName, ps[j]->szName))
+				pstatus = GetActualStatus(ps[j]);
+
+		if (pstatus == 0)
+			pstatus = CallProtoService(protos[i]->szModuleName, PS_GETSTATUS, 0, 0);
+
+		if (db_get_b(NULL, protos[i]->szModuleName, "LockMainStatus", 0)) {
+			// if proto is locked, pstatus must be the current status
+			if (pstatus != CallProtoService(protos[i]->szModuleName, PS_GETSTATUS, 0, 0))
+				return 0;
+		}
+		else {
+			if (gstatus == 0)
+				gstatus = pstatus;
+
+			if (pstatus != gstatus)
+				return 0;
+		}
+	}
+
+	return gstatus;
+}
+
+static void SetStatusMsg(PROTOCOLSETTINGEX *ps, int newstatus)
+{
+	wchar_t* tszMsg = GetDefaultStatusMessage(ps, newstatus);
+	if (tszMsg) {
+		/* replace the default vars in msg  (I believe this is from core) */
+		for (int j = 0; tszMsg[j]; j++) {
+			if (tszMsg[j] != '%')
+				continue;
+
+			wchar_t substituteStr[128];
+			if (!wcsnicmp(tszMsg + j, L"%time%", 6))
+				GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, 0, 0, substituteStr, _countof(substituteStr));
+			else if (!wcsnicmp(tszMsg + j, L"%date%", 6))
+				GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, 0, 0, substituteStr, _countof(substituteStr));
+			else
+				continue;
+
+			if (mir_wstrlen(substituteStr) > 6)
+				tszMsg = (wchar_t*)mir_realloc(tszMsg, sizeof(wchar_t)*(mir_wstrlen(tszMsg) + 1 + mir_wstrlen(substituteStr) - 6));
+			memmove(tszMsg + j + mir_wstrlen(substituteStr), tszMsg + j + 6, sizeof(wchar_t)*(mir_wstrlen(tszMsg) - j - 5));
+			memcpy(tszMsg + j, substituteStr, sizeof(wchar_t)*mir_wstrlen(substituteStr));
+		}
+
+		wchar_t *szFormattedMsg = variables_parsedup(tszMsg, ps->tszAccName, NULL);
+		if (szFormattedMsg != NULL) {
+			mir_free(tszMsg);
+			tszMsg = szFormattedMsg;
+		}
+	}
+	log_debugA("CommonStatus sets status message for %s directly", ps->szName);
+	CallProtoService(ps->szName, PS_SETAWAYMSG, newstatus, (LPARAM)tszMsg);
+	mir_free(tszMsg);
+}
+
+INT_PTR SetStatusEx(WPARAM wParam, LPARAM)
+{
+	PROTOCOLSETTINGEX** protoSettings = *(PROTOCOLSETTINGEX***)wParam;
+	if (protoSettings == NULL)
+		return -1;
+
+	int globStatus = equalsGlobalStatus(protoSettings);
+
+	// issue with setting global status;
+	// things get messy because SRAway hooks ME_CLIST_STATUSMODECHANGE, so the status messages of SRAway and
+	// commonstatus will clash
+	NotifyEventHooks(hCSStatusChangedExEvent, (WPARAM)&protoSettings, protoList->getCount());
+
+	// set all status messages first
+	for (int i = 0; i < protoList->getCount(); i++) {
+		char *szProto = protoSettings[i]->szName;
+		if (!Proto_GetAccount(szProto)) {
+			log_debugA("CommonStatus: %s is not loaded", szProto);
+			continue;
+		}
+		// some checks
+		int newstatus = GetActualStatus(protoSettings[i]);
+		if (newstatus == 0) {
+			log_debugA("CommonStatus: incorrect status for %s (%d)", szProto, protoSettings[i]->status);
+			continue;
+		}
+		int oldstatus = CallProtoService(szProto, PS_GETSTATUS, 0, 0);
+		// set last status
+		protoSettings[i]->lastStatus = oldstatus;
+		if (IsStatusConnecting(oldstatus)) {
+			// ignore if connecting, but it didn't came this far if it did
+			log_debugA("CommonStatus: %s is already connecting", szProto);
+			continue;
+		}
+
+		// status checks
+		long protoFlag = Proto_Status2Flag(newstatus);
+		int b_Caps2 = CallProtoService(szProto, PS_GETCAPS, PFLAGNUM_2, 0) & protoFlag;
+		int b_Caps5 = CallProtoService(szProto, PS_GETCAPS, PFLAGNUM_5, 0) & protoFlag;
+		if (newstatus != ID_STATUS_OFFLINE && (!b_Caps2 || b_Caps5)) {
+			// status and status message for this status not supported
+			//log_debug("CommonStatus: status not supported %s", szProto);
+			continue;
+		}
+
+		int b_Caps1 = CallProtoService(szProto, PS_GETCAPS, PFLAGNUM_1, 0) & PF1_MODEMSGSEND & ~PF1_INDIVMODEMSG;
+		int b_Caps3 = CallProtoService(szProto, PS_GETCAPS, PFLAGNUM_3, 0) & protoFlag;
+		if (newstatus == oldstatus && (!b_Caps1 || !b_Caps3)) {
+			// no status change and status messages are not supported
+			//log_debug("CommonStatus: no change, %s (%d %d)", szProto, oldstatus, newstatus);
+			continue;
+		}
+
+		// set status message first
+		if (b_Caps1 && b_Caps3)
+			SetStatusMsg(protoSettings[i], newstatus);
+
+		// set the status
+		if (newstatus != oldstatus /*&& !(b_Caps1 && b_Caps3 && ServiceExists(MS_NAS_SETSTATE))*/) {
+			log_debugA("CommonStatus sets status for %s to %d", szProto, newstatus);
+			CallProtoService(szProto, PS_SETSTATUS, newstatus, 0);
+		}
+	}
+
+	if (globStatus != 0) {
+		if (!ServiceExists(MS_CLIST_SETSTATUSMODE)) {
+			log_debugA("CommonStatus: MS_CLIST_SETSTATUSMODE not available!");
+			return -1;
+		}
+		log_debugA("CommonStatus: setting global status %u", globStatus);
+		CallService(MS_CLIST_SETSTATUSMODE, globStatus, 0);
+	}
+
+	return 0;
+}
+
+static INT_PTR GetProtocolCountService(WPARAM, LPARAM)
+{
+	return GetProtoCount();
+}
+
+bool IsSuitableProto(PROTOACCOUNT *pa)
+{
+	return (pa == NULL) ? false : (pcli->pfnGetProtocolVisibility(pa->szModuleName) != 0);
+}
+
+int GetProtoCount()
+{
+	int pCount = 0, count;
+	PROTOACCOUNT **accs;
+	Proto_EnumAccounts(&count, &accs);
+
+	for (int i = 0; i < count; i++)
+		if (IsSuitableProto(accs[i]))
+			pCount++;
+
+	return pCount;
+}
+
+static int CreateServices()
+{
+	if (ServiceExists(MS_CS_SETSTATUSEX))
+		return -1;
+
+	hCSStatusChangedExEvent = CreateHookableEvent(ME_CS_STATUSCHANGEEX);
+
+	CreateServiceFunction(MS_CS_SETSTATUSEX, SetStatusEx);
+	CreateServiceFunction(MS_CS_SHOWCONFIRMDLGEX, ShowConfirmDialogEx);
+	CreateServiceFunction(MS_CS_GETPROTOCOUNT, GetProtocolCountService);
+	return 0;
+}
+
+static int onShutdown(WPARAM, LPARAM)
+{
+	DestroyHookableEvent(hCSStatusChangedExEvent);
+	return 0;
+}
+
+int InitCommonStatus()
+{
+	if (!CreateServices())
+		HookEvent(ME_SYSTEM_PRESHUTDOWN, onShutdown);
+
+	return 0;
+}
diff --git a/plugins/StatusManager/src/commonstatus.h b/plugins/StatusManager/src/commonstatus.h
new file mode 100644
index 0000000000..352b9f1f93
--- /dev/null
+++ b/plugins/StatusManager/src/commonstatus.h
@@ -0,0 +1,88 @@
+/*
+	AdvancedAutoAway Plugin for Miranda-IM (www.miranda-im.org)
+	KeepStatus Plugin for Miranda-IM (www.miranda-im.org)
+	StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	*/
+
+#ifndef COMMONSTATUSHEADER
+#define COMMONSTATUSHEADER
+
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <windows.h>
+#include <shlobj.h>
+#include <uxtheme.h>
+#include <stdio.h>
+
+#include <newpluginapi.h>
+#include <m_system.h>
+#include <m_system_cpp.h>
+#include <m_awaymsg.h>
+#include <m_database.h>
+#include <m_protosvc.h>
+#include <m_clist.h>
+#include <m_string.h>
+#include <m_langpack.h>
+#include <m_popup.h>
+#include <m_variables.h>
+#include <m_netlib.h>
+#include "m_statusplugins.h"
+#include <m_utils.h>
+#include <m_NewAwaySys.h>
+#include <win2k.h>
+
+#if defined( _WIN64 )
+#define __PLATFORM_NAME  "64"
+#else
+#define __PLATFORM_NAME  ""
+#endif
+
+#include "../helpers/gen_helpers.h"
+
+#define UM_STSMSGDLGCLOSED				WM_APP+1
+#define UM_CLOSECONFIRMDLG				WM_APP+2
+
+#define PREFIX_LAST						"last_"
+#define PREFIX_LASTMSG					"lastmsg_"
+#define DEFAULT_STATUS					ID_STATUS_LAST
+#define ID_STATUS_LAST					40081 // doesn't interfere with ID_STATUS_IDLE, since we don't use it. However this *is* a good lesson not to do this again.
+#define ID_STATUS_CURRENT				40082
+#define ID_STATUS_DISABLED				41083 // this should not be send to setstatus(ex)
+#define MAX_STATUS						ID_STATUS_CURRENT
+#define MIN_STATUS						ID_STATUS_OFFLINE
+#define DEF_CLOSE_TIME					5 //secs
+#define PF2_OFFLINE						0x00000200
+static int statusModeList[] = { ID_STATUS_OFFLINE, ID_STATUS_ONLINE, ID_STATUS_AWAY, ID_STATUS_NA, ID_STATUS_OCCUPIED, ID_STATUS_DND, ID_STATUS_FREECHAT, ID_STATUS_INVISIBLE, ID_STATUS_ONTHEPHONE, ID_STATUS_OUTTOLUNCH };
+static int statusModePf2List[] = { PF2_OFFLINE, PF2_ONLINE, PF2_SHORTAWAY, PF2_LONGAWAY, PF2_LIGHTDND, PF2_HEAVYDND, PF2_FREECHAT, PF2_INVISIBLE, PF2_ONTHEPHONE, PF2_OUTTOLUNCH };
+
+wchar_t *GetDefaultStatusMessage(PROTOCOLSETTINGEX *ps, int status);
+int GetActualStatus(PROTOCOLSETTINGEX *protoSetting);
+int InitCommonStatus();
+bool IsSuitableProto(PROTOACCOUNT *pa);
+
+/* SimpleAway */
+
+// wParam = 0
+// lParam = 0
+// allways returns 1
+#define MS_SA_ISSARUNNING  "SimpleAway/IsSARunning"
+
+extern HINSTANCE hInst;
+extern OBJLIST<PROTOCOLSETTINGEX>* protoList;
+
+#endif //COMMONSTATUSHEADER
diff --git a/plugins/StatusManager/src/confirmdialog.cpp b/plugins/StatusManager/src/confirmdialog.cpp
new file mode 100644
index 0000000000..3a246cf8e3
--- /dev/null
+++ b/plugins/StatusManager/src/confirmdialog.cpp
@@ -0,0 +1,425 @@
+/*
+	AdvancedAutoAway Plugin for Miranda-IM (www.miranda-im.org)
+	KeepStatus Plugin for Miranda-IM (www.miranda-im.org)
+	StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+#define TIMER_ID	1
+
+// variables
+static HWND win;
+static int timeOut;
+
+struct TConfirmSetting : public PROTOCOLSETTINGEX
+{
+	TConfirmSetting(const PROTOCOLSETTINGEX& x)
+	{
+		memcpy(this, &x, sizeof(PROTOCOLSETTINGEX));
+		if (szMsg)
+			szMsg = wcsdup(szMsg);
+	}
+
+	~TConfirmSetting()
+	{
+		free(szMsg);
+	}
+};
+
+static int CompareSettings(const TConfirmSetting* p1, const TConfirmSetting* p2)
+{
+	return mir_strcmp(p1->szName, p2->szName);
+}
+
+static OBJLIST<TConfirmSetting> *confirmSettings;
+
+static INT_PTR CALLBACK StatusMessageDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static PROTOCOLSETTINGEX* protoSetting = NULL;
+	switch (msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+
+		protoSetting = (PROTOCOLSETTINGEX *)lParam;
+		if (protoSetting->szMsg == NULL) {
+			wchar_t* smsg = GetDefaultStatusMessage(protoSetting, GetActualStatus(protoSetting));
+			if (smsg != NULL) {
+				SetDlgItemText(hwndDlg, IDC_STSMSG, smsg);
+				mir_free(smsg);
+			}
+		}
+		else SetDlgItemText(hwndDlg, IDC_STSMSG, protoSetting->szMsg);
+
+		{
+			wchar_t desc[512];
+			mir_snwprintf(desc,   TranslateT("Set %s message for %s."),
+				pcli->pfnGetStatusModeDescription(GetActualStatus(protoSetting), 0), protoSetting->tszAccName);
+			SetDlgItemText(hwndDlg, IDC_DESCRIPTION, desc);
+		}
+		break;
+
+	case WM_COMMAND:
+		switch (LOWORD(wParam)) {
+		case IDC_OK:
+		{
+			int len = SendDlgItemMessage(hwndDlg, IDC_STSMSG, WM_GETTEXTLENGTH, 0, 0);
+			if (len > 0) {
+				protoSetting->szMsg = (wchar_t*)realloc(protoSetting->szMsg, sizeof(wchar_t)*(len + 1));
+				if (protoSetting->szMsg != NULL)
+					GetDlgItemText(hwndDlg, IDC_STSMSG, protoSetting->szMsg, len + 1);
+			}
+			SendMessage(GetParent(hwndDlg), UM_STSMSGDLGCLOSED, TRUE, 0);
+			EndDialog(hwndDlg, IDC_OK);
+		}
+		break;
+
+		case IDC_CANCEL:
+			SendMessage(GetParent(hwndDlg), UM_STSMSGDLGCLOSED, 0, 0);
+			EndDialog(hwndDlg, IDC_CANCEL);
+			break;
+		}
+		break;
+	}
+
+	return FALSE;
+}
+
+static int SetStatusList(HWND hwndDlg)
+{
+	if (confirmSettings->getCount() == 0)
+		return -1;
+
+	HWND hList = GetDlgItem(hwndDlg, IDC_STARTUPLIST);
+	wchar_t buf[100];
+
+	// create items
+	LVITEM lvItem = { 0 };
+	lvItem.mask = LVIF_TEXT | LVIF_PARAM;
+
+	for (int i = 0; i < confirmSettings->getCount(); i++) {
+		lvItem.pszText = (*confirmSettings)[i].tszAccName;
+		if (ListView_GetItemCount(hList) < confirmSettings->getCount())
+			ListView_InsertItem(hList, &lvItem);
+
+		int actualStatus;
+		switch ((*confirmSettings)[i].status) {
+		case ID_STATUS_LAST:    actualStatus = (*confirmSettings)[i].lastStatus;   break;
+		case ID_STATUS_CURRENT: actualStatus = CallProtoService((*confirmSettings)[i].szName, PS_GETSTATUS, 0, 0); break;
+		default:                actualStatus = (*confirmSettings)[i].status;
+		}
+		wchar_t* status = pcli->pfnGetStatusModeDescription(actualStatus, 0);
+		switch ((*confirmSettings)[i].status) {
+		case ID_STATUS_LAST:
+			mir_snwprintf(buf, L"%s (%s)", TranslateT("<last>"), status);
+			ListView_SetItemText(hList, lvItem.iItem, 1, buf);
+			break;
+		case ID_STATUS_CURRENT:
+			mir_snwprintf(buf, L"%s (%s)", TranslateT("<current>"), status);
+			ListView_SetItemText(hList, lvItem.iItem, 1, buf);
+			break;
+		default:
+			ListView_SetItemText(hList, lvItem.iItem, 1, status);
+		}
+
+		// status message
+		if (!((!((CallProtoService((*confirmSettings)[i].szName, PS_GETCAPS, (WPARAM)PFLAGNUM_1, 0)&PF1_MODEMSGSEND)&~PF1_INDIVMODEMSG)) || (!(CallProtoService((*confirmSettings)[i].szName, PS_GETCAPS, (WPARAM)PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus))))) {
+			wchar_t *msg = GetDefaultStatusMessage(&(*confirmSettings)[i], actualStatus);
+			if (msg != NULL) {
+				wchar_t* fMsg = variables_parsedup(msg, (*confirmSettings)[i].tszAccName, NULL);
+				ListView_SetItemText(hList, lvItem.iItem, 2, fMsg);
+				mir_free(fMsg);
+				mir_free(msg);
+			}
+			else ListView_SetItemText(hList, lvItem.iItem, 2, TranslateT("<n/a>"));
+		}
+		else ListView_SetItemText(hList, lvItem.iItem, 2, TranslateT("<n/a>"));
+
+		ListView_SetColumnWidth(hList, 0, LVSCW_AUTOSIZE);
+		ListView_SetColumnWidth(hList, 2, LVSCW_AUTOSIZE);
+		lvItem.lParam = (LPARAM)&(*confirmSettings)[i];
+		ListView_SetItem(hList, &lvItem);
+		lvItem.iItem++;
+	}
+
+	// grey out status box
+	EnableWindow(GetDlgItem(hwndDlg, IDC_STATUS), (ListView_GetNextItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), -1, LVNI_SELECTED) >= 0));
+	return 0;
+}
+
+static INT_PTR CALLBACK ConfirmDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch (msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+		{
+			HWND hList = GetDlgItem(hwndDlg, IDC_STARTUPLIST);
+			SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
+
+			// create columns
+			LVCOLUMN lvCol = { 0 };
+			lvCol.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
+			lvCol.pszText = TranslateT("Protocol");
+			ListView_InsertColumn(hList, 0, &lvCol);
+
+			lvCol.cx = 100;
+			lvCol.pszText = TranslateT("Status");
+			ListView_InsertColumn(hList, 1, &lvCol);
+
+			lvCol.pszText = TranslateT("Message");
+			ListView_InsertColumn(hList, 2, &lvCol);
+		}
+
+		// create items
+		SetStatusList(hwndDlg);
+
+		EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), FALSE);
+		// fill profile combo box
+		if (!ServiceExists(MS_SS_GETPROFILE))
+			EnableWindow(GetDlgItem(hwndDlg, IDC_PROFILE), FALSE);
+		else {
+			int defaultProfile;
+			int profileCount = (int)CallService(MS_SS_GETPROFILECOUNT, (WPARAM)&defaultProfile, 0);
+			for (int i = 0; i < profileCount; i++) {
+				wchar_t profileName[128];
+				CallService(MS_SS_GETPROFILENAME, i, (LPARAM)profileName);
+				int item = SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_ADDSTRING, 0, (LPARAM)profileName);
+				SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_SETITEMDATA, item, i);
+			}
+			if (profileCount == 0)
+				EnableWindow(GetDlgItem(hwndDlg, IDC_PROFILE), FALSE);
+			else
+				SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_SETCURSEL, defaultProfile, 0);
+		}
+		// start timer
+		if (timeOut > 0) {
+			wchar_t text[32];
+			mir_snwprintf(text, TranslateT("Closing in %d"), timeOut);
+			SetDlgItemText(hwndDlg, IDC_CLOSE, text);
+			SetTimer(hwndDlg, TIMER_ID, 1000, NULL);
+		}
+		return TRUE;
+
+	case WM_TIMER:
+	{
+		wchar_t text[32];
+		mir_snwprintf(text, TranslateT("Closing in %d"), timeOut - 1);
+		SetDlgItemText(hwndDlg, IDC_CLOSE, text);
+		if (timeOut <= 0) {
+			KillTimer(hwndDlg, TIMER_ID);
+			SendMessage(hwndDlg, UM_CLOSECONFIRMDLG, 0, 0);
+		}
+		else timeOut--;
+	}
+	break;
+
+	case WM_COMMAND:
+		// stop timer
+		KillTimer(hwndDlg, TIMER_ID);
+		SetDlgItemText(hwndDlg, IDC_CLOSE, TranslateT("Close"));
+		if ((HIWORD(wParam) == CBN_SELCHANGE) || (HIWORD(wParam) == BN_CLICKED) || (HIWORD(wParam) == NM_CLICK)) { // something clicked
+			switch (LOWORD(wParam)) {
+			case IDC_PROFILE:
+			{
+				int profile = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA, SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
+				for (int i = 0; i < confirmSettings->getCount(); i++)
+					if ((*confirmSettings)[i].szMsg != NULL) {
+						free((*confirmSettings)[i].szMsg);
+						(*confirmSettings)[i].szMsg = NULL;
+					}
+
+				CallService(MS_SS_GETPROFILE, (WPARAM)profile, (LPARAM)confirmSettings);
+				for (int i = 0; i < confirmSettings->getCount(); i++)
+					if ((*confirmSettings)[i].szMsg != NULL) // we free this later, copy to our memory space
+						(*confirmSettings)[i].szMsg = wcsdup((*confirmSettings)[i].szMsg);
+
+				SetStatusList(hwndDlg);
+			}
+			break;
+
+			case IDC_STATUS:
+			{
+				LVITEM lvItem = { 0 };
+				lvItem.mask = LVIF_TEXT | LVIF_PARAM;
+				lvItem.iSubItem = 0;
+				lvItem.iItem = ListView_GetNextItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), -1, LVNI_SELECTED);
+				if (lvItem.iItem == -1)
+					break;
+
+				ListView_GetItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), &lvItem);
+				PROTOCOLSETTINGEX* proto = (PROTOCOLSETTINGEX*)lvItem.lParam;
+				int actualStatus = proto->status = (int)SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_GETITEMDATA, SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_GETCURSEL, 0, 0), 0);
+
+				// LAST STATUS
+				if (proto->status == ID_STATUS_LAST) {
+					wchar_t last[80];
+					mir_snwprintf(last, L"%s (%s)", TranslateT("<last>"), pcli->pfnGetStatusModeDescription(proto->lastStatus, 0));
+					ListView_SetItemText(GetDlgItem(hwndDlg, IDC_STARTUPLIST), lvItem.iItem, 1, last);
+					actualStatus = proto->lastStatus;
+				}
+
+				// CURRENT STATUS
+				else if (proto->status == ID_STATUS_CURRENT) {
+					int currentStatus = CallProtoService(proto->szName, PS_GETSTATUS, 0, 0);
+					wchar_t current[80];
+					mir_snwprintf(current, L"%s (%s)", TranslateT("<current>"), pcli->pfnGetStatusModeDescription(currentStatus, 0));
+					ListView_SetItemText(GetDlgItem(hwndDlg, IDC_STARTUPLIST), lvItem.iItem, 1, current);
+					actualStatus = currentStatus;
+				}
+				else ListView_SetItemText(GetDlgItem(hwndDlg, IDC_STARTUPLIST), lvItem.iItem, 1, pcli->pfnGetStatusModeDescription(proto->status, 0));
+
+				if ((!((CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_1, 0)&PF1_MODEMSGSEND)&~PF1_INDIVMODEMSG)) || (!(CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus))))
+					EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), FALSE);
+				else if ((proto->status == ID_STATUS_LAST) || (proto->status == ID_STATUS_CURRENT))
+					EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), TRUE);
+				else
+					EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), (CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus)) ? TRUE : FALSE);
+				SetStatusList(hwndDlg);
+			}
+			break;
+
+			case IDC_SETSTSMSG:
+			{
+				LVITEM lvItem = { 0 };
+				lvItem.mask = LVIF_TEXT | LVIF_PARAM;
+				lvItem.iSubItem = 0;
+				lvItem.iItem = ListView_GetNextItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), -1, LVNI_SELECTED);
+				if (lvItem.iItem == -1)
+					break;
+
+				ListView_GetItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), &lvItem);
+				DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SETSTSMSGDIALOG), hwndDlg, StatusMessageDlgProc, lvItem.lParam);
+			}
+			break;
+
+			case IDC_CLOSE:
+				SendMessage(hwndDlg, UM_CLOSECONFIRMDLG, 0, 0);
+				break;
+
+			case IDC_CANCEL:
+				DestroyWindow(hwndDlg);
+				break;
+			}
+		}
+		break;
+
+	case WM_NOTIFY:
+		switch (((NMHDR*)lParam)->idFrom) {
+		case IDC_STARTUPLIST:
+			if (((NMHDR*)lParam)->code == NM_CLICK) {
+				KillTimer(hwndDlg, TIMER_ID);
+				SetDlgItemText(hwndDlg, IDC_CLOSE, TranslateT("Close"));
+
+				LVITEM lvItem = { 0 };
+				lvItem.mask = LVIF_TEXT | LVIF_PARAM;
+				lvItem.iSubItem = 0;
+				lvItem.iItem = ListView_GetNextItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), -1, LVNI_SELECTED);
+
+				if (ListView_GetItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), &lvItem) == FALSE) {
+					SetStatusList(hwndDlg);
+					break;
+				}
+
+				PROTOCOLSETTINGEX *proto = (PROTOCOLSETTINGEX*)lvItem.lParam;
+				int flags = CallProtoService(proto->szName, PS_GETCAPS, PFLAGNUM_2, 0) & ~CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_5, 0);
+				// clear box and add new status, loop status and check if compatible with proto
+				SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_RESETCONTENT, 0, 0);
+				int actualStatus = proto->status;
+
+				// last
+				wchar_t buf[100];
+				mir_snwprintf(buf, L"%s (%s)", TranslateT("<last>"), pcli->pfnGetStatusModeDescription(proto->lastStatus, 0));
+				int item = SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_ADDSTRING, 0, (LPARAM)buf);
+				SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_SETITEMDATA, item, ID_STATUS_LAST);
+				if (proto->status == ID_STATUS_LAST) {
+					SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_SETCURSEL, item, 0);
+					actualStatus = proto->lastStatus;
+				}
+
+				// current
+				int currentStatus = CallProtoService(proto->szName, PS_GETSTATUS, 0, 0);
+				mir_snwprintf(buf, L"%s (%s)", TranslateT("<current>"), pcli->pfnGetStatusModeDescription(currentStatus, 0));
+				item = SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_ADDSTRING, 0, (LPARAM)buf);
+				SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_SETITEMDATA, item, ID_STATUS_CURRENT);
+				if (proto->status == ID_STATUS_CURRENT) {
+					SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_SETCURSEL, item, 0);
+					actualStatus = currentStatus;
+				}
+
+				for (int i = 0; i < _countof(statusModeList); i++) {
+					if (((flags & statusModePf2List[i]) || (statusModePf2List[i] == PF2_OFFLINE)) && (!((!(flags)& Proto_Status2Flag(statusModePf2List[i]))) || ((CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_5, 0)&Proto_Status2Flag(statusModePf2List[i]))))) {
+						wchar_t *statusMode = pcli->pfnGetStatusModeDescription(statusModeList[i], 0);
+						item = SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_ADDSTRING, 0, (LPARAM)statusMode);
+						SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_SETITEMDATA, item, statusModeList[i]);
+						if (statusModeList[i] == proto->status)
+							SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_SETCURSEL, item, 0);
+					}
+				}
+
+				// enable status box
+				EnableWindow(GetDlgItem(hwndDlg, IDC_STATUS), (ListView_GetNextItem(GetDlgItem(hwndDlg, IDC_STARTUPLIST), -1, LVNI_SELECTED) >= 0));
+				if ((!((CallProtoService(proto->szName, PS_GETCAPS, PFLAGNUM_1, 0)&PF1_MODEMSGSEND)&~PF1_INDIVMODEMSG)) || (!(CallProtoService(proto->szName, PS_GETCAPS, PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus))))
+					EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), FALSE);
+				else if (proto->status == ID_STATUS_LAST || proto->status == ID_STATUS_CURRENT)
+					EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), TRUE);
+				else
+					EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), (CallProtoService(proto->szName, PS_GETCAPS, PFLAGNUM_3, 0) & Proto_Status2Flag(actualStatus)) ? TRUE : FALSE);
+			}
+		}
+		break;
+
+	case UM_STSMSGDLGCLOSED:
+		SetStatusList(hwndDlg);
+		break;
+
+	case UM_CLOSECONFIRMDLG:
+		CallService(MS_CS_SETSTATUSEX, (WPARAM)confirmSettings, 0);
+		DestroyWindow(hwndDlg);
+		break;
+
+	case WM_DESTROY:
+		delete confirmSettings; confirmSettings = 0;
+		break;
+	}
+
+	return 0;
+}
+
+INT_PTR ShowConfirmDialogEx(WPARAM wParam, LPARAM lParam)
+{
+	if (wParam == 0)
+		return -1;
+
+	delete confirmSettings;
+	confirmSettings = new OBJLIST<TConfirmSetting>(10, CompareSettings);
+
+	OBJLIST<PROTOCOLSETTINGEX>& param = *(OBJLIST<PROTOCOLSETTINGEX>*)wParam;
+	for (int i = 0; i < param.getCount(); i++)
+		confirmSettings->insert(new TConfirmSetting(param[i]));
+
+	timeOut = lParam;
+	if (timeOut < 0)
+		timeOut = DEF_CLOSE_TIME;
+
+	if (GetWindow(win, 0) == NULL) {
+		win = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_CONFIRMDIALOG), NULL, ConfirmDlgProc, NULL);
+		EnableWindow(win, TRUE);
+	}
+
+	return (INT_PTR)win;
+}
diff --git a/plugins/StatusManager/src/keepstatus.cpp b/plugins/StatusManager/src/keepstatus.cpp
new file mode 100644
index 0000000000..9cb409aff2
--- /dev/null
+++ b/plugins/StatusManager/src/keepstatus.cpp
@@ -0,0 +1,1207 @@
+/*
+	KeepStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	*/
+
+#include "stdafx.h"
+
+struct TimerInfo {
+	int timer;
+	int timeout;
+	BOOL restart;
+	int result;
+	HANDLE hEvent;
+};
+
+static mir_cs GenTimerCS, GenStatusCS, CheckContinueslyCS;
+
+static HANDLE hProtoAckHook = NULL;
+static HANDLE hStatusChangeHook = NULL;
+static HANDLE hCSStatusChangeHook = NULL;
+static HANDLE hCSStatusChangeExHook = NULL;
+
+extern HANDLE hConnectionEvent;
+extern PLUGININFOEX pluginInfoEx;
+
+static HWND hMessageWindow = NULL;
+
+static int CompareConnections(const TConnectionSettings *p1, const TConnectionSettings *p2)
+{
+	return mir_strcmp(p1->szName, p2->szName);
+}
+
+static OBJLIST<TConnectionSettings> connectionSettings(10, CompareConnections);
+
+static UINT_PTR checkConnectionTimerId = 0;
+static UINT_PTR afterCheckTimerId = 0;
+static UINT_PTR processAckTimerId = 0;
+static UINT_PTR checkContinTimerId = 0;
+static UINT_PTR checkConnectingTimerId = 0;
+static int retryCount = 0;
+static BOOL bLastPingResult = TRUE;
+// variables (options)
+static int maxRetries = 0;
+static int initDelay = 0;
+static int currentDelay = 0;
+static int maxDelay = 0;
+static int ackDelay = 500;
+static int increaseExponential = 0;
+static int showConnectionPopups = 0;
+// prototypes
+static int StartTimer(int timer, int timeout, BOOL restart);
+static int StopTimer(int timer);
+int KSLoadMainOptions();
+static void GetCurrentConnectionSettings();
+static int AssignStatus(TConnectionSettings* connSetting, int status, int lastStatus, wchar_t *szMsg);
+static int ProcessProtoAck(WPARAM wParam, LPARAM lParam);
+static VOID CALLBACK CheckConnectingTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime);
+static VOID CALLBACK CheckAckStatusTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime);
+static int StatusChange(WPARAM wParam, LPARAM lParam);
+static int CSStatusChange(WPARAM wParam, LPARAM lParam);
+static int CSStatusChangeEx(WPARAM wParam, LPARAM lParam);
+static VOID CALLBACK StatusChangeTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime);
+static VOID CALLBACK CheckConnectionTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime);
+static int StopChecking();
+static VOID CALLBACK AfterCheckTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime);
+static void ContinueslyCheckFunction(void *arg);
+static VOID CALLBACK CheckContinueslyTimer(HWND hwnd, UINT message, UINT_PTR idEvent, DWORD dwTime);
+INT_PTR IsProtocolEnabledService(WPARAM wParam, LPARAM lParam);
+
+static int ProcessPopup(int reason, LPARAM lParam);
+static INT_PTR ShowPopup(wchar_t *msg, HICON hIcon);
+LRESULT CALLBACK PopupDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+static DWORD CALLBACK MessageWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+
+// options.c
+extern int KeepStatusOptionsInit(WPARAM wparam, LPARAM);
+
+TConnectionSettings::TConnectionSettings(PROTOACCOUNT *pa)
+{
+	cbSize = sizeof(PROTOCOLSETTINGEX);
+	szName = pa->szModuleName;
+	tszAccName = pa->tszAccountName;
+	szMsg = NULL;
+
+	int iStatus = CallProtoService(pa->szModuleName, PS_GETSTATUS, 0, 0);
+	AssignStatus(this, iStatus, iStatus, NULL);
+}
+
+TConnectionSettings::~TConnectionSettings()
+{
+	if (szMsg != NULL)
+		free(szMsg);
+}
+
+int KSLoadMainOptions()
+{
+	UnhookEvent(hProtoAckHook);
+	UnhookEvent(hStatusChangeHook);
+	UnhookEvent(hCSStatusChangeHook);
+	UnhookEvent(hCSStatusChangeExHook);
+	hProtoAckHook = hStatusChangeHook = hCSStatusChangeHook = hCSStatusChangeExHook = 0;
+
+	if (IsWindow(hMessageWindow))
+		DestroyWindow(hMessageWindow);
+	if (StartTimer(IDT_CHECKCONTIN, -1, FALSE)) {
+		WSACleanup();
+	}
+	StopTimer(IDT_CHECKCONN | IDT_PROCESSACK | IDT_AFTERCHECK | IDT_CHECKCONTIN | IDT_CHECKCONNECTING);
+
+	GetCurrentConnectionSettings();
+
+	if (db_get_b(NULL, KSMODULENAME, SETTING_CHECKCONNECTION, FALSE)) {
+		if (db_get_b(NULL, KSMODULENAME, SETTING_CONTCHECK, FALSE)) {
+			if (db_get_b(NULL, KSMODULENAME, SETTING_BYPING, FALSE)) {
+				WSADATA wsaData;
+				WSAStartup(MAKEWORD(2, 2), &wsaData);
+			}
+			StartTimer(IDT_CHECKCONTIN, 0, FALSE);
+		}
+		increaseExponential = db_get_b(NULL, KSMODULENAME, SETTING_INCREASEEXPONENTIAL, FALSE);
+		currentDelay = initDelay = 1000 * db_get_dw(NULL, KSMODULENAME, SETTING_INITDELAY, DEFAULT_INITDELAY);
+		maxDelay = 1000 * db_get_dw(NULL, KSMODULENAME, SETTING_MAXDELAY, DEFAULT_MAXDELAY);
+		maxRetries = db_get_b(NULL, KSMODULENAME, SETTING_MAXRETRIES, 0);
+		if (maxRetries == 0)
+			maxRetries = -1;
+		hProtoAckHook = HookEvent(ME_PROTO_ACK, ProcessProtoAck);
+		hStatusChangeHook = HookEvent(ME_CLIST_STATUSMODECHANGE, StatusChange);
+		if (ServiceExists(ME_CS_STATUSCHANGE))
+			hCSStatusChangeHook = HookEvent(ME_CS_STATUSCHANGE, CSStatusChange);
+		hCSStatusChangeExHook = HookEvent(ME_CS_STATUSCHANGEEX, CSStatusChangeEx);
+		if (db_get_b(NULL, KSMODULENAME, SETTING_CHECKAPMRESUME, 0) && (CallService(MS_SYSTEM_GETVERSION, 0, 0) >= 0x00040000)) {
+			if (!IsWindow(hMessageWindow)) {
+				hMessageWindow = CreateWindowEx(0, L"STATIC", NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
+				SetWindowLongPtr(hMessageWindow, GWLP_WNDPROC, (LONG_PTR)MessageWndProc);
+			}
+		}
+		retryCount = 0;
+	}
+
+	return 0;
+}
+
+static void GetCurrentConnectionSettings()
+{
+	connectionSettings.destroy();
+
+	int count;
+	PROTOACCOUNT** protos;
+	Proto_EnumAccounts(&count, &protos);
+
+	for (int i = 0; i < count; i++)
+		if (IsSuitableProto(protos[i]))
+			connectionSettings.insert(new TConnectionSettings(protos[i]));
+}
+
+static PROTOCOLSETTINGEX** GetCurrentProtoSettingsCopy()
+{
+	mir_cslock lck(GenStatusCS);
+	PROTOCOLSETTINGEX **ps = (PROTOCOLSETTINGEX**)malloc(connectionSettings.getCount()*sizeof(PROTOCOLSETTINGEX *));
+	if (ps == NULL) {
+		return NULL;
+	}
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		ps[i] = (PROTOCOLSETTINGEX*)calloc(1, sizeof(PROTOCOLSETTINGEX));
+		if (ps[i] == NULL) {
+			free(ps);
+			return NULL;
+		}
+
+		TConnectionSettings& cs = connectionSettings[i];
+		ps[i]->cbSize = sizeof(PROTOCOLSETTINGEX);
+		ps[i]->lastStatus = cs.lastStatus;
+		ps[i]->status = cs.status;
+		ps[i]->szMsg = NULL;
+		ps[i]->szName = cs.szName;
+		ps[i]->tszAccName = cs.tszAccName;
+	}
+
+	return ps;
+}
+
+static void FreeProtoSettings(PROTOCOLSETTINGEX** ps)
+{
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		if (ps[i]->szMsg != NULL)
+			free(ps[i]->szMsg);
+		free(ps[i]);
+	}
+	free(ps);
+}
+
+static int AssignStatus(TConnectionSettings* cs, int status, int lastStatus, wchar_t *szMsg)
+{
+	if (status < MIN_STATUS || status > MAX_STATUS)
+		return -1;
+
+	mir_cslock lck(GenStatusCS);
+
+	char dbSetting[128];
+	mir_snprintf(dbSetting, "%s_enabled", cs->szName);
+	cs->lastStatus = lastStatus == 0 ? cs->status : lastStatus;
+	if (!db_get_b(NULL, KSMODULENAME, dbSetting, 1))
+		cs->status = ID_STATUS_DISABLED;
+	else if (status == ID_STATUS_LAST)
+		cs->status = cs->lastStatus;
+	else
+		cs->status = status;
+
+	log_infoA("KeepStatus: assigning status %d to %s", cs->status, cs->szName);
+
+	if (szMsg != NULL && mir_wstrcmp(szMsg, cs->szMsg)) {
+		if (cs->szMsg != NULL)
+			free(cs->szMsg);
+
+		cs->szMsg = wcsdup(szMsg);
+	}
+	else if (szMsg != cs->szMsg) {
+		if (cs->szMsg != NULL)
+			free(cs->szMsg);
+
+		cs->szMsg = NULL;
+	}
+	return 0;
+}
+
+static int GetStatus(const TConnectionSettings& cs)
+{
+	if (cs.status == ID_STATUS_CURRENT)
+		return CallProtoService(cs.szName, PS_GETSTATUS, 0, 0);
+
+	return cs.status;
+}
+
+static int SetCurrentStatus()
+{
+	PROTOCOLSETTINGEX **ps = GetCurrentProtoSettingsCopy();
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		int realStatus = CallProtoService(ps[i]->szName, PS_GETSTATUS, 0, 0);
+		if (ps[i]->status == ID_STATUS_DISABLED || ps[i]->status == realStatus)	{ // ignore this proto by removing it's name (not so nice)
+			ps[i]->szName = "";
+		}
+		else if ((ps[i]->status != ID_STATUS_DISABLED) && (ps[i]->status != realStatus) && (realStatus != ID_STATUS_OFFLINE) && (db_get_b(NULL, KSMODULENAME, SETTING_FIRSTOFFLINE, FALSE))) {
+			// force offline before reconnecting
+			log_infoA("KeepStatus: Setting %s offline before making a new connection attempt", ps[i]->szName);
+			CallProtoService(ps[i]->szName, PS_SETSTATUS, (WPARAM)ID_STATUS_OFFLINE, 0);
+		}
+	}
+	ProcessPopup(KS_CONN_STATE_RETRY, (LPARAM)ps);
+	INT_PTR ret = CallService(MS_CS_SETSTATUSEX, (WPARAM)&ps, 0);
+	FreeProtoSettings(ps);
+
+	return ret;
+}
+
+static int StatusChange(WPARAM wParam, LPARAM lParam)
+{
+	char* szProto = (char *)lParam;
+	if (szProto == NULL) { // global status change
+		for (int i = 0; i < connectionSettings.getCount(); i++) {
+			TConnectionSettings& cs = connectionSettings[i];
+			if (GetStatus(cs) != ID_STATUS_DISABLED)
+				if (db_get_b(NULL, KSMODULENAME, SETTING_NOLOCKED, 0) ||
+					!db_get_b(NULL, cs.szName, "LockMainStatus", 0))
+					AssignStatus(&cs, wParam, 0, cs.szMsg);
+		}
+	}
+	else {
+		for (int i = 0; i < connectionSettings.getCount(); i++) {
+			TConnectionSettings& cs = connectionSettings[i];
+			if (GetStatus(cs) != ID_STATUS_DISABLED && !mir_strcmp(cs.szName, szProto))
+				AssignStatus(&cs, wParam, 0, cs.szMsg);
+		}
+	}
+
+	return 0;
+}
+
+static int CSStatusChange(WPARAM wParam, LPARAM)
+{
+	// the status was changed by commonstatus (old)
+	if (wParam != 0) {
+		PROTOCOLSETTING** protoSettings = *(PROTOCOLSETTING***)wParam;
+
+		if (protoSettings == NULL)
+			return -1;
+
+		for (int i = 0; i < connectionSettings.getCount(); i++) {
+			for (int j = 0; j < connectionSettings.getCount(); j++) {
+				if ((protoSettings[i]->szName == NULL) || (connectionSettings[j].szName == NULL))
+					continue;
+
+				if (!mir_strcmp(protoSettings[i]->szName, connectionSettings[j].szName))
+					if (GetStatus(connectionSettings[j]) != ID_STATUS_DISABLED)
+						AssignStatus(&connectionSettings[j], protoSettings[i]->status, protoSettings[i]->lastStatus, connectionSettings[j].szMsg);
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int CSStatusChangeEx(WPARAM wParam, LPARAM)
+{
+	// the status was changed by commonstatus (new)
+	if (wParam != 0) {
+		PROTOCOLSETTINGEX** protoSettings = *(PROTOCOLSETTINGEX***)wParam;
+
+		if (protoSettings == NULL)
+			return -1;
+
+		for (int i = 0; i < connectionSettings.getCount(); i++) {
+			for (int j = 0; j < connectionSettings.getCount(); j++) {
+				if ((protoSettings[i]->szName == NULL) || (connectionSettings[j].szName == NULL))
+					continue;
+				if (!mir_strcmp(protoSettings[i]->szName, connectionSettings[j].szName)) {
+					if (GetStatus(connectionSettings[j]) != ID_STATUS_DISABLED)
+						AssignStatus(&connectionSettings[j], protoSettings[i]->status, protoSettings[i]->lastStatus, protoSettings[i]->szMsg);
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int StartTimerFunction(int timer, int timeout, BOOL restart)
+{
+	int res = 0;
+
+	mir_cslock lck(GenTimerCS);
+	log_debugA("StartTimer: %d, %d, %d", timer, timeout, restart);
+	log_debugA("ack: %u, chk: %u, aft: %u, cnt: %u, con: %u", processAckTimerId, checkConnectionTimerId, afterCheckTimerId, checkContinTimerId, checkConnectingTimerId);
+	if (timer & IDT_PROCESSACK) {
+		res = (processAckTimerId == 0) ? 0 : 1;
+		if (((processAckTimerId == 0) && (checkConnectionTimerId == 0)) || (restart)) {
+			if (timeout != -1) {
+				if (restart)
+					KillTimer(NULL, processAckTimerId);
+				if (timeout == 0)
+					processAckTimerId = SetTimer(NULL, 0, ackDelay, CheckAckStatusTimer);
+				else
+					processAckTimerId = SetTimer(NULL, 0, timeout, CheckAckStatusTimer);
+			}
+		}
+	}
+
+	if (timer & IDT_CHECKCONN) {
+		res = (checkConnectionTimerId == 0 ? 0 : 1) || res;
+		if ((checkConnectionTimerId == 0) || (restart)) {
+			if (timeout != -1) {
+				if (restart)
+					KillTimer(NULL, checkConnectionTimerId);
+				if (timeout == 0)
+					checkConnectionTimerId = SetTimer(NULL, 0, initDelay, CheckConnectionTimer);
+				else
+					checkConnectionTimerId = SetTimer(NULL, 0, timeout, CheckConnectionTimer);
+			}
+		}
+	}
+
+	if (timer & IDT_AFTERCHECK) {
+		res = (afterCheckTimerId == 0 ? 0 : 1) || res;
+		if ((afterCheckTimerId == 0) || (restart)) {
+			if (timeout != -1) {
+				if (restart)
+					KillTimer(NULL, afterCheckTimerId);
+				if (timeout == 0)
+					afterCheckTimerId = SetTimer(NULL, 0, initDelay / 2, AfterCheckTimer);
+				else
+					afterCheckTimerId = SetTimer(NULL, 0, timeout, AfterCheckTimer);
+			}
+		}
+	}
+
+	if (timer & IDT_CHECKCONTIN) {
+		res = (checkContinTimerId == 0 ? 0 : 1) || res;
+		if ((checkContinTimerId == 0) || (restart)) {
+			if (timeout != -1) {
+				if (restart)
+					KillTimer(NULL, checkContinTimerId);
+				if (timeout == 0) {
+					checkContinTimerId = SetTimer(NULL, 0, 1000 * db_get_dw(NULL, KSMODULENAME, SETTING_CNTDELAY, CHECKCONTIN_DELAY), CheckContinueslyTimer);
+				}
+				else
+					checkContinTimerId = SetTimer(NULL, 0, timeout, CheckContinueslyTimer);
+			}
+		}
+	}
+
+	if (timer & IDT_CHECKCONNECTING) {
+		res = (checkConnectingTimerId == 0 ? 0 : 1) || res;
+		if ((checkConnectingTimerId == 0) || (restart)) {
+			if (timeout != -1) {
+				if (restart)
+					KillTimer(NULL, checkConnectingTimerId);
+				if (timeout == 0) {
+					timeout = initDelay / 2;
+				}
+				checkConnectingTimerId = SetTimer(NULL, 0, timeout, CheckConnectingTimer);
+			}
+		}
+	}
+
+	log_debugA("ack: %u, chk: %u, aft: %u, cnt: %u, con: %u", processAckTimerId, checkConnectionTimerId, afterCheckTimerId, checkContinTimerId, checkConnectingTimerId);
+	log_debugA("StartTimer done %d", res);
+
+	return res;
+}
+
+static VOID CALLBACK StartTimerApcProc(ULONG_PTR param)
+{
+	struct TimerInfo *ti = (struct TimerInfo *)param;
+	log_debugA("StartTimerApcProc %d %d %d", ti->timer, ti->timeout, ti->restart);
+	ti->result = StartTimerFunction(ti->timer, ti->timeout, ti->restart);
+	SetEvent(ti->hEvent);
+}
+
+static int StartTimer(int timer, int timeout, BOOL restart)
+{
+	if (GetCurrentThreadId() == mainThreadId)
+		return StartTimerFunction(timer, timeout, restart);
+
+	TimerInfo *ti = (TimerInfo*)calloc(1, sizeof(struct TimerInfo));
+	ti->timer = timer;
+	ti->timeout = timeout;
+	ti->restart = restart;
+	ti->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+	QueueUserAPC(StartTimerApcProc, hMainThread, (ULONG_PTR)ti);
+	WaitForSingleObject(ti->hEvent, INFINITE);
+	CloseHandle(ti->hEvent);
+	int res = ti->result;
+	free(ti);
+	return res;
+}
+
+static int StopTimer(int timer)
+{
+	int res = 0;
+
+	mir_cslock lck(GenTimerCS);
+	log_debugA("StopTimer %d", timer);
+	log_debugA("ack: %u, chk: %u, aft: %u, cnt: %u, con: %u", processAckTimerId, checkConnectionTimerId, afterCheckTimerId, checkContinTimerId, checkConnectingTimerId);
+
+	if (timer & IDT_PROCESSACK) {
+		if (processAckTimerId == 0)
+			res = 0;
+		else {
+			KillTimer(NULL, processAckTimerId);
+			processAckTimerId = 0;
+			res = 1;
+		}
+	}
+
+	if (timer & IDT_CHECKCONN) {
+		if (checkConnectionTimerId == 0)
+			res = 0 || res;
+		else {
+			KillTimer(NULL, checkConnectionTimerId);
+			checkConnectionTimerId = 0;
+			res = 1;
+		}
+	}
+
+	if (timer & IDT_AFTERCHECK) {
+		if (afterCheckTimerId == 0)
+			res = 0 || res;
+		else {
+			KillTimer(NULL, afterCheckTimerId);
+			afterCheckTimerId = 0;
+			res = 1;
+		}
+	}
+
+	if (timer & IDT_CHECKCONTIN) {
+		if (checkContinTimerId == 0)
+			res = 0 || res;
+		else {
+			KillTimer(NULL, checkContinTimerId);
+			checkContinTimerId = 0;
+			res = 1;
+		}
+	}
+
+	if (timer & IDT_CHECKCONNECTING) {
+		if (checkConnectingTimerId == 0)
+			res = 0 || res;
+		else {
+			KillTimer(NULL, checkConnectingTimerId);
+			checkConnectingTimerId = 0;
+			res = 1;
+		}
+	}
+
+	log_debugA("ack: %u, chk: %u, aft: %u, cnt: %u, con: %u", processAckTimerId, checkConnectionTimerId, afterCheckTimerId, checkContinTimerId, checkConnectingTimerId);
+	log_debugA("StopTimer done %d", res);
+
+	return res;
+}
+
+static int ProcessProtoAck(WPARAM, LPARAM lParam)
+{
+	ACKDATA *ack = (ACKDATA*)lParam;
+
+	if (ack->type != ACKTYPE_STATUS && ack->type != ACKTYPE_LOGIN)
+		return 0;
+
+	char dbSetting[128];
+	mir_snprintf(dbSetting, "%s_enabled", ack->szModule);
+	if (!db_get_b(NULL, KSMODULENAME, dbSetting, 1))
+		return 0;
+
+	if (ack->type == ACKTYPE_STATUS && ack->result == ACKRESULT_SUCCESS) {
+		for (int i = 0; i < connectionSettings.getCount(); i++) {
+			TConnectionSettings& cs = connectionSettings[i];
+			if (!mir_strcmp(cs.szName, ack->szModule))
+				cs.lastStatusAckTime = GetTickCount();
+		}
+		StartTimer(IDT_PROCESSACK, 0, FALSE);
+		return 0;
+	}
+
+	if (ack->type == ACKTYPE_LOGIN) {
+		if (ack->lParam == LOGINERR_OTHERLOCATION) {
+			for (int i = 0; i < connectionSettings.getCount(); i++) {
+				TConnectionSettings& cs = connectionSettings[i];
+				if (!mir_strcmp(ack->szModule, cs.szName)) {
+					AssignStatus(&cs, ID_STATUS_OFFLINE, 0, NULL);
+					if (db_get_b(NULL, KSMODULENAME, SETTING_CNCOTHERLOC, 0)) {
+						StopTimer(IDT_PROCESSACK);
+						for (int j = 0; j < connectionSettings.getCount(); j++) {
+							AssignStatus(&connectionSettings[j], ID_STATUS_OFFLINE, 0, NULL);
+						}
+					}
+
+					NotifyEventHooks(hConnectionEvent, (WPARAM)KS_CONN_STATE_OTHERLOCATION, (LPARAM)cs.szName);
+					ProcessPopup(KS_CONN_STATE_OTHERLOCATION, (LPARAM)ack->szModule);
+				}
+			}
+		}
+		else if (ack->result == ACKRESULT_FAILED) {
+			// login failed
+			NotifyEventHooks(hConnectionEvent, (WPARAM)KS_CONN_STATE_LOGINERROR, (LPARAM)ack->szModule);
+			switch (db_get_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_NOTHING)) {
+			case LOGINERR_CANCEL:
+			{
+				log_infoA("KeepStatus: cancel on login error (%s)", ack->szModule);
+				for (int i = 0; i < connectionSettings.getCount(); i++) {
+					TConnectionSettings& cs = connectionSettings[i];
+					if (!mir_strcmp(ack->szModule, cs.szName))
+						AssignStatus(&cs, ID_STATUS_OFFLINE, 0, NULL);
+				}
+				ProcessPopup(KS_CONN_STATE_LOGINERROR, (LPARAM)ack->szModule);
+				StopChecking();
+			}
+			break;
+
+			case LOGINERR_SETDELAY:
+			{
+				int newDelay = 1000 * db_get_dw(NULL, KSMODULENAME, SETTING_LOGINERR_DELAY, DEFAULT_MAXDELAY);
+				log_infoA("KeepStatus: set delay to %d on login error (%s)", newDelay / 1000, ack->szModule);
+				StartTimer(IDT_CHECKCONN, newDelay, TRUE);
+			}
+			ProcessPopup(KS_CONN_STATE_LOGINERROR, (LPARAM)ack->szModule);
+			break;
+
+			default:
+			case LOGINERR_NOTHING:
+				StartTimer(IDT_PROCESSACK, 0, FALSE);
+				break;
+			}
+		}
+	}
+
+	return 0;
+}
+
+static VOID CALLBACK CheckConnectingTimer(HWND, UINT, UINT_PTR, DWORD)
+{
+	int maxConnectingTime;
+
+	StopTimer(IDT_CHECKCONNECTING);
+	//log_debugA("KeepStatus: CheckConnectingTimer");
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+
+		int curStatus = GetStatus(cs);
+		if (IsStatusConnecting(curStatus)) { // connecting
+			maxConnectingTime = db_get_dw(NULL, KSMODULENAME, SETTING_MAXCONNECTINGTIME, 0);
+			if (maxConnectingTime > 0) {
+				if ((unsigned int)maxConnectingTime <= ((GetTickCount() - cs.lastStatusAckTime) / 1000)) {
+					// set offline
+					log_infoA("KeepStatus: %s is too long connecting; setting offline", cs.szName);
+					CallProtoService(cs.szName, PS_SETSTATUS, (WPARAM)ID_STATUS_OFFLINE, 0);
+				}
+			}
+		}
+	}
+}
+
+static VOID CALLBACK CheckAckStatusTimer(HWND, UINT, UINT_PTR, DWORD)
+{
+	int maxConnectingTime;
+	bool needChecking = false;
+
+	StopTimer(IDT_PROCESSACK);
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+
+		int curStatus = GetStatus(cs);
+		int newStatus = CallProtoService(cs.szName, PS_GETSTATUS, 0, 0);
+		// ok, np
+		if (curStatus == ID_STATUS_CURRENT || curStatus == ID_STATUS_DISABLED || curStatus == newStatus || newStatus > MAX_STATUS)
+			continue;
+
+		if (IsStatusConnecting(newStatus)) { // connecting
+			maxConnectingTime = db_get_dw(NULL, KSMODULENAME, SETTING_MAXCONNECTINGTIME, 0);
+			if (maxConnectingTime > 0)
+				StartTimer(IDT_CHECKCONNECTING, (maxConnectingTime * 1000 - (GetTickCount() - cs.lastStatusAckTime)), FALSE);
+		}
+		// keepstatus' administration was wrong!
+		else if (newStatus != ID_STATUS_OFFLINE)
+			AssignStatus(&cs, newStatus, 0, NULL);
+
+		// connection lost
+		else if (newStatus == ID_STATUS_OFFLINE) {// start checking connection
+			if (!StartTimer(IDT_CHECKCONN, -1, FALSE)) { /* check if not already checking */
+				needChecking = true;
+				log_infoA("KeepStatus: connection lost! (%s)", cs.szName);
+				NotifyEventHooks(hConnectionEvent, (WPARAM)KS_CONN_STATE_LOST, (LPARAM)cs.szName);
+				ProcessPopup(KS_CONN_STATE_LOST, (LPARAM)cs.szName);
+			}
+		}
+	}
+
+	if (needChecking)
+		StartTimer(IDT_CHECKCONN, initDelay, FALSE);
+}
+
+static VOID CALLBACK CheckConnectionTimer(HWND, UINT, UINT_PTR, DWORD)
+{
+	int shouldBeStatus, realStatus;
+	HICON hIcon;
+
+	log_debugA("CheckConnectionTimer");
+	bool setStatus = false;
+	if (showConnectionPopups)
+		hIcon = Skin_LoadIcon(SKINICON_STATUS_OFFLINE);
+
+	for (int i = 0; i < connectionSettings.getCount() && !setStatus; i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+		realStatus = CallProtoService(cs.szName, PS_GETSTATUS, 0, 0);
+		shouldBeStatus = GetStatus(cs);
+		if (shouldBeStatus == ID_STATUS_LAST)
+			shouldBeStatus = cs.lastStatus;
+		if (shouldBeStatus == ID_STATUS_DISABLED)
+			continue;
+		if ((shouldBeStatus != realStatus) && (realStatus == ID_STATUS_OFFLINE) || (realStatus < MIN_STATUS)) {
+			setStatus = true;
+			if (showConnectionPopups)
+				hIcon = Skin_LoadProtoIcon(cs.szName, ID_STATUS_OFFLINE);
+		}
+	}
+
+	// one of the status was wrong
+	if (setStatus && (maxRetries == -1 || retryCount < maxRetries)) {
+		if (increaseExponential)
+			currentDelay = min(2 * currentDelay, maxDelay);
+
+		if (((db_get_b(NULL, KSMODULENAME, SETTING_CHKINET, 0)) && (!InternetGetConnectedState(NULL, 0))) || ((db_get_b(NULL, KSMODULENAME, SETTING_BYPING, FALSE)) && (!bLastPingResult))) {
+			// no network
+			NotifyEventHooks(hConnectionEvent, (WPARAM)KS_CONN_STATE_RETRYNOCONN, (LPARAM)retryCount + 1);
+			ProcessPopup(KS_CONN_STATE_RETRYNOCONN, 0);
+		}
+		else {
+			NotifyEventHooks(hConnectionEvent, (WPARAM)KS_CONN_STATE_RETRY, (LPARAM)retryCount + 1);
+			/* set the status */
+			SetCurrentStatus();
+		}
+		retryCount += 1;
+		StartTimer(IDT_AFTERCHECK, min(currentDelay, AFTERCHECK_DELAY) / 2, FALSE);
+		StartTimer(IDT_CHECKCONN, currentDelay, TRUE); // restart this timer
+	}
+	else // all status set ok already, or stop checking
+		StopChecking();
+
+	log_debugA("CheckConnectionTimer done");
+}
+
+static int StopChecking()
+{
+	StopTimer(IDT_CHECKCONN | IDT_PROCESSACK | IDT_AFTERCHECK | IDT_CHECKCONNECTING);
+
+	BOOL isOk = TRUE;
+	for (int i = 0; i < connectionSettings.getCount() && isOk; i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+		int curStatus = GetStatus(cs);
+		int newStatus = CallProtoService(cs.szName, PS_GETSTATUS, 0, 0);
+		if (newStatus != curStatus && curStatus != ID_STATUS_DISABLED) {
+			AssignStatus(&cs, newStatus, 0, NULL);
+			isOk = FALSE;
+		}
+	}
+
+	NotifyEventHooks(hConnectionEvent, (WPARAM)KS_CONN_STATE_STOPPEDCHECKING, (LPARAM)isOk);
+	ProcessPopup(KS_CONN_STATE_STOPPEDCHECKING, (LPARAM)isOk);
+	log_infoA("KeepStatus: stop checking (%s)", isOk ? "success" : "failure");
+	retryCount = 0;
+	currentDelay = initDelay;
+
+	return 0;
+}
+
+static VOID CALLBACK AfterCheckTimer(HWND, UINT, UINT_PTR, DWORD)
+{
+	// after each connection check, this function is called to see if connection was recovered
+	StopTimer(IDT_AFTERCHECK);
+
+	bool setStatus = false;
+
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+		int realStatus = CallProtoService(cs.szName, PS_GETSTATUS, 0, 0);
+		int shouldBeStatus = GetStatus(cs);
+		if (shouldBeStatus == ID_STATUS_LAST) // this should never happen
+			shouldBeStatus = cs.lastStatus;
+		if (shouldBeStatus == ID_STATUS_DISABLED) //  (on ignoring proto)
+			continue;
+		if ((shouldBeStatus != realStatus) && (realStatus == ID_STATUS_OFFLINE) || (realStatus < MIN_STATUS))
+			setStatus = true;
+	}
+
+	if (!setStatus || retryCount == maxRetries)
+		StopChecking();
+}
+
+static void CheckContinueslyFunction(void *)
+{
+	Thread_SetName("KeepStatus: CheckContinueslyFunction");
+
+	static int pingFailures = 0;
+
+	// one at the time is enough, do it the 'easy' way
+	mir_cslock lck(CheckContinueslyCS);
+
+	// do a ping, even if reconnecting
+	bool doPing = false;
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+		int shouldBeStatus = GetStatus(cs);
+		if (shouldBeStatus == ID_STATUS_LAST)
+			shouldBeStatus = cs.lastStatus;
+
+		if (shouldBeStatus == ID_STATUS_DISABLED)
+			continue;
+
+		if (shouldBeStatus != ID_STATUS_OFFLINE) {
+			log_debugA("CheckContinueslyFunction: %s should be %d", cs.szName, shouldBeStatus);
+			doPing = true;
+		}
+	}
+
+	if (!doPing) {
+		log_debugA("CheckContinueslyFunction: All protocols should be offline, no need to check connection");
+		return;
+	}
+
+	BOOL ping = db_get_b(NULL, KSMODULENAME, SETTING_BYPING, FALSE);
+	if (ping) {
+		DBVARIANT dbv;
+		if (db_get(NULL, KSMODULENAME, SETTING_PINGHOST, &dbv))
+			ping = FALSE;
+		else {
+			char *start, *end;
+			char host[MAX_PATH];
+			DWORD *addr;
+			struct hostent *hostent;
+			char reply[sizeof(ICMP_ECHO_REPLY) + 8];
+
+			bLastPingResult = FALSE;
+			HANDLE hICMPFile = (HANDLE)IcmpCreateFile();
+			if (hICMPFile == INVALID_HANDLE_VALUE) {
+				bLastPingResult = TRUE;
+				log_infoA("KeepStatus: icmp.dll error (2)");
+			}
+			if (bLastPingResult == FALSE) {
+				start = dbv.pszVal;
+				while ((*start != '\0') && (!bLastPingResult)) {
+					end = start;
+					while ((*end != ' ') && (*end != '\0'))
+						end++;
+					memset(host, '\0', sizeof(host));
+					strncpy(host, start, end - start);
+					hostent = gethostbyname(host);
+					if (hostent != NULL) {
+						addr = (DWORD *)(*hostent->h_addr_list);
+						bLastPingResult = (IcmpSendEcho(hICMPFile, *addr, 0, 0, NULL, reply, sizeof(ICMP_ECHO_REPLY) + 8, 5000) != 0);
+
+						if (bLastPingResult)
+							pingFailures = 0;
+						else
+							pingFailures++;
+
+						log_debugA("CheckContinueslyFunction: pinging %s (result: %d/%d)", host, bLastPingResult, pingFailures);
+					}
+					else log_debugA("CheckContinueslyFunction: unable to resolve %s", host);
+
+					start = end;
+					while (*start == ' ')
+						start++;
+				}
+			}
+			IcmpCloseHandle(hICMPFile);
+		}
+		db_free(&dbv);
+	}
+
+	if (StartTimer(IDT_CHECKCONN, -1, FALSE)) {
+		return; // already connecting, leave
+	}
+
+	if (((!ping) && (!InternetGetConnectedState(NULL, 0))) || ((ping) && (!bLastPingResult) && (pingFailures >= db_get_w(NULL, KSMODULENAME, SETTING_PINGCOUNT, DEFAULT_PINGCOUNT)))) {
+		pingFailures = 0;
+
+		int count;
+		PROTOACCOUNT** protos;
+		Proto_EnumAccounts(&count, &protos);
+
+		for (int i = 0; i < count; i++) {
+			if (!IsSuitableProto(protos[i]))
+				continue;
+
+			if (IsStatusConnecting(CallProtoService(protos[i]->szModuleName, PS_GETSTATUS, 0, 0))) {
+				log_debugA("CheckContinueslyFunction: %s is connecting", protos[i]->szModuleName);
+				continue; // connecting, leave alone
+			}
+			if (IsProtocolEnabledService(0, (LPARAM)protos[i]->szModuleName)) {
+				log_debugA("CheckContinueslyFunction: forcing %s offline", protos[i]->szModuleName);
+				CallProtoService(protos[i]->szModuleName, PS_SETSTATUS, (WPARAM)ID_STATUS_OFFLINE, 0);
+			}
+		}
+		if (StartTimer(IDT_CHECKCONN | IDT_PROCESSACK, -1, FALSE)) {// are our 'set offlines' noticed?
+			log_debugA("CheckContinueslyFunction: currently checking");
+			return;
+		}
+		log_infoA("KeepStatus: connection lost! (continuesly check)");
+		NotifyEventHooks(hConnectionEvent, (WPARAM)KS_CONN_STATE_LOST, 0);
+		ProcessPopup(KS_CONN_STATE_LOST, 0);
+		maxRetries = db_get_b(NULL, KSMODULENAME, SETTING_MAXRETRIES, 0);
+		if (maxRetries == 0)
+			maxRetries = -1;
+		StartTimer(IDT_CHECKCONN, initDelay, FALSE);
+	}
+}
+
+static VOID CALLBACK CheckContinueslyTimer(HWND, UINT, UINT_PTR, DWORD)
+{
+	if (db_get_b(NULL, KSMODULENAME, SETTING_BYPING, FALSE))
+		mir_forkthread(CheckContinueslyFunction, NULL);
+	else
+		CheckContinueslyFunction(NULL);
+}
+
+// =============== popup ======================
+static wchar_t* GetHumanName(LPARAM lParam)
+{
+	PROTOACCOUNT *ProtoAccount = Proto_GetAccount((char*)lParam);
+	return (ProtoAccount != NULL) ? ProtoAccount->tszAccountName : TranslateT("Protocol");
+}
+
+static int ProcessPopup(int reason, LPARAM lParam)
+{
+	HICON hIcon = NULL;
+	wchar_t text[MAX_SECONDLINE];
+
+	if (!db_get_b(NULL, KSMODULENAME, SETTING_SHOWCONNECTIONPOPUPS, FALSE) || !ServiceExists(MS_POPUP_ADDPOPUPT))
+		return -1;
+
+	switch (reason) {
+	case KS_CONN_STATE_OTHERLOCATION: // lParam = 1 proto
+		if (!db_get_b(NULL, KSMODULENAME, SETTING_PUOTHER, TRUE))
+			return -1;
+
+		hIcon = Skin_LoadProtoIcon((char*)lParam, SKINICON_STATUS_OFFLINE);
+		mir_snwprintf(text, TranslateT("%s connected from another location"), GetHumanName(lParam));
+		break;
+
+	case KS_CONN_STATE_LOGINERROR:	// lParam = 1 proto
+		if (!db_get_b(NULL, KSMODULENAME, SETTING_PUOTHER, TRUE))
+			return -1;
+
+		hIcon = Skin_LoadProtoIcon((char*)lParam, SKINICON_STATUS_OFFLINE);
+		if (db_get_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_NOTHING) == LOGINERR_CANCEL)
+			mir_snwprintf(text, TranslateT("%s login error, cancel reconnecting"), GetHumanName(lParam));
+		else if (db_get_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_NOTHING) == LOGINERR_SETDELAY)
+			mir_snwprintf(text, TranslateT("%s login error (next retry (%d) in %d s)"), GetHumanName(lParam), retryCount + 1, db_get_dw(NULL, KSMODULENAME, SETTING_LOGINERR_DELAY, DEFAULT_MAXDELAY));
+		else
+			return -1;
+		break;
+
+	case KS_CONN_STATE_LOST: // lParam = 1 proto, or NULL
+		if (!db_get_b(NULL, KSMODULENAME, SETTING_PUCONNLOST, TRUE))
+			return -1;
+
+		if (lParam) { // Óêàçàòåëü íà èìÿ ìîäóëÿ. 
+			hIcon = Skin_LoadProtoIcon((char*)lParam, SKINICON_STATUS_OFFLINE);
+			mir_snwprintf(text, TranslateT("%s status error (next retry (%d) in %d s)"), GetHumanName(lParam), retryCount + 1, currentDelay / 1000);
+		}
+		else mir_snwprintf(text, TranslateT("Status error (next retry (%d) in %d s)"), retryCount + 1, currentDelay / 1000);
+		break;
+
+	case KS_CONN_STATE_RETRY:  // lParam = PROTOCOLSETTINGEX**
+		if (!db_get_b(NULL, KSMODULENAME, SETTING_PUCONNRETRY, TRUE))
+			return -1;
+		if (lParam) {
+			PROTOCOLSETTINGEX **ps = (PROTOCOLSETTINGEX **)lParam;
+			wchar_t protoInfoLine[512], protoInfo[MAX_SECONDLINE];
+			memset(protoInfoLine, '\0', sizeof(protoInfoLine));
+			memset(protoInfo, '\0', sizeof(protoInfo));
+			mir_wstrcpy(protoInfo, L"\r\n");
+			for (int i = 0; i < connectionSettings.getCount(); i++) {
+				if (mir_wstrlen(ps[i]->tszAccName) > 0 && mir_strlen(ps[i]->szName) > 0) {
+					if (db_get_b(NULL, KSMODULENAME, SETTING_PUSHOWEXTRA, TRUE)) {
+						mir_snwprintf(protoInfoLine, TranslateT("%s\t(will be set to %s)\r\n"), ps[i]->tszAccName, pcli->pfnGetStatusModeDescription(ps[i]->status, 0));
+						mir_wstrncat(protoInfo, protoInfoLine, _countof(protoInfo) - mir_wstrlen(protoInfo) - 1);
+					}
+				}
+			}
+			hIcon = Skin_LoadProtoIcon(ps[0]->szName, SKINICON_STATUS_OFFLINE);
+
+			rtrimw(protoInfo);
+			if (retryCount == (maxRetries - 1))
+				mir_snwprintf(text, TranslateT("Resetting status... (last try (%d))%s"), retryCount + 1, protoInfo);
+			else
+				mir_snwprintf(text, TranslateT("Resetting status... (next retry (%d) in %d s)%s"), retryCount + 2, currentDelay / 1000, protoInfo);
+		}
+		break;
+
+	case KS_CONN_STATE_RETRYNOCONN: // lParam = NULL
+		if (!db_get_b(NULL, KSMODULENAME, SETTING_PUOTHER, TRUE))
+			return -1;
+
+		if (retryCount == maxRetries - 1)
+			mir_snwprintf(text, TranslateT("No internet connection seems available... (last try (%d))"), retryCount + 1);
+		else
+			mir_snwprintf(text, TranslateT("No internet connection seems available... (next retry (%d) in %d s)"), retryCount + 2, currentDelay / 1000);
+		break;
+
+	case KS_CONN_STATE_STOPPEDCHECKING: // lParam == BOOL succes
+		if (!db_get_b(NULL, KSMODULENAME, SETTING_PURESULT, TRUE))
+			return -1;
+
+		if (lParam) {
+			hIcon = Skin_LoadIcon(SKINICON_STATUS_ONLINE);
+			mir_snwprintf(text, TranslateT("Status was set ok"));
+		}
+		else mir_snwprintf(text, TranslateT("Giving up"));
+		break;
+	}
+	if (hIcon == NULL)
+		hIcon = Skin_LoadIcon(SKINICON_STATUS_OFFLINE);
+
+	log_info(L"KeepStatus: %s", text);
+	return ShowPopup(text, hIcon);
+}
+
+static INT_PTR ShowPopup(wchar_t *msg, HICON hIcon)
+{
+	POPUPDATAT ppd = { 0 };
+	ppd.lchIcon = hIcon;
+	wcsncpy(ppd.lptzContactName, TranslateT("KeepStatus"), MAX_CONTACTNAME);
+	wcsncpy(ppd.lptzText, msg, MAX_SECONDLINE);
+	if (db_get_b(NULL, KSMODULENAME, SETTING_POPUP_USEWINCOLORS, 0)) {
+		ppd.colorBack = GetSysColor(COLOR_BTNFACE);
+		ppd.colorText = GetSysColor(COLOR_WINDOWTEXT);
+	}
+	else if (!db_get_b(NULL, KSMODULENAME, SETTING_POPUP_USEDEFCOLORS, 0)) {
+		ppd.colorBack = db_get_dw(NULL, KSMODULENAME, SETTING_POPUP_BACKCOLOR, 0xAAAAAA);
+		ppd.colorText = db_get_dw(NULL, KSMODULENAME, SETTING_POPUP_TEXTCOLOR, 0x0000CC);
+	}
+	ppd.PluginWindowProc = PopupDlgProc;
+
+	switch (db_get_b(NULL, KSMODULENAME, SETTING_POPUP_DELAYTYPE, POPUP_DELAYFROMPU)) {
+	case POPUP_DELAYCUSTOM:
+		ppd.iSeconds = (int)db_get_dw(NULL, KSMODULENAME, SETTING_POPUP_TIMEOUT, 0);
+		if (ppd.iSeconds == 0)
+			ppd.iSeconds = currentDelay / 1000 - 1;
+		break;
+
+	case POPUP_DELAYPERMANENT:
+		ppd.iSeconds = -1;
+		break;
+
+	case POPUP_DELAYFROMPU:
+	default:
+		ppd.iSeconds = 0;
+		break;
+	}
+	return PUAddPopupT(&ppd);
+}
+
+LRESULT CALLBACK PopupDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch (message) {
+	case WM_CONTEXTMENU: // right
+	case WM_COMMAND: // left
+		switch (db_get_b(NULL, KSMODULENAME,
+			(message == WM_COMMAND) ? SETTING_POPUP_LEFTCLICK : SETTING_POPUP_RIGHTCLICK,
+			POPUP_ACT_CLOSEPOPUP)) {
+		case POPUP_ACT_CANCEL:
+			// cancel timer
+			StopChecking();
+			PUDeletePopup(hWnd);
+			break;
+
+		case POPUP_ACT_CLOSEPOPUP:
+			// close the popup
+			PUDeletePopup(hWnd);
+			break;
+		}
+		break;
+	}
+
+	return DefWindowProc(hWnd, message, wParam, lParam);
+}
+
+// =============== services ===================
+INT_PTR StopReconnectingService(WPARAM, LPARAM)
+{
+	int ret = StartTimer(IDT_CHECKCONN | IDT_AFTERCHECK, -1, FALSE);
+	StopChecking();
+	return ret;
+}
+
+INT_PTR EnableProtocolService(WPARAM wParam, LPARAM lParam)
+{
+	char *szProto = (char *)lParam;
+	if (szProto == NULL)
+		return -1;
+
+	char dbSetting[128];
+	mir_snprintf(dbSetting, "%s_enabled", szProto);
+	if (!db_get_b(NULL, KSMODULENAME, dbSetting, 1)) // 'hard' disabled
+		return -1;
+
+	int ret = -2;
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+		if (!mir_strcmp(szProto, cs.szName)) {
+			if (wParam) {
+				if (GetStatus(cs) == ID_STATUS_DISABLED)
+					AssignStatus(&cs, CallProtoService(cs.szName, PS_GETSTATUS, 0, 0), 0, NULL);
+			}
+			else AssignStatus(&cs, ID_STATUS_DISABLED, 0, NULL);
+
+			ret = 0;
+			break;
+		}
+	}
+	return ret;
+}
+
+INT_PTR IsProtocolEnabledService(WPARAM, LPARAM lParam)
+{
+	char *szProto = (char *)lParam;
+
+	char dbSetting[128];
+	mir_snprintf(dbSetting, "%s_enabled", szProto);
+	if (!db_get_b(NULL, KSMODULENAME, dbSetting, 1))
+		return FALSE;
+
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+		if (!mir_strcmp(szProto, cs.szName))
+			return GetStatus(cs) != ID_STATUS_DISABLED;
+	}
+
+	return FALSE;
+}
+
+INT_PTR AnnounceStatusChangeService(WPARAM, LPARAM lParam)
+{
+	PROTOCOLSETTINGEX *newSituation = (PROTOCOLSETTINGEX *)lParam;
+	log_infoA("Another plugin announced a status change to %d for %s", newSituation->status, newSituation->szName == NULL ? "all" : newSituation->szName);
+
+	for (int i = 0; i < connectionSettings.getCount(); i++) {
+		TConnectionSettings& cs = connectionSettings[i];
+		if (!mir_strcmp(cs.szName, newSituation->szName))
+			AssignStatus(&cs, newSituation->status, newSituation->lastStatus, newSituation->szMsg);
+	}
+
+	return 0;
+}
+
+// =============== window for suspend ===============
+
+static DWORD CALLBACK MessageWndProc(HWND, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static PROTOCOLSETTINGEX** ps = NULL;
+
+	switch (msg) {
+	case WM_POWERBROADCAST:
+		switch (wParam) {
+		case PBT_APMSUSPEND:
+			log_infoA("KeepStatus: suspend state detected: %08X %08X", wParam, lParam);
+			if (ps == NULL) {
+				ps = GetCurrentProtoSettingsCopy();
+				for (int i = 0; i < connectionSettings.getCount(); i++)
+					EnableProtocolService(0, (LPARAM)ps[i]->szName);
+
+				// set proto's offline, the clist will not try to reconnect in that case
+				CallService(MS_CLIST_SETSTATUSMODE, (WPARAM)ID_STATUS_OFFLINE, 0);
+			}
+			break;
+
+			//case PBT_APMRESUMEAUTOMATIC: ?
+		case PBT_APMRESUMESUSPEND:
+		case PBT_APMRESUMECRITICAL:
+			log_infoA("KeepStatus: resume from suspend state");
+			if (ps != NULL) {
+				for (int i = 0; i < connectionSettings.getCount(); i++)
+					AssignStatus(&connectionSettings[i], ps[i]->status, ps[i]->lastStatus, ps[i]->szMsg);
+				FreeProtoSettings(ps);
+				ps = NULL;
+			}
+			StartTimer(IDT_PROCESSACK, 0, FALSE);
+			break;
+		}
+		break;
+
+	case WM_DESTROY:
+		if (ps != NULL) {
+			FreeProtoSettings(ps);
+			ps = NULL;
+		}
+		break;
+	}
+
+	return TRUE;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Account control event
+
+int OnKSAccChanged(WPARAM wParam, LPARAM lParam)
+{
+	PROTOACCOUNT *pa = (PROTOACCOUNT*)lParam;
+	switch (wParam) {
+	case PRAC_ADDED:
+		connectionSettings.insert(new TConnectionSettings(pa));
+		break;
+
+	case PRAC_REMOVED:
+		for (int i = 0; i < connectionSettings.getCount(); i++) {
+			if (!mir_strcmp(connectionSettings[i].szName, pa->szModuleName)) {
+				connectionSettings.remove(i);
+				break;
+			}
+		}
+		break;
+	}
+	return 0;
+}
+
+// =============== init stuff =================
+
+static int onShutdown(WPARAM, LPARAM)
+{
+	UnhookEvent(hStatusChangeHook);
+	UnhookEvent(hProtoAckHook);
+	UnhookEvent(hCSStatusChangeHook);
+	UnhookEvent(hCSStatusChangeExHook);
+
+	StopTimer(IDT_CHECKCONN | IDT_PROCESSACK | IDT_AFTERCHECK | IDT_CHECKCONTIN);
+	if (IsWindow(hMessageWindow))
+		DestroyWindow(hMessageWindow);
+
+	connectionSettings.destroy();
+
+	return 0;
+}
+
+int KSCSModuleLoaded(WPARAM, LPARAM)
+{
+	protoList = (OBJLIST<PROTOCOLSETTINGEX>*)&connectionSettings;
+
+	hMessageWindow = NULL;
+	KSLoadMainOptions();
+
+	HookEvent(ME_OPT_INITIALISE, KeepStatusOptionsInit);
+	HookEvent(ME_SYSTEM_PRESHUTDOWN, onShutdown);
+	HookEvent(ME_PROTO_ACCLISTCHANGED, OnKSAccChanged);
+	return 0;
+}
diff --git a/plugins/StatusManager/src/keepstatus.h b/plugins/StatusManager/src/keepstatus.h
new file mode 100644
index 0000000000..d44b312e80
--- /dev/null
+++ b/plugins/StatusManager/src/keepstatus.h
@@ -0,0 +1,128 @@
+/*
+	KeepStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	*/
+
+#ifndef __KEEPSTATUS_HEADER
+#define __KEEPSTATUS_HEADER
+
+
+#define KSMODULENAME                 "KeepStatus"
+#define SETTING_CHECKCONNECTION      "CheckConnection"
+#define SETTING_MAXRETRIES           "MaxRetries"
+#define SETTING_INCREASEEXPONENTIAL  "IncreaseExponential"
+#define SETTING_INITDELAY            "InitDelay"
+#define SETTING_MAXDELAY             "MaxDelay"
+#define SETTING_SHOWCONNECTIONPOPUPS "ShowConnectionPopups"
+#define SETTING_CHKINET              "CheckInet"
+#define SETTING_CNCOTHERLOC          "CancelIfOtherLocation"
+#define SETTING_LOGINERR             "OnLoginErr"
+#define SETTING_LOGINERR_DELAY       "OnLoginErrDelay"
+#define SETTING_CONTCHECK            "ContinueslyCheck"
+#define SETTING_BYPING               "ByPingingHost"
+#define SETTING_PINGHOST             "HostToPing"
+#define SETTING_CHECKAPMRESUME       "CheckAPMResume"
+#define SETTING_FIRSTOFFLINE         "FirstOffline"
+#define SETTING_NOLOCKED             "NoLocked"
+#define SETTING_MAXCONNECTINGTIME    "MaxConnectingTime"
+#define SETTING_PINGCOUNT            "PingCount"
+#define DEFAULT_PINGCOUNT            1
+#define SETTING_CNTDELAY             "CntDelay"
+#define STATUSCHANGEDELAY            500 // ms
+#define DEFAULT_MAXRETRIES           0
+#define DEFAULT_INITDELAY            10 // s
+#define DEFAULT_MAXDELAY             900 // s
+#define AFTERCHECK_DELAY             10000 //ms (divided by 2)
+#define CHECKCONTIN_DELAY            10 // s
+#define SETTING_POPUP_DELAYTYPE      "PopupDelayType"
+#define SETTING_POPUP_USEWINCOLORS   "PopupUseWinColors"
+#define SETTING_POPUP_USEDEFCOLORS   "PopupUseDefColors"
+#define SETTING_POPUP_BACKCOLOR      "PopupBackColor"
+#define SETTING_POPUP_TEXTCOLOR      "PopupTextColor"
+#define SETTING_POPUP_TIMEOUT        "PopupTimeout"
+#define SETTING_POPUP_LEFTCLICK      "PopupLeftClickAction"
+#define SETTING_POPUP_RIGHTCLICK     "PopupRightClickAction"
+#define SETTING_PUOTHER              "PopupShowOther"
+#define SETTING_PUCONNLOST           "PopupShowConnLost"
+#define SETTING_PUCONNRETRY          "PopupShowConnRetry"
+#define SETTING_PURESULT             "PopupShowResult"
+#define SETTING_PUSHOWEXTRA          "PopupShowExtra"
+#define POPUP_ACT_NOTHING            0
+#define POPUP_ACT_CANCEL             1
+#define POPUP_ACT_CLOSEPOPUP         2
+#define POPUP_DELAYFROMPU            0
+#define POPUP_DELAYCUSTOM            1
+#define POPUP_DELAYPERMANENT         2
+#define LOGINERR_NOTHING             0
+#define LOGINERR_CANCEL              1
+#define LOGINERR_SETDELAY            2
+
+#define IDT_PROCESSACK               0x01
+#define IDT_CHECKCONN                0x02
+#define IDT_AFTERCHECK               0x04
+#define IDT_CHECKCONTIN              0x08
+#define IDT_CHECKCONNECTING          0x10
+
+#define KS_ISENABLED                 WM_APP + 10
+#define KS_ENABLEITEMS               WM_APP + 11
+
+// action
+#define SETTING_ENABLECHECKING       "EnableChecking"
+// trigger
+#define TRIGGERNAME                  "KeepStatus: Connection state change"
+#define TRIGGER_CONNLOST             0x01
+#define TRIGGER_LOGINERROR           0x02
+#define TRIGGER_OTHERLOC             0x04
+#define TRIGGER_CONNRETRY            0x08
+#define TRIGGER_CONNSUCCESS          0x10
+#define TRIGGER_CONNGIVEUP           0x20
+#define SETTING_TRIGGERON            "TriggerOn"
+
+struct TConnectionSettings : public PROTOCOLSETTINGEX
+{
+	TConnectionSettings(PROTOACCOUNT *pa);
+	~TConnectionSettings();
+
+	int lastStatusAckTime; // the time the last status ack was received
+};
+
+/* old; replaced by PROTOCOLSETTINGEX see m_statusplugins.h */
+typedef struct {
+	char *szName;	// pointer to protocol modulename
+	WORD status;	// the status
+	WORD lastStatus;// last status
+} PROTOCOLSETTING;
+
+/* old; replaced by ME_CS_STATUSCHANGE see m_statusplugins.h */
+// wParam = PROTOCOLSETTING**
+// lParam = 0
+#define ME_CS_STATUSCHANGE				"CommonStatus/StatusChange"
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// main.cpp
+
+extern HINSTANCE hInst;
+extern HANDLE hMainThread;
+extern unsigned long mainThreadId;
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// keepstatus.cpp
+
+int KSLoadMainOptions();
+LRESULT CALLBACK PopupDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+#endif //__KEEPSTATUS_HEADER
diff --git a/plugins/StatusManager/src/ks_options.cpp b/plugins/StatusManager/src/ks_options.cpp
new file mode 100644
index 0000000000..e717025dfb
--- /dev/null
+++ b/plugins/StatusManager/src/ks_options.cpp
@@ -0,0 +1,590 @@
+/*
+	KeepStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	*/
+
+#include "stdafx.h"
+
+// prototypes
+INT_PTR CALLBACK OptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
+INT_PTR CALLBACK PopupOptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);
+
+static INT_PTR CALLBACK DlgProcKSBasicOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch (msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+		{
+			LVCOLUMN lvCol;
+			LVITEM lvItem;
+			DBVARIANT dbv;
+
+			SetDlgItemInt(hwndDlg, IDC_MAXRETRIES, db_get_b(NULL, KSMODULENAME, SETTING_MAXRETRIES, DEFAULT_MAXRETRIES), FALSE);
+			SetDlgItemInt(hwndDlg, IDC_INITDELAY, db_get_dw(NULL, KSMODULENAME, SETTING_INITDELAY, DEFAULT_INITDELAY), FALSE);
+			CheckDlgButton(hwndDlg, IDC_CHECKCONNECTION, db_get_b(NULL, KSMODULENAME, SETTING_CHECKCONNECTION, FALSE) ? BST_CHECKED : BST_UNCHECKED);
+			CheckDlgButton(hwndDlg, IDC_SHOWCONNECTIONPOPUPS, (db_get_b(NULL, KSMODULENAME, SETTING_SHOWCONNECTIONPOPUPS, FALSE) && ServiceExists(MS_POPUP_SHOWMESSAGE)) ? BST_CHECKED : BST_UNCHECKED);
+			CheckDlgButton(hwndDlg, IDC_CHKINET, db_get_b(NULL, KSMODULENAME, SETTING_CHKINET, FALSE) ? BST_CHECKED : BST_UNCHECKED);
+			CheckDlgButton(hwndDlg, IDC_CONTCHECK, db_get_b(NULL, KSMODULENAME, SETTING_CONTCHECK, FALSE) ? BST_CHECKED : BST_UNCHECKED);
+			CheckDlgButton(hwndDlg, IDC_BYPING, db_get_b(NULL, KSMODULENAME, SETTING_BYPING, FALSE) ? BST_CHECKED : BST_UNCHECKED);
+			if (!db_get_s(NULL, KSMODULENAME, SETTING_PINGHOST, &dbv)) {
+				SetDlgItemTextA(hwndDlg, IDC_PINGHOST, dbv.pszVal);
+				db_free(&dbv);
+			}
+			// proto list
+			HWND hList = GetDlgItem(hwndDlg, IDC_PROTOCOLLIST);
+			ListView_SetExtendedListViewStyleEx(hList, LVS_EX_FULLROWSELECT | LVS_EX_CHECKBOXES, LVS_EX_FULLROWSELECT | LVS_EX_CHECKBOXES);
+			memset(&lvCol, 0, sizeof(lvCol));
+			lvCol.mask = LVCF_WIDTH | LVCF_TEXT;
+			lvCol.pszText = TranslateT("Protocol");
+			lvCol.cx = 118;
+			ListView_InsertColumn(hList, 0, &lvCol);
+			// fill the list
+			memset(&lvItem, 0, sizeof(lvItem));
+			lvItem.mask = LVIF_TEXT | LVIF_PARAM;
+			lvItem.iItem = 0;
+			lvItem.iSubItem = 0;
+
+			int count;
+			PROTOACCOUNT** protos;
+			Proto_EnumAccounts(&count, &protos);
+
+			for (int i = 0; i < count; i++) {
+				if (!IsSuitableProto(protos[i]))
+					continue;
+
+				lvItem.pszText = protos[i]->tszAccountName;
+				lvItem.lParam = (LPARAM)protos[i]->szModuleName;
+				ListView_InsertItem(hList, &lvItem);
+
+				char dbSetting[128];
+				mir_snprintf(dbSetting, "%s_enabled", protos[i]->szModuleName);
+				ListView_SetCheckState(hList, lvItem.iItem, db_get_b(NULL, KSMODULENAME, dbSetting, TRUE));
+				lvItem.iItem++;
+			}
+			EnableWindow(GetDlgItem(hwndDlg, IDC_MAXRETRIES), IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_SHOWCONNECTIONPOPUPS), ServiceExists(MS_POPUP_SHOWMESSAGE) && IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_INITDELAY), IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_PROTOCOLLIST), IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_CHKINET), IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_CONTCHECK), IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_BYPING), (IsDlgButtonChecked(hwndDlg, IDC_CONTCHECK) && IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION)) ? TRUE : FALSE);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_PINGHOST), (IsDlgButtonChecked(hwndDlg, IDC_CONTCHECK)) && (IsDlgButtonChecked(hwndDlg, IDC_BYPING) && IsDlgButtonChecked(hwndDlg, IDC_CHECKCONNECTION)) ? TRUE : FALSE);
+		}
+		break;
+
+	case WM_COMMAND:
+		if (((HIWORD(wParam) == EN_CHANGE) || (HIWORD(wParam) == BN_CLICKED)) && ((HWND)lParam == GetFocus()))
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+		// something changed
+		switch (LOWORD(wParam)) {
+		case IDC_CHECKCONNECTION:
+		case IDC_CONTCHECK:
+		case IDC_BYPING:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_MAXRETRIES), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_SHOWCONNECTIONPOPUPS), ServiceExists(MS_POPUP_SHOWMESSAGE) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_INITDELAY), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_PROTOCOLLIST), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_CHKINET), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_CONTCHECK), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_BYPING), (IsDlgButtonChecked(hwndDlg, IDC_CONTCHECK) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0)) ? TRUE : FALSE);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_PINGHOST), (IsDlgButtonChecked(hwndDlg, IDC_CONTCHECK)) && (IsDlgButtonChecked(hwndDlg, IDC_BYPING) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0)) ? TRUE : FALSE);
+			break;
+		}
+		break;
+
+	case WM_NOTIFY:
+		if (((NMHDR*)lParam)->idFrom == IDC_PROTOCOLLIST) {
+			switch (((NMHDR*)lParam)->code) {
+			case LVN_ITEMCHANGED:
+			{
+				NMLISTVIEW *nmlv = (NMLISTVIEW *)lParam;
+				if (IsWindowVisible(GetDlgItem(hwndDlg, IDC_PROTOCOLLIST)) && ((nmlv->uNewState^nmlv->uOldState)&LVIS_STATEIMAGEMASK))
+					SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+			}
+			break;
+			}
+		}
+
+		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
+			int i;
+			LVITEM lvItem;
+
+			db_set_b(NULL, KSMODULENAME, SETTING_MAXRETRIES, (BYTE)GetDlgItemInt(hwndDlg, IDC_MAXRETRIES, NULL, FALSE));
+			db_set_b(NULL, KSMODULENAME, SETTING_CHECKCONNECTION, (BYTE)SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			db_set_b(NULL, KSMODULENAME, SETTING_SHOWCONNECTIONPOPUPS, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SHOWCONNECTIONPOPUPS));
+			db_set_dw(NULL, KSMODULENAME, SETTING_INITDELAY, (DWORD)GetDlgItemInt(hwndDlg, IDC_INITDELAY, NULL, FALSE));
+			db_set_b(NULL, KSMODULENAME, SETTING_CHKINET, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_CHKINET));
+			db_set_b(NULL, KSMODULENAME, SETTING_CONTCHECK, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_CONTCHECK));
+			db_set_b(NULL, KSMODULENAME, SETTING_BYPING, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_BYPING));
+			if (IsDlgButtonChecked(hwndDlg, IDC_BYPING)) {
+				char *host;
+
+				int len = SendDlgItemMessage(hwndDlg, IDC_PINGHOST, WM_GETTEXTLENGTH, 0, 0);
+				if (len > 0) {
+					host = (char*)malloc(len + 1);
+					if (host != NULL) {
+						memset(host, '\0', len + 1);
+						GetDlgItemTextA(hwndDlg, IDC_PINGHOST, host, len + 1);
+						db_set_s(NULL, KSMODULENAME, SETTING_PINGHOST, host);
+					}
+				}
+			}
+			HWND hList = GetDlgItem(hwndDlg, IDC_PROTOCOLLIST);
+			memset(&lvItem, 0, sizeof(lvItem));
+			lvItem.mask = LVIF_PARAM;
+			for (i = 0; i < ListView_GetItemCount(hList); i++) {
+				lvItem.iItem = i;
+				lvItem.iSubItem = 0;
+				ListView_GetItem(hList, &lvItem);
+
+				char dbSetting[128];
+				mir_snprintf(dbSetting, "%s_enabled", (char *)lvItem.lParam);
+				db_set_b(NULL, KSMODULENAME, dbSetting, (BYTE)ListView_GetCheckState(hList, lvItem.iItem));
+			}
+		}
+		break;
+	}
+
+	return 0;
+}
+
+static INT_PTR CALLBACK DlgProcKSAdvOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch (msg) {
+	case WM_INITDIALOG: {
+		TranslateDialogDefault(hwndDlg);
+		SetDlgItemInt(hwndDlg, IDC_MAXDELAY, db_get_dw(NULL, KSMODULENAME, SETTING_MAXDELAY, DEFAULT_MAXDELAY), FALSE);
+		SetDlgItemInt(hwndDlg, IDC_MAXCONNECTINGTIME, db_get_dw(NULL, KSMODULENAME, SETTING_MAXCONNECTINGTIME, 0), FALSE);
+		CheckDlgButton(hwndDlg, IDC_INCREASEEXPONENTIAL, db_get_b(NULL, KSMODULENAME, SETTING_INCREASEEXPONENTIAL, FALSE) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_CNCOTHERLOC, (db_get_b(NULL, KSMODULENAME, SETTING_CNCOTHERLOC, FALSE) && (CallService(MS_SYSTEM_GETVERSION, 0, 0) >= 0x00040000)) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_LOGINERR, db_get_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_NOTHING) == LOGINERR_NOTHING ? BST_UNCHECKED : BST_CHECKED);
+		CheckDlgButton(hwndDlg, IDC_CHECKAPMRESUME, (db_get_b(NULL, KSMODULENAME, SETTING_CHECKAPMRESUME, FALSE) && (CallService(MS_SYSTEM_GETVERSION, 0, 0) >= 0x00040000)) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_FIRSTOFFLINE, (db_get_b(NULL, KSMODULENAME, SETTING_FIRSTOFFLINE, FALSE)) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_NOLOCKED, (db_get_b(NULL, KSMODULENAME, SETTING_NOLOCKED, FALSE)) ? BST_CHECKED : BST_UNCHECKED);
+		SetDlgItemInt(hwndDlg, IDC_LOGINERR_DELAY, db_get_dw(NULL, KSMODULENAME, SETTING_LOGINERR_DELAY, DEFAULT_MAXDELAY), FALSE);
+		SetDlgItemInt(hwndDlg, IDC_PINGCOUNT, db_get_w(NULL, KSMODULENAME, SETTING_PINGCOUNT, DEFAULT_PINGCOUNT), FALSE);
+		SetDlgItemInt(hwndDlg, IDC_CNTDELAY, db_get_dw(NULL, KSMODULENAME, SETTING_CNTDELAY, CHECKCONTIN_DELAY), FALSE);
+		switch (db_get_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_CANCEL)) {
+		case LOGINERR_SETDELAY:
+			CheckRadioButton(hwndDlg, IDC_LOGINERR_CANCEL, IDC_LOGINERR_SETDELAY, IDC_LOGINERR_SETDELAY);
+			break;
+		default:
+		case LOGINERR_CANCEL:
+			CheckRadioButton(hwndDlg, IDC_LOGINERR_CANCEL, IDC_LOGINERR_SETDELAY, IDC_LOGINERR_CANCEL);
+			break;
+		}
+		SendMessage(hwndDlg, KS_ENABLEITEMS, 0, 0);
+		break;
+	}
+	case WM_COMMAND:
+		if (((HIWORD(wParam) == EN_CHANGE) || (HIWORD(wParam) == BN_CLICKED)) && ((HWND)lParam == GetFocus()))
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+		// something changed
+		switch (LOWORD(wParam)) {
+		case IDC_INCREASEEXPONENTIAL:
+		case IDC_LOGINERR:
+			SendMessage(hwndDlg, KS_ENABLEITEMS, 0, 0);
+			break;
+
+		case IDC_LOGINERR_CANCEL:
+		case IDC_LOGINERR_SETDELAY:
+			CheckRadioButton(hwndDlg, IDC_LOGINERR_CANCEL, IDC_LOGINERR_SETDELAY, LOWORD(wParam));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_LOGINERR_DELAY), IsDlgButtonChecked(hwndDlg, IDC_LOGINERR_SETDELAY) && IsDlgButtonChecked(hwndDlg, IDC_LOGINERR) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+			break;
+		}
+		break;
+
+	case WM_NOTIFY:
+		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
+			db_set_b(NULL, KSMODULENAME, SETTING_INCREASEEXPONENTIAL, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_INCREASEEXPONENTIAL));
+			db_set_dw(NULL, KSMODULENAME, SETTING_MAXDELAY, (DWORD)GetDlgItemInt(hwndDlg, IDC_MAXDELAY, NULL, FALSE));
+			db_set_dw(NULL, KSMODULENAME, SETTING_MAXCONNECTINGTIME, (DWORD)GetDlgItemInt(hwndDlg, IDC_MAXCONNECTINGTIME, NULL, FALSE));
+			db_set_b(NULL, KSMODULENAME, SETTING_FIRSTOFFLINE, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_FIRSTOFFLINE));
+			db_set_b(NULL, KSMODULENAME, SETTING_NOLOCKED, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_NOLOCKED));
+			db_set_b(NULL, KSMODULENAME, SETTING_CNCOTHERLOC, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_CNCOTHERLOC));
+			db_set_b(NULL, KSMODULENAME, SETTING_LOGINERR, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_LOGINERR));
+			if (IsDlgButtonChecked(hwndDlg, IDC_LOGINERR)) {
+				if (IsDlgButtonChecked(hwndDlg, IDC_LOGINERR_SETDELAY)) {
+					db_set_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_SETDELAY);
+					db_set_dw(NULL, KSMODULENAME, SETTING_LOGINERR_DELAY, GetDlgItemInt(hwndDlg, IDC_LOGINERR_DELAY, NULL, FALSE));
+				}
+				else db_set_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_CANCEL);
+			}
+			else db_set_b(NULL, KSMODULENAME, SETTING_LOGINERR, LOGINERR_NOTHING);
+
+			db_set_b(NULL, KSMODULENAME, SETTING_CHECKAPMRESUME, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_CHECKAPMRESUME));
+			db_set_w(NULL, KSMODULENAME, SETTING_PINGCOUNT, (WORD)GetDlgItemInt(hwndDlg, IDC_PINGCOUNT, NULL, FALSE));
+			db_set_dw(NULL, KSMODULENAME, SETTING_CNTDELAY, (DWORD)GetDlgItemInt(hwndDlg, IDC_CNTDELAY, NULL, FALSE) == 0 ? CHECKCONTIN_DELAY : GetDlgItemInt(hwndDlg, IDC_CNTDELAY, NULL, FALSE));
+		}
+		break;
+
+	case KS_ENABLEITEMS:
+		EnableWindow(GetDlgItem(hwndDlg, IDC_INCREASEEXPONENTIAL), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_MAXCONNECTINGTIME), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_CNCOTHERLOC), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0) && (CallService(MS_SYSTEM_GETVERSION, 0, 0) >= 0x00040000));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_LOGINERR), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_LOGINERR_SETDELAY), IsDlgButtonChecked(hwndDlg, IDC_LOGINERR) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_LOGINERR_DELAY), IsDlgButtonChecked(hwndDlg, IDC_LOGINERR_SETDELAY) && IsDlgButtonChecked(hwndDlg, IDC_LOGINERR) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_LOGINERR_CANCEL), IsDlgButtonChecked(hwndDlg, IDC_LOGINERR) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_MAXDELAY), (IsDlgButtonChecked(hwndDlg, IDC_INCREASEEXPONENTIAL) && SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0)) ? TRUE : FALSE);
+		EnableWindow(GetDlgItem(hwndDlg, IDC_CHECKAPMRESUME), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0) && (CallService(MS_SYSTEM_GETVERSION, 0, 0) >= 0x00040000));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_FIRSTOFFLINE), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_NOLOCKED), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CHECKCONNECTION, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_PINGCOUNT), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_BYPING, 0));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_CNTDELAY), SendMessage(GetParent(hwndDlg), KS_ISENABLED, (WPARAM)IDC_CONTCHECK, 0));
+		break;
+
+	case WM_SHOWWINDOW:
+		if (wParam)
+			SendMessage(hwndDlg, KS_ENABLEITEMS, 0, 0);
+
+		break;
+	}
+
+	return 0;
+}
+
+static INT_PTR CALLBACK DlgProcKsTabs(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static HWND hBasicTab;
+
+	switch (msg) {
+	case WM_INITDIALOG:
+	{
+		HWND hShow, hPage;
+		RECT rcTabs, rcOptions, rcPage;
+
+		TranslateDialogDefault(hwndDlg);
+
+		// set tabs
+		int tabCount = 0;
+		HWND hTab = GetDlgItem(hwndDlg, IDC_TABS);
+		GetWindowRect(hTab, &rcTabs);
+		GetWindowRect(hwndDlg, &rcOptions);
+
+		// basic tab
+		TCITEM tci;
+		memset(&tci, 0, sizeof(TCITEM));
+		tci.mask = TCIF_TEXT | TCIF_PARAM;
+		tci.pszText = TranslateT("Basic");
+		hShow = hBasicTab = hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_OPT_KS_BASIC), hwndDlg, DlgProcKSBasicOpts, (LPARAM)GetParent(hwndDlg));
+		EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
+
+		tci.lParam = (LPARAM)hPage;
+		GetClientRect(hPage, &rcPage);
+		MoveWindow(hPage, (rcTabs.left - rcOptions.left) + ((rcTabs.right - rcTabs.left) - (rcPage.right - rcPage.left)) / 2, 10 + (rcTabs.top - rcOptions.top) + ((rcTabs.bottom - rcTabs.top) - (rcPage.bottom - rcPage.top)) / 2, rcPage.right - rcPage.left, rcPage.bottom - rcPage.top, TRUE);
+		ShowWindow(hPage, SW_HIDE);
+		TabCtrl_InsertItem(hTab, tabCount++, &tci);
+
+		// advanced tab
+		tci.mask = TCIF_TEXT | TCIF_PARAM;
+		tci.pszText = TranslateT("Advanced");
+		hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_OPT_KS_ADV), hwndDlg, DlgProcKSAdvOpts, (LPARAM)GetParent(hwndDlg));
+		EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
+
+		tci.lParam = (LPARAM)hPage;
+		GetClientRect(hPage, &rcPage);
+		MoveWindow(hPage, (rcTabs.left - rcOptions.left) + ((rcTabs.right - rcTabs.left) - (rcPage.right - rcPage.left)) / 2, 10 + (rcTabs.top - rcOptions.top) + ((rcTabs.bottom - rcTabs.top) - (rcPage.bottom - rcPage.top)) / 2, rcPage.right - rcPage.left, rcPage.bottom - rcPage.top, TRUE);
+		ShowWindow(hPage, SW_HIDE);
+		TabCtrl_InsertItem(hTab, tabCount++, &tci);
+		ShowWindow(hShow, SW_SHOW);
+	}
+	break;
+
+	case KS_ISENABLED:
+		SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)IsDlgButtonChecked(hBasicTab, wParam));
+		return TRUE;
+
+	case PSM_CHANGED:
+		SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+		break;
+
+	case WM_NOTIFY:
+		if ((((NMHDR*)lParam)->idFrom == IDC_TABS)) {
+			if (((NMHDR*)lParam)->code == TCN_SELCHANGING) {
+				TCITEM tci;
+
+				tci.mask = TCIF_PARAM;
+				TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_TABS)), &tci);
+				ShowWindow((HWND)tci.lParam, SW_HIDE);
+			}
+			else if (((NMHDR*)lParam)->code == TCN_SELCHANGE) {
+				TCITEM tci;
+
+				tci.mask = TCIF_PARAM;
+				TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_TABS)), &tci);
+				ShowWindow((HWND)tci.lParam, SW_SHOW);
+			}
+		}
+		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
+			TCITEM tci;
+			int i, count;
+
+			tci.mask = TCIF_PARAM;
+			count = TabCtrl_GetItemCount(GetDlgItem(hwndDlg, IDC_TABS));
+			for (i = 0; i < count; i++) {
+				TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), i, &tci);
+				SendMessage((HWND)tci.lParam, WM_NOTIFY, 0, lParam);
+			}
+			// let main reload options
+			KSLoadMainOptions();
+		}
+		break;
+	}
+
+	return FALSE;
+}
+
+INT_PTR CALLBACK PopupOptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static bool bFreeze = false;
+
+	switch (msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+
+		bFreeze = true;
+
+		// left action
+		switch (db_get_b(NULL, KSMODULENAME, SETTING_POPUP_LEFTCLICK, POPUP_ACT_CANCEL)) {
+		case POPUP_ACT_CLOSEPOPUP:
+			CheckDlgButton(hwndDlg, IDC_LCLOSE, BST_CHECKED);
+			break;
+
+		case POPUP_ACT_CANCEL:
+			CheckDlgButton(hwndDlg, IDC_LCANCEL, BST_CHECKED);
+			break;
+
+		case POPUP_ACT_NOTHING:
+		default:
+			CheckDlgButton(hwndDlg, IDC_LNOTHING, BST_CHECKED);
+			break;
+		}
+		// right action
+		switch (db_get_b(NULL, KSMODULENAME, SETTING_POPUP_RIGHTCLICK, POPUP_ACT_CANCEL)) {
+		case POPUP_ACT_CLOSEPOPUP:
+			CheckDlgButton(hwndDlg, IDC_RCLOSE, BST_CHECKED);
+			break;
+
+		case POPUP_ACT_CANCEL:
+			CheckDlgButton(hwndDlg, IDC_RCANCEL, BST_CHECKED);
+			break;
+
+		case POPUP_ACT_NOTHING:
+		default:
+			CheckDlgButton(hwndDlg, IDC_RNOTHING, BST_CHECKED);
+			break;
+		}
+		// delay
+		EnableWindow(GetDlgItem(hwndDlg, IDC_DELAYCUSTOM), ServiceExists(MS_POPUP_ADDPOPUPT));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_DELAYFROMPU), ServiceExists(MS_POPUP_ADDPOPUPT));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_DELAYPERMANENT), ServiceExists(MS_POPUP_ADDPOPUPT));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_DELAY), ServiceExists(MS_POPUP_ADDPOPUPT));
+		switch (db_get_b(NULL, KSMODULENAME, SETTING_POPUP_DELAYTYPE, POPUP_DELAYFROMPU)) {
+		case POPUP_DELAYCUSTOM:
+			CheckDlgButton(hwndDlg, IDC_DELAYCUSTOM, BST_CHECKED);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DELAY), ServiceExists(MS_POPUP_ADDPOPUPT));
+			break;
+
+		case POPUP_DELAYPERMANENT:
+			CheckDlgButton(hwndDlg, IDC_DELAYPERMANENT, BST_CHECKED);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DELAY), FALSE);
+			break;
+
+		case POPUP_DELAYFROMPU:
+		default:
+			CheckDlgButton(hwndDlg, IDC_DELAYFROMPU, BST_CHECKED);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DELAY), FALSE);
+			break;
+		}
+		// delay
+		SetDlgItemInt(hwndDlg, IDC_DELAY, db_get_dw(NULL, KSMODULENAME, SETTING_POPUP_TIMEOUT, 0), FALSE);
+		// back color
+		SendDlgItemMessage(hwndDlg, IDC_BGCOLOR, CPM_SETCOLOUR, 0, db_get_dw(NULL, KSMODULENAME, SETTING_POPUP_BACKCOLOR, 0xAAAAAA));
+		// text
+		SendDlgItemMessage(hwndDlg, IDC_TEXTCOLOR, CPM_SETCOLOUR, 0, db_get_dw(NULL, KSMODULENAME, SETTING_POPUP_TEXTCOLOR, 0x0000CC));
+		// wincolors
+		CheckDlgButton(hwndDlg, IDC_WINCOLORS, db_get_b(NULL, KSMODULENAME, SETTING_POPUP_USEWINCOLORS, 0) ? BST_CHECKED : BST_UNCHECKED);
+		// defaultcolors
+		CheckDlgButton(hwndDlg, IDC_DEFAULTCOLORS, ((db_get_b(NULL, KSMODULENAME, SETTING_POPUP_USEDEFCOLORS, 0)) && (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS))) ? BST_CHECKED : BST_UNCHECKED);
+		EnableWindow(GetDlgItem(hwndDlg, IDC_BGCOLOR), ((BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS)) && (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS))));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_TEXTCOLOR), ((BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS)) && (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS))));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_DEFAULTCOLORS), (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS)));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_WINCOLORS), (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS)));
+		// popup types
+		CheckDlgButton(hwndDlg, IDC_PUCONNLOST, db_get_b(NULL, KSMODULENAME, SETTING_PUCONNLOST, TRUE) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_PUOTHER, db_get_b(NULL, KSMODULENAME, SETTING_PUOTHER, TRUE) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_PUCONNRETRY, db_get_b(NULL, KSMODULENAME, SETTING_PUCONNRETRY, TRUE) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_PURESULT, db_get_b(NULL, KSMODULENAME, SETTING_PURESULT, TRUE) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_PUSHOWEXTRA, db_get_b(NULL, KSMODULENAME, SETTING_PUSHOWEXTRA, TRUE) ? BST_CHECKED : BST_UNCHECKED);
+		bFreeze = false;
+		break;
+
+	case WM_COMMAND:
+		switch (LOWORD(wParam)) {
+		case IDC_WINCOLORS:
+		case IDC_DEFAULTCOLORS:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_BGCOLOR), ((BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS)) && (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS))));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_TEXTCOLOR), ((BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS)) && (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS))));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DEFAULTCOLORS), (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS)));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_WINCOLORS), (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS)));
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+			break;
+
+		case IDC_DELAYFROMPU:
+		case IDC_DELAYPERMANENT:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DELAY), FALSE);
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+			break;
+
+		case IDC_DELAYCUSTOM:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DELAY), TRUE);
+			SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+			break;
+
+		case IDC_BGCOLOR:
+		case IDC_TEXTCOLOR:
+		case IDC_DELAY:
+		case IDC_LNOTHING:
+		case IDC_LCLOSE:
+		case IDC_LCANCEL:
+		case IDC_RNOTHING:
+		case IDC_RCLOSE:
+		case IDC_RCANCEL:
+		case IDC_PUCONNLOST:
+		case IDC_PUOTHER:
+		case IDC_PUCONNRETRY:
+		case IDC_PURESULT:
+		case IDC_PUSHOWEXTRA:
+			if (!bFreeze)
+				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+			break;
+
+		case IDC_PREV:
+		{
+			POPUPDATAT ppd = { NULL };
+
+			ppd.lchContact = NULL;
+			ppd.lchIcon = Skin_LoadIcon(SKINICON_STATUS_OFFLINE);
+			wcsncpy(ppd.lptzContactName, TranslateT("KeepStatus"), MAX_CONTACTNAME);
+			wcsncpy(ppd.lptzText, TranslateT("You broke the Internet!"), MAX_SECONDLINE);
+			if (IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS))
+			{
+				ppd.colorBack = GetSysColor(COLOR_BTNFACE);
+				ppd.colorText = GetSysColor(COLOR_WINDOWTEXT);
+			}
+			else if (IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS))
+			{
+				ppd.colorBack = NULL;
+				ppd.colorText = NULL;
+			}
+			else
+			{
+				ppd.colorBack = SendDlgItemMessage(hwndDlg, IDC_BGCOLOR, CPM_GETCOLOUR, 0, 0);
+				ppd.colorText = SendDlgItemMessage(hwndDlg, IDC_TEXTCOLOR, CPM_GETCOLOUR, 0, 0);
+			}
+			ppd.PluginWindowProc = PopupDlgProc;
+			ppd.PluginData = NULL;
+			if (IsDlgButtonChecked(hwndDlg, IDC_DELAYFROMPU))
+			{
+				ppd.iSeconds = 0;
+			}
+			else if (IsDlgButtonChecked(hwndDlg, IDC_DELAYCUSTOM))
+			{
+				ppd.iSeconds = GetDlgItemInt(hwndDlg, IDC_DELAY, NULL, FALSE);
+			}
+			else if (IsDlgButtonChecked(hwndDlg, IDC_DELAYPERMANENT))
+			{
+				ppd.iSeconds = -1;
+			}
+			PUAddPopupT(&ppd);
+		}
+		break;
+		}
+		break;
+
+	case WM_NOTIFY:
+		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
+			// left action
+			if (IsDlgButtonChecked(hwndDlg, IDC_LNOTHING))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_LEFTCLICK, POPUP_ACT_NOTHING);
+			else if (IsDlgButtonChecked(hwndDlg, IDC_LCLOSE))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_LEFTCLICK, POPUP_ACT_CLOSEPOPUP);
+			else if (IsDlgButtonChecked(hwndDlg, IDC_LCANCEL))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_LEFTCLICK, POPUP_ACT_CANCEL);
+			// right action
+			if (IsDlgButtonChecked(hwndDlg, IDC_RNOTHING))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_RIGHTCLICK, POPUP_ACT_NOTHING);
+			else if (IsDlgButtonChecked(hwndDlg, IDC_RCLOSE))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_RIGHTCLICK, POPUP_ACT_CLOSEPOPUP);
+			else if (IsDlgButtonChecked(hwndDlg, IDC_RCANCEL))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_RIGHTCLICK, POPUP_ACT_CANCEL);
+			// delay
+			if (IsDlgButtonChecked(hwndDlg, IDC_DELAYFROMPU))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_DELAYTYPE, POPUP_DELAYFROMPU);
+			else if (IsDlgButtonChecked(hwndDlg, IDC_DELAYCUSTOM))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_DELAYTYPE, POPUP_DELAYCUSTOM);
+			else if (IsDlgButtonChecked(hwndDlg, IDC_DELAYPERMANENT))
+				db_set_b(NULL, KSMODULENAME, SETTING_POPUP_DELAYTYPE, POPUP_DELAYPERMANENT);
+			// delay
+			db_set_dw(NULL, KSMODULENAME, SETTING_POPUP_TIMEOUT, GetDlgItemInt(hwndDlg, IDC_DELAY, NULL, FALSE));
+			// back color
+			db_set_dw(NULL, KSMODULENAME, SETTING_POPUP_BACKCOLOR, SendDlgItemMessage(hwndDlg, IDC_BGCOLOR, CPM_GETCOLOUR, 0, 0));
+			// text color
+			db_set_dw(NULL, KSMODULENAME, SETTING_POPUP_TEXTCOLOR, SendDlgItemMessage(hwndDlg, IDC_TEXTCOLOR, CPM_GETCOLOUR, 0, 0));
+			// use win
+			db_set_b(NULL, KSMODULENAME, SETTING_POPUP_USEWINCOLORS, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_WINCOLORS));
+			// use def
+			db_set_b(NULL, KSMODULENAME, SETTING_POPUP_USEDEFCOLORS, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_DEFAULTCOLORS));
+			// store types
+			db_set_b(NULL, KSMODULENAME, SETTING_PUCONNLOST, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_PUCONNLOST));
+			db_set_b(NULL, KSMODULENAME, SETTING_PUOTHER, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_PUOTHER));
+			db_set_b(NULL, KSMODULENAME, SETTING_PUCONNRETRY, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_PUCONNRETRY));
+			db_set_b(NULL, KSMODULENAME, SETTING_PURESULT, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_PURESULT));
+			db_set_b(NULL, KSMODULENAME, SETTING_PUSHOWEXTRA, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_PUSHOWEXTRA));
+		}
+		break;
+	}
+
+	return 0;
+}
+
+int KeepStatusOptionsInit(WPARAM wparam, LPARAM)
+{
+	OPTIONSDIALOGPAGE odp = { 0 };
+	odp.hInstance = hInst;
+	odp.pwszGroup = LPGENW("Status");
+	odp.pwszTitle = LPGENW("KeepStatus");
+	odp.flags = ODPF_BOLDGROUPS | ODPF_UNICODE;
+	odp.pszTemplate = MAKEINTRESOURCEA(IDD_OPT_TABS);
+	odp.pfnDlgProc = DlgProcKsTabs;
+	Options_AddPage(wparam, &odp);
+
+	if (ServiceExists(MS_POPUP_ADDPOPUPT)) {
+		memset(&odp, 0, sizeof(odp));
+		odp.position = 150000000;
+		odp.pwszGroup = LPGENW("Popups");
+		odp.groupPosition = 910000000;
+		odp.hInstance = hInst;
+		odp.pszTemplate = MAKEINTRESOURCEA(IDD_PUOPT_KEEPSTATUS);
+		odp.pwszTitle = LPGENW("KeepStatus");
+		odp.pfnDlgProc = PopupOptDlgProc;
+		odp.flags = ODPF_BOLDGROUPS | ODPF_UNICODE;
+		Options_AddPage(wparam, &odp);
+	}
+	return 0;
+}
diff --git a/plugins/StatusManager/src/main.cpp b/plugins/StatusManager/src/main.cpp
new file mode 100644
index 0000000000..41455e029a
--- /dev/null
+++ b/plugins/StatusManager/src/main.cpp
@@ -0,0 +1,166 @@
+/*
+	KeepStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	*/
+
+#include "stdafx.h"
+
+unsigned long mainThreadId = 0;
+
+HANDLE hMainThread = 0,
+	hCSModuleLoadedHook,
+	hGetProfileService,
+	hGetProfileCountService,
+	hGetProfileNameService,
+	hStateChangedEvent;
+
+HANDLE hConnectionEvent = NULL,
+	hStopRecon = NULL,
+	hEnableProto = NULL,
+	hIsProtoEnabled = NULL,
+	hAnnounceStat = NULL;
+
+HINSTANCE hInst;
+int hLangpack = 0;
+CLIST_INTERFACE *pcli;
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// dll entry point
+
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID)
+{
+	if (fdwReason == DLL_PROCESS_ATTACH)
+		hInst = hinstDLL;
+
+	return TRUE;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// returns plugin's extended information
+
+PLUGININFOEX pluginInfoEx = {
+	sizeof(PLUGININFOEX),
+	__PLUGIN_NAME,
+	PLUGIN_MAKE_VERSION(__MAJOR_VERSION, __MINOR_VERSION, __RELEASE_NUM, __BUILD_NUM),
+	__DESC,
+	__AUTHOR,
+	__AUTHOREMAIL,
+	__COPYRIGHT,
+	__AUTHORWEB,
+	UNICODE_AWARE,
+	// {FADD4A8A-1FD0-4398-83BD-E378B85ED8F1}
+	{ 0xfadd4a8a, 0x1fd0, 0x4398, { 0x83, 0xbd, 0xe3, 0x78, 0xb8, 0x5e, 0xd8, 0xf1 } }
+};
+
+extern "C" __declspec(dllexport) PLUGININFOEX* MirandaPluginInfoEx(DWORD)
+{
+	return &pluginInfoEx;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// interfaces
+
+extern "C" __declspec(dllexport) const MUUID MirandaInterfaces[] = { MIID_AUTOAWAY, MIID_LAST };
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// plugin's entry point
+
+INT_PTR StopReconnectingService(WPARAM wParam, LPARAM lParam);
+INT_PTR EnableProtocolService(WPARAM wParam, LPARAM lParam);
+INT_PTR IsProtocolEnabledService(WPARAM wParam, LPARAM lParam);
+INT_PTR AnnounceStatusChangeService(WPARAM wParam, LPARAM lParam);
+
+static INT_PTR SrvGetProfile(WPARAM wParam, LPARAM lParam)
+{
+	return GetProfile((int)wParam, *(TSettingsList*)lParam);
+}
+
+extern "C" int __declspec(dllexport) Load(void)
+{
+	mir_getLP(&pluginInfoEx);
+	pcli = Clist_GetInterface();
+
+	//common
+	InitCommonStatus();
+
+	/* KeepStatus */
+	hCSModuleLoadedHook = HookEvent(ME_SYSTEM_MODULESLOADED, KSCSModuleLoaded);
+
+	hConnectionEvent = CreateHookableEvent(ME_KS_CONNECTIONEVENT);
+
+	hStopRecon = CreateServiceFunction(MS_KS_STOPRECONNECTING, StopReconnectingService);
+	hEnableProto = CreateServiceFunction(MS_KS_ENABLEPROTOCOL, EnableProtocolService);
+	hIsProtoEnabled = CreateServiceFunction(MS_KS_ISPROTOCOLENABLED, IsProtocolEnabledService);
+	hAnnounceStat = CreateServiceFunction(MS_KS_ANNOUNCESTATUSCHANGE, AnnounceStatusChangeService);
+
+	DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &hMainThread, THREAD_SET_CONTEXT, FALSE, 0);
+	mainThreadId = GetCurrentThreadId();
+
+	/* StartupStatus */
+	hCSModuleLoadedHook = HookEvent(ME_SYSTEM_MODULESLOADED, SSCSModuleLoaded);
+
+	if (db_get_b(NULL, SSMODULENAME, SETTING_SETPROFILE, 1) ||
+		db_get_b(NULL, SSMODULENAME, SETTING_OFFLINECLOSE, 0))
+		db_set_w(NULL, "CList", "Status", (WORD)ID_STATUS_OFFLINE);
+
+	// docking
+	if (db_get_b(NULL, SSMODULENAME, SETTING_SETDOCKED, 0)) {
+		int docked = db_get_b(NULL, SSMODULENAME, SETTING_DOCKED, DOCKED_NONE);
+		if (docked == DOCKED_LEFT || docked == DOCKED_RIGHT)
+			docked = -docked;
+
+		db_set_b(NULL, MODULE_CLIST, SETTING_DOCKED, (BYTE)docked);
+	}
+
+	// Create service functions; the get functions are created here; they don't rely on commonstatus
+	hGetProfileService = CreateServiceFunction(MS_SS_GETPROFILE, SrvGetProfile);
+	hGetProfileCountService = CreateServiceFunction(MS_SS_GETPROFILECOUNT, GetProfileCount);
+	hGetProfileNameService = CreateServiceFunction(MS_SS_GETPROFILENAME, GetProfileName);
+
+	LoadProfileModule();
+
+	/* AdvancedAutoAway */
+	hCSModuleLoadedHook = HookEvent(ME_SYSTEM_MODULESLOADED, AAACSModuleLoaded);
+	hStateChangedEvent = CreateHookableEvent(ME_AAA_STATECHANGED);
+
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// plugin's exit point
+
+extern "C" int __declspec(dllexport) Unload(void)
+{
+	UnhookEvent(hCSModuleLoadedHook);
+
+	// StartupStatus
+	DestroyHookableEvent(hConnectionEvent);
+
+	if (hMainThread)
+		CloseHandle(hMainThread);
+	DestroyServiceFunction(hStopRecon);
+	DestroyServiceFunction(hEnableProto);
+	DestroyServiceFunction(hIsProtoEnabled);
+	DestroyServiceFunction(hAnnounceStat);
+
+	// StartupStatus
+	DestroyServiceFunction(hGetProfileService);
+	DestroyServiceFunction(hGetProfileCountService);
+	DestroyServiceFunction(hGetProfileNameService);
+
+	return 0;
+}
diff --git a/plugins/StatusManager/src/resource.h b/plugins/StatusManager/src/resource.h
new file mode 100644
index 0000000000..f49d2abbd5
--- /dev/null
+++ b/plugins/StatusManager/src/resource.h
@@ -0,0 +1,168 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by resource.rc
+//
+#define IDD_OPT_KEEPSTATUS              101
+#define IDD_OPT_KS_BASIC                101
+#define IDD_CONFIRMDIALOG               102
+#define IDD_OPT_AUTOAWAY                104
+#define IDD_CMDLOPTIONS                 106
+#define IDD_ADDPROFILE                  109
+#define IDD_OPT_STARTUPSTATUS           110
+#define IDD_PUOPT_KEEPSTATUS            113
+#define IDD_OPT_AUTOAWAYMSG             114
+#define IDI_TICK                        117
+#define IDI_NOTICK                      118
+#define IDD_OPT_GENAUTOAWAY             119
+#define IDD_OPT_KS_ACTION               120
+#define IDD_SETSTSMSGDIALOG             121
+#define IDD_OPT_STATUSPROFILES          123
+#define IDD_OPT_AAATABS                 126
+#define IDD_OPT_TABS                    126
+#define IDD_OPT_KS_ADV                  127
+#define IDD_TRG_AAASTATECHANGE          128
+#define IDI_TTBDOWN                     129
+#define IDI_TTBUP                       130
+#define IDC_PROTOCOL                    1000
+#define IDC_STATUS                      1001
+#define IDC_PROFILE                     1002
+#define IDC_STARTUPLIST                 1008
+#define IDC_STATUSMSG                   1008
+#define IDC_SETSTATUSONSTARTUP          1010
+#define IDC_SETPROFILE                  1010
+#define IDC_SETWINDOW                   1011
+#define IDC_SETWINSTATE                 1011
+#define IDC_WINDOW                      1012
+#define IDC_WINSTATE                    1012
+#define IDC_CLOSE                       1013
+#define IDC_SHOWDIALOG                  1014
+#define IDC_OFFLINECLOSE                1016
+#define IDC_CONFIRM                     1017
+#define IDC_SHOWCMDL                    1018
+#define IDC_COPY                        1019
+#define IDC_CMDL                        1020
+#define IDC_OK                          1021
+#define IDC_SHORTCUT                    1022
+#define IDC_CHECKCONNECTION             1025
+#define IDC_MAXRETRIES                  1026
+#define IDC_INITDELAY                   1027
+#define IDC_SETSTATUSDELAY              1027
+#define IDC_SETPROFILEDELAY             1027
+#define IDC_DOCKED                      1028
+#define IDC_SETDOCKED                   1029
+#define IDC_MAXDELAY                    1031
+#define IDC_INCREASEEXPONENTIAL         1032
+#define IDC_LNOTHING                    1032
+#define IDC_LCLOSE                      1033
+#define IDC_LV1STATUS                   1035
+#define IDC_LV2STATUS                   1036
+#define IDC_STATUSLIST                  1037
+#define IDC_LV1AFTERSTR                 1038
+#define IDC_SHOWCONNECTIONPOPUPS        1040
+#define IDC_ADDPROFILE                  1041
+#define IDC_DELPROFILE                  1042
+#define IDC_PROFILENAME                 1043
+#define IDC_CANCEL                      1044
+#define IDC_DEFAULTPROFILE              1045
+#define IDC_MONITORMIRANDA              1045
+#define IDC_WINCOLORS                   1045
+#define IDC_CHKINET                     1045
+#define IDC_IGNLOCK                     1045
+#define IDC_CREATETTBBUTTONS            1046
+#define IDC_CREATETTB                   1046
+#define IDC_PERPROTOCOLSETTINGS         1050
+#define IDC_SAMESETTINGS                1051
+#define IDC_RESETSTATUS                 1052
+#define IDC_SETSTSMSG                   1053
+#define IDC_DEFAULTCOLORS               1057
+#define IDC_ONLOCK                      1057
+#define IDC_LOGINERR                    1057
+#define IDC_LV2ONINACTIVE               1062
+#define IDC_CNCOTHERLOC                 1062
+#define IDC_PUCONNLOST                  1062
+#define IDC_DLGTIMEOUT                  1063
+#define IDC_AWAYCHECKTIMEINSECS         1063
+#define IDC_STSMSG                      1063
+#define IDC_PINGHOST                    1063
+#define IDC_CONFIRMDELAY                1064
+#define IDC_PROTOCOLLIST                1066
+#define IDC_LCANCEL                     1068
+#define IDC_RNOTHING                    1069
+#define IDC_RCLOSE                      1070
+#define IDC_RCANCEL                     1071
+#define IDC_DELAY                       1072
+#define IDC_BGCOLOR                     1074
+#define IDC_TEXTCOLOR                   1075
+#define IDC_PREV                        1076
+#define IDC_LOGINERR_DELAY              1077
+#define IDC_PROTOLIST                   1079
+#define IDC_ENABLECHECKING              1080
+#define IDC_DISABLECHECKING             1081
+#define IDC_IDLEWARNING                 1084
+#define IDC_DESCRIPTION                 1085
+#define IDC_CONTCHECK                   1087
+#define IDC_BYPING                      1088
+#define IDC_CHECKAPMRESUME              1089
+#define IDC_PUCONNRETRY                 1090
+#define IDC_PURESULT                    1091
+#define IDC_PUOTHER                     1092
+#define IDC_DELAYFROMPU                 1093
+#define IDC_DELAYCUSTOM                 1094
+#define IDC_DELAYPERMANENT              1095
+#define IDC_LOGINERR_CANCEL             1096
+#define IDC_LOGINERR_SETDELAY           1097
+#define IDC_PUSHOWEXTRA                 1098
+#define IDC_CREATEMMI                   1100
+#define IDC_SETWINLOCATION              1104
+#define IDC_XPOS                        1105
+#define IDC_YPOS                        1106
+#define IDC_SETWINSIZE                  1107
+#define IDC_WIDTH                       1108
+#define IDC_HEIGHT                      1109
+#define IDC_OVERRIDE                    1111
+#define IDC_MIRANDAMSG                  1112
+#define IDC_CUSTOMMSG                   1113
+#define IDC_CURWINLOC                   1114
+#define IDC_CURWINSIZE                  1115
+#define IDC_HOTKEY                      1116
+#define IDC_REGHOTKEY                   1117
+#define IDC_VARIABLESHELP               1118
+#define IDC_AUTODIAL                    1120
+#define IDC_AUTOHANGUP                  1121
+#define IDC_MONITORKEYBOARD             1122
+#define IDC_MONITORMOUSE                1123
+#define IDC_IGNSYSKEYS                  1124
+#define IDC_IGNALTCOMBO                 1125
+#define IDC_FIRSTOFFLINE                1126
+#define IDC_INSUBMENU                   1127
+#define IDC_MAXCONNECTINGTIME           1128
+#define IDC_TABS                        1130
+#define IDC_NOLOCKED                    1131
+#define IDC_PINGCOUNT                   1132
+#define IDC_CNTDELAY                    1133
+#define IDC_ENTERFIRST                  1134
+#define IDC_ENTERSECOND                 1135
+#define IDC_LEAVEFIRST                  1136
+#define IDC_LEAVESECOND                 1137
+#define IDC_BECOMEACTIVE                1138
+#define IDC_SCREENSAVE                  1145
+#define IDC_TIMED                       1146
+#define IDC_AWAYTIME                    1147
+#define IDC_SETNA                       1148
+#define IDC_NATIME                      1149
+#define IDC_SCREENSAVE2                 1150
+#define IDC_FULLSCREEN                  1150
+#define IDC_RADUSEMIRANDA               1210
+#define IDC_RADUSECUSTOM                1212
+#define IDC_SETNASTR                    1568
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        129
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1141
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/plugins/StatusManager/src/ss_options.cpp b/plugins/StatusManager/src/ss_options.cpp
new file mode 100644
index 0000000000..7a5c1b92e4
--- /dev/null
+++ b/plugins/StatusManager/src/ss_options.cpp
@@ -0,0 +1,929 @@
+/*
+	StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+TSettingsList* GetCurrentProtoSettings()
+{
+	int count;
+	PROTOACCOUNT **protos;
+	Proto_EnumAccounts(&count, &protos);
+
+	TSettingsList *result = new TSettingsList(count, CompareSettings);
+	if (result == NULL)
+		return NULL;
+
+	for (int i=0; i < count; i++)
+		if ( IsSuitableProto(protos[i]))
+			result->insert( new TSSSetting(protos[i]));
+
+	return result;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Command line processing
+
+static char* GetStatusDesc(int status)
+{
+	switch (status) {
+		case ID_STATUS_AWAY:       return "away";
+		case ID_STATUS_NA:         return "na";
+		case ID_STATUS_DND:        return "dnd";
+		case ID_STATUS_OCCUPIED:   return "occupied";
+		case ID_STATUS_FREECHAT:   return "freechat";
+		case ID_STATUS_ONLINE:     return "online";
+		case ID_STATUS_OFFLINE:    return "offline";
+		case ID_STATUS_INVISIBLE:  return "invisible";
+		case ID_STATUS_ONTHEPHONE: return "onthephone";
+		case ID_STATUS_OUTTOLUNCH: return "outtolunch";
+		case ID_STATUS_LAST:       return "last";
+	}
+	return "offline";
+}
+
+static char* GetCMDLArguments(TSettingsList& protoSettings)
+{
+	if ( protoSettings.getCount() == NULL )
+		return NULL;
+
+	char *cmdl, *pnt;
+	pnt = cmdl = ( char* )malloc(mir_strlen(protoSettings[0].szName) + mir_strlen(GetStatusDesc(protoSettings[0].status)) + 4);
+
+	for (int i=0; i < protoSettings.getCount(); i++ ) {
+		*pnt++ = '/';
+		mir_strcpy(pnt, protoSettings[i].szName);
+		pnt += mir_strlen(protoSettings[i].szName);
+		*pnt++ = '=';
+		mir_strcpy(pnt, GetStatusDesc(protoSettings[i].status));
+		pnt += mir_strlen(GetStatusDesc(protoSettings[i].status));
+		if (i != protoSettings.getCount()-1) {
+			*pnt++ = ' ';
+			*pnt++ = '\0';
+			cmdl = ( char* )realloc(cmdl, mir_strlen(cmdl) + mir_strlen(protoSettings[i+1].szName) + mir_strlen(GetStatusDesc(protoSettings[i+1].status)) + 4);
+			pnt = cmdl + mir_strlen(cmdl);
+	}	}
+
+	if ( db_get_b( NULL, SSMODULENAME, SETTING_SHOWDIALOG, FALSE ) == TRUE ) {
+		*pnt++ = ' ';
+		*pnt++ = '\0';
+		cmdl = ( char* )realloc(cmdl, mir_strlen(cmdl) + 12);
+		pnt = cmdl + mir_strlen(cmdl);
+		mir_strcpy(pnt, "/showdialog");
+		pnt += 11;
+		*pnt = '\0';
+	}
+
+	return cmdl;
+}
+
+static char* GetCMDL(TSettingsList& protoSettings)
+{
+	char path[MAX_PATH];
+	GetModuleFileNameA(NULL, path, MAX_PATH);
+
+	char* cmdl = ( char* )malloc(mir_strlen(path) + 4);
+	mir_snprintf(cmdl, mir_strlen(path) + 4, "\"%s\" ", path);
+
+	char* args = GetCMDLArguments(protoSettings);
+	if ( args ) {
+		cmdl = ( char* )realloc(cmdl, mir_strlen(cmdl) + mir_strlen(args) + 1);
+		mir_strcat(cmdl, args);
+		free(args);
+	}
+	return cmdl;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Link processing
+
+static wchar_t* GetLinkDescription(TSettingsList& protoSettings)
+{
+	if ( protoSettings.getCount() == 0 )
+		return NULL;
+
+	CMStringW result(SHORTCUT_DESC);
+	for (int i=0; i < protoSettings.getCount(); i++) {
+		TSSSetting &p = protoSettings[i];
+
+		wchar_t *status;
+		if ( p.status == ID_STATUS_LAST)
+			status = TranslateT("<last>");
+		else if (p.status == ID_STATUS_CURRENT)
+			status = TranslateT("<current>");
+		else if (p.status >= MIN_STATUS && p.status <= MAX_STATUS)
+			status = pcli->pfnGetStatusModeDescription(p.status, 0);
+		else
+			status = NULL;
+		if (status == NULL)
+			status = TranslateT("<unknown>");
+
+		result.AppendChar('\r');
+		result.Append(p.tszAccName);
+		result.AppendChar(':');
+		result.AppendChar(' ');
+		result.Append(status);
+	}
+
+	return mir_wstrndup(result, result.GetLength());
+}
+
+HRESULT CreateLink(TSettingsList& protoSettings)
+{
+	wchar_t savePath[MAX_PATH];
+	if (SHGetSpecialFolderPath(NULL, savePath, 0x10, FALSE))
+		wcsncat_s(savePath, SHORTCUT_FILENAME, _countof(savePath) - mir_wstrlen(savePath));
+	else
+		mir_snwprintf(savePath, L".\\%s", SHORTCUT_FILENAME);
+
+	// Get a pointer to the IShellLink interface.
+	IShellLink *psl;
+	HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, ( void** )&psl);
+	if (SUCCEEDED(hres)) {
+		char *args = GetCMDLArguments(protoSettings);
+		wchar_t *desc = GetLinkDescription(protoSettings);
+
+		// Set the path to the shortcut target, and add the
+		// description.
+		wchar_t path[MAX_PATH];
+		GetModuleFileName(NULL, path, _countof(path));
+		psl->SetPath(path);
+		psl->SetDescription(desc);
+		psl->SetArguments( _A2T(args));
+
+		// Query IShellLink for the IPersistFile interface for saving the
+		// shortcut in persistent storage.
+		IPersistFile *ppf;
+		hres = psl->QueryInterface(IID_IPersistFile, ( void** )&ppf);
+
+		if (SUCCEEDED(hres)) {
+			// Save the link by calling IPersistFile::Save.
+			hres = ppf->Save(savePath, TRUE);
+			ppf->Release();
+		}
+		psl->Release();
+		free(args);
+		free(desc);
+	}
+
+	return hres;
+}
+
+INT_PTR CALLBACK CmdlOptionsDlgProc(HWND hwndDlg,UINT msg,WPARAM wParam,LPARAM lParam)
+{
+	static TSettingsList* optionsProtoSettings;
+
+	switch(msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+		{
+			optionsProtoSettings = (TSettingsList*)lParam;
+			char* cmdl = GetCMDL(*optionsProtoSettings);
+			SetDlgItemTextA(hwndDlg, IDC_CMDL, cmdl);
+			free(cmdl);
+		}
+		break;
+
+	case WM_COMMAND:
+		switch (LOWORD(wParam)) {
+		case IDC_COPY:
+			if ( OpenClipboard( hwndDlg )) {
+				EmptyClipboard();
+
+				char cmdl[2048];
+				GetDlgItemTextA(hwndDlg,IDC_CMDL, cmdl, _countof(cmdl));
+				HGLOBAL cmdlGlob = GlobalAlloc(GMEM_MOVEABLE, sizeof(cmdl));
+				if (cmdlGlob == NULL) {
+					CloseClipboard();
+					break;
+				}
+				LPTSTR cmdlStr = ( LPTSTR )GlobalLock(cmdlGlob);
+				memcpy(cmdlStr, &cmdl, sizeof(cmdl));
+				GlobalUnlock(cmdlGlob);
+				SetClipboardData(CF_TEXT, cmdlGlob);
+				CloseClipboard();
+			}
+			break;
+
+		case IDC_SHORTCUT:
+			CreateLink(*optionsProtoSettings);
+			break;
+
+		case IDC_OK:
+			DestroyWindow(hwndDlg);
+			break;
+		}
+		break;
+
+	case WM_CLOSE:
+		DestroyWindow(hwndDlg);
+		break;
+
+	case WM_DESTROY:
+		delete optionsProtoSettings; optionsProtoSettings = 0;
+		break;
+	}
+
+	return 0;
+}
+
+static INT_PTR CALLBACK StartupStatusOptDlgProc(HWND hwndDlg,UINT msg,WPARAM wParam,LPARAM lParam)
+{
+	static BOOL bInitDone = FALSE;
+
+	switch(msg) {
+	case WM_INITDIALOG:
+		bInitDone = FALSE;
+
+		TranslateDialogDefault(hwndDlg);
+		CheckDlgButton(hwndDlg, IDC_SETPROFILE, db_get_b(NULL, SSMODULENAME, SETTING_SETPROFILE, 1) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_OVERRIDE, db_get_b(NULL, SSMODULENAME, SETTING_OVERRIDE, 1) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_SHOWDIALOG, db_get_b(NULL, SSMODULENAME, SETTING_SHOWDIALOG, 0) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_SETWINSTATE, db_get_b(NULL, SSMODULENAME, SETTING_SETWINSTATE, 0) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_SETWINLOCATION, db_get_b(NULL, SSMODULENAME, SETTING_SETWINLOCATION, 0) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_SETDOCKED, db_get_b(NULL, SSMODULENAME, SETTING_SETDOCKED, 0) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_SETWINSIZE, db_get_b(NULL, SSMODULENAME, SETTING_SETWINSIZE, 0) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_OFFLINECLOSE, db_get_b(NULL, SSMODULENAME, SETTING_OFFLINECLOSE, 1) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_AUTODIAL, db_get_b(NULL, SSMODULENAME, SETTING_AUTODIAL, 0) ? BST_CHECKED : BST_UNCHECKED);
+		CheckDlgButton(hwndDlg, IDC_AUTOHANGUP, db_get_b(NULL, SSMODULENAME, SETTING_AUTOHANGUP, 0) ? BST_CHECKED : BST_UNCHECKED);
+		SetDlgItemInt(hwndDlg, IDC_SETPROFILEDELAY, db_get_dw(NULL, SSMODULENAME, SETTING_SETPROFILEDELAY, 500), FALSE);
+		SetDlgItemInt(hwndDlg, IDC_DLGTIMEOUT, db_get_dw(NULL, SSMODULENAME, SETTING_DLGTIMEOUT, 5), FALSE);
+		SetDlgItemInt(hwndDlg, IDC_XPOS, db_get_dw(NULL, SSMODULENAME, SETTING_XPOS, 0), TRUE);
+		SetDlgItemInt(hwndDlg, IDC_YPOS, db_get_dw(NULL, SSMODULENAME, SETTING_YPOS, 0), TRUE);
+		SetDlgItemInt(hwndDlg, IDC_WIDTH, db_get_dw(NULL, SSMODULENAME, SETTING_WIDTH, 0), FALSE);
+		SetDlgItemInt(hwndDlg, IDC_HEIGHT, db_get_dw(NULL, SSMODULENAME, SETTING_HEIGHT, 0), FALSE);
+		{
+			int val = db_get_b(NULL, SSMODULENAME, SETTING_DOCKED, DOCKED_NONE);
+			int item = SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_ADDSTRING, 0, (LPARAM)TranslateT("Left"));
+			SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_SETITEMDATA, (WPARAM)item, (LPARAM)DOCKED_LEFT);
+			if (val == DOCKED_LEFT)
+				SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_SETCURSEL, (WPARAM)item, 0);
+
+			item = SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_ADDSTRING, 0, (LPARAM)TranslateT("Right"));
+			SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_SETITEMDATA, (WPARAM)item, (LPARAM)DOCKED_RIGHT);
+			if (val == DOCKED_RIGHT)
+				SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_SETCURSEL, (WPARAM)item, 0);
+
+			item = SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_ADDSTRING, 0, (LPARAM)TranslateT("None"));
+			SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_SETITEMDATA, (WPARAM)item, (LPARAM)DOCKED_NONE);
+			if (val == DOCKED_NONE)
+				SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_SETCURSEL, (WPARAM)item, 0);
+		}
+
+		EnableWindow(GetDlgItem(hwndDlg, IDC_PROFILE), IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE)||IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_SETPROFILEDELAY), IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_OVERRIDE), IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_DLGTIMEOUT), IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_WINSTATE), IsDlgButtonChecked(hwndDlg, IDC_SETWINSTATE));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_XPOS), IsDlgButtonChecked(hwndDlg, IDC_SETWINLOCATION));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_YPOS), IsDlgButtonChecked(hwndDlg, IDC_SETWINLOCATION));
+		SendMessage(hwndDlg, UM_REINITPROFILES, 0, 0);
+		SendMessage(hwndDlg, UM_REINITDOCKED, 0, 0);
+		SendMessage(hwndDlg, UM_REINITWINSTATE, 0, 0);
+		SendMessage(hwndDlg, UM_REINITWINSIZE, 0, 0);
+		SetTimer(hwndDlg, 0, 100, NULL);
+		bInitDone = TRUE;
+		break;
+
+	case WM_TIMER:
+		if ( BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_SETWINLOCATION) && BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_SETWINSIZE)) {
+			SetDlgItemTextA(hwndDlg, IDC_CURWINSIZE, "");
+			SetDlgItemTextA(hwndDlg, IDC_CURWINLOC, "");
+			break;
+		}
+		else {
+			wchar_t text[128];
+			mir_snwprintf(text, TranslateT("size: %d x %d"),
+				db_get_dw(NULL, MODULE_CLIST, SETTING_WIDTH, 0),
+				db_get_dw(NULL, MODULE_CLIST, SETTING_HEIGHT, 0));
+			SetDlgItemText(hwndDlg, IDC_CURWINSIZE, text);
+
+			mir_snwprintf(text, TranslateT("loc: %d x %d"),
+				db_get_dw(NULL, MODULE_CLIST, SETTING_XPOS, 0),
+				db_get_dw(NULL, MODULE_CLIST, SETTING_YPOS, 0));
+			SetDlgItemText(hwndDlg, IDC_CURWINLOC, text);
+	   }
+		break;
+
+	case UM_REINITPROFILES:
+		// creates profile combo box according to 'dat'
+		SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_RESETCONTENT, 0, 0);
+		{
+			int defProfile;
+			int profileCount = GetProfileCount((WPARAM)&defProfile, 0);
+			for ( int i=0; i < profileCount; i++ ) {
+				wchar_t profileName[128];
+				if ( GetProfileName(i, (LPARAM)profileName))
+					continue;
+
+				int item = SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_ADDSTRING, 0, (LPARAM)profileName);
+				SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_SETITEMDATA, item, i);
+			}
+			SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_SETCURSEL, defProfile, 0);
+		}
+		break;
+
+	case UM_REINITDOCKED:
+		EnableWindow(GetDlgItem(hwndDlg, IDC_SETDOCKED), db_get_b(NULL, MODULE_CLIST, SETTING_TOOLWINDOW, 1));
+		if (!IsWindowEnabled(GetDlgItem(hwndDlg,IDC_SETDOCKED)))
+			CheckDlgButton(hwndDlg, IDC_SETDOCKED, BST_UNCHECKED);
+
+		EnableWindow(GetDlgItem(hwndDlg, IDC_DOCKED), IsDlgButtonChecked(hwndDlg, IDC_SETDOCKED));
+		break;
+
+	case UM_REINITWINSTATE:
+		{
+			int val = db_get_b(NULL, SSMODULENAME, SETTING_WINSTATE, SETTING_STATE_NORMAL);
+			SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_RESETCONTENT, 0, 0);
+
+			int item = SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_ADDSTRING, 0, (LPARAM)TranslateT("Hidden"));
+			SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_SETITEMDATA, item, (LPARAM)SETTING_STATE_HIDDEN);
+			if (val == SETTING_STATE_HIDDEN)
+				SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_SETCURSEL, item, 0);
+
+			if (!db_get_b(NULL, MODULE_CLIST, SETTING_TOOLWINDOW, 0)) {
+				item = SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_ADDSTRING, 0, (LPARAM)TranslateT("Minimized"));
+				SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_SETITEMDATA, item, SETTING_STATE_MINIMIZED);
+				if (val == SETTING_STATE_MINIMIZED)
+					SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_SETCURSEL, item, 0);
+			}
+			item = SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_ADDSTRING, 0, (LPARAM)TranslateT("Normal"));
+			SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_SETITEMDATA, item, SETTING_STATE_NORMAL);
+			if ( val == SETTING_STATE_NORMAL || (val == SETTING_STATE_MINIMIZED) && db_get_b(NULL, MODULE_CLIST, SETTING_TOOLWINDOW, 0))
+				SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_SETCURSEL, item, 0);
+		}
+		break;
+
+	case UM_REINITWINSIZE:
+		EnableWindow(GetDlgItem(hwndDlg, IDC_WIDTH), IsDlgButtonChecked(hwndDlg, IDC_SETWINSIZE));
+		EnableWindow(GetDlgItem(hwndDlg, IDC_HEIGHT), !db_get_b(NULL, MODULE_CLUI, SETTING_AUTOSIZE, 0)&&IsDlgButtonChecked(hwndDlg, IDC_SETWINSIZE));
+
+	case WM_COMMAND:
+		if ( HIWORD(wParam) == BN_CLICKED || HIWORD(wParam) == LBN_SELCHANGE || HIWORD(wParam) == CBN_SELCHANGE || HIWORD(wParam) == EN_CHANGE )
+			if ( bInitDone )
+				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
+
+		switch (LOWORD(wParam)) {
+		case IDC_SETPROFILE:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_PROFILE), IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE)||IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_SETPROFILEDELAY), IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_OVERRIDE), IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE));
+			break;
+		case IDC_SHOWDIALOG:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_PROFILE), IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE)||IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DLGTIMEOUT), IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG));
+			break;
+		case IDC_SETWINSTATE:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_WINSTATE), IsDlgButtonChecked(hwndDlg, IDC_SETWINSTATE));
+			break;
+		case IDC_SETDOCKED:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_DOCKED), IsDlgButtonChecked(hwndDlg, IDC_SETDOCKED));
+			break;
+		case IDC_SETWINLOCATION:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_XPOS), IsDlgButtonChecked(hwndDlg, IDC_SETWINLOCATION));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_YPOS), IsDlgButtonChecked(hwndDlg, IDC_SETWINLOCATION));
+			break;
+		case IDC_SETWINSIZE:
+			SendMessage(hwndDlg, UM_REINITWINSIZE, 0, 0);
+			break;
+		case IDC_SHOWCMDL:
+			{
+				int defProfile = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
+
+				TSettingsList* ps = GetCurrentProtoSettings();
+				if ( ps ) {
+					GetProfile( defProfile, *ps );
+					for ( int i=0; i < ps->getCount(); i++ )
+						if ( (*ps)[i].szMsg != NULL )
+							(*ps)[i].szMsg = wcsdup( (*ps)[i].szMsg );
+
+					CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_CMDLOPTIONS), hwndDlg, CmdlOptionsDlgProc, (LPARAM)ps);
+				}
+				break;
+			}
+		}
+		break;
+
+	case WM_SHOWWINDOW:
+		if (wParam == FALSE)
+			break;
+
+		bInitDone = FALSE;
+		SendMessage(hwndDlg, UM_REINITPROFILES, 0, 0);
+		SendMessage(hwndDlg, UM_REINITDOCKED, 0, 0);
+		SendMessage(hwndDlg, UM_REINITWINSTATE, 0, 0);
+		SendMessage(hwndDlg, UM_REINITWINSIZE, 0, 0);
+		bInitDone = TRUE;
+		break;
+
+	case WM_NOTIFY:
+		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
+			int val;
+
+			db_set_b(NULL, SSMODULENAME, SETTING_SETPROFILE, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE));
+			if (IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE))
+				db_set_dw(NULL, SSMODULENAME, SETTING_SETPROFILEDELAY, GetDlgItemInt(hwndDlg, IDC_SETPROFILEDELAY, NULL, FALSE));
+
+			if (IsDlgButtonChecked(hwndDlg, IDC_SETPROFILE) || IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG)) {
+				val = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
+				db_set_w(NULL, SSMODULENAME, SETTING_DEFAULTPROFILE, (WORD)val);
+			}
+			db_set_b(NULL, SSMODULENAME, SETTING_OVERRIDE, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_OVERRIDE));
+			db_set_b(NULL, SSMODULENAME, SETTING_SHOWDIALOG, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG));
+			if (IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG))
+				db_set_dw(NULL, SSMODULENAME, SETTING_DLGTIMEOUT, GetDlgItemInt(hwndDlg, IDC_DLGTIMEOUT, NULL, FALSE));
+
+			db_set_b(NULL, SSMODULENAME, SETTING_SETWINSTATE, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SETWINSTATE));
+			if (IsDlgButtonChecked(hwndDlg, IDC_SETWINSTATE)) {
+				val = (int)SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_WINSTATE, CB_GETCURSEL, 0, 0), 0);
+				db_set_b(NULL, SSMODULENAME, SETTING_WINSTATE, (BYTE)val);
+			}
+			db_set_b(NULL, SSMODULENAME, SETTING_SETDOCKED, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SETDOCKED));
+			if (IsDlgButtonChecked(hwndDlg, IDC_SETDOCKED)) {
+				val = (int)SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_DOCKED, CB_GETCURSEL, 0, 0), 0);
+				db_set_b(NULL, SSMODULENAME, SETTING_DOCKED, (BYTE)val);
+			}
+			db_set_b(NULL, SSMODULENAME, SETTING_SETWINLOCATION, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SETWINLOCATION));
+			if (IsDlgButtonChecked(hwndDlg, IDC_SETWINLOCATION)) {
+				db_set_dw(NULL, SSMODULENAME, SETTING_XPOS, GetDlgItemInt(hwndDlg, IDC_XPOS, NULL, TRUE));
+				db_set_dw(NULL, SSMODULENAME, SETTING_YPOS, GetDlgItemInt(hwndDlg, IDC_YPOS, NULL, TRUE));
+			}
+			db_set_b(NULL, SSMODULENAME, SETTING_SETWINSIZE, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SETWINSIZE));
+			if (IsDlgButtonChecked(hwndDlg, IDC_SETWINSIZE)) {
+				db_set_dw(NULL, SSMODULENAME, SETTING_WIDTH, GetDlgItemInt(hwndDlg, IDC_WIDTH, NULL, FALSE));
+				db_set_dw(NULL, SSMODULENAME, SETTING_HEIGHT, GetDlgItemInt(hwndDlg, IDC_HEIGHT, NULL, FALSE));
+			}
+			db_set_b(NULL, SSMODULENAME, SETTING_OFFLINECLOSE, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_OFFLINECLOSE));
+			db_set_b(NULL, SSMODULENAME, SETTING_AUTODIAL, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_AUTODIAL));
+			db_set_b(NULL, SSMODULENAME, SETTING_AUTOHANGUP, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_AUTOHANGUP));
+		}
+		break;
+	}
+
+	return FALSE;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// for db cleanup
+
+static int DeleteSetting(const char *szSetting, LPARAM lParam)
+{
+	LIST<char> *p = (LIST<char> *)lParam;
+	p->insert(mir_strdup(szSetting));
+	return 0;
+}
+
+static int ClearDatabase(char* filter)
+{
+	LIST<char> arSettings(10);
+	db_enum_settings(NULL, DeleteSetting, SSMODULENAME, &arSettings);
+
+	for (int i = 0; i < arSettings.getCount(); i++) {
+		if ((filter == NULL) || (!strncmp(filter, arSettings[i], mir_strlen(filter))))
+			db_unset(NULL, SSMODULENAME, arSettings[i]);
+		mir_free(arSettings[i]);
+	}
+	
+	if (filter == NULL)
+		db_unset(NULL, "AutoAway", "Confirm");
+
+	return 0;
+}
+
+
+static OBJLIST<PROFILEOPTIONS> arProfiles(5);
+
+INT_PTR CALLBACK addProfileDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	static HWND hwndParent;
+
+	switch (msg) {
+	case WM_INITDIALOG:
+		TranslateDialogDefault(hwndDlg);
+		hwndParent = (HWND)lParam;
+		EnableWindow(GetDlgItem(hwndDlg, IDC_OK), FALSE);
+		break;
+
+	case WM_COMMAND:
+		if (LOWORD(wParam) == IDC_OK) {
+			wchar_t profileName[128];
+			GetDlgItemText(hwndDlg, IDC_PROFILENAME, profileName, _countof(profileName));
+			SendMessage(hwndParent, UM_ADDPROFILE, 0, (LPARAM)profileName);
+			// done and exit
+			DestroyWindow(hwndDlg);
+		}
+		else if (LOWORD(wParam) == IDC_CANCEL) {
+			DestroyWindow(hwndDlg);
+		}
+		else if (LOWORD(wParam) == IDC_PROFILENAME) {
+			(SendDlgItemMessage(hwndDlg, IDC_PROFILENAME, EM_LINELENGTH, 0, 0) > 0) ? EnableWindow(GetDlgItem(hwndDlg, IDC_OK), TRUE) : EnableWindow(GetDlgItem(hwndDlg, IDC_OK), FALSE);
+		}
+		break;
+
+	case WM_DESTROY:
+		EnableWindow(hwndParent, TRUE);
+		break;
+	}
+
+	return 0;
+}
+
+static INT_PTR CALLBACK StatusProfilesOptDlgProc(HWND hwndDlg,UINT msg,WPARAM wParam,LPARAM lParam)
+{
+	static BOOL bNeedRebuildMenu = FALSE;
+	static BOOL bInitDone = FALSE;
+
+	switch(msg) {
+	case WM_INITDIALOG:
+		bInitDone = false;
+
+		TranslateDialogDefault(hwndDlg);
+		SetDlgItemText(hwndDlg, IDC_CREATEMMI, TranslateT("Create a status menu item"));
+		{
+			int defProfile;
+			int profileCount = GetProfileCount((WPARAM)&defProfile, 0);
+			if (profileCount == 0) {
+				profileCount = 1;
+				defProfile = 0;
+			}
+
+			for (int i=0; i < profileCount; i++) {
+				PROFILEOPTIONS *ppo = new PROFILEOPTIONS;
+				ppo->ps = GetCurrentProtoSettings();
+				TSettingsList& ar = *ppo->ps;
+
+				if ( GetProfile(i, ar) == -1) {
+					/* create an empty profile */
+					if (i == defProfile)
+						ppo->tszName = mir_wstrdup( TranslateT("default"));
+					else
+						ppo->tszName = mir_wstrdup( TranslateT("unknown"));
+				}
+				else {
+					for (int j=0; j < ar.getCount(); j++)
+						if ( ar[j].szMsg != NULL)
+							ar[j].szMsg = wcsdup( ar[j].szMsg );
+
+					ppo->tszName = db_get_wsa(NULL, SSMODULENAME, OptName(i, SETTING_PROFILENAME));
+					if (ppo->tszName == NULL) {
+						if (i == defProfile)
+							ppo->tszName = mir_wstrdup( TranslateT("default"));
+						else
+							ppo->tszName = mir_wstrdup( TranslateT("unknown"));
+					}
+					ppo->createTtb = db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_CREATETTBBUTTON), 0);
+					ppo->showDialog = db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_SHOWCONFIRMDIALOG), 0);
+					ppo->createMmi = db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_CREATEMMITEM), 0);
+					ppo->inSubMenu = db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_INSUBMENU), 1);
+					ppo->regHotkey = db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_REGHOTKEY), 0);
+					ppo->hotKey = db_get_w(NULL, SSMODULENAME, OptName(i, SETTING_HOTKEY), MAKEWORD((char)('0'+i), HOTKEYF_CONTROL|HOTKEYF_SHIFT));
+				}
+				arProfiles.insert(ppo);
+			}
+			if (hTTBModuleLoadedHook == NULL)
+				EnableWindow(GetDlgItem(hwndDlg, IDC_CREATETTB), FALSE);
+
+			SendMessage(hwndDlg, UM_REINITPROFILES, 0, 0);
+			ShowWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), ServiceExists(MS_VARS_SHOWHELPEX)?SW_SHOW:SW_HIDE);
+			bInitDone = true;
+		}
+		break;
+
+	case UM_REINITPROFILES:
+		bInitDone = false;
+		{
+			// creates profile combo box according to 'dat'
+			SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_RESETCONTENT, 0, 0);
+			for (int i=0; i < arProfiles.getCount(); i++ ) {
+				int item = SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_ADDSTRING, 0, (LPARAM)arProfiles[i].tszName);
+				SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_SETITEMDATA, (WPARAM)item, (LPARAM)i);
+			}
+			SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_SETCURSEL, 0, 0);
+			SendMessage(hwndDlg, UM_SETPROFILE, 0, 0);
+		}
+		bInitDone = true;
+		break;
+
+	case UM_SETPROFILE:
+		{
+			int sel = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA,
+				SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
+			CheckDlgButton(hwndDlg, IDC_CREATETTB, arProfiles[sel].createTtb ? BST_CHECKED : BST_UNCHECKED);
+			CheckDlgButton(hwndDlg, IDC_SHOWDIALOG, arProfiles[sel].showDialog ? BST_CHECKED : BST_UNCHECKED);
+			CheckDlgButton(hwndDlg, IDC_CREATEMMI, arProfiles[sel].createMmi ? BST_CHECKED : BST_UNCHECKED);
+			CheckDlgButton(hwndDlg, IDC_INSUBMENU, arProfiles[sel].inSubMenu ? BST_CHECKED : BST_UNCHECKED);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_INSUBMENU), IsDlgButtonChecked(hwndDlg, IDC_CREATEMMI));
+			CheckDlgButton(hwndDlg, IDC_REGHOTKEY, arProfiles[sel].regHotkey ? BST_CHECKED : BST_UNCHECKED);
+			SendDlgItemMessage(hwndDlg, IDC_HOTKEY, HKM_SETHOTKEY, arProfiles[sel].hotKey, 0);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_HOTKEY), IsDlgButtonChecked(hwndDlg, IDC_REGHOTKEY));
+			SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_RESETCONTENT, 0, 0);
+
+			// fill proto list
+			TSettingsList& ar = *arProfiles[sel].ps;
+			for ( int i=0; i < ar.getCount(); i++ ) {
+				int item = SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_ADDSTRING, 0, (LPARAM)ar[i].tszAccName );
+				SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_SETITEMDATA, (WPARAM)item, (LPARAM)&ar[i]);
+			}
+			SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_SETCURSEL, 0, 0);
+			SendMessage(hwndDlg, UM_SETPROTOCOL, 0, 0);
+		}
+		break;
+
+	case UM_SETPROTOCOL:
+		{
+			int idx = SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETCURSEL, 0, 0);
+			if ( idx != -1 ) {
+				// fill status box
+				TSSSetting* ps = ( TSSSetting* )SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETITEMDATA, idx, 0);
+
+				int flags = (CallProtoService(ps->szName, PS_GETCAPS, PFLAGNUM_2, 0))&~(CallProtoService(ps->szName, PS_GETCAPS, PFLAGNUM_5, 0));
+				SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_RESETCONTENT, 0, 0);
+				for ( int i=0; i < _countof(statusModeList); i++ ) {
+					if ( (flags&statusModePf2List[i]) || (statusModeList[i] == ID_STATUS_OFFLINE)) {
+						int item = SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_ADDSTRING, 0, (LPARAM)pcli->pfnGetStatusModeDescription(statusModeList[i], 0));
+						SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_SETITEMDATA, (WPARAM)item, (LPARAM)statusModeList[i]);
+						if (ps->status == statusModeList[i])
+							SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_SETCURSEL, (WPARAM)item, 0);
+					}
+				}
+
+				int item = SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_ADDSTRING, 0, (LPARAM)TranslateT("<current>"));
+				SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_SETITEMDATA, (WPARAM)item, (LPARAM)ID_STATUS_CURRENT);
+				if (ps->status == ID_STATUS_CURRENT)
+					SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_SETCURSEL, (WPARAM)item, 0);
+
+				item = SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_ADDSTRING, 0, (LPARAM)TranslateT("<last>"));
+				SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_SETITEMDATA, (WPARAM)item, (LPARAM)ID_STATUS_LAST);
+				if (ps->status == ID_STATUS_LAST)
+					SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_SETCURSEL, (WPARAM)item, 0);
+			}
+
+			SendMessage(hwndDlg, UM_SETSTATUSMSG, 0, 0);
+		}
+		break;
+
+	case UM_SETSTATUSMSG:
+		{
+			// set status message
+			BOOL bStatusMsg = FALSE;
+			int idx = SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETCURSEL, 0, 0);
+			if ( idx != -1 ) {
+				TSSSetting* ps = ( TSSSetting* )SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETITEMDATA, idx, 0);
+
+				CheckRadioButton(hwndDlg, IDC_MIRANDAMSG, IDC_CUSTOMMSG, ps->szMsg!=NULL?IDC_CUSTOMMSG:IDC_MIRANDAMSG);
+				if (ps->szMsg != NULL)
+					SetDlgItemText(hwndDlg, IDC_STATUSMSG, ps->szMsg);
+
+				bStatusMsg = ( (((CallProtoService(ps->szName, PS_GETCAPS, PFLAGNUM_1, 0)&PF1_MODEMSGSEND&~PF1_INDIVMODEMSG)) &&
+					(CallProtoService(ps->szName, PS_GETCAPS, PFLAGNUM_3, 0)&Proto_Status2Flag(ps->status))) || (ps->status == ID_STATUS_CURRENT) || (ps->status == ID_STATUS_LAST));
+			}
+			EnableWindow(GetDlgItem(hwndDlg, IDC_MIRANDAMSG), bStatusMsg);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_CUSTOMMSG), bStatusMsg);
+			EnableWindow(GetDlgItem(hwndDlg, IDC_STATUSMSG), bStatusMsg&&IsDlgButtonChecked(hwndDlg, IDC_CUSTOMMSG));
+			EnableWindow(GetDlgItem(hwndDlg, IDC_VARIABLESHELP), bStatusMsg&&IsDlgButtonChecked(hwndDlg, IDC_CUSTOMMSG));
+		}
+		break;
+
+	case UM_ADDPROFILE:
+		{
+			wchar_t *tszName = (wchar_t*)lParam;
+			if (tszName == NULL)
+				break;
+
+			PROFILEOPTIONS* ppo = new PROFILEOPTIONS;
+			ppo->tszName = mir_wstrdup(tszName);
+			ppo->ps = GetCurrentProtoSettings();
+			arProfiles.insert(ppo);
+
+			SendMessage(hwndDlg, UM_REINITPROFILES, 0, 0);
+		}
+		break;
+
+	case UM_DELPROFILE: {
+		// wparam == profile no
+		int i=(int)wParam;
+
+		if ( arProfiles.getCount() == 1) {
+			MessageBox(NULL, TranslateT("At least one profile must exist"), TranslateT("StartupStatus"), MB_OK);
+			break;
+		}
+
+		arProfiles.remove(i);
+
+		int defProfile;
+		GetProfileCount((WPARAM)&defProfile, 0);
+		if (i == defProfile) {
+			MessageBox(NULL, TranslateT("Your default profile will be changed"), TranslateT("StartupStatus"), MB_OK);
+			db_set_w(NULL, SSMODULENAME, SETTING_DEFAULTPROFILE, 0);
+		}
+		SendMessage(hwndDlg, UM_REINITPROFILES, 0, 0);
+		break;
+	}
+
+	case WM_COMMAND:
+		if ( ((HIWORD(wParam) == EN_CHANGE) || (HIWORD(wParam) == BN_CLICKED) || (HIWORD(wParam) == LBN_SELCHANGE)) && ((HWND)lParam == GetFocus()))
+			if ( bInitDone )
+				SendMessage(GetParent(hwndDlg),PSM_CHANGED,0,0);
+
+		switch (LOWORD(wParam)) {
+		case IDC_STATUS:
+			if (HIWORD(wParam) == LBN_SELCHANGE) {
+				int idx = SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETCURSEL, 0, 0);
+				if ( idx != -1 ) {
+					TSSSetting* ps = ( TSSSetting* )SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETITEMDATA, idx, 0);
+					ps->status = (int)SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_GETITEMDATA,
+						SendDlgItemMessage(hwndDlg, IDC_STATUS, LB_GETCURSEL, 0, 0), 0);
+				}
+				SendMessage(hwndDlg, UM_SETSTATUSMSG, 0, 0);
+			}
+			break;
+
+		case IDC_PROFILE:
+			if (HIWORD(wParam) != CBN_SELCHANGE)
+				break;
+
+			SendMessage(hwndDlg, UM_SETPROFILE, 0, 0);
+			break;
+
+		case IDC_PROTOCOL:
+			if (HIWORD(wParam) != LBN_SELCHANGE)
+				break;
+
+			SendMessage(hwndDlg, UM_SETPROTOCOL, 0, 0);
+			break;
+
+		case IDC_MIRANDAMSG:
+		case IDC_CUSTOMMSG:
+			{
+				int len;
+				TSSSetting* ps = ( TSSSetting* )SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETCURSEL, 0, 0), 0);
+				if (ps->szMsg != NULL)
+					free(ps->szMsg);
+
+				ps->szMsg = NULL;
+				if (IsDlgButtonChecked(hwndDlg, IDC_CUSTOMMSG)) {
+					len = SendDlgItemMessage(hwndDlg, IDC_STATUSMSG, WM_GETTEXTLENGTH, 0, 0);
+					ps->szMsg = (wchar_t*)calloc(sizeof(wchar_t), len+1);
+					GetDlgItemText(hwndDlg, IDC_STATUSMSG, ps->szMsg, (len + 1));
+				}
+				SendMessage(hwndDlg, UM_SETSTATUSMSG, 0, 0);
+			}
+			break;
+
+		case IDC_STATUSMSG:
+			if (HIWORD(wParam) == EN_CHANGE) {
+				// update the status message in memory, this is done on each character tick, not nice
+				// but it works
+				TSSSetting* ps = ( TSSSetting* )SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_PROTOCOL, LB_GETCURSEL, 0, 0), 0);
+				if (ps->szMsg != NULL) {
+					if ( *ps->szMsg )
+						free(ps->szMsg);
+					ps->szMsg = NULL;
+				}
+				int len = SendDlgItemMessage(hwndDlg, IDC_STATUSMSG, WM_GETTEXTLENGTH, 0, 0);
+				ps->szMsg = (wchar_t*)calloc(sizeof(wchar_t), len+1);
+				GetDlgItemText(hwndDlg, IDC_STATUSMSG, ps->szMsg, (len + 1));
+			}
+			break;
+
+		case IDC_CREATEMMI:
+			EnableWindow(GetDlgItem(hwndDlg, IDC_INSUBMENU), IsDlgButtonChecked(hwndDlg, IDC_CREATEMMI));
+		case IDC_INSUBMENU:
+			bNeedRebuildMenu = TRUE;
+		case IDC_REGHOTKEY:
+		case IDC_CREATETTB:
+		case IDC_SHOWDIALOG:
+			{
+				int sel = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA, SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
+				PROFILEOPTIONS& po = arProfiles[sel];
+				po.createMmi = IsDlgButtonChecked(hwndDlg, IDC_CREATEMMI);
+				po.inSubMenu = IsDlgButtonChecked(hwndDlg, IDC_INSUBMENU);
+				po.createTtb = IsDlgButtonChecked(hwndDlg, IDC_CREATETTB);
+				po.regHotkey = IsDlgButtonChecked(hwndDlg, IDC_REGHOTKEY);
+				po.showDialog = IsDlgButtonChecked(hwndDlg, IDC_SHOWDIALOG);
+				EnableWindow(GetDlgItem(hwndDlg, IDC_HOTKEY), IsDlgButtonChecked(hwndDlg, IDC_REGHOTKEY));
+			}
+			break;
+
+		case IDC_HOTKEY:
+			if (HIWORD(wParam) == EN_CHANGE) {
+				int sel = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
+				arProfiles[sel].hotKey = (WORD)SendDlgItemMessage(hwndDlg, IDC_HOTKEY, HKM_GETHOTKEY, 0, 0);
+			}
+			break;
+
+		case IDC_ADDPROFILE:
+			// add a profile
+			CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_ADDPROFILE), hwndDlg, addProfileDlgProc, (LPARAM)hwndDlg);
+			EnableWindow(hwndDlg, FALSE);
+			break;
+
+		case IDC_DELPROFILE:
+			{
+				int sel = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA,
+					SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
+				SendMessage(hwndDlg, UM_DELPROFILE, (WPARAM)sel, 0);
+			}
+			break;
+
+		case IDC_VARIABLESHELP:
+			variables_showhelp(hwndDlg, IDC_STATUSMSG, VHF_INPUT|VHF_EXTRATEXT|VHF_HELP|VHF_FULLFILLSTRUCT|VHF_HIDESUBJECTTOKEN, NULL, "Protocol ID");
+			break;
+		}
+		break;
+
+	case WM_NOTIFY:
+		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
+			char setting[128];
+			int oldCount = db_get_w(NULL, SSMODULENAME, SETTING_PROFILECOUNT, 0);
+			for (int i=0; i < oldCount; i++) {
+				mir_snprintf(setting, "%d_", i);
+				ClearDatabase(setting);
+			}
+			for (int i=0; i < arProfiles.getCount(); i++) {
+				PROFILEOPTIONS& po = arProfiles[i];
+				db_set_b(NULL, SSMODULENAME, OptName(i, SETTING_SHOWCONFIRMDIALOG), po.showDialog);
+				db_set_b(NULL, SSMODULENAME, OptName(i, SETTING_CREATETTBBUTTON), po.createTtb);
+				db_set_b(NULL, SSMODULENAME, OptName(i, SETTING_CREATEMMITEM), po.createMmi);
+				db_set_b(NULL, SSMODULENAME, OptName(i, SETTING_INSUBMENU), po.inSubMenu);
+				db_set_b(NULL, SSMODULENAME, OptName(i, SETTING_REGHOTKEY), po.regHotkey);
+				db_set_w(NULL, SSMODULENAME, OptName(i, SETTING_HOTKEY), po.hotKey);
+				db_set_ws(NULL, SSMODULENAME, OptName(i, SETTING_PROFILENAME), po.tszName);
+
+				TSettingsList& ar = *po.ps;
+				for (int j=0; j < ar.getCount(); j++) {
+					if ( ar[j].szMsg != NULL ) {
+						mir_snprintf(setting, "%s_%s", ar[j].szName, SETTING_PROFILE_STSMSG);
+						db_set_ws(NULL, SSMODULENAME, OptName(i, setting), ar[j].szMsg);
+					}
+					db_set_w(NULL, SSMODULENAME, OptName(i, ar[j].szName), ar[j].status);
+				}
+			}
+			db_set_w(NULL, SSMODULENAME, SETTING_PROFILECOUNT, (WORD)arProfiles.getCount());
+
+			// Rebuild status menu
+			if (bNeedRebuildMenu)
+				pcli->pfnReloadProtoMenus();
+
+			SSLoadMainOptions();
+		}
+		break;
+
+	case WM_DESTROY:
+		arProfiles.destroy();
+		break;
+	}
+
+	return 0;
+}
+
+int StartupStatusOptionsInit(WPARAM wparam,LPARAM)
+{
+	OPTIONSDIALOGPAGE odp = { 0 };
+	odp.hInstance = hInst;
+	odp.pszGroup = LPGEN("Status");
+	odp.pszTitle = LPGEN("StartupStatus");
+	odp.flags = ODPF_BOLDGROUPS;
+
+	odp.pszTab = LPGEN("General");
+	odp.pszTemplate = MAKEINTRESOURCEA(IDD_OPT_STARTUPSTATUS);
+	odp.pfnDlgProc = StartupStatusOptDlgProc;
+	Options_AddPage(wparam,&odp);
+
+	odp.pszTab = LPGEN("Status profiles");
+	odp.pszTemplate = MAKEINTRESOURCEA(IDD_OPT_STATUSPROFILES);
+	odp.pfnDlgProc = StatusProfilesOptDlgProc;
+	Options_AddPage(wparam,&odp);
+	return 0;
+}
+
+char* OptName(int i, const char* setting)
+{
+	static char buf[100];
+	mir_snprintf(buf, "%d_%s", i, setting);
+	return buf;
+}
diff --git a/plugins/StatusManager/src/ss_profiles.cpp b/plugins/StatusManager/src/ss_profiles.cpp
new file mode 100644
index 0000000000..521d498fe9
--- /dev/null
+++ b/plugins/StatusManager/src/ss_profiles.cpp
@@ -0,0 +1,343 @@
+/*
+	StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+#define MAX_MMITEMS		6
+
+extern HINSTANCE hInst;
+extern int protoCount;
+
+static int menuprofiles[MAX_MMITEMS];
+static HANDLE hProfileServices[MAX_MMITEMS];
+static int mcount = 0;
+
+static PROFILECE *pce = NULL;
+static int pceCount = 0;
+
+static UINT_PTR releaseTtbTimerId = 0;
+
+static HANDLE hTBModuleLoadedHook;
+static HANDLE hLoadAndSetProfileService;
+static HANDLE hMessageHook = NULL;
+
+static HWND hMessageWindow = NULL;
+static HKINFO *hkInfo = NULL;
+static int hkiCount = 0;
+
+static HANDLE* ttbButtons = NULL;
+static int ttbButtonCount = 0;
+
+HANDLE hTTBModuleLoadedHook;
+
+static INT_PTR profileService(WPARAM, LPARAM, LPARAM param)
+{
+	LoadAndSetProfile((WPARAM)menuprofiles[param], 0);
+	return 0;
+}
+
+static int CreateMainMenuItems(WPARAM, LPARAM)
+{
+	CMenuItem mi;
+	mi.position = 2000100000;
+	mi.flags = CMIF_UNICODE;
+	mcount = 0;
+	int count = GetProfileCount(0, 0);
+	for (int i = 0; i < count && mcount < MAX_MMITEMS; i++) {
+		wchar_t profilename[128];
+		if (!db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_CREATEMMITEM), 0) || GetProfileName(i, (LPARAM)profilename))
+			continue;
+
+		if (db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_INSUBMENU), 1) && !mi.root) {
+			mi.root = Menu_CreateRoot(MO_STATUS, LPGENW("Status profiles"), 2000100000);
+			Menu_ConfigureItem(mi.root, MCI_OPT_UID, "1AB30D51-BABA-4B27-9288-1A12278BAD8D");
+		}
+
+		char servicename[128];
+		mir_snprintf(servicename, "%s%d", MS_SS_MENUSETPROFILEPREFIX, mcount);
+		hProfileServices[mcount] = CreateServiceFunctionParam(servicename, profileService, mcount);
+
+		mi.name.w = profilename;
+		mi.position = 2000100000 + mcount;
+		mi.pszService = servicename;
+		if (Menu_AddStatusMenuItem(&mi))
+			menuprofiles[mcount++] = i;
+	}
+
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+INT_PTR GetProfileName(WPARAM wParam, LPARAM lParam)
+{
+	int profile = (int)wParam;
+	if (profile < 0) // get default profile
+		profile = db_get_w(NULL, SSMODULENAME, SETTING_DEFAULTPROFILE, 0);
+
+	int count = db_get_w(NULL, SSMODULENAME, SETTING_PROFILECOUNT, 0);
+	if (profile >= count && count > 0)
+		return -1;
+
+	wchar_t* buf = (wchar_t*)lParam;
+	if (count == 0) {
+		wcsncpy(buf, TranslateT("default"), 128 - 1);
+		return 0;
+	}
+
+	DBVARIANT dbv;
+	char setting[80];
+	mir_snprintf(setting, "%d_%s", profile, SETTING_PROFILENAME);
+	if (db_get_ws(NULL, SSMODULENAME, setting, &dbv))
+		return -1;
+
+	wcsncpy(buf, dbv.ptszVal, 128 - 1); buf[127] = 0;
+	db_free(&dbv);
+	return 0;
+}
+
+INT_PTR GetProfileCount(WPARAM wParam, LPARAM)
+{
+	int *def = (int*)wParam;
+	int count = db_get_w(NULL, SSMODULENAME, SETTING_PROFILECOUNT, 1);
+	if (def != 0) {
+		*def = db_get_w(NULL, SSMODULENAME, SETTING_DEFAULTPROFILE, 0);
+		if (*def >= count)
+			*def = 0;
+	}
+
+	return count;
+}
+
+wchar_t *GetStatusMessage(int profile, char *szProto)
+{
+	char dbSetting[80];
+	DBVARIANT dbv;
+
+	for (int i = 0; i < pceCount; i++) {
+		if ((pce[i].profile == profile) && (!mir_strcmp(pce[i].szProto, szProto))) {
+			mir_snprintf(dbSetting, "%d_%s_%s", profile, szProto, SETTING_PROFILE_STSMSG);
+			if (!db_get_ws(NULL, SSMODULENAME, dbSetting, &dbv)) { // reload from db
+				pce[i].msg = (wchar_t*)realloc(pce[i].msg, sizeof(wchar_t)*(mir_wstrlen(dbv.ptszVal) + 1));
+				if (pce[i].msg != NULL) {
+					mir_wstrcpy(pce[i].msg, dbv.ptszVal);
+				}
+				db_free(&dbv);
+			}
+			else {
+				if (pce[i].msg != NULL) {
+					free(pce[i].msg);
+					pce[i].msg = NULL;
+				}
+			}
+			return pce[i].msg;
+		}
+	}
+	pce = (PROFILECE*)realloc(pce, (pceCount + 1)*sizeof(PROFILECE));
+	if (pce == NULL)
+		return NULL;
+
+	pce[pceCount].profile = profile;
+	pce[pceCount].szProto = _strdup(szProto);
+	pce[pceCount].msg = NULL;
+	mir_snprintf(dbSetting, "%d_%s_%s", profile, szProto, SETTING_PROFILE_STSMSG);
+	if (!db_get_ws(NULL, SSMODULENAME, dbSetting, &dbv)) {
+		pce[pceCount].msg = wcsdup(dbv.ptszVal);
+		db_free(&dbv);
+	}
+	pceCount++;
+
+	return pce[pceCount - 1].msg;
+}
+
+int GetProfile(int profile, TSettingsList& arSettings)
+{
+	if (profile < 0) // get default profile
+		profile = db_get_w(NULL, SSMODULENAME, SETTING_DEFAULTPROFILE, 0);
+
+	int count = db_get_w(NULL, SSMODULENAME, SETTING_PROFILECOUNT, 0);
+	if (profile >= count && count > 0)
+		return -1;
+
+	arSettings.destroy();
+
+	// if count == 0, continue so the default profile will be returned
+	PROTOACCOUNT** protos;
+	Proto_EnumAccounts(&count, &protos);
+
+	for (int i = 0; i < count; i++)
+		if (IsSuitableProto(protos[i]))
+			arSettings.insert(new TSSSetting(profile, protos[i]));
+
+	return (arSettings.getCount() == 0) ? -1 : 0;
+}
+
+static void CALLBACK releaseTtbTimerFunction(HWND, UINT, UINT_PTR, DWORD)
+{
+	KillTimer(NULL, releaseTtbTimerId);
+	for (int i = 0; i < ttbButtonCount; i++)
+		CallService(MS_TTB_SETBUTTONSTATE, (WPARAM)ttbButtons[i], 0);
+}
+
+INT_PTR LoadAndSetProfile(WPARAM iProfileNo, LPARAM)
+{
+	// wParam == profile no.
+	int profile = (int)iProfileNo;
+	TSettingsList profileSettings(10, CompareSettings);
+	if (!GetProfile(profile, profileSettings)) {
+		profile = (profile >= 0) ? profile : db_get_w(NULL, SSMODULENAME, SETTING_DEFAULTPROFILE, 0);
+
+		char setting[64];
+		mir_snprintf(setting, "%d_%s", profile, SETTING_SHOWCONFIRMDIALOG);
+		if (!db_get_b(NULL, SSMODULENAME, setting, 0))
+			CallService(MS_CS_SETSTATUSEX, (WPARAM)&profileSettings, 0);
+		else
+			CallService(MS_CS_SHOWCONFIRMDLGEX, (WPARAM)&profileSettings, (LPARAM)db_get_dw(NULL, SSMODULENAME, SETTING_DLGTIMEOUT, 5));
+	}
+
+	// add timer here
+	if (hTTBModuleLoadedHook)
+		releaseTtbTimerId = SetTimer(NULL, 0, 100, releaseTtbTimerFunction);
+
+	return 0;
+}
+
+static UINT GetFsModifiers(WORD wHotKey)
+{
+	UINT fsm = 0;
+	if (HIBYTE(wHotKey)&HOTKEYF_ALT)
+		fsm |= MOD_ALT;
+	if (HIBYTE(wHotKey)&HOTKEYF_CONTROL)
+		fsm |= MOD_CONTROL;
+	if (HIBYTE(wHotKey)&HOTKEYF_SHIFT)
+		fsm |= MOD_SHIFT;
+	if (HIBYTE(wHotKey)&HOTKEYF_EXT)
+		fsm |= MOD_WIN;
+
+	return fsm;
+}
+
+static DWORD CALLBACK MessageWndProc(HWND, UINT msg, WPARAM wParam, LPARAM)
+{
+	if (msg == WM_HOTKEY) {
+		for (int i = 0; i < hkiCount; i++)
+			if ((int)hkInfo[i].id == wParam)
+				LoadAndSetProfile((WPARAM)hkInfo[i].profile, 0);
+	}
+
+	return TRUE;
+}
+
+static int UnregisterHotKeys()
+{
+	if (hkInfo != NULL) {
+		for (int i = 0; i < hkiCount; i++) {
+			UnregisterHotKey(hMessageWindow, (int)hkInfo[i].id);
+			GlobalDeleteAtom(hkInfo[i].id);
+		}
+		free(hkInfo);
+	}
+	DestroyWindow(hMessageWindow);
+
+	hkiCount = 0;
+	hkInfo = NULL;
+	hMessageWindow = NULL;
+
+	return 0;
+}
+
+// assumes UnregisterHotKeys was called before
+static int RegisterHotKeys()
+{
+	hMessageWindow = CreateWindowEx(0, L"STATIC", NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
+	SetWindowLongPtr(hMessageWindow, GWLP_WNDPROC, (LONG_PTR)MessageWndProc);
+
+	int count = GetProfileCount(0, 0);
+	for (int i = 0; i < count; i++) {
+		if (!db_get_b(NULL, SSMODULENAME, OptName(i, SETTING_REGHOTKEY), 0))
+			continue;
+
+		WORD wHotKey = db_get_w(NULL, SSMODULENAME, OptName(i, SETTING_HOTKEY), 0);
+		hkInfo = (HKINFO*)realloc(hkInfo, (hkiCount + 1)*sizeof(HKINFO));
+		if (hkInfo == NULL)
+			return -1;
+
+		char atomname[255];
+		mir_snprintf(atomname, "StatusProfile_%d", i);
+		hkInfo[hkiCount].id = GlobalAddAtomA(atomname);
+		if (hkInfo[hkiCount].id == 0)
+			continue;
+
+		hkInfo[hkiCount].profile = i;
+		hkiCount++;
+		RegisterHotKey(hMessageWindow, (int)hkInfo[hkiCount - 1].id, GetFsModifiers(wHotKey), LOBYTE(wHotKey));
+	}
+
+	if (hkiCount == 0)
+		UnregisterHotKeys();
+
+	return 0;
+}
+
+int SSLoadMainOptions()
+{
+	if (hTTBModuleLoadedHook) {
+		RemoveTopToolbarButtons();
+		CreateTopToolbarButtons(0, 0);
+	}
+
+	UnregisterHotKeys();
+	RegisterHotKeys();
+	return 0;
+}
+
+int LoadProfileModule()
+{
+	hLoadAndSetProfileService = CreateServiceFunction(MS_SS_LOADANDSETPROFILE, LoadAndSetProfile);
+	return 0;
+}
+
+int InitProfileModule()
+{
+	hTTBModuleLoadedHook = HookEvent(ME_TTB_MODULELOADED, CreateTopToolbarButtons);
+
+	HookEvent(ME_CLIST_PREBUILDSTATUSMENU, CreateMainMenuItems);
+
+	CreateMainMenuItems(0, 0);
+	RegisterHotKeys();
+	return 0;
+}
+
+int DeinitProfilesModule()
+{
+	for (int i = 0; i < mcount; i++)
+		DestroyServiceFunction(hProfileServices[i]);
+
+	if (pce) {
+		for (int i = 0; i < pceCount; i++)
+			free(pce[i].szProto);
+		free(pce);
+	}
+
+	UnregisterHotKeys();
+	RemoveTopToolbarButtons();
+
+	DestroyServiceFunction(hLoadAndSetProfileService);
+	return 0;
+}
diff --git a/plugins/StatusManager/src/ss_toolbars.cpp b/plugins/StatusManager/src/ss_toolbars.cpp
new file mode 100644
index 0000000000..2ecf0a6b95
--- /dev/null
+++ b/plugins/StatusManager/src/ss_toolbars.cpp
@@ -0,0 +1,72 @@
+/*
+	StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+#define MAX_MMITEMS		6
+
+static LIST<void> ttbButtons(1);
+
+static IconItem iconList[] = 
+{
+	{ LPGEN("Pressed toolbar icon"),  "StartupStatus/TtbDown", IDI_TTBDOWN },
+	{ LPGEN("Released toolbar icon"), "StartupStatus/TtbUp",   IDI_TTBUP   },
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+void RemoveTopToolbarButtons()
+{
+	for (int i=ttbButtons.getCount()-1; i >= 0; i--)
+		CallService(MS_TTB_REMOVEBUTTON, (WPARAM)ttbButtons[i], 0);
+	ttbButtons.destroy();
+}
+
+int CreateTopToolbarButtons(WPARAM, LPARAM)
+{
+	if (iconList[0].hIcolib == NULL)
+		Icon_Register(hInst, "Toolbar/StartupStatus", iconList, _countof(iconList));
+
+	int profileCount = CallService(MS_SS_GETPROFILECOUNT, 0, 0);
+
+	TTBButton ttb = { 0 };
+	ttb.dwFlags = TTBBF_VISIBLE | TTBBF_SHOWTOOLTIP;
+	ttb.pszService = MS_SS_LOADANDSETPROFILE;
+	for (int i=0; i < profileCount; i++) {
+		char setting[80];
+		mir_snprintf(setting, "%d_%s", i, SETTING_CREATETTBBUTTON);
+		if (!db_get_b(NULL, SSMODULENAME, setting, FALSE))
+			continue;
+		
+		DBVARIANT dbv;
+		mir_snprintf(setting, "%d_%s", i, SETTING_PROFILENAME);
+		if (db_get(NULL, SSMODULENAME, setting, &dbv))
+			continue;
+
+		ttb.hIconHandleDn = iconList[0].hIcolib;
+		ttb.hIconHandleUp = iconList[1].hIcolib;
+		ttb.wParamDown = ttb.wParamUp = i;
+		ttb.name = ttb.pszTooltipUp = dbv.pszVal;
+		HANDLE ttbAddResult = TopToolbar_AddButton(&ttb);
+		if (ttbAddResult)
+			ttbButtons.insert(ttbAddResult);
+		db_free(&dbv);
+	}
+	return 0;
+}
diff --git a/plugins/StatusManager/src/startupstatus.cpp b/plugins/StatusManager/src/startupstatus.cpp
new file mode 100644
index 0000000000..995aa68934
--- /dev/null
+++ b/plugins/StatusManager/src/startupstatus.cpp
@@ -0,0 +1,486 @@
+/*
+	StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+	Copyright 2003-2006 P. Boon
+
+	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; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "stdafx.h"
+
+static UINT_PTR setStatusTimerId = 0;
+
+int CompareSettings(const TSSSetting *p1, const TSSSetting *p2)
+{
+	return mir_strcmp(p1->szName, p2->szName);
+}
+
+static TSettingsList startupSettings(10, CompareSettings);
+
+TSSSetting::TSSSetting(PROTOACCOUNT *pa)
+{
+	cbSize = sizeof(PROTOCOLSETTINGEX);
+	szName = pa->szModuleName;
+	tszAccName = pa->tszAccountName;
+	status = lastStatus = CallProtoService(pa->szModuleName, PS_GETSTATUS, 0, 0);
+	szMsg = NULL;
+}
+
+TSSSetting::TSSSetting(int profile, PROTOACCOUNT *pa)
+{
+	cbSize = sizeof(PROTOCOLSETTINGEX);
+
+	// copy name
+	szName = pa->szModuleName;
+	tszAccName = pa->tszAccountName;
+
+	// load status
+	char setting[80];
+	mir_snprintf(setting, "%d_%s", profile, pa->szModuleName);
+	int iStatus = db_get_w(NULL, SSMODULENAME, setting, 0);
+	if (iStatus < MIN_STATUS || iStatus > MAX_STATUS)
+		iStatus = DEFAULT_STATUS;
+	status = iStatus;
+
+	// load last status
+	mir_snprintf(setting, "%s%s", PREFIX_LAST, szName);
+	iStatus = db_get_w(NULL, SSMODULENAME, setting, 0);
+	if (iStatus < MIN_STATUS || iStatus > MAX_STATUS)
+		iStatus = DEFAULT_STATUS;
+	lastStatus = iStatus;
+
+	szMsg = GetStatusMessage(profile, szName);
+	if (szMsg)
+		szMsg = wcsdup(szMsg);
+}
+
+TSSSetting::~TSSSetting()
+{
+	free(szMsg);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+static HANDLE hProtoAckHook, hCSStatusChangeHook, hStatusChangeHook;
+
+static HWND hMessageWindow;
+
+static BYTE showDialogOnStartup = 0;
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// command line options
+
+static PROTOCOLSETTINGEX* IsValidProtocol(TSettingsList& protoSettings, char* protoName)
+{
+	for (int i = 0; i < protoSettings.getCount(); i++)
+		if (!strncmp(protoSettings[i].szName, protoName, mir_strlen(protoSettings[i].szName)))
+			return &protoSettings[i];
+
+	return NULL;
+}
+
+static int IsValidStatusDesc(char* statusDesc)
+{
+	if (!strncmp("away", statusDesc, 4))
+		return ID_STATUS_AWAY;
+	if (!strncmp("na", statusDesc, 2))
+		return ID_STATUS_NA;
+	if (!strncmp("dnd", statusDesc, 3))
+		return ID_STATUS_DND;
+	if (!strncmp("occupied", statusDesc, 8))
+		return ID_STATUS_OCCUPIED;
+	if (!strncmp("freechat", statusDesc, 8))
+		return ID_STATUS_FREECHAT;
+	if (!strncmp("online", statusDesc, 6))
+		return ID_STATUS_ONLINE;
+	if (!strncmp("offline", statusDesc, 7))
+		return ID_STATUS_OFFLINE;
+	if (!strncmp("invisible", statusDesc, 9))
+		return ID_STATUS_INVISIBLE;
+	if (!strncmp("onthephone", statusDesc, 10))
+		return ID_STATUS_ONTHEPHONE;
+	if (!strncmp("outtolunch", statusDesc, 10))
+		return ID_STATUS_OUTTOLUNCH;
+	if (!strncmp("last", statusDesc, 4))
+		return ID_STATUS_LAST;
+
+	return 0;
+}
+
+static void ProcessCommandLineOptions(TSettingsList& protoSettings)
+{
+	if (protoSettings.getCount() == 0)
+		return;
+
+	char *cmdl = GetCommandLineA();
+	while (*cmdl != '\0') {
+		while (*cmdl != '/') {
+			if (*cmdl == '\0')
+				return;
+
+			cmdl++;
+		}
+		if (*cmdl == '\0')
+			return;
+
+		cmdl++;
+		if (!strncmp(cmdl, "showdialog", 10)) {
+			showDialogOnStartup = TRUE;
+			continue;
+		}
+		char *protoName = cmdl; // first protocol ?
+		PROTOCOLSETTINGEX* protoSetting = IsValidProtocol(protoSettings, protoName);
+		if (protoSetting != NULL) {
+			while (*cmdl != '=') {
+				if (*cmdl == '\0')
+					return;
+
+				cmdl++; // skip to status
+			}
+
+			if (*cmdl == '\0')
+				return;
+
+			cmdl++;
+			char *statusDesc = cmdl;
+			int status = IsValidStatusDesc(statusDesc);
+			if (status != 0)
+				protoSetting->status = status;
+		}
+	}
+}
+
+static void SetLastStatusMessages(TSettingsList &ps)
+{
+	for (int i = 0; i < ps.getCount(); i++) {
+		if (ps[i].status != ID_STATUS_LAST)
+			continue;
+
+		char dbSetting[128];
+		mir_snprintf(dbSetting, "%s%s", PREFIX_LASTMSG, ps[i].szName);
+
+		DBVARIANT dbv;
+		if (ps[i].szMsg == NULL && !db_get_ws(NULL, SSMODULENAME, dbSetting, &dbv)) {
+			ps[i].szMsg = wcsdup(dbv.ptszVal); // remember this won't be freed
+			db_free(&dbv);
+		}
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Account control event
+
+int OnSSAccChanged(WPARAM wParam, LPARAM lParam)
+{
+	PROTOACCOUNT *pa = (PROTOACCOUNT*)lParam;
+	switch (wParam) {
+	case PRAC_ADDED:
+		startupSettings.insert(new TSSSetting(-1, pa));
+		break;
+
+	case PRAC_REMOVED:
+		for (int i = 0; i < startupSettings.getCount(); i++) {
+			if (!mir_strcmp(startupSettings[i].szName, pa->szModuleName)) {
+				startupSettings.remove(i);
+				break;
+			}
+		}
+		break;
+	}
+
+	return 0;
+}
+
+// 'allow override'
+static int ProcessProtoAck(WPARAM, LPARAM lParam)
+{
+	// 'something' made a status change
+	ACKDATA *ack = (ACKDATA*)lParam;
+	if (ack->type != ACKTYPE_STATUS && ack->result != ACKRESULT_FAILED)
+		return 0;
+
+	if (!db_get_b(NULL, SSMODULENAME, SETTING_OVERRIDE, 1) || startupSettings.getCount() == 0)
+		return 0;
+
+	for (int i = 0; i < startupSettings.getCount(); i++) {
+		if (!mir_strcmp(ack->szModule, startupSettings[i].szName)) {
+			startupSettings[i].szName = "";
+			log_debugA("StartupStatus: %s overridden by ME_PROTO_ACK, status will not be set", ack->szModule);
+		}
+	}
+
+	return 0;
+}
+
+static int StatusChange(WPARAM, LPARAM lParam)
+{
+	// change by menu
+	if (!db_get_b(NULL, SSMODULENAME, SETTING_OVERRIDE, 1) || startupSettings.getCount() == 0)
+		return 0;
+
+	char *szProto = (char *)lParam;
+	if (szProto == NULL) { // global status change
+		for (int i = 0; i < startupSettings.getCount(); i++) {
+			startupSettings[i].szName = "";
+			log_debugA("StartupStatus: all protos overridden by ME_CLIST_STATUSMODECHANGE, status will not be set");
+		}
+	}
+	else {
+		for (int i = 0; i < startupSettings.getCount(); i++) {
+			if (!mir_strcmp(startupSettings[i].szName, szProto)) {
+				startupSettings[i].szName = "";
+				log_debugA("StartupStatus: %s overridden by ME_CLIST_STATUSMODECHANGE, status will not be set", szProto);
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int CSStatusChangeEx(WPARAM wParam, LPARAM)
+{
+	// another status plugin made the change
+	if (!db_get_b(NULL, SSMODULENAME, SETTING_OVERRIDE, 1) || startupSettings.getCount() == 0)
+		return 0;
+
+	if (wParam != 0) {
+		PROTOCOLSETTINGEX** ps = *(PROTOCOLSETTINGEX***)wParam;
+		if (ps == NULL)
+			return -1;
+
+		for (int i = 0; i < startupSettings.getCount(); i++) {
+			for (int j = 0; j < startupSettings.getCount(); j++) {
+				if (ps[i]->szName == NULL || startupSettings[j].szName == NULL)
+					continue;
+
+				if (!mir_strcmp(ps[i]->szName, startupSettings[j].szName)) {
+					log_debugA("StartupStatus: %s overridden by MS_CS_SETSTATUSEX, status will not be set", ps[i]->szName);
+					// use a hack to disable this proto
+					startupSettings[j].szName = "";
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+static void CALLBACK SetStatusTimed(HWND, UINT, UINT_PTR, DWORD)
+{
+	KillTimer(NULL, setStatusTimerId);
+	UnhookEvent(hProtoAckHook);
+	UnhookEvent(hCSStatusChangeHook);
+	UnhookEvent(hStatusChangeHook);
+	CallService(MS_CS_SETSTATUSEX, (WPARAM)&startupSettings, 0);
+}
+
+static int OnOkToExit(WPARAM, LPARAM)
+{
+	// save last protocolstatus
+	int count;
+	PROTOACCOUNT** protos;
+	Proto_EnumAccounts(&count, &protos);
+
+	for (int i = 0; i < count; i++) {
+		PROTOACCOUNT *pa = protos[i];
+		if (!IsSuitableProto(pa))
+			continue;
+
+		if (!Proto_GetAccount(pa->szModuleName))
+			continue;
+
+		char lastName[128], lastMsg[128];
+		mir_snprintf(lastName, "%s%s", PREFIX_LAST, pa->szModuleName);
+		db_set_w(NULL, SSMODULENAME, lastName, (WORD)CallProtoService(pa->szModuleName, PS_GETSTATUS, 0, 0));
+		mir_snprintf(lastMsg, "%s%s", PREFIX_LASTMSG, pa->szModuleName);
+		db_unset(NULL, SSMODULENAME, lastMsg);
+
+		if (!(CallProtoService(pa->szModuleName, PS_GETCAPS, PFLAGNUM_1, 0) & PF1_MODEMSGSEND & ~PF1_INDIVMODEMSG))
+			continue;
+
+		int status = CallProtoService(pa->szModuleName, PS_GETSTATUS, 0, 0);
+		if (!(CallProtoService(pa->szModuleName, PS_GETCAPS, PFLAGNUM_3, 0) & Proto_Status2Flag(status)))
+			continue;
+
+		// NewAwaySys
+		if (ServiceExists(MS_NAS_GETSTATE)) {
+			NAS_PROTOINFO npi = { sizeof(npi) };
+			npi.szProto = pa->szModuleName;
+			CallService(MS_NAS_GETSTATE, (WPARAM)&npi, 1);
+			if (npi.szMsg == NULL) {
+				npi.status = 0;
+				npi.szProto = NULL;
+				CallService(MS_NAS_GETSTATE, (WPARAM)&npi, 1);
+			}
+			if (npi.szMsg != NULL) {
+				db_set_ws(NULL, SSMODULENAME, lastMsg, npi.tszMsg);
+				mir_free(npi.tszMsg);
+			}
+		}
+	}
+
+	if (db_get_b(NULL, SSMODULENAME, SETTING_SETPROFILE, 1) || db_get_b(NULL, SSMODULENAME, SETTING_OFFLINECLOSE, 0)) {
+		if (ServiceExists(MS_CLIST_SETSTATUSMODE))
+			CallService(MS_CLIST_SETSTATUSMODE, ID_STATUS_OFFLINE, 0);
+		else
+			log_debugA("StartupStatus: MS_CLIST_SETSTATUSMODE not available!");
+	}
+
+	return 0;
+}
+
+static int OnShutdown(WPARAM, LPARAM)
+{
+	DeinitProfilesModule();
+
+	// set windowstate and docked for next startup
+	if (db_get_b(NULL, SSMODULENAME, SETTING_SETWINSTATE, 0)) {
+		int state = db_get_b(NULL, SSMODULENAME, SETTING_WINSTATE, SETTING_STATE_NORMAL);
+		HWND hClist = pcli->hwndContactList;
+		BOOL isHidden = !IsWindowVisible(hClist);
+		switch (state) {
+		case SETTING_STATE_HIDDEN:
+			// try to use services where possible
+			if (!isHidden)
+				pcli->pfnShowHide();
+			break;
+
+		case SETTING_STATE_MINIMIZED:
+			if (!db_get_b(NULL, MODULE_CLIST, SETTING_TOOLWINDOW, 0))
+				ShowWindow(hClist, SW_SHOWMINIMIZED);
+			break;
+
+		case SETTING_STATE_NORMAL:
+			// try to use services where possible (that's what they're for)
+			if (isHidden)
+				pcli->pfnShowHide();
+			break;
+		}
+	}
+
+	// hangup
+	if (db_get_b(NULL, SSMODULENAME, SETTING_AUTOHANGUP, 0))
+		InternetAutodialHangup(0);
+
+	int state = db_get_b(NULL, SSMODULENAME, SETTING_WINSTATE, SETTING_STATE_NORMAL);
+	// set windowstate and docked for next startup
+	if (db_get_b(NULL, SSMODULENAME, SETTING_SETWINSTATE, 0))
+		db_set_b(NULL, MODULE_CLIST, SETTING_WINSTATE, (BYTE)state);
+
+	if (hMessageWindow)
+		DestroyWindow(hMessageWindow);
+
+	startupSettings.destroy();
+	return 0;
+}
+
+/* Window proc for poweroff event */
+static DWORD CALLBACK MessageWndProc(HWND, UINT msg, WPARAM wParam, LPARAM)
+{
+	switch (msg) {
+	case WM_ENDSESSION:
+		log_debugA("WM_ENDSESSION");
+		if (wParam) {
+			log_debugA("WM_ENDSESSION: calling exit");
+			OnShutdown(0, 0);
+			log_debugA("WM_ENDSESSION: exit called");
+		}
+		break;
+	}
+
+	return TRUE;
+}
+
+int SSCSModuleLoaded(WPARAM, LPARAM)
+{
+	protoList = (OBJLIST<PROTOCOLSETTINGEX>*)&startupSettings;
+
+	InitProfileModule();
+
+	HookEvent(ME_PROTO_ACCLISTCHANGED, OnSSAccChanged);
+	HookEvent(ME_OPT_INITIALISE, StartupStatusOptionsInit);
+
+	/* shutdown hook for normal shutdown */
+	HookEvent(ME_SYSTEM_OKTOEXIT, OnOkToExit);
+	HookEvent(ME_SYSTEM_PRESHUTDOWN, OnShutdown);
+	/* message window for poweroff */
+	hMessageWindow = CreateWindowEx(0, L"STATIC", NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
+	SetWindowLongPtr(hMessageWindow, GWLP_WNDPROC, (LONG_PTR)MessageWndProc);
+
+	GetProfile(-1, startupSettings);
+
+	// override with cmdl
+	ProcessCommandLineOptions(startupSettings);
+	if (startupSettings.getCount() == 0)
+		return 0;// no protocols are loaded
+
+	SetLastStatusMessages(startupSettings);
+	showDialogOnStartup = (showDialogOnStartup || db_get_b(NULL, SSMODULENAME, SETTING_SHOWDIALOG, 0));
+
+	// dial
+	if (showDialogOnStartup || db_get_b(NULL, SSMODULENAME, SETTING_SETPROFILE, 1))
+		if (db_get_b(NULL, SSMODULENAME, SETTING_AUTODIAL, 0))
+			InternetAutodial(0, NULL);
+
+	// set the status!
+	if (showDialogOnStartup || db_get_b(NULL, SSMODULENAME, SETTING_SHOWDIALOG, 0))
+		CallService(MS_CS_SHOWCONFIRMDLGEX, (WPARAM)&startupSettings, db_get_dw(NULL, SSMODULENAME, SETTING_DLGTIMEOUT, 5));
+	else if (db_get_b(NULL, SSMODULENAME, SETTING_SETPROFILE, 1)) {
+		// set hooks for override
+		if (db_get_b(NULL, SSMODULENAME, SETTING_OVERRIDE, 1)) {
+			hProtoAckHook = HookEvent(ME_PROTO_ACK, ProcessProtoAck);
+			hCSStatusChangeHook = HookEvent(ME_CS_STATUSCHANGEEX, CSStatusChangeEx);
+			hStatusChangeHook = HookEvent(ME_CLIST_STATUSMODECHANGE, StatusChange);
+		}
+		setStatusTimerId = SetTimer(NULL, 0, db_get_dw(NULL, SSMODULENAME, SETTING_SETPROFILEDELAY, 500), SetStatusTimed);
+	}
+
+	// win size and location
+	if (db_get_b(NULL, SSMODULENAME, SETTING_SETWINLOCATION, 0) || db_get_b(NULL, SSMODULENAME, SETTING_SETWINSIZE, 0)) {
+		HWND hClist = pcli->hwndContactList;
+
+		// store in db
+		if (db_get_b(NULL, SSMODULENAME, SETTING_SETWINLOCATION, 0)) {
+			db_set_dw(NULL, MODULE_CLIST, SETTING_XPOS, db_get_dw(NULL, SSMODULENAME, SETTING_XPOS, 0));
+			db_set_dw(NULL, MODULE_CLIST, SETTING_YPOS, db_get_dw(NULL, SSMODULENAME, SETTING_YPOS, 0));
+		}
+		if (db_get_b(NULL, SSMODULENAME, SETTING_SETWINSIZE, 0)) {
+			db_set_dw(NULL, MODULE_CLIST, SETTING_WIDTH, db_get_dw(NULL, SSMODULENAME, SETTING_WIDTH, 0));
+			if (!db_get_b(NULL, MODULE_CLUI, SETTING_AUTOSIZE, 0))
+				db_set_dw(NULL, MODULE_CLIST, SETTING_HEIGHT, db_get_dw(NULL, SSMODULENAME, SETTING_HEIGHT, 0));
+		}
+
+		WINDOWPLACEMENT wndpl = { sizeof(wndpl) };
+		if (GetWindowPlacement(hClist, &wndpl)) {
+			if (wndpl.showCmd == SW_SHOWNORMAL && !Clist_IsDocked()) {
+				RECT rc;
+				if (GetWindowRect(hClist, &rc)) {
+					int x = rc.left;
+					int y = rc.top;
+					int width = rc.right - rc.left;
+					int height = rc.bottom - rc.top;
+					if (db_get_b(NULL, SSMODULENAME, SETTING_SETWINLOCATION, 0)) {
+						x = db_get_dw(NULL, SSMODULENAME, SETTING_XPOS, x);
+						y = db_get_dw(NULL, SSMODULENAME, SETTING_YPOS, y);
+					}
+					if (db_get_b(NULL, SSMODULENAME, SETTING_SETWINSIZE, 0)) {
+						width = db_get_dw(NULL, SSMODULENAME, SETTING_WIDTH, width);
+						if (!db_get_b(NULL, MODULE_CLUI, SETTING_AUTOSIZE, 0))
+							height = db_get_dw(NULL, SSMODULENAME, SETTING_HEIGHT, height);
+					}
+					MoveWindow(hClist, x, y, width, height, TRUE);
+	}	}	}	}
+	
+	return 0;
+}
diff --git a/plugins/StatusManager/src/startupstatus.h b/plugins/StatusManager/src/startupstatus.h
new file mode 100644
index 0000000000..f106a141d9
--- /dev/null
+++ b/plugins/StatusManager/src/startupstatus.h
@@ -0,0 +1,155 @@
+/*
+    StartupStatus Plugin for Miranda-IM (www.miranda-im.org)
+    Copyright 2003-2006 P. Boon
+
+    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; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+#ifndef __STARTUPSTATUSHEADER
+#define __STARTUPSTATUSHEADER
+
+#define SSMODULENAME    "StartupStatus"
+
+struct TSSSetting : public PROTOCOLSETTINGEX, public MZeroedObject
+{
+	TSSSetting(PROTOACCOUNT *pa);
+	TSSSetting(int profile, PROTOACCOUNT *pa);
+	~TSSSetting();
+};
+
+typedef OBJLIST<TSSSetting> TSettingsList;
+
+struct PROFILECE
+{
+	int profile;
+	char *szProto;
+	wchar_t *msg;
+};
+
+struct PROFILEOPTIONS : public MZeroedObject
+{
+	__inline ~PROFILEOPTIONS()
+	{
+		delete ps;
+		mir_free(tszName);
+	}
+
+	wchar_t *tszName;
+	TSettingsList* ps;
+	BOOL showDialog;
+	BOOL createTtb;
+	BOOL createMmi;
+	BOOL inSubMenu;
+	BOOL regHotkey;
+	WORD hotKey;
+};
+
+typedef struct {
+	ATOM id;
+	int profile;
+} HKINFO;
+
+#define UM_REINITPROFILES	WM_USER + 1
+#define UM_SETPROFILE		WM_USER + 2
+#define UM_SETPROTOCOL		WM_USER + 3
+#define UM_SETSTATUSMSG		WM_USER + 4
+#define UM_ADDPROFILE		WM_USER + 5
+#define UM_DELPROFILE		WM_USER + 6
+#define UM_REINITDOCKED		WM_USER + 7
+#define UM_REINITWINSTATE	WM_USER + 8
+#define UM_REINITWINSIZE	WM_USER + 9
+
+#define CLUIINTM_REDRAW (WM_USER+100)
+
+#define MODULE_CLIST					"CList"
+#define MODULE_CLUI						"CLUI"
+#define SETTING_STATUS					"Status"
+
+#define SETTING_SETWINSTATE				"SetState"
+#define SETTING_WINSTATE				"State"
+
+#define SETTING_SETDOCKED				"SetDocked"
+#define SETTING_DOCKED					"Docked"
+
+#define SETTING_SHOWDIALOG				"ShowDialog"
+#define SETTING_OFFLINECLOSE			"OfflineOnClose"
+#define SETTING_SETPROFILE				"SetStatusOnStartup"
+#define SETTING_AUTODIAL				"AutoDial"
+#define SETTING_AUTOHANGUP				"AutoHangup"
+
+#define SETTING_TOOLWINDOW				"ToolWindow"
+
+#define SETTING_OVERRIDE				"AllowOverride"
+
+#define SETTING_SETWINLOCATION			"SetWinLoc"
+#define SETTING_XPOS					"x"
+#define SETTING_YPOS					"y"
+
+#define SETTING_SETWINSIZE				"SetWinSize"
+#define SETTING_WIDTH					"Width"
+#define SETTING_HEIGHT					"Height"
+#define SETTING_AUTOSIZE				"AutoSize"
+
+#define SETTING_PROFILECOUNT			"ProfileCount"
+#define SETTING_DEFAULTPROFILE			"DefaultProfile"
+#define SETTING_PROFILENAME				"ProfileName"
+#define SETTING_CREATETTBBUTTON			"CreateTTBButton"
+#define SETTING_PROFILE_STSMSG			"StatusMsg"
+#define SETTING_SHOWCONFIRMDIALOG		"profile_ShowDialog"
+#define SETTING_CREATEMMITEM			"CreateMMItem"
+#define SETTING_INSUBMENU				"InSubMenu"
+#define SETTING_REGHOTKEY				"RegHotKey"
+#define SETTING_HOTKEY					"HotKey"
+#define SETTING_PROFILENO				"ProfileNo"
+
+#define SETTING_SETPROFILEDELAY			"SetStatusDelay"
+#define SETTING_DLGTIMEOUT				"DialogTimeout"
+
+#define SHORTCUT_DESC					L"Miranda NG"
+#define SHORTCUT_FILENAME				L"\\Miranda NG.lnk"
+
+#define DOCKED_NONE						0
+#define DOCKED_LEFT						1
+#define DOCKED_RIGHT					2
+
+#define MS_SS_MENUSETPROFILEPREFIX		"StartupStatus/SetProfile_"
+
+// options
+int StartupStatusOptionsInit(WPARAM wparam,LPARAM lparam);
+char* OptName(int i, const char* setting);
+
+// startupstatus
+int SSLoadMainOptions();
+
+int CompareSettings( const TSSSetting* p1, const TSSSetting* p2 );
+
+TSettingsList* GetCurrentProtoSettings();
+
+// profile
+int GetProfile(int profileID, TSettingsList& arSettings );
+wchar_t *GetStatusMessage(int profile, char *szProto);
+
+INT_PTR LoadAndSetProfile(WPARAM wParam, LPARAM lParam);
+INT_PTR GetProfileCount(WPARAM wParam, LPARAM lParam);
+INT_PTR GetProfileName(WPARAM wParam, LPARAM lParam);
+
+extern HANDLE hTTBModuleLoadedHook;
+void RemoveTopToolbarButtons();
+int  CreateTopToolbarButtons(WPARAM wParam, LPARAM lParam);
+
+int LoadProfileModule();
+int InitProfileModule();
+int DeinitProfilesModule();
+
+#endif //__STARTUPSTATUSHEADER
diff --git a/plugins/StatusManager/src/stdafx.cxx b/plugins/StatusManager/src/stdafx.cxx
new file mode 100644
index 0000000000..3968e037fa
--- /dev/null
+++ b/plugins/StatusManager/src/stdafx.cxx
@@ -0,0 +1,18 @@
+/*
+Copyright (C) 2012-16 Miranda NG project (http://miranda-ng.org)
+
+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 version 2
+of the License.
+
+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. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "stdafx.h"
\ No newline at end of file
diff --git a/plugins/StatusManager/src/stdafx.h b/plugins/StatusManager/src/stdafx.h
new file mode 100644
index 0000000000..a8fd9051a7
--- /dev/null
+++ b/plugins/StatusManager/src/stdafx.h
@@ -0,0 +1,37 @@
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+#include <windows.h>
+#include <process.h>
+#include <winsock.h>
+#include <wininet.h>
+#include <ipexport.h>
+#include <icmpapi.h>
+#include <commctrl.h>
+
+#include <newpluginapi.h>
+
+#include <m_core.h>
+#include <m_skin.h>
+#include <m_clist.h>
+#include <m_utils.h>
+#include <m_icolib.h>
+#include <m_options.h>
+#include <m_protosvc.h>
+#include <m_protocols.h>
+#include <m_toptoolbar.h>
+#include <m_statusplugins.h>
+
+#include "version.h"
+#include "resource.h"
+
+#include "commonstatus.h"
+#include "keepstatus.h"
+#include "startupstatus.h"
+#include "advancedautoaway.h"
+
+int KSCSModuleLoaded(WPARAM, LPARAM);
+int SSCSModuleLoaded(WPARAM, LPARAM);
+int AAACSModuleLoaded(WPARAM, LPARAM);
+
+#endif //_COMMON_H_
diff --git a/plugins/StatusManager/src/version.h b/plugins/StatusManager/src/version.h
new file mode 100644
index 0000000000..a5e2a5b414
--- /dev/null
+++ b/plugins/StatusManager/src/version.h
@@ -0,0 +1,19 @@
+// plugin version part
+#define __MAJOR_VERSION          0
+#define __MINOR_VERSION          11
+#define __RELEASE_NUM            0
+#define __BUILD_NUM              0
+
+// other stuff for Version resource
+#include <stdver.h>
+
+// stuff that will be used in PluginInfo section and in Version resource
+#define __PLUGIN_NAME           "Status manager"
+#define __FILENAME              "StatusManager.dll"
+#define __DESC                  "KeepStatus, A connection checker.\r\n\
+StartupStatus, allows you to define the status Miranda should set on startup, configurable per protocol.\r\n\
+An Auto Away module with some more options than the original."
+#define __AUTHOR                "P Boon"
+#define __AUTHOREMAIL           "unregistered@users.sourceforge.net"
+#define __AUTHORWEB             "http://miranda-ng.org/p/StatusManager/"
+#define __COPYRIGHT             "© 2003-08 P. Boon, 2008-16 George Hazan"