Index: src/ch/OptionsDlg.cpp
===================================================================
diff -u -rd5c3edd0d167db9b5d47d04248820fda49499a5e -r0d5b67ee96b435d63f7bf075dc8e28603793b187
--- src/ch/OptionsDlg.cpp	(.../OptionsDlg.cpp)	(revision d5c3edd0d167db9b5d47d04248820fda49499a5e)
+++ src/ch/OptionsDlg.cpp	(.../OptionsDlg.cpp)	(revision 0d5b67ee96b435d63f7bf075dc8e28603793b187)
@@ -24,6 +24,9 @@
 #include "ShortcutsDlg.h"
 #include "RecentDlg.h"
 #include <assert.h>
+#include "structs.h"
+#include "CfgProperties.h"
+#include "../libchengine/TConfigSerializers.h"
 
 #ifdef _DEBUG
 #define new DEBUG_NEW
@@ -36,92 +39,82 @@
 /////////////////////////////////////////////////////////////////////////////
 // COptionsDlg dialog
 
-COptionsDlg::COptionsDlg(CWnd* pParent /*=NULL*/)
-	:ictranslate::CLanguageDialog(COptionsDlg::IDD, pParent, &m_bLock)
+COptionsDlg::COptionsDlg(CWnd* pParent /*=nullptr*/)
+	:ictranslate::CLanguageDialog(IDD_OPTIONS_DIALOG, pParent, &m_bLock),
+	m_spLog(logger::MakeLogger(GetLogFileData(), L"OptionsDlg"))
 {
-	//{{AFX_DATA_INIT(COptionsDlg)
-		// NOTE: the ClassWizard will add member initialization here
-	//}}AFX_DATA_INIT
 }
 
 void COptionsDlg::DoDataExchange(CDataExchange* pDX)
 {
 	CLanguageDialog::DoDataExchange(pDX);
-	//{{AFX_DATA_MAP(COptionsDlg)
 	DDX_Control(pDX, IDC_PROPERTIES_LIST, m_ctlProperties);
-	//}}AFX_DATA_MAP
 }
 
-BEGIN_MESSAGE_MAP(COptionsDlg,ictranslate::CLanguageDialog)
-	//{{AFX_MSG_MAP(COptionsDlg)
+BEGIN_MESSAGE_MAP(COptionsDlg, ictranslate::CLanguageDialog)
 	ON_BN_CLICKED(IDC_APPLY_BUTTON, OnApplyButton)
-	//}}AFX_MSG_MAP
 END_MESSAGE_MAP()
 
 /////////////////////////////////////////////////////////////////////////////
 // COptionsDlg message handlers
 
 // properties handling macros
 #define PROP_SEPARATOR(text)\
-	m_ctlProperties.AddString(text);
+	m_ctlProperties.AddString(text)
 
 #define PROP_BOOL(text, value)\
-	m_ctlProperties.AddString(text, ID_PROPERTY_COMBO_LIST, IDS_BOOLTEXT_STRING, (value));
+	m_ctlProperties.AddString(text, ID_PROPERTY_COMBO_LIST, IDS_BOOLTEXT_STRING, (value))
 
 #define PROP_UINT(text, value)\
-	m_ctlProperties.AddString(text, ID_PROPERTY_TEXT, _itot((int)(value), m_szBuffer, 10), 0);
+	m_ctlProperties.AddString(text, ID_PROPERTY_TEXT, boost::lexical_cast<std::wstring>((value)).c_str(), 0)
 
 #define PROP_COMBO(text, prop_text, value)\
-	m_ctlProperties.AddString(text, ID_PROPERTY_COMBO_LIST, prop_text, (int)((value)));
+	m_ctlProperties.AddString(text, ID_PROPERTY_COMBO_LIST, prop_text, boost::numeric_cast<int>((value)))
 
 #define PROP_DIR(text, prop_text, value)\
-	m_ctlProperties.AddString(text, ID_PROPERTY_DIR, (value)+CString(GetResManager()->LoadString(prop_text)), 0);
+	m_ctlProperties.AddString(text, ID_PROPERTY_DIR, (value)+CString(GetResManager().LoadString(prop_text)), 0)
 
 #define PROP_PATH(text, prop_text, value)\
-	m_ctlProperties.AddString(text, ID_PROPERTY_PATH, (value)+CString(GetResManager()->LoadString(prop_text)), 0);
+	m_ctlProperties.AddString(text, ID_PROPERTY_PATH, (value)+CString(GetResManager().LoadString(prop_text)), 0)
 
 #define PROP_CUSTOM_UINT(text, value, callback, param)\
-	m_ctlProperties.AddString(text, ID_PROPERTY_CUSTOM, CString(_itot((int)(value), m_szBuffer, 10)), callback, this, param, 0);
+	m_ctlProperties.AddString(text, ID_PROPERTY_CUSTOM, CString(boost::lexical_cast<std::wstring>((value)).c_str()), callback, this, param, 0)
 
+#define PROP_STRING(text, value)\
+	m_ctlProperties.AddString(text, ID_PROPERTY_TEXT, (value), 0)
+
 #define SKIP_SEPARATOR(pos)\
