SettingsUI.cpp

// Classic Shell (c) 2009-2016, Ivo Beltchev
// Confidential information of Ivo Beltchev. Not for disclosure or distribution without prior written consent from the author

#include "stdafx.h"
#include "resource.h"
#include "ClassicStartMenuDLL.h"
#include "ClassicStartButton.h"
#include "Settings.h"
#include "SkinManager.h"
#include "FNVHash.h"
#include "SettingsUIHelper.h"
#include "LanguageSettingsHelper.h"
#include "SettingsUI.h"
#include "ResourceHelper.h"
#include "MenuContainer.h"
#include "Translations.h"
#include "CustomMenu.h"
#include "dllmain.h"
#include <uxtheme.h>
#include <dwmapi.h>
#include <htmlhelp.h>
#define SECURITY_WIN32
#include <Security.h>

const int DEFAULT_GLASS_OPACITY=50; // 50%
const int DEFAULT_TASK_OPACITY7=25; // 25%
const int DEFAULT_TASK_OPACITY8=55; // 55%
const int DEFAULT_TASK_OPACITY10=85; // 85%

///////////////////////////////////////////////////////////////////////////////

class CSkinSettingsDlg: public CResizeableDlg<CSkinSettingsDlg>
{
public:
	enum {
		IDC_EDITBOX=101,
		IDC_BROWSEBTN=102,
		WM_EDITKEY=WM_APP+11,
	};

	CSkinSettingsDlg( void );
	void Create( MenuSkin::TSkinType skinType, HWND hWndParent, DLGTEMPLATE *pTemplate );

	BEGIN_MSG_MAP( CSkinSettingsDlg )
		MESSAGE_HANDLER( WM_INITDIALOG, OnInitDialog )
		MESSAGE_HANDLER( WM_DESTROY, OnDestroy )
		MESSAGE_HANDLER( WM_SIZE, OnSize )
		MESSAGE_HANDLER( WM_EDITKEY, OnEditKey )
		COMMAND_HANDLER( IDC_EDITBOX, EN_CHANGE, OnEditChange )
		COMMAND_HANDLER( IDC_EDITBOX, EN_KILLFOCUS, OnKillFocus )
		COMMAND_HANDLER( IDC_BROWSEBTN, BN_CLICKED, OnBrowse )
		COMMAND_HANDLER( IDC_BROWSEBTN, BN_KILLFOCUS, OnKillFocus )
		COMMAND_HANDLER( IDC_COMBOSKIN, CBN_SELENDOK, OnSelEndOK )
		COMMAND_HANDLER( IDC_ABOUT, BN_CLICKED, OnAbout )
		COMMAND_HANDLER( IDC_BUTTONRESET, BN_CLICKED, OnReset )
		NOTIFY_HANDLER( IDC_SKINOPTIONS, NM_CUSTOMDRAW, OnCustomDraw )
		NOTIFY_HANDLER( IDC_SKINOPTIONS, TVN_SELCHANGED, OnSelChanged )
		NOTIFY_HANDLER( IDC_SKINOPTIONS, TVN_ITEMEXPANDING, OnExpanding )
		NOTIFY_HANDLER( IDC_SKINOPTIONS, NM_CLICK, OnClick )
		NOTIFY_HANDLER( IDC_SKINOPTIONS, NM_DBLCLK, OnClick )
		NOTIFY_HANDLER( IDC_SKINOPTIONS, TVN_KEYDOWN, OnKeyDown )
		NOTIFY_HANDLER( IDC_SKINOPTIONS, TVN_GETINFOTIP, OnGetInfoTip )
	END_MSG_MAP()

	BEGIN_RESIZE_MAP
		RESIZE_CONTROL(IDC_COMBOSKIN,MOVE_SIZE_X)
		RESIZE_CONTROL(IDC_ABOUT,MOVE_MOVE_X)
		RESIZE_CONTROL(IDC_BUTTONRESET,MOVE_MOVE_X)
		RESIZE_CONTROL(IDC_STATICVER,MOVE_SIZE_X)
		RESIZE_CONTROL(IDC_SKINOPTIONS,MOVE_SIZE_X|MOVE_SIZE_Y)
		RESIZE_CONTROL(IDC_STATICALLPROGS,MOVE_SIZE_X|MOVE_MOVE_Y)
	END_RESIZE_MAP

