SettingsUIHelper.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 "Settings.h"
#include "SettingsUIHelper.h"
#include "ResourceHelper.h"
#include "ComHelper.h"
#include "FNVHash.h"
#include "StringUtils.h"
#include "Translations.h"
#include "DownloadHelper.h"
#include <uxtheme.h>
#include <map>
#include <algorithm>

const KNOWNFOLDERID FOLDERID_DesktopRoot={'DESK', 'TO', 'P', {'D', 'E', 'S', 'K', 'T', 'O', 'P', 0x00}};

static bool IsVariantTrue( const CComVariant &var )
{
	return (var.vt==VT_I4 && var.intVal==1);
}

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

void CTreeItem::SetCommand( CString command, const CStdCommand *pStdCommands, int style, int mask )
{
	this->command=command;
	pStdCommand=NULL;
	for (int i=0;pStdCommands[i].name;i++)
	{
		if (!pStdCommands[i].IsStyle(style,mask)) continue;
		if (_wcsicmp(pStdCommands[i].name,command)==0)
		{
			pStdCommand=&pStdCommands[i];
			return;
		}
		else if (pStdCommands[i].IsCustom())
		{
			pStdCommand=&pStdCommands[i];
		}
	}
}

unsigned int CTreeItem::GetIconKey( void ) const
{
	if (!icon.IsEmpty())
		return CalcFNVHash(icon);
	else if (pStdCommand && pStdCommand->knownFolder)
		return CalcFNVHash(pStdCommand->knownFolder,sizeof(GUID));
	else if (!link.IsEmpty())
		return CalcFNVHash(link);
	return 0;
}

HICON CTreeItem::LoadIcon( bool bSmall, std::vector<HMODULE> &modules ) const
{
	if (!icon.IsEmpty())
	{
		if (_wcsicmp(icon,L"none")==0)
			return bSmall?HICON_NONE:NULL;
		return ::LoadIcon(GetSystemMetrics(bSmall?SM_CXSMICON:SM_CXICON),icon,modules);
	}
	else
	{
		CAbsolutePidl pidl;
		if (pStdCommand && pStdCommand->knownFolder)
		{
			SHGetKnownFolderIDList(*pStdCommand->knownFolder,0,NULL,&pidl);
		}
		else if (!link.IsEmpty())
		{
			const wchar_t *c=wcschr(link,'|');
			if (c)
			{
				for (c++;*c==' ';)
					c++;
			}
			else
				c=link;
			wchar_t buf[_MAX_PATH];
			Strcpy(buf,_countof(buf),c);
			DoEnvironmentSubst(buf,_countof(buf));

			wchar_t *second=wcschr(buf,';');
			if (second)
			{
				wchar_t *end= second;
				while (end>buf)
				{
					*end=0;
					end--;
					if (*end!=' ')
						break;
				}
			}

			ShParseDisplayName(buf,&pidl,0,NULL);
		}
		if (pidl)
		{
			HICON hIcon=::LoadIcon(GetSystemMetrics(bSmall?SM_CXSMICON:SM_CXICON),pidl);
			return hIcon;
		}
	}
	return NULL;
}

unsigned int CTreeItem::GetIconDKey( unsigned int iconKey ) const
{
	if (iconD.IsEmpty())
		return ~iconKey;
	return CalcFNVHash(iconD);
}

HICON CTreeItem::LoadIconD( HICON hIcon, std::vector<HMODULE> &modules ) const
{
	if (!iconD.IsEmpty())
	{
		if (_wcsicmp(iconD,L"none")==0)
			return NULL;
		return ::LoadIcon(GetSystemMetrics(SM_CXICON),iconD,modules);
	}
	else if (hIcon)
		return CreateDisabledIcon(hIcon,GetSystemMetrics(SM_CXICON));
	else
		return NULL;
}