-	pos++;
+	pos++
 
 BOOL COptionsDlg::OnInitDialog() 
 {
 	CLanguageDialog::OnInitDialog();
-	
+
+	// set dialog icon
+	HICON hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
+	SetIcon(hIcon, FALSE);
+
+	AddResizableControl(IDC_PROPERTIES_LIST, 0.0, 0.0, 1.0, 1.0);
+	AddResizableControl(IDOK, 1.0, 1.0, 0.0, 0.0);
+	AddResizableControl(IDCANCEL, 1.0, 1.0, 0.0, 0.0);
+	AddResizableControl(IDC_APPLY_BUTTON, 1.0, 1.0, 0.0, 0.0);
+	AddResizableControl(IDHELP, 1.0, 1.0, 0.0, 0.0);
+
+	InitializeResizableControls();
+
 	m_ctlProperties.Init();
 
 	// copy shortcut and recent paths
-	icpf::config* pConfig = GetConfig();
-	assert(pConfig);
-	if(!pConfig)
-		return FALSE;
+	chengine::TConfig& rConfig = GetConfig();
 
-	m_cvRecent.clear(true);
-	size_t stSize = pConfig->get_value_count(PP_RECENTPATHS);
-	const tchar_t* pszPath = NULL;
-	for(size_t stIndex = 0; stIndex < stSize; stIndex++)
-	{
-		pszPath = pConfig->get_string(PP_RECENTPATHS, stIndex);
-		if(pszPath)
-			m_cvRecent.push_back(pszPath);
-	}
+	m_cvRecent.clear();
+	GetPropValue<PP_RECENTPATHS>(rConfig, m_cvRecent);
 
-	m_cvShortcuts.clear(true);
-	stSize = pConfig->get_value_count(PP_SHORTCUTS);
-	for(size_t stIndex = 0; stIndex < stSize; stIndex++)
-	{
-		pszPath = pConfig->get_string(PP_SHORTCUTS, stIndex);
-		if(pszPath)
-			m_cvShortcuts.push_back(pszPath);
-	}
+	m_cvShortcuts.clear();
+	GetPropValue<PP_SHORTCUTS>(rConfig, m_cvShortcuts);
 
-	_tcscpy(m_szLangPath, _T("<PROGRAM>\\Langs\\"));
-	GetApp()->ExpandPath(m_szLangPath);
+	GetResManager().Scan(GetApp().ExpandPath(_T("<PROGRAM>\\Langs\\")), &m_vld);
 
-	GetResManager()->Scan(m_szLangPath, &m_vld);
-
 	// some attributes
 	m_ctlProperties.SetBkColor(RGB(255, 255, 255));
 	m_ctlProperties.SetTextColor(RGB(80, 80, 80));
@@ -139,33 +132,49 @@
 void CustomPropertyCallbackProc(LPVOID lpParam, int iParam, CPtrList* pList, int iIndex)
 {
 	COptionsDlg* pDlg=static_cast<COptionsDlg*>(lpParam);
-	CBufferSizeDlg dlg;
 
-	dlg.m_bsSizes.m_bOnlyDefault=pDlg->GetBoolProp(iIndex-iParam-1);
-	dlg.m_bsSizes.m_uiDefaultSize=pDlg->GetUintProp(iIndex-iParam);
-	dlg.m_bsSizes.m_uiOneDiskSize=pDlg->GetUintProp(iIndex-iParam+1);
-	dlg.m_bsSizes.m_uiTwoDisksSize=pDlg->GetUintProp(iIndex-iParam+2);
-	dlg.m_bsSizes.m_uiCDSize=pDlg->GetUintProp(iIndex-iParam+3);
-	dlg.m_bsSizes.m_uiLANSize=pDlg->GetUintProp(iIndex-iParam+4);
-	dlg.m_iActiveIndex=iParam;	// selected buffer for editing
+	chengine::TBufferSizes tBufferSizes(pDlg->GetBoolProp(iIndex - iParam - 1),
+		pDlg->GetUintProp(iIndex - iParam + 7),
+		pDlg->GetUintProp(iIndex - iParam),
+		pDlg->GetUintProp(iIndex - iParam + 1),
+		pDlg->GetUintProp(iIndex - iParam + 2),
+		pDlg->GetUintProp(iIndex - iParam + 3),
+		pDlg->GetUintProp(iIndex - iParam + 4),
+		pDlg->GetUintProp(iIndex - iParam + 8),
+		pDlg->GetUintProp(iIndex - iParam + 9),
+		pDlg->GetUintProp(iIndex - iParam + 10));
 
+	CBufferSizeDlg dlg(&tBufferSizes, (chengine::TBufferSizes::EBufferType)iParam);
 	if (dlg.DoModal() == IDOK)
 	{
+		tBufferSizes = dlg.GetBufferSizes();
+
 		PROPERTYITEM* pItem;
-		TCHAR xx[32];
+		TCHAR szData[32];
 
 		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex-iParam-1));
-		pItem->nPropertySelected=(dlg.m_bsSizes.m_bOnlyDefault ? 1 : 0);
+		pItem->nPropertySelected=(tBufferSizes.IsOnlyDefault() ? 1 : 0);
 		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex-iParam));
-		pItem->csProperties.SetAt(0, _itot(dlg.m_bsSizes.m_uiDefaultSize, xx, 10));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetDefaultSize(), szData, 10));
 		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex-iParam+1));
-		pItem->csProperties.SetAt(0, _itot(dlg.m_bsSizes.m_uiOneDiskSize, xx, 10));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetOneDiskSize(), szData, 10));
 		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex-iParam+2));
-		pItem->csProperties.SetAt(0, _itot(dlg.m_bsSizes.m_uiTwoDisksSize, xx, 10));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetTwoDisksSize(), szData, 10));
 		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex-iParam+3));
-		pItem->csProperties.SetAt(0, _itot(dlg.m_bsSizes.m_uiCDSize, xx, 10));
-		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex-iParam+4));
-		pItem->csProperties.SetAt(0, _itot(dlg.m_bsSizes.m_uiLANSize, xx, 10));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetCDSize(), szData, 10));
+		pItem = (PROPERTYITEM*) pList->GetAt(pList->FindIndex(iIndex - iParam + 4));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetLANSize(), szData, 10));
+		pItem = (PROPERTYITEM*) pList->GetAt(pList->FindIndex(iIndex - iParam + 7));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetBufferCount(), szData, 10));
+
+		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex - iParam + 8));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetMaxReadAheadBuffers(), szData, 10));
+
+		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex - iParam + 9));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetMaxConcurrentReads(), szData, 10));
+
+		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex - iParam + 10));
+		pItem->csProperties.SetAt(0, _itot(tBufferSizes.GetMaxConcurrentWrites(), szData, 10));
 	}
 }
 
@@ -174,19 +183,18 @@
 	COptionsDlg* pDlg=static_cast<COptionsDlg*>(lpParam);
 
 	CShortcutsDlg dlg;
-	dlg.m_cvShortcuts.assign(pDlg->m_cvShortcuts.begin(), pDlg->m_cvShortcuts.end(), true, true);
+	dlg.m_cvShortcuts = pDlg->m_cvShortcuts;
 	dlg.m_pcvRecent=&pDlg->m_cvRecent;
 	if (dlg.DoModal() == IDOK)
 	{
 		// restore shortcuts to pDlg->cvShortcuts
-		pDlg->m_cvShortcuts.assign(dlg.m_cvShortcuts.begin(), dlg.m_cvShortcuts.end(), true, false);
-		dlg.m_cvShortcuts.erase(dlg.m_cvShortcuts.begin(), dlg.m_cvShortcuts.end(), false);
+		pDlg->m_cvShortcuts = dlg.m_cvShortcuts;
 
 		// property list
 		TCHAR szBuf[32];
 		PROPERTYITEM* pItem;
 		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex));
-		pItem->csProperties.SetAt(0, _itot(pDlg->m_cvShortcuts.size(), szBuf, 10));
+		pItem->csProperties.SetAt(0, _ui64tot(pDlg->m_cvShortcuts.size(), szBuf, 10));
 	}
 }
 
@@ -195,18 +203,17 @@
 	COptionsDlg* pDlg=static_cast<COptionsDlg*>(lpParam);
 
 	CRecentDlg dlg;