	void SetGroup( CSetting *pGroup );

protected:
	// Handler prototypes:
	//  LRESULT MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
	//  LRESULT CommandHandler(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
	//  LRESULT NotifyHandler(int idCtrl, LPNMHDR pnmh, BOOL& bHandled);
	LRESULT OnInitDialog( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnDestroy( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnSize( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnSelEndOK( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled );
	LRESULT OnAbout( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled );
	LRESULT OnReset( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled );
	LRESULT OnCustomDraw( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnSelChanged( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnExpanding( int idCtrl, LPNMHDR pnmh, BOOL& bHandled ) { return TRUE; } // prevent collapsing
	LRESULT OnClick( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnKeyDown( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnGetInfoTip( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnEditKey( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnEditChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled );
	LRESULT OnKillFocus( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled );
	LRESULT OnBrowse( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled );

private:

	MenuSkin::TSkinType m_SkinType;
	MenuSkin m_CurrentSkin;
	CWindow m_Tree;
	CWindow m_EditBox;
	CWindow m_BrowseButton;
	TSkinOptionType m_EditMode;
	HTREEITEM m_EditItem;
	int m_EditItemIndex;
	bool m_bLoadSuccess;
	bool m_bIgnoreFocus;
	CSetting *m_pSetting;
	std::vector<CString> m_SkinNames;
	int m_SkinIndex;
	int m_VariationIndex;

	void InitSkinUI( void );
	void UpdateSkinSettings( void );
	void StoreSkinOptions( void );
	void ToggleItem( HTREEITEM hItem );
	void ItemSelected( HTREEITEM hItem, int index, bool bEnabled );
	void ApplyEditBox( void );
	void UpdateEditPosition( void );
};

CSkinSettingsDlg::CSkinSettingsDlg( void )
{
	m_SkinType=MenuSkin::SKIN_TYPE_COUNT;
	m_pSetting=NULL;
	m_SkinIndex=m_VariationIndex=0;
	m_EditItem=NULL;
	m_EditMode=SKIN_OPTION_NONE;
	m_EditItemIndex=-1;
	m_bIgnoreFocus=false;
	m_bLoadSuccess=false;
}

void CSkinSettingsDlg::Create( MenuSkin::TSkinType skinType, HWND hWndParent, DLGTEMPLATE *pTemplate )
{
	m_SkinType=skinType;
	CResizeableDlg<CSkinSettingsDlg>::Create(hWndParent,pTemplate);
}

// Subclass the edit control to forward some keyboard messages to the parent and to act as a hotkey control
static LRESULT CALLBACK SubclassEditProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
	if (uMsg==WM_CHAR && wParam==VK_RETURN)
		return 0;
	if (uMsg==WM_GETDLGCODE && wParam==VK_RETURN)
		return DLGC_WANTALLKEYS;
	if (uMsg==WM_KEYDOWN)
	{
		if (wParam==VK_UP || wParam==VK_DOWN || wParam==VK_PRIOR || wParam==VK_NEXT || (wParam==VK_SPACE && GetKeyState(VK_CONTROL)<0))
			return SendMessage(GetParent(hWnd),uMsg,wParam,lParam);
		if (wParam==VK_RETURN || wParam==VK_ESCAPE)
			return SendMessage(GetParent(GetParent(hWnd)),CSkinSettingsDlg::WM_EDITKEY,wParam,0);
	}
	if (uMsg==WM_KILLFOCUS)
	{
		if (wParam && (HWND)wParam==GetDlgItem(GetParent(hWnd),CSkinSettingsDlg::IDC_BROWSEBTN))
			return 0;
	}
	return DefSubclassProc(hWnd,uMsg,wParam,lParam);
}

// Subclass the tooltip to delay the tip when the mouse moves from one tree item to the next
static LRESULT CALLBACK SubclassInfoTipProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
	if (uMsg==TTM_UPDATE)
	{
		int time=(int)SendMessage(hWnd,TTM_GETDELAYTIME,TTDT_RESHOW,0);
		SetTimer(hWnd,'CLSH',time,NULL);
		return 0;
	}
	if (uMsg==WM_TIMER && wParam=='CLSH')
	{
		KillTimer(hWnd,wParam);
		DefSubclassProc(hWnd,TTM_UPDATE,0,0);
		return 0;
	}
	return DefSubclassProc(hWnd,uMsg,wParam,lParam);
}

// Subclass the tree control to forward the command messages to the parent
static LRESULT CALLBACK SubclassTreeProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
	if (uMsg==WM_COMMAND)
		return SendMessage(GetParent(hWnd),uMsg,wParam,lParam);
	return DefSubclassProc(hWnd,uMsg,wParam,lParam);
}

LRESULT CSkinSettingsDlg::OnInitDialog( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	InitResize();
	EnableThemeDialogTexture(m_hWnd,ETDT_ENABLETAB);

	m_Tree=GetDlgItem(IDC_SKINOPTIONS);
	SetWindowSubclass(m_Tree,SubclassTreeProc,'CLSH',0);
	TreeView_SetImageList(m_Tree,GetSettingsImageList(m_Tree),TVSIL_NORMAL);
	m_Tree.SendMessage(TVM_SETEXTENDEDSTYLE,TVS_EX_DOUBLEBUFFER,TVS_EX_DOUBLEBUFFER);
	m_Tree.SetWindowLong(GWL_STYLE,m_Tree.GetWindowLong(GWL_STYLE)|TVS_SHOWSELALWAYS); // should be in the dialog template, but I don't want to have to edit all language DLLs
	if (IsAppThemed())
	{
		m_Tree.SetWindowLong(GWL_STYLE,m_Tree.GetWindowLong(GWL_STYLE)|TVS_TRACKSELECT);
		SetWindowTheme(m_Tree,L"Explorer",NULL);
	}

	m_SkinNames.clear();
	m_SkinNames.push_back(LoadStringEx(IDS_DEFAULT_SKIN));
	wchar_t find[_MAX_PATH];
	GetSkinsPath(find);
	Strcat(find,_countof(find),L"1.txt");
	if (GetFileAttributes(find)!=INVALID_FILE_ATTRIBUTES)
	{
		m_SkinNames.push_back(L"Custom");
	}

	*PathFindFileName(find)=0;
	Strcat(find,_countof(find),m_SkinType==MenuSkin::SKIN_TYPE_WIN7?L"*.skin7":L"*.skin");
	WIN32_FIND_DATA data;
	HANDLE h=FindFirstFile(find,&data);
	while (h!=INVALID_HANDLE_VALUE)
	{
		if (!(data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
		{
			*PathFindExtension(data.cFileName)=0;
			m_SkinNames.push_back(data.cFileName);
		}
		if (!FindNextFile(h,&data))
		{
			FindClose(h);
			break;
		}
	}

	CWindow skins=GetDlgItem(IDC_COMBOSKIN);
	for (std::vector<CString>::const_iterator it=m_SkinNames.begin();it!=m_SkinNames.end();++it)
		skins.SendMessage(CB_ADDSTRING,0,(LPARAM)(const wchar_t *)*it);

	CWindow tooltip=TreeView_GetToolTips(m_Tree);
	tooltip.SendMessage(TTM_SETDELAYTIME,TTDT_AUTOPOP,10000);
	tooltip.SendMessage(TTM_SETDELAYTIME,TTDT_INITIAL,1000);
	tooltip.SendMessage(TTM_SETDELAYTIME,TTDT_RESHOW,1000);
	SetWindowSubclass(tooltip,SubclassInfoTipProc,'CLSH',0);

	TOOLINFO tool={sizeof(tool),TTF_SUBCLASS,m_hWnd,'CLSH'};
	CString str=LoadStringEx(IDS_SETTING_LOCKED);
	tool.lpszText=(LPWSTR)(LPCWSTR)str;
	skins.GetClientRect(&tool.rect);
	skins.MapWindowPoints(m_hWnd,&tool.rect);
	tooltip.SendMessage(TTM_ADDTOOL,0,(LPARAM)&tool);

	GetDlgItem(IDC_STATICALLPROGS).ShowWindow(m_SkinType==MenuSkin::SKIN_TYPE_ALL_PROGRAMS?SW_SHOW:SW_HIDE);

	HINSTANCE hInstance=_AtlBaseModule.GetResourceInstance();
	HFONT font=m_Tree.GetFont();
	m_EditBox=CreateWindow(L"EDIT",NULL,WS_CHILD|WS_BORDER|ES_AUTOHSCROLL,0,0,0,0,m_Tree,(HMENU)IDC_EDITBOX,hInstance,NULL);
	m_EditBox.SetFont(font);
	SetWindowSubclass(m_EditBox,SubclassEditProc,'CLSH',0);
	m_BrowseButton=CreateWindow(L"BUTTON",L"...",WS_CHILD|BS_PUSHBUTTON,0,0,0,0,m_Tree,(HMENU)IDC_BROWSEBTN,hInstance,NULL);
	m_BrowseButton.SetFont(font);
	m_EditMode=SKIN_OPTION_NONE;
	m_EditItem=NULL;
	m_EditItemIndex=-1;
	m_bIgnoreFocus=false;

	return TRUE;
}

LRESULT CSkinSettingsDlg::OnDestroy( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	m_EditMode=SKIN_OPTION_NONE;
	bHandled=FALSE;
	return 0;
}

// Fills the tree with the options for the current skin
void CSkinSettingsDlg::InitSkinUI( void )
{
	m_Tree.SetRedraw(FALSE);
	TreeView_DeleteAllItems(m_Tree);
	m_VariationIndex=-1;
	m_EditItemIndex=-1;
	m_EditMode=SKIN_OPTION_NONE;
	m_BrowseButton.ShowWindow(SW_HIDE);
	m_EditBox.ShowWindow(SW_HIDE);

	m_bLoadSuccess=m_CurrentSkin.LoadMenuSkin(m_SkinNames[m_SkinIndex],NULL,L"",m_SkinType,0,96);
	if (!m_bLoadSuccess)
		m_CurrentSkin.Reset();

	if (m_CurrentSkin.Version>MAX_SKIN_VERSION)
	{
		GetDlgItem(IDC_STATICVER).ShowWindow(SW_SHOW);
		m_CurrentSkin.Variations.clear();
		m_CurrentSkin.Options.clear();
	}
	else
		GetDlgItem(IDC_STATICVER).ShowWindow(SW_HIDE);

	CWindow label=GetDlgItem(IDC_STATICOPT);

	if (m_CurrentSkin.Options.empty() && m_CurrentSkin.Variations.empty())
	{
		label.ShowWindow(SW_HIDE);
		m_Tree.SetRedraw(TRUE);
		m_Tree.ShowWindow(SW_HIDE);
	}
	else
	{
		// init variations
		if (!m_CurrentSkin.Variations.empty())
		{
			const wchar_t *variaton=L"";
			if (m_pSetting[1].value.vt==VT_BSTR)
				variaton=m_pSetting[1].value.bstrVal;

			m_VariationIndex=0;
			CString vars=LoadStringEx(IDC_SKINVARIATION);
			TVINSERTSTRUCT insert={NULL,TVI_LAST,{TVIF_STATE|TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_PARAM,NULL,TVIS_EXPANDED,TVIS_EXPANDED|TVIS_OVERLAYMASK,(LPWSTR)(LPCWSTR)vars,0,SETTING_STATE_SETTING,SETTING_STATE_SETTING}};
			insert.item.lParam=(LPARAM)(m_pSetting+1);
			if (m_pSetting[1].IsLocked())
			{
				insert.item.state|=INDEXTOOVERLAYMASK(1);
				insert.item.iImage=insert.item.iSelectedImage=SETTING_STATE_SETTING|SETTING_STATE_DISABLED;
			}
			HTREEITEM hVars=TreeView_InsertItem(m_Tree,&insert);
			int n=(int)m_CurrentSkin.Variations.size();
			for (int i=0;i<n;i++)
			{
				const MenuSkin::Variation &var=m_CurrentSkin.Variations[i].second;
				if (_wcsicmp(var.label,variaton)==0 || _wcsicmp(var.labelEn,variaton)==0)
					m_VariationIndex=i;
				TVINSERTSTRUCT insert2={hVars,TVI_LAST,{TVIF_TEXT|TVIF_PARAM,NULL,0,0,(LPWSTR)(LPCWSTR)var.label}};
				insert2.item.lParam=-i-1;
				TreeView_InsertItem(m_Tree,&insert2);
			}
		}

		HTREEITEM hLastGroup=NULL;
		int n=(int)m_CurrentSkin.Options.size();
		for (int i=0;i<n;i++)
		{
			const MenuSkin::Option &option=m_CurrentSkin.Options[i];
			TVINSERTSTRUCT insert={NULL,TVI_LAST,{TVIF_TEXT|TVIF_PARAM|TVIF_STATE|TVIF_IMAGE|TVIF_SELECTEDIMAGE,NULL,TVIS_EXPANDED,TVIS_OVERLAYMASK|TVIS_EXPANDED,(LPWSTR)(LPCWSTR)(LPWSTR)(LPCWSTR)option.label}};
			if (option.type==SKIN_OPTION_GROUP)
				insert.item.iImage=insert.item.iSelectedImage=SETTING_STATE_SETTING;
			else if (option.groupId>=0)
				insert.hParent=hLastGroup;
			insert.item.lParam=i;
			if (m_pSetting[2].IsLocked())
				insert.item.state|=INDEXTOOVERLAYMASK(1);
			HTREEITEM hItem=TreeView_InsertItem(m_Tree,&insert);
			if (option.type==SKIN_OPTION_GROUP)
				hLastGroup=hItem;
		}
		UpdateSkinSettings();
		label.ShowWindow(SW_SHOW);
		m_Tree.SetRedraw(TRUE);
		m_Tree.Invalidate();
		m_Tree.ShowWindow(SW_SHOW);
	}
}

void CSkinSettingsDlg::UpdateSkinSettings( void )
{
	HTREEITEM hItem=TreeView_GetRoot(m_Tree);
	if (!hItem) return;
	TVITEM item={TVIF_PARAM|TVIF_IMAGE|TVIF_SELECTEDIMAGE,hItem};
	TreeView_GetItem(m_Tree,&item);
	if (item.lParam==(LPARAM)(m_pSetting+1))
	{
		// has variations
		for (HTREEITEM hVar=TreeView_GetChild(m_Tree,hItem);hVar;hVar=TreeView_GetNextSibling(m_Tree,hVar))
		{
			item.hItem=hVar;
			TreeView_GetItem(m_Tree,&item);
			int image=SETTING_STATE_RADIO;
			if (-1-(int)item.lParam==m_VariationIndex)
				image|=SETTING_STATE_CHECKED;
			if (m_pSetting[1].IsLocked())
				image|=SETTING_STATE_DISABLED;
			if (item.iImage!=image)
			{
				item.iImage=item.iSelectedImage=image;
				TreeView_SetItem(m_Tree,&item);
				RECT rc;
				TreeView_GetItemRect(m_Tree,hVar,&rc,FALSE);
				m_Tree.InvalidateRect(&rc);
			}
		}
		hItem=TreeView_GetNextSibling(m_Tree,hItem);
	}

	bool bLocked=m_pSetting[2].IsLocked();
	std::map<CString,CString> options;
	if (m_pSetting[2].value.vt==VT_BSTR)
		m_CurrentSkin.ParseOptionsString(m_pSetting[2].value.bstrVal,options);
	{
		std::vector<const wchar_t*> values;
		m_CurrentSkin.ComputeOptionStates(options,values,false);
	}

	HTREEITEM hLastGroup=NULL;
	while (hItem)
	{
		wchar_t text[256];
		item.hItem=hItem;
		item.pszText=text;
		TreeView_GetItem(m_Tree,&item);
		int idx=(int)item.lParam;
		const MenuSkin::Option &option=m_CurrentSkin.Options[idx];
		if (option.type==SKIN_OPTION_GROUP)
		{
			hLastGroup=hItem;
			hItem=TreeView_GetChild(m_Tree,hItem);
		}
		else
		{
			int image=option.groupId>=0?SETTING_STATE_RADIO:SETTING_STATE_CHECKBOX;
			if (option.bValue)
				image|=SETTING_STATE_CHECKED;
			if (!option.bEnabled || bLocked)
				image|=SETTING_STATE_DISABLED;
			if (option.bValue && option.type>SKIN_OPTION_BOOL)
				Sprintf(text,_countof(text),L"%s: %s",option.label,option.sValue);
			else
				Sprintf(text,_countof(text),L"%s",option.label);

			item.iImage=item.iSelectedImage=image;
			item.mask|=TVIF_TEXT;
			TreeView_SetItem(m_Tree,&item);
			item.mask&=~TVIF_TEXT;
			RECT rc;
			TreeView_GetItemRect(m_Tree,hItem,&rc,FALSE);
			m_Tree.InvalidateRect(&rc);

			hItem=TreeView_GetNextSibling(m_Tree,hItem);
			if (!hItem && hLastGroup)
			{
				hItem=TreeView_GetNextSibling(m_Tree,hLastGroup);
				hLastGroup=NULL;
			}
		}
	}
}

void CSkinSettingsDlg::StoreSkinOptions( void )
{
	std::vector<wchar_t> buffer;
	m_CurrentSkin.SerializeOptionStates(buffer);

	CSettingsLockWrite lock;
	const wchar_t *strNew=&buffer[0];
	const wchar_t *strOld=m_pSetting[2].value.vt==VT_BSTR?m_pSetting[2].value.bstrVal:L"";
	if (wcscmp(strNew,strOld)!=0)
		SetSettingsDirty();

	m_pSetting[2].value=CComVariant(strNew);
}

LRESULT CSkinSettingsDlg::OnCustomDraw( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	NMTVCUSTOMDRAW *pDraw=(NMTVCUSTOMDRAW*)pnmh;
	if (pDraw->nmcd.dwDrawStage==CDDS_PREPAINT)
	{
		UpdateEditPosition();
		return CDRF_NOTIFYITEMDRAW;
	}
	else if (pDraw->nmcd.dwDrawStage==CDDS_ITEMPREPAINT)
	{
		TVITEM item={TVIF_IMAGE|TVIF_STATE,(HTREEITEM)pDraw->nmcd.dwItemSpec,0,TVIS_SELECTED};
		TreeView_GetItem(m_Tree,&item);
		if ((item.iImage&SETTING_STATE_DISABLED) && (!(item.state&TVIS_SELECTED) || IsAppThemed()))
			pDraw->clrText=GetSysColor(COLOR_GRAYTEXT);
		return CDRF_NOTIFYPOSTPAINT;
	}
	else if (pDraw->nmcd.dwDrawStage==CDDS_ITEMPOSTPAINT)
	{
		if (IS_INTRESOURCE(pDraw->nmcd.lItemlParam) && m_CurrentSkin.Options[pDraw->nmcd.lItemlParam].bValue && m_CurrentSkin.Options[pDraw->nmcd.lItemlParam].type==SKIN_OPTION_COLOR)
		{
			RECT rc;
			if (TreeView_GetItemRect(m_Tree,(HTREEITEM)pDraw->nmcd.dwItemSpec,&rc,TRUE))
			{
				const wchar_t *str=m_CurrentSkin.Options[pDraw->nmcd.lItemlParam].sValue;
				wchar_t *end;
				COLORREF color=wcstoul(str,&end,16);
				SetDCBrushColor(pDraw->nmcd.hdc,color&0xFFFFFF);
				SelectObject(pDraw->nmcd.hdc,GetStockObject(DC_BRUSH));
				SelectObject(pDraw->nmcd.hdc,GetStockObject(BLACK_PEN));
				Rectangle(pDraw->nmcd.hdc,rc.right,rc.top,rc.right+rc.bottom-rc.top,rc.bottom-1);
			}
		}
	}
	return CDRF_DODEFAULT;
}

LRESULT CSkinSettingsDlg::OnSelChanged( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	HTREEITEM hItem=TreeView_GetSelection(m_Tree);
	if (hItem)
	{
		TVITEM item={TVIF_PARAM|TVIF_IMAGE,hItem};
		TreeView_GetItem(m_Tree,&item);
		if (IS_INTRESOURCE(item.lParam))
			ItemSelected(item.hItem,(int)item.lParam,(item.iImage&SETTING_STATE_CHECKED)!=0);
		else
			ItemSelected(NULL,-1,false);
	}
	else
		ItemSelected(NULL,-1,false);
	return 0;
}

void CSkinSettingsDlg::ToggleItem( HTREEITEM hItem )
{
	if (!hItem) return;
	TVITEM item={TVIF_PARAM|TVIF_IMAGE,hItem};
	TreeView_GetItem(m_Tree,&item);
	if (item.iImage&SETTING_STATE_DISABLED)
		return;
	if (IS_INTRESOURCE(item.lParam))
	{
		const MenuSkin::Option &option=m_CurrentSkin.Options[item.lParam];
		if (option.groupId>=0)
		{
			// radio button
			if (item.iImage&SETTING_STATE_CHECKED)
				return;
			for (std::vector<MenuSkin::Option>::const_iterator it=m_CurrentSkin.Options.begin();it!=m_CurrentSkin.Options.end();++it)
			{
				if (it->type==SKIN_OPTION_GROUP || it->groupId!=option.groupId)
					continue;
				it->bValue=&option==&*it;
			}
		}
		else
		{
			option.bValue=!(item.iImage&SETTING_STATE_CHECKED);
		}
		StoreSkinOptions();
	}
	else if (IS_INTRESOURCE(-item.lParam))
	{
		// select variation
		if (item.iImage&SETTING_STATE_CHECKED)
			return;
		m_VariationIndex=-1-(int)item.lParam;
		CSettingsLockWrite lock;
		const wchar_t *strNew=m_CurrentSkin.Variations[m_VariationIndex].second.labelEn;
		const wchar_t *strOld=m_pSetting[1].value.vt==VT_BSTR?m_pSetting[1].value.bstrVal:L"???";
		if (wcscmp(strNew,strOld)!=0)
			SetSettingsDirty();
		m_pSetting[1].value=CComVariant(strNew);
	}
	UpdateSkinSettings();
	if (IS_INTRESOURCE(item.lParam))
		ItemSelected(hItem,(int)item.lParam,m_CurrentSkin.Options[item.lParam].bValue);
}

LRESULT CSkinSettingsDlg::OnClick( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	DWORD pos=GetMessagePos();
	TVHITTESTINFO test={{(short)LOWORD(pos),(short)HIWORD(pos)}};
	m_Tree.ScreenToClient(&test.pt);
	if (TreeView_HitTest(m_Tree,&test))
	{
		if (test.flags&(TVHT_ONITEMICON|TVHT_ONITEMLABEL))
		{
			if (test.flags&TVHT_ONITEMLABEL)
			{
				TVITEM item={TVIF_STATE|TVIF_PARAM,test.hItem};
				TreeView_GetItem(m_Tree,&item);
				if (!(item.state&TVIS_SELECTED) && IS_INTRESOURCE(item.lParam))
				{
					const MenuSkin::Option &option=m_CurrentSkin.Options[item.lParam];
					if (option.type>SKIN_OPTION_BOOL && option.bValue && option.groupId==-1)
						return 0;
				}
			}
			ToggleItem(test.hItem);
		}
		if (test.flags&TVHT_ONITEMRIGHT)
		{
			TVITEM item={TVIF_STATE|TVIF_PARAM,test.hItem};
			TreeView_GetItem(m_Tree,&item);
			if (item.lParam!=m_EditItemIndex && IS_INTRESOURCE(item.lParam))
			{
				const MenuSkin::Option &option=m_CurrentSkin.Options[item.lParam];
				if (option.type==SKIN_OPTION_COLOR && option.bValue)
				{
					RECT rc;
					if (TreeView_GetItemRect(m_Tree,item.hItem,&rc,TRUE) && test.pt.x>=rc.right && test.pt.x<rc.right+rc.bottom-rc.top)
					{
						if (!(item.state&TVIS_SELECTED))
							TreeView_SelectItem(m_Tree,item.hItem);
						ItemSelected(item.hItem,(int)item.lParam,true);
						SendMessage(WM_COMMAND,MAKEWPARAM(IDC_BROWSEBTN,BN_CLICKED));
					}
				}
			}
		}
	}

	return 0;
}

LRESULT CSkinSettingsDlg::OnKeyDown( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	NMTVKEYDOWN *pKey=(NMTVKEYDOWN*)pnmh;
	if (pKey->wVKey==VK_SPACE)
	{
		ToggleItem(TreeView_GetSelection(m_Tree));
		return 1;
	}
	bHandled=FALSE;
	return 0;
}

LRESULT CSkinSettingsDlg::OnGetInfoTip( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	NMTVGETINFOTIP *pTip=(NMTVGETINFOTIP*)pnmh;
	TVITEM item={TVIF_STATE|TVIF_IMAGE|TVIF_PARAM,pTip->hItem,0,TVIS_OVERLAYMASK};
	TreeView_GetItem(m_Tree,&item);
	int len=0;
	if (IS_INTRESOURCE(item.lParam))
	{
		len=Strcpy(pTip->pszText,pTip->cchTextMax,m_CurrentSkin.Options[item.lParam].tip);
	}
	else if (IS_INTRESOURCE(-item.lParam))
	{
		len=Strcpy(pTip->pszText,pTip->cchTextMax,m_CurrentSkin.Variations[-1-item.lParam].second.tip);
	}
	if (item.state&TVIS_OVERLAYMASK)
	{
		Sprintf(pTip->pszText+len,pTip->cchTextMax-len,L"\r\n%s",LoadStringEx(IDS_SETTING_LOCKED));
	}
	return 0;
}

LRESULT CSkinSettingsDlg::OnEditKey( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (wParam==VK_RETURN && !(m_EditBox.GetWindowLong(GWL_STYLE)&ES_READONLY))
		ItemSelected(m_EditItem,m_EditItemIndex,true);
	return 0;
}

LRESULT CSkinSettingsDlg::OnEditChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
	UpdateEditPosition();
	return 0;
}

LRESULT CSkinSettingsDlg::OnKillFocus( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
	if (!m_bIgnoreFocus && m_EditItemIndex>=0)
	{
		ApplyEditBox();
		UpdateEditPosition();
	}
	return 0;
}

LRESULT CSkinSettingsDlg::OnBrowse( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
	if (m_EditMode==SKIN_OPTION_IMAGE)
	{
		m_bIgnoreFocus=true;
		CString str;
		m_EditBox.GetWindowText(str);
		str.TrimLeft(); str.TrimRight();
		wchar_t text[1024];
		if (_wcsicmp(PathFindExtension(str),L".bmp")==0 || _wcsicmp(PathFindExtension(str),L".png")==0 || _wcsicmp(PathFindExtension(str),L".jpg")==0)
		{
			Strcpy(text,_countof(text),str);
			DoEnvironmentSubst(text,_countof(text));
		}
		else
			text[0]=0;
		if (BrowseForBitmap(m_hWnd,text,true))
		{
			m_EditBox.SetWindowText(text);
		}
		SendMessage(WM_NEXTDLGCTL,(LPARAM)m_EditBox.m_hWnd,TRUE);
		m_EditBox.SetFocus();
		m_bIgnoreFocus=false;
	}
	else if (m_EditMode==SKIN_OPTION_COLOR)
	{
		m_bIgnoreFocus=true;
		CString str;
		m_EditBox.GetWindowText(str);
		str.TrimLeft(); str.TrimRight();
		wchar_t *end;
		COLORREF val=wcstol(str,&end,16)&0xFFFFFF;
		static COLORREF customColors[16];
		CHOOSECOLOR choose={sizeof(choose),m_hWnd,NULL,val,customColors};
		choose.Flags=CC_ANYCOLOR|CC_FULLOPEN|CC_RGBINIT;
		if (ChooseColor(&choose))
		{
			wchar_t text[100];
			Sprintf(text,_countof(text),L"%06X",choose.rgbResult);
			m_EditBox.SetWindowText(text);
			ApplyEditBox();
			m_Tree.Invalidate();
		}
		SendMessage(WM_NEXTDLGCTL,(LPARAM)m_EditBox.m_hWnd,TRUE);
		m_EditBox.SetFocus();
		m_bIgnoreFocus=false;
	}
	return 0;
}

void CSkinSettingsDlg::ApplyEditBox( void )
{
	if (m_EditItemIndex>=0)
	{
		CString str;
		m_EditBox.GetWindowText(str);
		str.TrimLeft(); str.TrimRight();
		m_CurrentSkin.Options[m_EditItemIndex].sValue=str;
		StoreSkinOptions();
	}
}

void CSkinSettingsDlg::ItemSelected( HTREEITEM hItem, int index, bool bEnabled )
{
	if (m_EditItemIndex>=0)
	{
		ApplyEditBox();
		const MenuSkin::Option &option=m_CurrentSkin.Options[m_EditItemIndex];
		wchar_t text[256];
		if (option.bValue && option.type>SKIN_OPTION_BOOL)
			Sprintf(text,_countof(text),L"%s: %s",option.label,option.sValue);
		else
			Sprintf(text,_countof(text),L"%s",option.label);
		TVITEM item={TVIF_TEXT,m_EditItem,0,0,text};
		TreeView_SetItem(m_Tree,&item);
		m_EditItemIndex=-1;
	}
	m_EditItem=NULL;
	TSkinOptionType mode=SKIN_OPTION_NONE;
	CString text;
	if (index>=0)
	{
		const MenuSkin::Option &option=m_CurrentSkin.Options[index];
		if (option.type>SKIN_OPTION_BOOL)
			mode=option.type;
		text=option.sValue;
	}

	RECT rc;
	m_EditMode=mode;
	if (mode!=SKIN_OPTION_NONE)
	{
		CString str=m_CurrentSkin.Options[index].label;
		TVITEM item={TVIF_TEXT,hItem,0,0,(LPWSTR)(LPCWSTR)str};
		TreeView_SetItem(m_Tree,&item);
		m_Tree.GetClientRect(&rc);
		int w=rc.right;
		TreeView_GetItemRect(m_Tree,hItem,&rc,TRUE);
		rc.left=rc.right;
		rc.right=w;
		if (bEnabled && mode>SKIN_OPTION_BOOL)
		{
			m_EditItem=hItem;
			m_EditItemIndex=index;
		}
	}

	if (bEnabled && (mode==SKIN_OPTION_IMAGE || mode==SKIN_OPTION_COLOR))
	{
		RECT rc2=rc;
		int width=(rc2.bottom-rc2.top)*3/2;
		rc2.left=rc2.right-width;
		m_BrowseButton.SetWindowPos(NULL,&rc2,SWP_NOZORDER|SWP_SHOWWINDOW);
		m_BrowseButton.EnableWindow(bEnabled);
		rc.right=rc2.left;
	}
	else
		m_BrowseButton.ShowWindow(SW_HIDE);

	if (bEnabled && mode>SKIN_OPTION_BOOL)
	{
		m_EditBox.SetWindowText(text);
		m_EditBox.SendMessage(EM_SETREADONLY,!bEnabled,0);
		m_EditBox.SetWindowPos(NULL,&rc,SWP_NOZORDER|SWP_SHOWWINDOW);
		SendMessage(WM_NEXTDLGCTL,(LPARAM)m_EditBox.m_hWnd,TRUE);
	}
	else
		m_EditBox.ShowWindow(SW_HIDE);
}

void CSkinSettingsDlg::UpdateEditPosition( void )
{
	if (m_EditMode==SKIN_OPTION_NONE) return;

	RECT rc;
	m_Tree.GetClientRect(&rc);
	int w=rc.right;
	TreeView_GetItemRect(m_Tree,m_EditItem,&rc,TRUE);
	rc.left=rc.right;
	rc.right=w;
	w-=rc.left;
	int width=(rc.bottom-rc.top)*3/2;

	HDC hdc=CreateCompatibleDC(NULL);
	HFONT font0=(HFONT)SelectObject(hdc,m_EditBox.GetFont());
	SIZE size;
	CString str;
	m_EditBox.GetWindowText(str);
	GetTextExtentPoint(hdc,str,str.GetLength(),&size);
	SelectObject(hdc,font0);
	DeleteDC(hdc);
	DWORD margins=(DWORD)m_EditBox.SendMessage(EM_GETMARGINS);
	size.cx+=HIWORD(margins)+LOWORD(margins)+12;
	if (m_EditMode==SKIN_OPTION_IMAGE || m_EditMode==SKIN_OPTION_COLOR)
		size.cx+=width;
	if (size.cx<w)
		rc.right=rc.left+size.cx;

	if (m_EditMode==SKIN_OPTION_IMAGE || m_EditMode==SKIN_OPTION_COLOR)
	{
		RECT rc2=rc;
		rc2.left=rc2.right-width;
		m_BrowseButton.SetWindowPos(NULL,&rc2,SWP_NOZORDER|SWP_NOCOPYBITS);
		rc.right=rc2.left;
	}

	m_EditBox.SetWindowPos(NULL,&rc,SWP_NOZORDER|SWP_NOCOPYBITS);
}

LRESULT CSkinSettingsDlg::OnSize( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	CResizeableDlg<CSkinSettingsDlg>::OnSize();
	UpdateEditPosition();

	CWindow skins=GetDlgItem(IDC_COMBOSKIN);
	CWindow tooltip=TreeView_GetToolTips(m_Tree);
	TOOLINFO tool={sizeof(tool),TTF_SUBCLASS,m_hWnd,'CLSH'};
	skins.GetClientRect(&tool.rect);
	skins.MapWindowPoints(m_hWnd,&tool.rect);
	tooltip.SendMessage(TTM_NEWTOOLRECT,0,(LPARAM)&tool);

	return 0;
}

LRESULT CSkinSettingsDlg::OnSelEndOK( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
	m_SkinIndex=(int)SendDlgItemMessage(IDC_COMBOSKIN,CB_GETCURSEL);
	{
		CSettingsLockWrite lock;
		const wchar_t *strNew=m_SkinIndex==0?L"":m_SkinNames[m_SkinIndex];
		const wchar_t *strOld=m_pSetting[0].value.vt==VT_BSTR?m_pSetting[0].value.bstrVal:L"???";
		if (wcscmp(strNew,strOld)!=0)
			SetSettingsDirty();
		m_pSetting[0].value=CComBSTR(strNew);
	}
	InitSkinUI();
	return 0;
}

static HRESULT CALLBACK TaskDialogCallbackProc( HWND hwnd, UINT uNotification, WPARAM wParam, LPARAM lParam, LONG_PTR dwRefData )
{
	if (uNotification==TDN_HYPERLINK_CLICKED)
	{
		ShellExecute(hwnd,L"open",(const wchar_t*)lParam,NULL,NULL,SW_SHOWNORMAL);
	}
	return S_OK;
}

LRESULT CSkinSettingsDlg::OnAbout( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
	int idx=(int)SendDlgItemMessage(IDC_COMBOSKIN,CB_GETCURSEL,0,0);
	const wchar_t *name=m_SkinNames[idx];
	wchar_t caption[256];
	Sprintf(caption,_countof(caption),LoadStringEx(IDS_SKIN_ABOUT),name);
	if (!m_bLoadSuccess)
	{
		MessageBox(LoadStringEx(IDS_SKIN_FAIL),caption,MB_OK|MB_ICONERROR);
		return TRUE;
	}
	TASKDIALOGCONFIG task={sizeof(task),m_hWnd,NULL,TDF_ENABLE_HYPERLINKS|TDF_ALLOW_DIALOG_CANCELLATION|TDF_USE_HICON_MAIN,TDCBF_OK_BUTTON};
	task.pszWindowTitle=caption;
	task.pszContent=m_CurrentSkin.About;
	task.hMainIcon=m_CurrentSkin.AboutIcon?m_CurrentSkin.AboutIcon:LoadIcon(NULL,IDI_INFORMATION);
	task.pfCallback=TaskDialogCallbackProc;
	TaskDialogIndirect(&task,NULL,NULL,NULL);
	return TRUE;
}

LRESULT CSkinSettingsDlg::OnReset( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
	{
		CSettingsLockWrite lock;
		if (!m_pSetting[0].IsLocked())
			m_pSetting[0].value=m_pSetting[0].defValue;
		if (!m_pSetting[1].IsLocked())
			m_pSetting[1].value=m_pSetting[1].defValue;
		if (!m_pSetting[2].IsLocked())
			m_pSetting[2].value=m_pSetting[2].defValue;
		SetSettingsDirty();
	}
	SetGroup(m_pSetting-1);
	return TRUE;
}

void CSkinSettingsDlg::SetGroup( CSetting *pGroup )
{
	m_pSetting=pGroup+1;
	// the skin settings are never default
	{
		CSettingsLockWrite lock;
		m_pSetting[0].flags&=~CSetting::FLAG_DEFAULT;
		m_pSetting[1].flags&=~CSetting::FLAG_DEFAULT;
		m_pSetting[2].flags&=~CSetting::FLAG_DEFAULT;
	}

	const wchar_t *skin=L"";
	if (m_pSetting[0].value.vt==VT_BSTR)
		skin=m_pSetting[0].value.bstrVal;

	m_SkinIndex=-1;
	if (!*skin)
		SendDlgItemMessage(IDC_COMBOSKIN,CB_SETCURSEL,0);
	else
	{
		int n=(int)m_SkinNames.size();
		for (int i=1;i<n;i++)
		{
			if (_wcsicmp(skin,m_SkinNames[i])==0)
			{
				SendDlgItemMessage(IDC_COMBOSKIN,CB_SETCURSEL,i);
				m_SkinIndex=i;
				break;
			}
		}
	}

	if (m_SkinIndex<0)
	{
		CSettingsLockWrite lock;
		m_pSetting[0].value=CComVariant(m_SkinNames[0]);
		m_pSetting[1].value=CComVariant(L"");
		m_pSetting[2].value=CComVariant(L"");
		SendDlgItemMessage(IDC_COMBOSKIN,CB_SETCURSEL,0);
		m_SkinIndex=0;
	}
	GetDlgItem(IDC_COMBOSKIN).EnableWindow(!m_pSetting[0].IsLocked());

	InitSkinUI();
}

class CSkinSettingsPanel: public ISettingsPanel
{
public:
	CSkinSettingsPanel( MenuSkin::TSkinType skinType ) { m_SkinType=skinType; }
	virtual HWND Create( HWND parent );
	virtual HWND Activate( CSetting *pGroup, const RECT &rect, bool bReset );
	virtual bool Validate( HWND parent ) { return true; }

private:
	MenuSkin::TSkinType m_SkinType;

	static CSkinSettingsDlg s_Dialogs[MenuSkin::SKIN_TYPE_COUNT];
};

CSkinSettingsDlg CSkinSettingsPanel::s_Dialogs[MenuSkin::SKIN_TYPE_COUNT];

HWND CSkinSettingsPanel::Create( HWND parent )
{
	CSkinSettingsDlg &dlg=s_Dialogs[m_SkinType];
	if (!dlg.m_hWnd)
		dlg.Create(m_SkinType,parent,LoadDialogEx(IDD_SKINSETTINGS));
	return dlg.m_hWnd;
}

HWND CSkinSettingsPanel::Activate( CSetting *pGroup, const RECT &rect, bool bReset )
{
	CSkinSettingsDlg &dlg=s_Dialogs[m_SkinType];
	dlg.SetGroup(pGroup);
	dlg.SetWindowPos(HWND_TOP,&rect,SWP_SHOWWINDOW);
	return dlg.m_hWnd;
}

static CSkinSettingsPanel g_SkinSettingsPanelClassic1(MenuSkin::SKIN_TYPE_CLASSIC1);
static CSkinSettingsPanel g_SkinSettingsPanelClassic2(MenuSkin::SKIN_TYPE_CLASSIC2);
static CSkinSettingsPanel g_SkinSettingsPanelWin7(MenuSkin::SKIN_TYPE_WIN7);
static CSkinSettingsPanel g_SkinSettingsPanelAll(MenuSkin::SKIN_TYPE_ALL_PROGRAMS);

///////////////////////////////////////////////////////////////////////////////

static const CStdCommand g_StdCommands[]={
	{L"SEPARATOR",IDS_SEPARATOR_ITEM,IDS_SEPARATOR_TIP},
	{L"COLUMN_BREAK",IDS_COLUMN_BREAK_ITEM,IDS_BREAK_TIP},
	{L"COLUMN_PADDING",IDS_COLUMN_PADDING_ITEM,IDS_PADDING_TIP},
	{L"programs",IDS_PROGRAMS_ITEM,IDS_PROGRAMS_TIP,L"ProgramsMenu",L"$Menu.Programs",L"$Menu.ProgramsTip",L"shell32.dll,326",&FOLDERID_Programs,StdMenuItem::MENU_TRACK},
	{L"apps",IDS_APPS_ITEM,IDS_APPS_TIP,L"AppsMenu",L"$Menu.Apps",L"",L",2",NULL,StdMenuItem::MENU_TRACK},
	{L"favorites",IDS_SHOW_FAVORITES,IDS_FAVORITES_TIP,L"FavoritesItem",L"$Menu.Favorites",L"",L"imageres.dll,1024",&FOLDERID_Favorites},
	{L"recent_documents",IDS_SHOW_DOCUMENTS,IDS_DOCUMENTS_TIP,L"RecentDocumentsItem",L"$Menu.Documents",L"",L"shell32.dll,327",&FOLDERID_Recent,StdMenuItem::MENU_ITEMS_FIRST},
	{L"computer",IDS_SHOW_COMPUTER,IDS_COMPUTER_TIP,L"ComputerItem",L"",L"",L"",&FOLDERID_ComputerFolder},
	{L"settings",IDS_SETTINGS_ITEM,IDS_SETTINGS_MENU_TIP,L"SettingsMenu",L"$Menu.Settings",L"",L"shell32.dll,330"},