CString CTreeItem::GetDisplayName( bool bTitle ) const
{
	if (pStdCommand->IsCustom())
	{
		if (!label.IsEmpty())
		{
			if (label[0]!='$')
				return label;
			const wchar_t *pLabel=label;
			return FindTranslation(pLabel+1,pLabel);
		}
		if (!bTitle && !link.IsEmpty())
		{
			const wchar_t *c=wcschr(link,'|');
			if (c)
			{
				for (c++;*c==' ';)
					c++;
			}
			else
				c=link;
			wchar_t buf[_MAX_PATH];
			Strcpy(buf,_countof(buf),c);
			DoEnvironmentSubst(buf,_countof(buf));

			wchar_t *second=wcschr(buf,';');
			if (second)
			{
				wchar_t *end= second;
				while (end>buf)
				{
					*end=0;
					end--;
					if (*end!=' ')
						break;
				}
			}

			CAbsolutePidl pidl;
			ShParseDisplayName(buf,&pidl,0,NULL);
			if (pidl)
			{
				CComPtr<IShellItem> pItem;
				if (SUCCEEDED(SHCreateItemFromIDList(pidl,IID_IShellItem,(void**)&pItem)))
				{
					CComString pName;
					if (SUCCEEDED(pItem->GetDisplayName(SIGDN_NORMALDISPLAY,&pName)))
					{
						CString name;
						name.Format(L"%s (%s)",LoadStringEx(pStdCommand->displayNameId),pName);
						return name;
					}
				}
			}
		}
		if (!bTitle && !tip.IsEmpty())
		{
			const wchar_t *pTip=tip;
			CString name;
			if (pTip[0]=='$')
				name.Format(L"%s (%s)",LoadStringEx(pStdCommand->displayNameId),FindTranslation(pTip+1,pTip));
			else
				name.Format(L"%s (%s)",LoadStringEx(pStdCommand->displayNameId),pTip);
			return name;
		}
	}
	return LoadStringEx(pStdCommand->displayNameId);
}

// Subclass the renaming editbox to handle Esc and Enter
static LRESULT CALLBACK SubclassEditboxProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
	if (uMsg==WM_GETDLGCODE)
		return DLGC_WANTALLKEYS;
	return DefSubclassProc(hWnd,uMsg,wParam,lParam);
}

class CSettingsTree: public CWindowImpl<CSettingsTree, CWindow>
{
public:
	BEGIN_MSG_MAP( CSettingsTree )
		MESSAGE_HANDLER( WM_DESTROY, OnDestroy )
		MESSAGE_HANDLER( WM_MOUSEMOVE, OnMouseMove )
		MESSAGE_HANDLER( WM_LBUTTONUP, OnLButtonUp )
		MESSAGE_HANDLER( WM_RBUTTONDOWN, OnRButtonDown )
		MESSAGE_HANDLER( WM_KEYUP, OnKeyUp )
		MESSAGE_HANDLER( WM_GETDLGCODE, OnGetDlgCode )
		MESSAGE_HANDLER( WM_CHAR, OnChar )
		MESSAGE_HANDLER( WM_CAPTURECHANGED, OnCaptureChanged )
		MESSAGE_HANDLER( WM_TIMER, OnTimer )
		REFLECTED_NOTIFY_CODE_HANDLER( TVN_DELETEITEM, OnDeleteItem )
		REFLECTED_NOTIFY_CODE_HANDLER( TVN_BEGINDRAG, OnBeginDrag )
		REFLECTED_NOTIFY_CODE_HANDLER( TVN_BEGINLABELEDIT, OnBeginLabelEdit )
		REFLECTED_NOTIFY_CODE_HANDLER( TVN_ENDLABELEDIT, OnEndLabelEdit )
		REFLECTED_NOTIFY_CODE_HANDLER( TVN_KEYDOWN, OnKeyDown )
	END_MSG_MAP()

	CSettingsTree( int mask ) { m_ImageList=NULL; m_StyleMask=mask; }
	void SubclassWindow( HWND hWnd, CCustomTreeDlg *pOwner );
	int LoadIcon( const CTreeItem *pItem );
	int UpdateItem( CTreeItem *pItem, HTREEITEM hItem );
	void SetDisabled( bool bDisabled ) { m_bDisabled=bDisabled; }
	bool IsDragging( void ) const { return m_DragMode!=DRAG_NONE; }

	void DeleteItem( HTREEITEM hItem );

	void BeginDrag( const CStdCommand *pCommand );
	HTREEITEM CreateStdItem( const CStdCommand *pCommand, HTREEITEM hParent, HTREEITEM hAfter );