-	dlg.m_cvRecent.assign(pDlg->m_cvRecent.begin(), pDlg->m_cvRecent.end(), true, true);
+	dlg.m_cvRecent = pDlg->m_cvRecent;
 	if (dlg.DoModal() == IDOK)
 	{
 		// restore
-		pDlg->m_cvRecent.assign(dlg.m_cvRecent.begin(), dlg.m_cvRecent.end(), true, false);
-		dlg.m_cvRecent.erase(dlg.m_cvRecent.begin(), dlg.m_cvRecent.end(), false);
+		pDlg->m_cvRecent = dlg.m_cvRecent;
 
 		// property list
 		TCHAR szBuf[32];
 		PROPERTYITEM* pItem;
 		pItem = (PROPERTYITEM*)pList->GetAt(pList->FindIndex(iIndex));
-		pItem->csProperties.SetAt(0, _itot(pDlg->m_cvRecent.size(), szBuf, 10));
+		pItem->csProperties.SetAt(0, _ui64tot(pDlg->m_cvRecent.size(), szBuf, 10));
 	}
 }
 
@@ -218,6 +225,7 @@
 	ApplyProperties();
 
 	SendClosingNotify();
+
 	CLanguageDialog::OnOK();
 }
 
@@ -226,242 +234,276 @@
 	CString strPath;
 
 	// load settings
-	PROP_SEPARATOR(IDS_PROGRAM_STRING)
-	PROP_BOOL(IDS_CLIPBOARDMONITORING_STRING, GetConfig()->get_bool(PP_PCLIPBOARDMONITORING))
-	PROP_UINT(IDS_CLIPBOARDINTERVAL_STRING, GetConfig()->get_signed_num(PP_PMONITORSCANINTERVAL))
-	PROP_BOOL(IDS_AUTORUNPROGRAM_STRING, GetConfig()->get_bool(PP_PRELOADAFTERRESTART))
-	PROP_BOOL(IDS_AUTOSHUTDOWN_STRING, GetConfig()->get_bool(PP_PSHUTDOWNAFTREFINISHED))
-	PROP_UINT(IDS_SHUTDOWNTIME_STRING, GetConfig()->get_signed_num(PP_PTIMEBEFORESHUTDOWN))
-	PROP_COMBO(IDS_FORCESHUTDOWN_STRING, IDS_FORCESHUTDOWNVALUES_STRING, GetConfig()->get_bool(PP_PFORCESHUTDOWN))
-	PROP_UINT(IDS_AUTOSAVEINTERVAL_STRING, GetConfig()->get_signed_num(PP_PAUTOSAVEINTERVAL))
-	PROP_COMBO(IDS_CFGPRIORITYCLASS_STRING, IDS_CFGPRIORITYCLASSITEMS_STRING, PriorityClassToIndex(GetConfig()->get_signed_num(PP_PPROCESSPRIORITYCLASS)))
-	PROP_DIR(IDS_TEMPFOLDER_STRING, IDS_TEMPFOLDERCHOOSE_STRING, strPath)
+	PROP_SEPARATOR(IDS_PROGRAM_STRING);
+	PROP_BOOL(IDS_CLIPBOARDMONITORING_STRING, GetPropValue<PP_PCLIPBOARDMONITORING>(GetConfig()));
+	PROP_UINT(IDS_CLIPBOARDINTERVAL_STRING, GetPropValue<PP_PMONITORSCANINTERVAL>(GetConfig()));
+	PROP_BOOL(IDS_AUTORUNPROGRAM_STRING, GetPropValue<PP_PRELOADAFTERRESTART>(GetConfig()));
 
+	PROP_COMBO(IDS_CFG_CHECK_FOR_UPDATES_FREQUENCY, IDS_UPDATE_FREQUENCIES, GetPropValue<PP_PCHECK_FOR_UPDATES_FREQUENCY>(GetConfig()));
+	PROP_COMBO(IDS_CFG_UPDATECHANNEL, IDS_CFGUPDATECHANNELITEMS_STRING, GetPropValue<PP_PUPDATECHANNEL>(GetConfig()));
+	PROP_COMBO(IDS_CFG_USE_SECURE_CONNECTION, IDS_SECURE_CONNECTION_TYPES, GetPropValue<PP_PUPDATE_USE_SECURE_CONNECTION>(GetConfig()));
+
+	PROP_BOOL(IDS_AUTOSHUTDOWN_STRING, GetPropValue<PP_PSHUTDOWNAFTREFINISHED>(GetConfig()));
+	PROP_UINT(IDS_SHUTDOWNTIME_STRING, GetPropValue<PP_PTIMEBEFORESHUTDOWN>(GetConfig()));
+	PROP_COMBO(IDS_FORCESHUTDOWN_STRING, IDS_FORCESHUTDOWNVALUES_STRING, GetPropValue<PP_PFORCESHUTDOWN>(GetConfig()) ? 1 : 0);
+	PROP_UINT(IDS_AUTOSAVEINTERVAL_STRING, GetPropValue<PP_PAUTOSAVEINTERVAL>(GetConfig()));
+	PROP_COMBO(IDS_CFGPRIORITYCLASS_STRING, IDS_CFGPRIORITYCLASSITEMS_STRING, PriorityClassToIndex(boost::numeric_cast<int>(GetPropValue<PP_PPROCESSPRIORITYCLASS>(GetConfig()))));
+	PROP_DIR(IDS_TEMPFOLDER_STRING, IDS_TEMPFOLDERCHOOSE_STRING, strPath);
+
 	// lang
 	CString strLangs;
-	UINT uiIndex=0;
-	for (vector<ictranslate::CLangData>::iterator it=m_vld.begin();it != m_vld.end();it++)
+	size_t stIndex=0;
+	for (std::vector<ictranslate::CLangData>::iterator it=m_vld.begin();it != m_vld.end();++it)
 	{
 		strLangs+=(*it).GetLangName();
 		strLangs+=_T("!");
-		if (_tcsicmp((*it).GetFilename(true), GetResManager()->m_ld.GetFilename(true)) == 0)
-			uiIndex=it-m_vld.begin();
+		if (_tcsicmp((*it).GetFilename(true), GetResManager().m_ld.GetFilename(true)) == 0)
+			stIndex = it - m_vld.begin();
 	}
 	strLangs.TrimRight(_T('!'));
 
-	PROP_COMBO(IDS_LANGUAGE_STRING, strLangs, uiIndex)
+	PROP_COMBO(IDS_LANGUAGE_STRING, strLangs, stIndex);
 
 	/////////////////
 	PROP_SEPARATOR(IDS_STATUSWINDOW_STRING);
-	PROP_UINT(IDS_REFRESHSTATUSINTERVAL_STRING, GetConfig()->get_signed_num(PP_STATUSREFRESHINTERVAL))
-	PROP_BOOL(IDS_STATUSSHOWDETAILS_STRING, GetConfig()->get_bool(PP_STATUSSHOWDETAILS))
-	PROP_BOOL(IDS_STATUSAUTOREMOVE_STRING, GetConfig()->get_bool(PP_STATUSAUTOREMOVEFINISHED))
+	PROP_UINT(IDS_REFRESHSTATUSINTERVAL_STRING, GetPropValue<PP_STATUSREFRESHINTERVAL>(GetConfig()));
+	PROP_BOOL(IDS_STATUSAUTOREMOVE_STRING, GetPropValue<PP_STATUSAUTOREMOVEFINISHED>(GetConfig()));
 
-	PROP_SEPARATOR(IDS_MINIVIEW_STRING)
-	PROP_BOOL(IDS_SHOWFILENAMES_STRING, GetConfig()->get_bool(PP_MVSHOWFILENAMES))
-	PROP_BOOL(IDS_SHOWSINGLETASKS_STRING, GetConfig()->get_bool(PP_MVSHOWSINGLETASKS))
-	PROP_UINT(IDS_MINIVIEWREFRESHINTERVAL_STRING, GetConfig()->get_signed_num(PP_MVREFRESHINTERVAL))
-	PROP_BOOL(IDS_MINIVIEWSHOWAFTERSTART_STRING, GetConfig()->get_bool(PP_MVAUTOSHOWWHENRUN))
-	PROP_BOOL(IDS_MINIVIEWAUTOHIDE_STRING, GetConfig()->get_bool(PP_MVAUTOHIDEWHENEMPTY))
-	PROP_BOOL(IDS_MINIVIEWSMOOTHPROGRESS_STRING, GetConfig()->get_bool(PP_MVUSESMOOTHPROGRESS))
+	PROP_SEPARATOR(IDS_MINIVIEW_STRING);
+	PROP_BOOL(IDS_SHOWFILENAMES_STRING, GetPropValue<PP_MVSHOWFILENAMES>(GetConfig()));
+	PROP_BOOL(IDS_SHOWSINGLETASKS_STRING, GetPropValue<PP_MVSHOWSINGLETASKS>(GetConfig()));
+	PROP_UINT(IDS_MINIVIEWREFRESHINTERVAL_STRING, GetPropValue<PP_MVREFRESHINTERVAL>(GetConfig()));
+	PROP_BOOL(IDS_MINIVIEWSHOWAFTERSTART_STRING, GetPropValue<PP_MVAUTOSHOWWHENRUN>(GetConfig()));
+	PROP_BOOL(IDS_MINIVIEWAUTOHIDE_STRING, GetPropValue<PP_MVAUTOHIDEWHENEMPTY>(GetConfig()));
+	PROP_BOOL(IDS_MINIVIEWSMOOTHPROGRESS_STRING, GetPropValue<PP_MVUSESMOOTHPROGRESS>(GetConfig()));
 
-	PROP_SEPARATOR(IDS_CFGFOLDERDIALOG_STRING)
-	PROP_BOOL(IDS_CFGFDEXTVIEW_STRING, GetConfig()->get_bool(PP_FDEXTENDEDVIEW))
-	PROP_UINT(IDS_CFGFDWIDTH_STRING, GetConfig()->get_signed_num(PP_FDWIDTH))
-	PROP_UINT(IDS_CFGFDHEIGHT_STRING, GetConfig()->get_signed_num(PP_FDHEIGHT))
-	PROP_COMBO(IDS_CFGFDSHORTCUTS_STRING, IDS_CFGFDSHORTCUTSSTYLES_STRING, GetConfig()->get_signed_num(PP_FDSHORTCUTLISTSTYLE))
-	PROP_BOOL(IDS_CFGFDIGNOREDIALOGS_STRING, GetConfig()->get_bool(PP_FDIGNORESHELLDIALOGS))
+	PROP_SEPARATOR(IDS_CFGFOLDERDIALOG_STRING);
+	PROP_BOOL(IDS_CFGFDEXTVIEW_STRING, GetPropValue<PP_FDEXTENDEDVIEW>(GetConfig()));
+	PROP_UINT(IDS_CFGFDWIDTH_STRING, GetPropValue<PP_FDWIDTH>(GetConfig()));
+	PROP_UINT(IDS_CFGFDHEIGHT_STRING, GetPropValue<PP_FDHEIGHT>(GetConfig()));
+	PROP_COMBO(IDS_CFGFDSHORTCUTS_STRING, IDS_CFGFDSHORTCUTSSTYLES_STRING, GetPropValue<PP_FDSHORTCUTLISTSTYLE>(GetConfig()));
+	PROP_BOOL(IDS_CFGFDIGNOREDIALOGS_STRING, GetPropValue<PP_FDIGNORESHELLDIALOGS>(GetConfig()));
 
-	PROP_SEPARATOR(IDS_CFGSHELL_STRING)
-	PROP_BOOL(IDS_CFGSHCOPY_STRING, GetConfig()->get_bool(PP_SHSHOWCOPY))
-	PROP_BOOL(IDS_CFGSHMOVE_STRING, GetConfig()->get_bool(PP_SHSHOWMOVE))
-	PROP_BOOL(IDS_CFGSHCMSPECIAL_STRING, GetConfig()->get_bool(PP_SHSHOWCOPYMOVE))
-	PROP_BOOL(IDS_CFGSHPASTE_STRING, GetConfig()->get_bool(PP_SHSHOWPASTE))
-	PROP_BOOL(IDS_CFGSHPASTESPECIAL_STRING, GetConfig()->get_bool(PP_SHSHOWPASTESPECIAL))
-	PROP_BOOL(IDS_CFGSHCOPYTO_STRING, GetConfig()->get_bool(PP_SHSHOWCOPYTO))
-	PROP_BOOL(IDS_CFGSHMOVETO_STRING, GetConfig()->get_bool(PP_SHSHOWMOVETO))
-	PROP_BOOL(IDS_CFGSHCMTOSPECIAL_STRING, GetConfig()->get_bool(PP_SHSHOWCOPYMOVETO))
-	PROP_BOOL(IDS_CFGSHSHOWFREESPACE_STRING, GetConfig()->get_bool(PP_SHSHOWFREESPACE))
-	PROP_BOOL(IDS_CFGSHSHOWICONS_STRING, GetConfig()->get_bool(PP_SHSHOWSHELLICONS))
-	PROP_BOOL(IDS_CFGSHOVERRIDEDRAG_STRING, GetConfig()->get_bool(PP_SHUSEDRAGDROP))
-	PROP_COMBO(IDS_CFGOVERRIDEDEFACTION_STRING, IDS_CFGACTIONS_STRING, GetConfig()->get_signed_num(PP_SHDEFAULTACTION));
+	PROP_SEPARATOR(IDS_CFGSHELL_STRING);
+	PROP_BOOL(IDS_CFGSHCOPY_STRING, GetPropValue<PP_SHSHOWCOPY>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHMOVE_STRING, GetPropValue<PP_SHSHOWMOVE>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHCMSPECIAL_STRING, GetPropValue<PP_SHSHOWCOPYMOVE>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHPASTE_STRING, GetPropValue<PP_SHSHOWPASTE>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHPASTESPECIAL_STRING, GetPropValue<PP_SHSHOWPASTESPECIAL>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHCOPYTO_STRING, GetPropValue<PP_SHSHOWCOPYTO>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHMOVETO_STRING, GetPropValue<PP_SHSHOWMOVETO>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHCMTOSPECIAL_STRING, GetPropValue<PP_SHSHOWCOPYMOVETO>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHSHOWFREESPACE_STRING, GetPropValue<PP_SHSHOWFREESPACE>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHSHOWICONS_STRING, GetPropValue<PP_SHSHOWSHELLICONS>(GetConfig()));
+	PROP_BOOL(IDS_CFGSHINTERCEPTDRAG_STRING, GetPropValue<PP_SHINTERCEPTDRAGDROP>(GetConfig()));
+	PROP_BOOL(IDS_CFGINTERCEPTKEYACTION_STRING, GetPropValue<PP_SHINTERCEPTKEYACTIONS>(GetConfig()));
+	PROP_BOOL(IDS_CFGINTERCEPTCONTEXTMENU_STRING, GetPropValue<PP_SHINTERCEPTCTXMENUACTIONS>(GetConfig()));
 