	std::vector<HMODULE> m_Modules;

protected:
	LRESULT OnDestroy( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnMouseMove( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnLButtonUp( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnRButtonDown( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnKeyUp( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnGetDlgCode( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnChar( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnCaptureChanged( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnTimer( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnDeleteItem( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnBeginDrag( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnBeginLabelEdit( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnEndLabelEdit( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );
	LRESULT OnKeyDown( int idCtrl, LPNMHDR pnmh, BOOL& bHandled );

private:
	CCustomTreeDlg *m_pOwner;
	std::map<unsigned int,int> m_IconCache;
	HIMAGELIST m_ImageList;
	bool m_bDisabled;

	enum TDragMode
	{
		DRAG_NONE,
		DRAG_DELETE,
		DRAG_ERROR,
		DRAG_MOVE, // these must be the last two
		DRAG_COPY,
	};

	enum TDropLocation
	{
		DROP_NOWHERE,
		DROP_INSIDE,
		DROP_BEFORE,
		DROP_AFTER,
		DROP_LAST,
	};

	enum {
		TIMER_SCROLL=1,
		TIMER_HOVER=2,
	};

	int m_StyleMask;
	TDragMode m_DragMode;
	HCURSOR m_CursorError, m_CursorMove, m_CursorCopy, m_CursorDel;
	HTREEITEM m_DragItem;
	HTREEITEM m_DropTarget;
	HTREEITEM m_DropSubmenu;
	TDropLocation m_DropLocation;
	int m_Scroll;
	HTREEITEM m_HoverItem;
	const CStdCommand *m_pStdDragItem;
	bool m_bDragLink; // the item being dragged is a link

	bool FindItemByName( HTREEITEM hParent, const wchar_t *name, HTREEITEM hExclude );
	CString CreateUniqueName( CString oldName );
	HTREEITEM CreateDeepCopy( HTREEITEM hSource, HTREEITEM hParent, HTREEITEM hAfter, bool bRename );
};

void CSettingsTree::SubclassWindow( HWND hWnd, CCustomTreeDlg *pOwner )
{
	m_pOwner=pOwner;
	int size=GetSystemMetrics(SM_CXSMICON);
	if (!m_ImageList)
		m_ImageList=ImageList_Create(size,size,ILC_COLOR32|ILC_MASK|ILC_MIRROR,1,16);
	CWindowImpl<CSettingsTree, CWindow>::SubclassWindow(hWnd);
	TreeView_SetImageList(hWnd,m_ImageList,TVSIL_NORMAL);

	BITMAPINFO bi={0};
	bi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
	bi.bmiHeader.biWidth=bi.bmiHeader.biHeight=size;
	bi.bmiHeader.biPlanes=1;
	bi.bmiHeader.biBitCount=32;
	RECT rc={0,0,size,size};

	HDC hdc=CreateCompatibleDC(NULL);
	HBITMAP bmp=CreateDIBSection(hdc,&bi,DIB_RGB_COLORS,NULL,NULL,0);
	HGDIOBJ bmp0=SelectObject(hdc,bmp);
	FillRect(hdc,&rc,(HBRUSH)(COLOR_WINDOW+1));
	SelectObject(hdc,bmp0);
	DeleteDC(hdc);
	ImageList_AddMasked(m_ImageList,bmp,GetSysColor(COLOR_WINDOW));
	DeleteObject(bmp);

	SHFILEINFO info;
	if (SHGetFileInfo(L"file",FILE_ATTRIBUTE_NORMAL,&info,sizeof(info),SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_SMALLICON))
	{
		ImageList_AddIcon(m_ImageList,info.hIcon);
		DestroyIcon(info.hIcon);
	}
	m_DragMode=DRAG_NONE;
	HMODULE hOle32=LoadLibrary(L"ole32.dll");
	if (hOle32)
	{
		m_CursorError=(HCURSOR)LoadImage(hOle32,MAKEINTRESOURCE(1),IMAGE_CURSOR,0,0,LR_DEFAULTSIZE);
		m_CursorMove=(HCURSOR)LoadImage(hOle32,MAKEINTRESOURCE(2),IMAGE_CURSOR,0,0,LR_DEFAULTSIZE);
		m_CursorCopy=(HCURSOR)LoadImage(hOle32,MAKEINTRESOURCE(3),IMAGE_CURSOR,0,0,LR_DEFAULTSIZE);
		m_CursorDel=(HCURSOR)LoadImage(hOle32,MAKEINTRESOURCE(5),IMAGE_CURSOR,0,0,LR_DEFAULTSIZE);
		FreeLibrary(hOle32);
	}
}

int CSettingsTree::LoadIcon( const CTreeItem *pItem )
{
	unsigned int key=pItem->GetIconKey();
	std::map<unsigned int,int>::const_iterator it=m_IconCache.find(key);
	if (it!=m_IconCache.end())
		return it->second;

	// extract icon
	HICON hIcon=pItem->LoadIcon(true,m_Modules);
	if (hIcon==HICON_NONE)
	{
		m_IconCache[key]=0;
		return 0;
	}
	int index=1;
	if (hIcon)
	{
		index=ImageList_AddIcon(m_ImageList,hIcon);
		DestroyIcon(hIcon);
	}
	m_IconCache[key]=index;
	return index;
}

int CSettingsTree::UpdateItem( CTreeItem *pItem, HTREEITEM hItem )
{
	TVITEM item={TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_TEXT,hItem};

	item.iImage=item.iSelectedImage=LoadIcon(pItem);
	if (hItem)
	{
		CString dispName=pItem->GetDisplayName(false);
		item.pszText=(LPWSTR)(LPCWSTR)dispName;
		TreeView_SetItem(m_hWnd,&item);
	}
	return item.iImage;
}

LRESULT CSettingsTree::OnDestroy( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	for (std::vector<HMODULE>::const_iterator it=m_Modules.begin();it!=m_Modules.end();++it)
		FreeLibrary(*it);
	m_Modules.clear();
	if (m_CursorError) DestroyCursor(m_CursorError);
	if (m_CursorMove) DestroyCursor(m_CursorMove);
	if (m_CursorCopy) DestroyCursor(m_CursorCopy);
	if (m_CursorDel) DestroyCursor(m_CursorDel);
	return 0;
}

LRESULT CSettingsTree::OnDeleteItem( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	// free data
	NMTREEVIEW *pItem=(NMTREEVIEW*)pnmh;
	delete (CTreeItem*)pItem->itemOld.lParam;
	return 0;
}

void CSettingsTree::BeginDrag( const CStdCommand *pCommand )
{
	if (m_bDisabled) return;
	m_pStdDragItem=pCommand;
	m_bDragLink=pCommand->knownFolder!=NULL;
	m_DragItem=TreeView_GetSelection(m_hWnd);
	SetFocus();
	SetCapture();
	m_DragMode=DRAG_COPY;
	m_DropTarget=NULL;
	m_DropLocation=DROP_NOWHERE;
	m_Scroll=0;
	m_HoverItem=NULL;
	m_DropSubmenu=NULL;
	SetCursor(m_CursorCopy);
	TreeView_SelectItem(m_hWnd,NULL);
}

LRESULT CSettingsTree::OnBeginDrag( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	if (m_bDisabled) return 0;
	NMTREEVIEW *pDrag=(NMTREEVIEW*)pnmh;
	CTreeItem *pItem=(CTreeItem*)pDrag->itemNew.lParam;
	if (!pItem) return 0;
	m_pStdDragItem=NULL;
	m_DragItem=pDrag->itemNew.hItem;
	m_bDragLink=(pItem->pStdCommand && pItem->pStdCommand->knownFolder) || !pItem->link.IsEmpty();
	TreeView_SelectItem(m_hWnd,m_DragItem);
	SetCapture();
	m_DragMode=GetKeyState(VK_CONTROL)<0?DRAG_COPY:DRAG_MOVE;
	m_DropTarget=NULL;
	m_DropLocation=DROP_NOWHERE;
	m_Scroll=0;
	m_HoverItem=NULL;
	m_DropSubmenu=NULL;
	SetCursor(m_DragMode==DRAG_COPY?m_CursorCopy:m_CursorMove);
	SetFocus();
	TreeView_SelectItem(m_hWnd,NULL);
	return 0;
}

LRESULT CSettingsTree::OnMouseMove( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_DragMode==DRAG_NONE)
	{
		bHandled=FALSE;
		return 0;
	}
	// find the drop location
	m_DropTarget=NULL;
	m_DropLocation=DROP_NOWHERE;
	TVHITTESTINFO test={{(short)LOWORD(lParam),(short)HIWORD(lParam)}};
	RECT rc;
	GetClientRect(&rc);
	int h=TreeView_GetItemHeight(m_hWnd);
	int scroll=0;
	if (test.pt.y<h)
		scroll=-1;
	if (test.pt.y>rc.bottom-h)
		scroll=1;
	if (m_Scroll!=scroll)
	{
		m_Scroll=scroll;
		if (m_Scroll)
			SetTimer(TIMER_SCROLL,100);
		else
			KillTimer(TIMER_SCROLL);
	}
	bool bDelete=!PtInRect(&rc,test.pt);
	if (!bDelete)
	{
		HTREEITEM hLast=TreeView_GetLastVisible(m_hWnd);
		if (hLast)
		{
			TreeView_GetItemRect(m_hWnd,hLast,&rc,FALSE);
			if (TreeView_HitTest(m_hWnd,&test))
			{
				m_DropTarget=test.hItem;
			}
			else
			{
				if (test.pt.y>=rc.bottom)
				{
					// after the last visible item
					m_DropTarget=hLast;
				}
			}
		}
		else if (m_pStdDragItem)
			m_DropLocation=DROP_LAST;

		if (m_DropTarget && !m_pStdDragItem)
		{
			// can't drop inside itself
			for (HTREEITEM hItem=TreeView_GetParent(m_hWnd,m_DropTarget);hItem;hItem=TreeView_GetParent(m_hWnd,hItem))
			{
				if (hItem==m_DragItem)
				{
					m_DropTarget=NULL;
					break;
				}
			}
		}
		if (m_DropTarget)
		{
			TreeView_GetItemRect(m_hWnd,m_DropTarget,&rc,FALSE);
			TVITEM item={TVIF_PARAM,m_DropTarget};
			TreeView_GetItem(m_hWnd,&item);
			int dy=test.pt.y-rc.top;
			int h1=(rc.bottom-rc.top)/4;
			int h2=(rc.bottom-rc.top)-h1;
			if (!item.lParam || ((CTreeItem*)item.lParam)->pStdCommand->IsSeparator())
			{
				h1=(rc.bottom-rc.top)/2;
				h2=(rc.bottom-rc.top)-h1;
			}
			if (dy<h1)
				m_DropLocation=DROP_BEFORE;
			else if (dy>=h2)
				m_DropLocation=DROP_AFTER;
			else
			{
				// can't drop in a separator or itself
				if (!item.lParam || ((CTreeItem*)item.lParam)->pStdCommand->IsSeparator() || (m_DropTarget==m_DragItem && !m_pStdDragItem))
					m_DropTarget=NULL;
				else
					m_DropLocation=DROP_INSIDE;
			}
		}
	}
	// display drop location
	if (!m_DropTarget)
	{
		TreeView_SelectDropTarget(m_hWnd,NULL);
		TreeView_SetInsertMark(m_hWnd,NULL,FALSE);
		if (m_DropLocation==DROP_LAST)
		{
			m_DragMode=DRAG_COPY;
			SetCursor(m_CursorCopy);
		}
		else
		{
			if (m_pStdDragItem)
				bDelete=false;
			m_DragMode=bDelete?DRAG_DELETE:DRAG_ERROR;
			SetCursor(bDelete?m_CursorDel:m_CursorError);
		}
	}
	else
	{
		m_DragMode=(m_pStdDragItem || GetKeyState(VK_CONTROL)<0)?DRAG_COPY:DRAG_MOVE;
		SetCursor(m_DragMode==DRAG_COPY?m_CursorCopy:m_CursorMove);
		if (m_DropLocation==DROP_INSIDE)
		{
			TreeView_SelectDropTarget(m_hWnd,m_DropTarget);
			TreeView_SetInsertMark(m_hWnd,NULL,FALSE);
		}
		else
		{
			TreeView_SelectDropTarget(m_hWnd,NULL);
			TreeView_SetInsertMark(m_hWnd,m_DropTarget,m_DropLocation==DROP_AFTER);
		}
	}

	if (m_DropLocation==DROP_INSIDE)
	{
		if (m_HoverItem!=m_DropTarget)
		{
			SetTimer(TIMER_HOVER,400);
			m_HoverItem=m_DropTarget;
		}
	}
	else if (m_HoverItem)
	{
		m_HoverItem=NULL;
		KillTimer(TIMER_HOVER);
	}
	return 0;
}

bool CSettingsTree::FindItemByName( HTREEITEM hParent, const wchar_t *name, HTREEITEM hExclude )
{
	for (HTREEITEM hItem=hParent?TreeView_GetChild(m_hWnd,hParent):TreeView_GetRoot(m_hWnd);hItem;hItem=TreeView_GetNextSibling(m_hWnd,hItem))
	{
		if (FindItemByName(hItem,name,hExclude))
			return true;
		if (hItem!=hExclude)
		{
			TVITEM item={TVIF_PARAM,hItem};
			TreeView_GetItem(m_hWnd,&item);
			if (item.lParam && _wcsicmp(((CTreeItem*)item.lParam)->name,name)==0)
				return true;
		}
	}
	return false;
}

CString CSettingsTree::CreateUniqueName( CString oldName )
{
	if (!FindItemByName(NULL,oldName,NULL))
		return oldName;
	wchar_t name[256];
	Strcpy(name,_countof(name)-3,oldName);
	// find numeric part
	int pos=Strlen(name);
	while (pos>0 && name[pos-1]>='0' && name[pos-1]<='9')
		pos--;
	for (int i=2;;i++)
	{
		Sprintf(name+pos,_countof(name)-pos,L"%d",i);
		if (!FindItemByName(NULL,name,NULL))
			break;
	}
	return name;
}

HTREEITEM CSettingsTree::CreateDeepCopy( HTREEITEM hSource, HTREEITEM hParent, HTREEITEM hAfter, bool bRename )
{
	TVINSERTSTRUCT insert={hParent,hAfter?hAfter:TVI_FIRST,{TVIF_PARAM|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_STATE,hSource,0,TVIS_EXPANDED}};
	TreeView_GetItem(m_hWnd,&insert.item);
	CTreeItem *pSource=(CTreeItem*)insert.item.lParam;
	if (!pSource) return NULL;
	CTreeItem *pNewItem=new CTreeItem(*pSource);
	if (bRename && !pNewItem->pStdCommand->IsSeparator())
	{
		pNewItem->name=CreateUniqueName(pNewItem->name);
	}
	insert.item.lParam=(LPARAM)pNewItem;
	insert.item.mask|=TVIF_TEXT;
	CString dispName=pNewItem->GetDisplayName(false);
	insert.item.pszText=(LPWSTR)(LPCWSTR)dispName;
	HTREEITEM hResult=TreeView_InsertItem(m_hWnd,&insert);
	for (HTREEITEM hChild=TreeView_GetChild(m_hWnd,hSource);hChild;hChild=TreeView_GetNextSibling(m_hWnd,hChild))
		CreateDeepCopy(hChild,hResult,TVI_LAST,bRename);
	return hResult;
}

HTREEITEM CSettingsTree::CreateStdItem( const CStdCommand *pCommand, HTREEITEM hParent, HTREEITEM hAfter )
{
	TVINSERTSTRUCT insert={hParent,hAfter?hAfter:TVI_FIRST,{TVIF_PARAM|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_STATE|TVIF_TEXT,NULL,TVIS_EXPANDED,TVIS_EXPANDED}};
	CTreeItem *pNewItem=new CTreeItem;
	pNewItem->label=pCommand->label;
	pNewItem->tip=pCommand->tip;
	pNewItem->icon=pCommand->icon;
	pNewItem->iconD=pCommand->iconD;
	pNewItem->pStdCommand=pCommand;
	pNewItem->settings=pCommand->settings&~m_StyleMask;

	if (pCommand->IsSeparator())
	{
		pNewItem->name=pCommand->name;
	}
	else
	{
		pNewItem->command=pCommand->name;
		pNewItem->name=CreateUniqueName(pCommand->itemName);
		insert.item.iImage=insert.item.iSelectedImage=UpdateItem(pNewItem,NULL);
	}

	insert.item.lParam=(LPARAM)pNewItem;
	CString dispName=pNewItem->GetDisplayName(false);
	insert.item.pszText=(LPWSTR)(LPCWSTR)dispName;
	return TreeView_InsertItem(m_hWnd,&insert);
}

LRESULT CSettingsTree::OnRButtonDown( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	// ignore right-click during dragging
	if (m_DragMode==DRAG_NONE)
		bHandled=FALSE;
	return 0;
}

LRESULT CSettingsTree::OnLButtonUp( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_DragMode!=DRAG_NONE)
	{
		TDragMode mode=m_DragMode;
		HTREEITEM dragItem=m_DragItem;
		if (m_DropSubmenu==m_DropTarget && mode>=DRAG_MOVE)
			m_DropSubmenu=NULL;
		m_DragItem=NULL;
		ReleaseCapture();
		// perform drop operation
		if (mode==DRAG_DELETE)
		{
			TreeView_EnsureVisible(m_hWnd,dragItem);
			if (!m_pStdDragItem)
			{
				TreeView_DeleteItem(m_hWnd,dragItem);
				m_pOwner->SerializeData();
			}
		}
		else if (mode>=DRAG_MOVE)
		{
			HTREEITEM hParent=m_DropTarget;
			HTREEITEM hAfter=TVI_LAST;
			if (m_DropLocation==DROP_AFTER)
			{
				hAfter=hParent;
				hParent=TreeView_GetParent(m_hWnd,hParent);
			}
			else if (m_DropLocation==DROP_BEFORE)
			{
				hAfter=TreeView_GetPrevSibling(m_hWnd,hParent);
				if (!hAfter) hAfter=TVI_FIRST;
				hParent=TreeView_GetParent(m_hWnd,hParent);
			}
			if (hParent)
			{
				HTREEITEM hChild=TreeView_GetChild(m_hWnd,hParent);
				if (hChild)
				{
					TVITEM item={TVIF_PARAM,hChild};
					TreeView_GetItem(m_hWnd,&item);
					if (!item.lParam)
					{
						TreeView_DeleteItem(m_hWnd,hChild);
						hAfter=TVI_LAST;
					}
				}
			}

			HTREEITEM hNewItem;
			if (m_pStdDragItem)
			{
				hNewItem=CreateStdItem(m_pStdDragItem,hParent,hAfter);
			}
			else
			{
				hNewItem=CreateDeepCopy(dragItem,hParent,hAfter,mode==DRAG_COPY);
				if (mode==DRAG_MOVE)
					TreeView_DeleteItem(m_hWnd,dragItem);
			}

			TreeView_SelectItem(m_hWnd,hNewItem);
			TreeView_EnsureVisible(m_hWnd,hNewItem);
			m_pOwner->SerializeData();
		}
	}
	bHandled=FALSE;
	return 0;
}

LRESULT CSettingsTree::OnKeyUp( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_DragMode>=DRAG_MOVE)
	{
		m_DragMode=(m_pStdDragItem || GetKeyState(VK_CONTROL)<0)?DRAG_COPY:DRAG_MOVE;
		SetCursor(m_DragMode==DRAG_COPY?m_CursorCopy:m_CursorMove);
	}
	bHandled=FALSE;
	return 0;
}

LRESULT CSettingsTree::OnGetDlgCode( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_DragMode!=DRAG_NONE || (lParam && ((MSG*)lParam)->message==WM_KEYDOWN && ((MSG*)lParam)->wParam==VK_RETURN))
		return DLGC_WANTALLKEYS;
	bHandled=FALSE;
	return 0;
}

LRESULT CSettingsTree::OnChar( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (wParam==VK_RETURN)
		return 0;
	bHandled=FALSE;
	return 0;
}

LRESULT CSettingsTree::OnCaptureChanged( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_DragMode!=DRAG_NONE)
	{
		m_DragMode=DRAG_NONE;
		TreeView_SelectDropTarget(m_hWnd,NULL);
		TreeView_SetInsertMark(m_hWnd,NULL,FALSE);
		SetCursor(LoadCursor(NULL,IDC_ARROW));
		if (m_DragItem) TreeView_SelectItem(m_hWnd,m_DragItem);
		KillTimer(TIMER_SCROLL);
		KillTimer(TIMER_HOVER);
		if (m_DropSubmenu)
			TreeView_DeleteItem(m_hWnd,m_DropSubmenu);
		m_DropSubmenu=NULL;
		m_HoverItem=NULL;
	}
	bHandled=FALSE;
	return 0;
}

LRESULT CSettingsTree::OnTimer( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (wParam==TIMER_SCROLL)
	{
		if (m_Scroll>0)
			SendMessage(WM_VSCROLL,SB_LINEDOWN);
		else
			SendMessage(WM_VSCROLL,SB_LINEUP);
	}
	else if (wParam==TIMER_HOVER)
	{
		if (m_HoverItem)
		{
			TreeView_Expand(m_hWnd,m_HoverItem,TVE_EXPAND);
			if (!TreeView_GetChild(m_hWnd,m_HoverItem))
			{
				if (m_DropSubmenu)
					TreeView_DeleteItem(m_hWnd,m_DropSubmenu);
				TVINSERTSTRUCT insert={m_HoverItem,TVI_FIRST,{TVIF_PARAM|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_STATE|TVIF_TEXT,NULL,TVIS_EXPANDED,TVIS_EXPANDED}};
				CString text=LoadStringEx(IDS_EMPTY_MENU);
				insert.item.pszText=(LPWSTR)(LPCWSTR)text;
				m_DropSubmenu=TreeView_InsertItem(m_hWnd,&insert);
				TreeView_SelectItem(m_hWnd,m_DropSubmenu);
				TreeView_EnsureVisible(m_hWnd,m_DropSubmenu);
			}
		}
		KillTimer(TIMER_HOVER);
	}
	else
		bHandled=FALSE;
	return 0;
}

LRESULT CSettingsTree::OnBeginLabelEdit( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	if (m_bDisabled) return TRUE;
	CWindow edit=TreeView_GetEditControl(m_hWnd);
	SetWindowSubclass(edit,SubclassEditboxProc,'CLSH',0);
	NMTVDISPINFO *pInfo=(NMTVDISPINFO*)pnmh;
	if (!pInfo->item.lParam)
		return TRUE;
	CTreeItem *pItem=(CTreeItem*)pInfo->item.lParam;
	if (!pItem->pStdCommand->IsCustom())
		return TRUE;
	edit.SetWindowText(pItem->label);
	return FALSE;
}

LRESULT CSettingsTree::OnEndLabelEdit( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	NMTVDISPINFO *pInfo=(NMTVDISPINFO*)pnmh;
	if (pInfo->item.pszText)
	{
		CTreeItem *pItem=(CTreeItem*)pInfo->item.lParam;
		pItem->label=pInfo->item.pszText;
		m_pOwner->SerializeData();
		UpdateItem(pItem,pInfo->item.hItem);
	}
	return FALSE;
}

LRESULT CSettingsTree::OnKeyDown( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
	NMTVKEYDOWN *pKey=(NMTVKEYDOWN*)pnmh;
	if (m_DragMode!=DRAG_NONE)
	{
		if (pKey->wVKey==VK_ESCAPE)
		{
			ReleaseCapture();
			return TRUE;
		}
		if (m_DragMode>=DRAG_MOVE)
		{
			m_DragMode=(m_pStdDragItem || GetKeyState(VK_CONTROL)<0)?DRAG_COPY:DRAG_MOVE;
			SetCursor(m_DragMode==DRAG_COPY?m_CursorCopy:m_CursorMove);
		}
	}
	// F2 to rename
	if (pKey->wVKey==VK_F2)
	{
		HTREEITEM hSelected=TreeView_GetSelection(m_hWnd);
		if (hSelected)
			TreeView_EditLabel(m_hWnd,hSelected);
	}
	// Del to delete
	if (pKey->wVKey==VK_DELETE)
	{
		HTREEITEM hSelected=TreeView_GetSelection(m_hWnd);
		if (hSelected)
			DeleteItem(hSelected);
	}
	return 0;
}

void CSettingsTree::DeleteItem( HTREEITEM hItem )
{
	if (!m_bDisabled)
	{
		TreeView_DeleteItem(m_hWnd,hItem);
		m_pOwner->SerializeData();
	}
}

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

class CCommandsTree: public CWindowImpl<CCommandsTree, CWindow>
{
public:
	BEGIN_MSG_MAP( CCommandsTree )
		MESSAGE_HANDLER( WM_GETDLGCODE, OnGetDlgCode )
		MESSAGE_HANDLER( WM_CHAR, OnChar )
	END_MSG_MAP()

protected:
	LRESULT OnGetDlgCode( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnChar( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
};

LRESULT CCommandsTree::OnGetDlgCode( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (lParam && ((MSG*)lParam)->message==WM_KEYDOWN && ((MSG*)lParam)->wParam==VK_RETURN)
		return DLGC_WANTALLKEYS;
	bHandled=FALSE;
	return 0;
}

LRESULT CCommandsTree::OnChar( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (wParam==VK_RETURN)
		return 0;
	bHandled=FALSE;
	return 0;
}

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

CEditCustomItemDlg::~CEditCustomItemDlg( void )
{
	if (m_hIcon) DestroyIcon(m_hIcon);
	if (m_hIconD) DestroyIcon(m_hIconD);
}

void CEditCustomItemDlg::InitDialog( CWindow commandCombo, const CStdCommand *pStdcommands, int style, int mask, CWindow linkCombo, const KNOWNFOLDERID *const *pCommonLinks )
{
	InitResize(MOVE_HORIZONTAL|MOVE_GRIPPER);
	CString str;
	GetWindowText(str);
	CString title;
	title.Format(str,m_pItem->GetDisplayName(true));
	SetWindowText(title);

	for (int i=0;pStdcommands[i].name;i++)
		if (pStdcommands[i].IsStyle(style,mask) && !pStdcommands[i].IsSeparator() && !pStdcommands[i].IsCustom())
			commandCombo.SendMessage(CB_ADDSTRING,0,(LPARAM)pStdcommands[i].name);

	commandCombo.SetWindowText(m_pItem->command);
	int idx=(int)commandCombo.SendMessage(CB_FINDSTRINGEXACT,-1,(LPARAM)(const wchar_t*)m_pItem->command);
	if (idx>=0)
		commandCombo.SendMessage(CB_SETCURSEL,idx);

	for (int i=0;pCommonLinks[i];i++)
	{
		if (*pCommonLinks[i]==FOLDERID_DesktopRoot)
		{
			linkCombo.SendMessage(CB_ADDSTRING,0,(LPARAM)L"Main Desktop | ::{Desktop}");
		}
		else
		{
			CAbsolutePidl path;
			if (FAILED(SHGetKnownFolderIDList(*pCommonLinks[i],0,NULL,&path)) || !path) continue;
			CComString pName;
			if (SUCCEEDED(SHGetNameFromIDList(path,SIGDN_NORMALDISPLAY,&pName)))
			{
				CComString pPath;
				if (SUCCEEDED(SHGetNameFromIDList(path,SIGDN_DESKTOPABSOLUTEPARSING,&pPath)))
				{
					wchar_t text[_MAX_PATH*2];
					int len=Sprintf(text,_countof(text),L"%s | ",pName);
					if (!PathUnExpandEnvStrings(pPath,text+len,_countof(text)-len))
						Strcpy(text+len,_countof(text)-len,pPath);
					linkCombo.SendMessage(CB_ADDSTRING,0,(LPARAM)text);
				}
			}
		}
	}

	linkCombo.SetWindowText(m_pItem->link);
	idx=(int)linkCombo.SendMessage(CB_FINDSTRINGEXACT,-1,(LPARAM)(const wchar_t*)m_pItem->link);
	if (idx>=0)
		linkCombo.SendMessage(CB_SETCURSEL,idx);

	m_hIcon=NULL;
	m_IconKey=0;
	m_hIconD=NULL;
	m_IconDKey=0;
	m_StoredItem=*m_pItem;

	RECT rc;
	CRegKey regSettings;
	if (regSettings.Open(HKEY_CURRENT_USER,GetSettingsRegPath())==ERROR_SUCCESS)
	{
		ULONG size=sizeof(rc);
		if (regSettings.QueryBinaryValue(L"CEditCustomItemDlg",&rc,&size)==ERROR_SUCCESS && size==sizeof(rc))
			SetStoreRect(rc);
	}