-	PROP_SEPARATOR(IDS_PROCESSINGTHREAD_STRING)
-	PROP_BOOL(IDS_AUTOCOPYREST_STRING, GetConfig()->get_bool(PP_CMUSEAUTOCOMPLETEFILES))
-	PROP_BOOL(IDS_SETDESTATTRIB_STRING, GetConfig()->get_bool(PP_CMSETDESTATTRIBUTES))
-	PROP_BOOL(IDS_SETDESTTIME_STRING, GetConfig()->get_bool(PP_CMSETDESTDATE))
-	PROP_BOOL(IDS_PROTECTROFILES_STRING, GetConfig()->get_bool(PP_CMPROTECTROFILES))
-	PROP_UINT(IDS_LIMITOPERATIONS_STRING, GetConfig()->get_signed_num(PP_CMLIMITMAXOPERATIONS))
-	PROP_BOOL(IDS_READSIZEBEFOREBLOCK_STRING, GetConfig()->get_bool(PP_CMREADSIZEBEFOREBLOCKING))
-	PROP_COMBO(IDS_SHOWVISUALFEEDBACK_STRING, IDS_FEEDBACKTYPE_STRING, GetConfig()->get_signed_num(PP_CMSHOWVISUALFEEDBACK))
-	PROP_BOOL(IDS_USETIMEDDIALOGS_STRING, GetConfig()->get_bool(PP_CMUSETIMEDFEEDBACK))
-	PROP_UINT(IDS_TIMEDDIALOGINTERVAL_STRING, GetConfig()->get_signed_num(PP_CMFEEDBACKTIME))
-	PROP_BOOL(IDS_AUTORETRYONERROR_STRING, GetConfig()->get_bool(PP_CMAUTORETRYONERROR))
-	PROP_UINT(IDS_AUTORETRYINTERVAL_STRING, GetConfig()->get_signed_num(PP_CMAUTORETRYINTERVAL))
-	PROP_COMBO(IDS_DEFAULTPRIORITY_STRING, MakeCompoundString(IDS_PRIORITY0_STRING, 7, _T("!")), PriorityToIndex(GetConfig()->get_signed_num(PP_CMDEFAULTPRIORITY)))
-	PROP_BOOL(IDS_CFGDISABLEPRIORITYBOOST_STRING, GetConfig()->get_bool(PP_CMDISABLEPRIORITYBOOST))
-	PROP_BOOL(IDS_DELETEAFTERFINISHED_STRING, GetConfig()->get_bool(PP_CMDELETEAFTERFINISHED))
-	PROP_BOOL(IDS_CREATELOGFILES_STRING, GetConfig()->get_bool(PP_CMCREATELOG))
+	PROP_SEPARATOR(IDS_DIALOGS_SHOW_HIDE_STRING);
+	PROP_COMBO(IDS_SHELLEXT_REGISTER_SHOWHIDE_STRING, MakeCompoundString(IDS_ALWAYS_SHOW_STRING, 3, _T("!")), GetPropValue<PP_HIDE_SHELLEXT_UNREGISTERED>(GetConfig()));
+	PROP_COMBO(IDS_SHELLEXT_VERSIONMISMATCH_SHOWHIDE_STRING, MakeCompoundString(IDS_ALWAYS_SHOW_STRING, 3, _T("!")), GetPropValue<PP_HIDE_SHELLEXT_VERSIONMISMATCH>(GetConfig()));
 
+	PROP_SEPARATOR(IDS_PROCESSINGTHREAD_STRING);
+	PROP_BOOL(IDS_SETDESTATTRIB_STRING, GetPropValue<PP_CMSETDESTATTRIBUTES>(GetConfig()));
+	PROP_BOOL(IDS_PROTECTROFILES_STRING, GetPropValue<PP_CMPROTECTROFILES>(GetConfig()));
+
+	PROP_BOOL(IDS_USECUSTOMNAMING, GetPropValue<PP_USECUSTOMNAMING>(GetConfig()));
+	PROP_STRING(IDS_CUSTOMNAME_FIRST, GetPropValue<PP_CUSTOMNAME_FIRST>(GetConfig()));
+	PROP_STRING(IDS_CUSTOMNAME_SUBSEQUENT, GetPropValue<PP_CUSTOMNAME_SUBSEQUENT>(GetConfig()));
+
+	PROP_UINT(IDS_LIMITOPERATIONS_STRING, GetPropValue<PP_CMLIMITMAXOPERATIONS>(GetConfig()));
+	PROP_BOOL(IDS_READSIZEBEFOREBLOCK_STRING, GetPropValue<PP_CMREADSIZEBEFOREBLOCKING>(GetConfig()));
+	PROP_BOOL(IDS_FASTMOVEBEFOREBLOCK_STRING, GetPropValue<PP_CMFASTMOVEBEFOREBLOCKING>(GetConfig()));
+	PROP_COMBO(IDS_DEFAULTPRIORITY_STRING, MakeCompoundString(IDS_PRIORITY0_STRING, 7, _T("!")), PriorityToIndex(boost::numeric_cast<int>(GetPropValue<PP_CMDEFAULTPRIORITY>(GetConfig()))));
+	PROP_BOOL(IDS_CFGDISABLEPRIORITYBOOST_STRING, GetPropValue<PP_CMDISABLEPRIORITYBOOST>(GetConfig()));
+	PROP_BOOL(IDS_DELETEAFTERFINISHED_STRING, GetPropValue<PP_CMDELETEAFTERFINISHED>(GetConfig()));
+
 	// Buffer
-	PROP_SEPARATOR(IDS_OPTIONSBUFFER_STRING)
-	PROP_BOOL(IDS_AUTODETECTBUFFERSIZE_STRING, GetConfig()->get_bool(PP_BFUSEONLYDEFAULT))
-	PROP_CUSTOM_UINT(IDS_DEFAULTBUFFERSIZE_STRING, GetConfig()->get_signed_num(PP_BFDEFAULT), &CustomPropertyCallbackProc, 0)
-	PROP_CUSTOM_UINT(IDS_ONEDISKBUFFERSIZE_STRING, GetConfig()->get_signed_num(PP_BFONEDISK), &CustomPropertyCallbackProc, 1)
-	PROP_CUSTOM_UINT(IDS_TWODISKSBUFFERSIZE_STRING, GetConfig()->get_signed_num(PP_BFTWODISKS), &CustomPropertyCallbackProc, 2)
-	PROP_CUSTOM_UINT(IDS_CDBUFFERSIZE_STRING, GetConfig()->get_signed_num(PP_BFCD), &CustomPropertyCallbackProc, 3)
-	PROP_CUSTOM_UINT(IDS_LANBUFFERSIZE_STRING, GetConfig()->get_signed_num(PP_BFLAN), &CustomPropertyCallbackProc, 4)
-	PROP_BOOL(IDS_USENOBUFFERING_STRING, GetConfig()->get_bool(PP_BFUSENOBUFFERING))
-	PROP_UINT(IDS_LARGEFILESMINSIZE_STRING, GetConfig()->get_signed_num(PP_BFBOUNDARYLIMIT))
+	PROP_SEPARATOR(IDS_OPTIONSBUFFER_STRING);
+	PROP_BOOL(IDS_AUTODETECTBUFFERSIZE_STRING, GetPropValue<PP_BFUSEONLYDEFAULT>(GetConfig()));
+	PROP_CUSTOM_UINT(IDS_DEFAULTBUFFERSIZE_STRING, GetPropValue<PP_BFDEFAULT>(GetConfig()), &CustomPropertyCallbackProc, 0);
+	PROP_CUSTOM_UINT(IDS_ONEDISKBUFFERSIZE_STRING, GetPropValue<PP_BFONEDISK>(GetConfig()), &CustomPropertyCallbackProc, 1);
+	PROP_CUSTOM_UINT(IDS_TWODISKSBUFFERSIZE_STRING, GetPropValue<PP_BFTWODISKS>(GetConfig()), &CustomPropertyCallbackProc, 2);
+	PROP_CUSTOM_UINT(IDS_CDBUFFERSIZE_STRING, GetPropValue<PP_BFCD>(GetConfig()), &CustomPropertyCallbackProc, 3);
+	PROP_CUSTOM_UINT(IDS_LANBUFFERSIZE_STRING, GetPropValue<PP_BFLAN>(GetConfig()), &CustomPropertyCallbackProc, 4);
+	PROP_BOOL(IDS_USENOBUFFERING_STRING, GetPropValue<PP_BFUSENOBUFFERING>(GetConfig()));
+	PROP_UINT(IDS_LARGEFILESMINSIZE_STRING, GetPropValue<PP_BFBOUNDARYLIMIT>(GetConfig()));
+	PROP_UINT(IDS_BUFFER_QUEUE_DEPTH, GetPropValue<PP_BFQUEUEDEPTH>(GetConfig()));
+	PROP_UINT(IDS_BUFFER_MAX_READAHEAD, GetPropValue<PP_MAXREADAHEAD>(GetConfig()));
+	PROP_UINT(IDS_BUFFER_MAX_CONCURRENT_READS, GetPropValue<PP_MAXCONCURRENTREADS>(GetConfig()));
+	PROP_UINT(IDS_BUFFER_MAX_CONCURRENT_WRITES, GetPropValue<PP_MAXCONCURRENTWRITES>(GetConfig()));
 
+	PROP_SEPARATOR(IDS_CFGLOGFILE_STRING);
+	PROP_UINT(IDS_CFGMAXLIMIT_STRING, GetPropValue<PP_LOGMAXSIZE>(GetConfig()));
+	PROP_UINT(IDS_CFGROTATEDCOUNT_STRING, GetPropValue<PP_LOGROTATECOUNT>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_APP, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_APP>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_ENGINEDEFAULT, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_ENGINEDEFAULT>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_SERIALIZER, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_SERIALIZER>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_TASK, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_TASK>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_SUBTASK_SCANDIR, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_SUBTASK_SCANDIR>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_SUBTASK_COPYMOVE, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_SUBTASK_COPYMOVE>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_SUBTASK_FASTMOVE, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_SUBTASK_FASTMOVE>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_SUBTASK_DELETE, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_SUBTASK_DELETE>(GetConfig()));
+	PROP_COMBO(IDS_CFGLOGLEVEL_FILESYSTEM, IDS_CFGLOGLEVEL_VALUES, GetPropValue<PP_LOGLEVEL_FILESYSTEM>(GetConfig()));
 
 	// Sounds
-	PROP_SEPARATOR(IDS_SOUNDS_STRING)
-	PROP_BOOL(IDS_PLAYSOUNDS_STRING, GetConfig()->get_bool(PP_SNDPLAYSOUNDS))
-	GetConfig()->get_string(PP_SNDERRORSOUNDPATH, strPath.GetBuffer(_MAX_PATH), _MAX_PATH);
-	strPath.ReleaseBuffer();
-	PROP_PATH(IDS_SOUNDONERROR_STRING, IDS_SOUNDSWAVFILTER_STRING, strPath)
-	GetConfig()->get_string(PP_SNDFINISHEDSOUNDPATH, strPath.GetBuffer(_MAX_PATH), _MAX_PATH);
-	strPath.ReleaseBuffer();
-	PROP_PATH(IDS_SOUNDONFINISH_STRING, IDS_SOUNDSWAVFILTER_STRING, strPath)
+	PROP_SEPARATOR(IDS_SOUNDS_STRING);
+	PROP_BOOL(IDS_PLAYSOUNDS_STRING, GetPropValue<PP_SNDPLAYSOUNDS>(GetConfig()));
+	PROP_PATH(IDS_SOUNDONERROR_STRING, IDS_SOUNDSWAVFILTER_STRING, GetPropValue<PP_SNDERRORSOUNDPATH>(GetConfig()));
+	PROP_PATH(IDS_SOUNDONFINISH_STRING, IDS_SOUNDSWAVFILTER_STRING, GetPropValue<PP_SNDFINISHEDSOUNDPATH>(GetConfig()));
 
-	PROP_SEPARATOR(IDS_CFGSHORTCUTS_STRING)
-	PROP_CUSTOM_UINT(IDS_CFGSCCOUNT_STRING, m_cvShortcuts.size(), &ShortcutsPropertyCallbackProc, 0)
+	PROP_SEPARATOR(IDS_CFGSHORTCUTS_STRING);
+	PROP_CUSTOM_UINT(IDS_CFGSCCOUNT_STRING, m_cvShortcuts.size(), &ShortcutsPropertyCallbackProc, 0);
 
-	PROP_SEPARATOR(IDS_CFGRECENT_STRING)
-	PROP_CUSTOM_UINT(IDS_CFGRPCOUNT_STRING, m_cvRecent.size(), &RecentPropertyCallbackProc, 0)
-
- /*	PROP_SEPARATOR(IDS_CFGLOGFILE_STRING)
-	PROP_BOOL(IDS_CFGENABLELOGGING_STRING, GetConfig()->get_bool(PP_LOGENABLELOGGING))
-	PROP_BOOL(IDS_CFGLIMITATION_STRING, GetConfig()->get_bool(PP_LOGLIMITATION))
-	PROP_UINT(IDS_CFGMAXLIMIT_STRING, GetConfig()->get_signed_num(PP_LOGMAXLIMIT))
-	PROP_BOOL(IDS_CFGLOGPRECISELIMITING_STRING, GetConfig()->get_bool(PP_LOGPRECISELIMITING))
-	PROP_UINT(IDS_CFGTRUNCBUFFERSIZE_STRING, GetConfig()->get_signed_num(PP_LOGTRUNCBUFFERSIZE))*/
+	PROP_SEPARATOR(IDS_CFGRECENT_STRING);
+	PROP_CUSTOM_UINT(IDS_CFGRPCOUNT_STRING, m_cvRecent.size(), &RecentPropertyCallbackProc, 0);
 }
 
 void COptionsDlg::ApplyProperties()
 {
 	// counter
 	int iPosition=0;
 
-	icpf::config* pConfig = GetConfig();
-	assert(pConfig);
-	if(!pConfig)
-		return;
+	chengine::TConfig& rConfig = GetConfig();
+	rConfig.DelayNotifications();
 
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_PCLIPBOARDMONITORING, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_PMONITORSCANINTERVAL, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_PRELOADAFTERRESTART, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_PSHUTDOWNAFTREFINISHED, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_PTIMEBEFORESHUTDOWN, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_PFORCESHUTDOWN, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_PAUTOSAVEINTERVAL, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_PPROCESSPRIORITYCLASS, IndexToPriorityClass(GetIndexProp(iPosition++)));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_PCLIPBOARDMONITORING>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_PMONITORSCANINTERVAL>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_PRELOADAFTERRESTART>(rConfig, GetBoolProp(iPosition++));
+
+	SetPropValue<PP_PCHECK_FOR_UPDATES_FREQUENCY>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_PUPDATECHANNEL>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_PUPDATE_USE_SECURE_CONNECTION>(rConfig, GetIndexProp(iPosition++));
+
+	SetPropValue<PP_PSHUTDOWNAFTREFINISHED>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_PTIMEBEFORESHUTDOWN>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_PFORCESHUTDOWN>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_PAUTOSAVEINTERVAL>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_PPROCESSPRIORITYCLASS>(rConfig, IndexToPriorityClass(GetIndexProp(iPosition++)));
+
 	// language
-	PCTSTR pszSrc=m_vld.at(GetIndexProp(iPosition++)).GetFilename(true);
-	if (_tcsnicmp(pszSrc, GetApp()->GetProgramPath(), _tcslen(GetApp()->GetProgramPath())) == 0)
+	CString strSrc = m_vld.at(GetIndexProp(iPosition++)).GetFilename(true);
+	CString strProgramPath = GetApp().GetProgramPath();
+	if (_tcsnicmp(strSrc, GetApp().GetProgramPath(), GetApp().GetProgramPath().GetLength()) == 0)
 	{
 		// replace the first part of path with <PROGRAM>
 		TCHAR szData[_MAX_PATH];
-		_sntprintf(szData, _MAX_PATH, _T("<PROGRAM>%s"), pszSrc+_tcslen(GetApp()->GetProgramPath()));
-		pConfig->set_string(PP_PLANGUAGE, szData);
+		_sntprintf(szData, _MAX_PATH, _T("<PROGRAM>%s"), (PCTSTR)strSrc.Mid(strProgramPath.GetLength()));
+		SetPropValue<PP_PLANGUAGE>(rConfig, szData);
 	}
 	else
-		pConfig->set_string(PP_PLANGUAGE, pszSrc);
+		SetPropValue<PP_PLANGUAGE>(rConfig, strSrc);
 
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_signed_num(PP_STATUSREFRESHINTERVAL, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_STATUSSHOWDETAILS, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_STATUSAUTOREMOVEFINISHED, GetBoolProp(iPosition++));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_STATUSREFRESHINTERVAL>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_STATUSAUTOREMOVEFINISHED>(rConfig, GetBoolProp(iPosition++));
 
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_MVSHOWFILENAMES, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_MVSHOWSINGLETASKS, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_MVREFRESHINTERVAL, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_MVAUTOSHOWWHENRUN, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_MVAUTOHIDEWHENEMPTY, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_MVUSESMOOTHPROGRESS, GetBoolProp(iPosition++));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_MVSHOWFILENAMES>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_MVSHOWSINGLETASKS>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_MVREFRESHINTERVAL>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_MVAUTOSHOWWHENRUN>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_MVAUTOHIDEWHENEMPTY>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_MVUSESMOOTHPROGRESS>(rConfig, GetBoolProp(iPosition++));
 
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_FDEXTENDEDVIEW, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_FDWIDTH, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_FDHEIGHT, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_FDSHORTCUTLISTSTYLE, GetIndexProp(iPosition++));
-	pConfig->set_bool(PP_FDIGNORESHELLDIALOGS, GetBoolProp(iPosition++));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_FDEXTENDEDVIEW>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_FDWIDTH>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_FDHEIGHT>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_FDSHORTCUTLISTSTYLE>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_FDIGNORESHELLDIALOGS>(rConfig, GetBoolProp(iPosition++));
 
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_SHSHOWCOPY, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWMOVE, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWCOPYMOVE, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWPASTE, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWPASTESPECIAL, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWCOPYTO, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWMOVETO, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWCOPYMOVETO, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWFREESPACE, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHSHOWSHELLICONS, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_SHUSEDRAGDROP, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_SHDEFAULTACTION, GetIndexProp(iPosition++));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_SHSHOWCOPY>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWMOVE>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWCOPYMOVE>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWPASTE>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWPASTESPECIAL>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWCOPYTO>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWMOVETO>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWCOPYMOVETO>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWFREESPACE>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHSHOWSHELLICONS>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHINTERCEPTDRAGDROP>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHINTERCEPTKEYACTIONS>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SHINTERCEPTCTXMENUACTIONS>(rConfig, GetBoolProp(iPosition++));
 
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_CMUSEAUTOCOMPLETEFILES, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_CMSETDESTATTRIBUTES, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_CMSETDESTDATE, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_CMPROTECTROFILES, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_CMLIMITMAXOPERATIONS, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_CMREADSIZEBEFOREBLOCKING, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_CMSHOWVISUALFEEDBACK, GetIndexProp(iPosition++));
-	pConfig->set_bool(PP_CMUSETIMEDFEEDBACK, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_CMFEEDBACKTIME, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_CMAUTORETRYONERROR, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_CMAUTORETRYINTERVAL, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_CMDEFAULTPRIORITY, IndexToPriority(GetIndexProp(iPosition++)));
-	pConfig->set_bool(PP_CMDISABLEPRIORITYBOOST, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_CMDELETEAFTERFINISHED, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_CMCREATELOG, GetBoolProp(iPosition++));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_HIDE_SHELLEXT_UNREGISTERED>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_HIDE_SHELLEXT_VERSIONMISMATCH>(rConfig, GetIndexProp(iPosition++));
 
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_CMSETDESTATTRIBUTES>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_CMPROTECTROFILES>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_USECUSTOMNAMING>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_CUSTOMNAME_FIRST>(rConfig, GetStringProp(iPosition++));
+	SetPropValue<PP_CUSTOMNAME_SUBSEQUENT>(rConfig, GetStringProp(iPosition++));
+
+	SetPropValue<PP_CMLIMITMAXOPERATIONS>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_CMREADSIZEBEFOREBLOCKING>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_CMFASTMOVEBEFOREBLOCKING>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_CMDEFAULTPRIORITY>(rConfig, IndexToPriority(GetIndexProp(iPosition++)));
+	SetPropValue<PP_CMDISABLEPRIORITYBOOST>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_CMDELETEAFTERFINISHED>(rConfig, GetBoolProp(iPosition++));
+
 	// Buffer
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_BFUSEONLYDEFAULT, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_BFDEFAULT, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_BFONEDISK, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_BFTWODISKS, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_BFCD, GetUintProp(iPosition++));
-	pConfig->set_signed_num(PP_BFLAN, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_BFUSENOBUFFERING, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_BFBOUNDARYLIMIT, GetUintProp(iPosition++));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_BFUSEONLYDEFAULT>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_BFDEFAULT>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_BFONEDISK>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_BFTWODISKS>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_BFCD>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_BFLAN>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_BFUSENOBUFFERING>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_BFBOUNDARYLIMIT>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_BFQUEUEDEPTH>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_MAXREADAHEAD>(GetConfig(), GetUintProp(iPosition++));
+	SetPropValue<PP_MAXCONCURRENTREADS>(GetConfig(), GetUintProp(iPosition++));
+	SetPropValue<PP_MAXCONCURRENTWRITES>(GetConfig(), GetUintProp(iPosition++));
 
 	// log file
-/*	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_LOGENABLELOGGING, GetBoolProp(iPosition++));
-	pConfig->set_bool(PP_LOGLIMITATION, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_LOGMAXLIMIT, GetUintProp(iPosition++));
-	pConfig->set_bool(PP_LOGPRECISELIMITING, GetBoolProp(iPosition++));
-	pConfig->set_signed_num(PP_LOGTRUNCBUFFERSIZE, GetUintProp(iPosition++));*/
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_LOGMAXSIZE>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_LOGROTATECOUNT>(rConfig, GetUintProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_APP>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_ENGINEDEFAULT>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_SERIALIZER>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_TASK>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_SUBTASK_SCANDIR>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_SUBTASK_COPYMOVE>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_SUBTASK_FASTMOVE>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_SUBTASK_DELETE>(rConfig, GetIndexProp(iPosition++));
+	SetPropValue<PP_LOGLEVEL_FILESYSTEM>(rConfig, GetIndexProp(iPosition++));
 
 	// Sounds
-	SKIP_SEPARATOR(iPosition)
-	pConfig->set_bool(PP_SNDPLAYSOUNDS, GetBoolProp(iPosition++));
-	pConfig->set_string(PP_SNDERRORSOUNDPATH, GetStringProp(iPosition++));
-	pConfig->set_string(PP_SNDFINISHEDSOUNDPATH, GetStringProp(iPosition++));
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_SNDPLAYSOUNDS>(rConfig, GetBoolProp(iPosition++));
+	SetPropValue<PP_SNDERRORSOUNDPATH>(rConfig, GetStringProp(iPosition++));
+	SetPropValue<PP_SNDFINISHEDSOUNDPATH>(rConfig, GetStringProp(iPosition++));
 
 	// shortcuts & recent paths
-	SKIP_SEPARATOR(iPosition)
-	pConfig->clear_array_values(PP_SHORTCUTS);
-	for(char_vector::iterator it = m_cvShortcuts.begin(); it != m_cvShortcuts.end(); it++)
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_SHORTCUTS>(rConfig, m_cvShortcuts);
+
+	SKIP_SEPARATOR(iPosition);
+	SetPropValue<PP_RECENTPATHS>(rConfig, m_cvRecent);
+
+	rConfig.ResumeNotifications();
+
+	rConfig.Write();
+
+	LOG_INFO(m_spLog) << L"Updating shell extension configuration";
+	try
 	{
-		pConfig->set_string(PP_SHORTCUTS, (*it), icpf::property::action_add);
+		TShellExtensionConfigPtr spConfig = GetShellExtensionConfig();
+		if(spConfig)
+			spConfig->PrepareConfig();
 	}
-	
-	SKIP_SEPARATOR(iPosition)
-	pConfig->clear_array_values(PP_RECENTPATHS);
-	for(char_vector::iterator it = m_cvRecent.begin(); it != m_cvRecent.end(); it++)
+	catch(const std::exception& e)
 	{
-		pConfig->set_string(PP_RECENTPATHS, (*it), icpf::property::action_add);
+		LOG_INFO(m_spLog) << L"Failed to set shell extension configuration. Error: " << e.what();
 	}
-
-	pConfig->write(NULL);
 }
 
 void COptionsDlg::OnCancel() 
@@ -480,38 +522,43 @@
 	assert(lpszSeparator);
 	if(!lpszSeparator)
 		return _T("");
-	_tcscpy(m_szBuffer, GetResManager()->LoadString(uiBase+0));
-	for (int i=1;i<iCount;i++)
+
+	CString strText = GetResManager().LoadString(uiBase + 0);
+	for(int i = 1; i < iCount; i++)
 	{
-		_tcscat(m_szBuffer, lpszSeparator);
-		_tcscat(m_szBuffer, GetResManager()->LoadString(uiBase+i));
+		strText += lpszSeparator;
+		strText += GetResManager().LoadString(uiBase + i);
 	}
 
-	return CString((PCTSTR)m_szBuffer);
+	return strText;
 }
 
 bool COptionsDlg::GetBoolProp(int iPosition)
 {
-	m_ctlProperties.GetProperty(iPosition, &m_iSel);
-	return m_iSel != 0;
+	int iSel = 0;
+	m_ctlProperties.GetProperty(iPosition, &iSel);
+	return iSel != 0;
 }
 
 UINT COptionsDlg::GetUintProp(int iPosition)
 {
-	m_ctlProperties.GetProperty(iPosition, &m_strTemp);
-	return _ttoi(m_strTemp);
+	CString strValue;
+	m_ctlProperties.GetProperty(iPosition, &strValue);
+	return _ttoi(strValue);
 }
 
 CString COptionsDlg::GetStringProp(int iPosition)
 {
-	m_ctlProperties.GetProperty(iPosition, &m_strTemp);
-	return m_strTemp;
+	CString strValue;
+	m_ctlProperties.GetProperty(iPosition, &strValue);
+	return strValue;
 }
 
 int COptionsDlg::GetIndexProp(int iPosition)
 {
-	m_ctlProperties.GetProperty(iPosition, &m_iSel);
-	return m_iSel;
+	int iSel = 0;
+	m_ctlProperties.GetProperty(iPosition, &iSel);
+	return iSel;
 }
 
 void COptionsDlg::OnApplyButton()