MenuContainer.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

// MenuContainer.cpp - contains the main logic of CMenuContainer

#include "stdafx.h"
#include "MenuContainer.h"
#include "Accessibility.h"
#include "ClassicStartMenuDLL.h"
#include "ClassicStartButton.h"
#include "Settings.h"
#include "Translations.h"
#include "CustomMenu.h"
#include "LogManager.h"
#include "FNVHash.h"
#include "ResourceHelper.h"
#include "SettingsUIHelper.h"
#include "DownloadHelper.h"
#include "SettingsUI.h"
#include "MetroLinkManager.h"
#include "ProgramsTree.h"
#include "dllmain.h"
#include "resource.h"
#include <uxtheme.h>
#include <vsstyle.h>
#include <vssym32.h>
#include <WtsApi32.h>
#include <Lm.h>
#include <Dsgetdc.h>
#include <PowrProf.h>
#include <dwmapi.h>
#include <propkey.h>
#define SECURITY_WIN32
#include <Security.h>
#include <algorithm>
#include <wuapi.h>

struct StdMenuOption
{
	TMenuID id;
	int options;
};

// Options for special menu items
enum
{
	MENU_NONE     = 0,
	MENU_ENABLED  = 1, // the item shows in the menu
	MENU_EXPANDED = 2, // the item is expanded
};

static StdMenuOption g_StdOptions[]=
{
	{MENU_COMPUTER,MENU_NONE}, // MENU_ENABLED|MENU_EXPANDED from settings
	{MENU_FAVORITES,MENU_NONE}, // MENU_ENABLED|MENU_EXPANDED from settings, check policy
	{MENU_DOCUMENTS,MENU_NONE}, // MENU_ENABLED|MENU_EXPANDED from settings, check policy
	{MENU_HELP,MENU_ENABLED}, // check policy
	{MENU_RUN,MENU_ENABLED}, // check policy
	{MENU_LOGOFF,MENU_ENABLED}, // MENU_ENABLED from settings, check policy
	{MENU_RESTART,MENU_ENABLED}, // MENU_ENABLED
	{MENU_RESTART_NOUPDATE,MENU_ENABLED}, // only available when there are updates
	{MENU_DISCONNECT,MENU_NONE}, // MENU_ENABLED if in a remote session, check policy
	{MENU_SHUTDOWN_BOX,MENU_ENABLED}, // MENU_NONE if in a remote session, check policy
	{MENU_SHUTDOWN_BUTTON,MENU_ENABLED|MENU_EXPANDED}, // MENU_ENABLED|MENU_EXPANDED from the settings
	{MENU_SHUTDOWN,MENU_ENABLED}, // MENU_NONE if in a remote session, check policy
	{MENU_SHUTDOWN_NOUPDATE,MENU_ENABLED}, // only available when there are updates
	{MENU_UNDOCK,MENU_ENABLED}, // from settings, check policy
	{MENU_CONTROLPANEL,MENU_ENABLED|MENU_EXPANDED}, // MENU_EXPANDED from settings, check policy
	{MENU_NETWORK,MENU_ENABLED}, // MENU_EXPANDED from settings, check policy
	{MENU_SECURITY,MENU_ENABLED}, // MENU_ENABLED if in a remote session
	{MENU_PRINTERS,MENU_ENABLED}, // MENU_EXPANDED from settings, check policy
	{MENU_TASKBAR,MENU_ENABLED}, // check policy
	{MENU_FEATURES,MENU_ENABLED}, // no setting (prevents the Programs and Features from expanding), check policy (for control panel)
	{MENU_CLASSIC_SETTINGS,MENU_ENABLED}, // MENU_ENABLED from ini file
	{MENU_SEARCH,MENU_ENABLED}, // check policy
	{MENU_SEARCH_BOX,MENU_NONE}, // check settings
	{MENU_SEARCH_PRINTER,MENU_NONE}, // MENU_ENABLED if Active Directory is available
	{MENU_SEARCH_COMPUTERS,MENU_NONE}, // MENU_ENABLED if Active Directory is available, check policy
	{MENU_SEARCH_PEOPLE,MENU_NONE}, // MENU_ENABLED if %ProgramFiles%\Windows Mail\wab.exe exists
	{MENU_USERFILES,MENU_ENABLED}, // check policy
	{MENU_USERDOCUMENTS,MENU_ENABLED}, // check policy
	{MENU_USERPICTURES,MENU_ENABLED}, // check policy
	{MENU_SLEEP,MENU_ENABLED}, // check power caps
	{MENU_HIBERNATE,MENU_ENABLED}, // check power caps
	{MENU_SWITCHUSER,MENU_ENABLED}, // check group policy
	{MENU_APPS,MENU_ENABLED}, // enable on Win8+
	{MENU_PCSETTINGS,MENU_ENABLED}, // enable on Win8+
};

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

void CUserWindow::Init( CMenuContainer *pOwner )
{
	const MenuSkin &skin=CMenuContainer::s_Skin;
	m_pOwner=pOwner;
	m_Size=skin.User_bitmapSize;
	BITMAPINFO bi={0};
	bi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
	bi.bmiHeader.biWidth=m_Size.cx;
	bi.bmiHeader.biHeight=m_Size.cy;
	bi.bmiHeader.biPlanes=1;
	bi.bmiHeader.biBitCount=32;
	HDC hdc=CreateCompatibleDC(NULL);
	m_Bitmap=CreateDIBSection(hdc,&bi,DIB_RGB_COLORS,(void**)&m_Bits,NULL,0);
	DeleteDC(hdc);
	memset(m_Bits,0,m_Size.cx*m_Size.cy*4);
	m_Source.resize(m_Size.cx*m_Size.cy*2);
	m_bUserBitmapMask=(skin.User_mask.bIsBitmap && skin.User_mask.bIs32 && skin.User_maskSize.cx==skin.User_image_size && skin.User_maskSize.cy==skin.User_image_size);
	if (m_bUserBitmapMask)
		m_UserBitmap=CMenuContainer::LoadUserImage(skin.User_image_size,skin.User_mask.GetBitmap());
	else
		m_UserBitmap=CMenuContainer::LoadUserImage(skin.User_image_size,NULL);
	m_TimerBitmap=(HBITMAP)1;
	SetImage(NULL,false);
}

void CUserWindow::StartImageTimer( HBITMAP bmp )
{
	if (m_TimerBitmap==bmp) return;
	m_TimerBitmap=bmp;
	DWORD time;
	SystemParametersInfo(SPI_GETMOUSEHOVERTIME,NULL,&time,0);
	SetTimer(TIMER_SET,time);
}

void CUserWindow::SetImage( HBITMAP bmp, bool bAnimate )
{
	m_bDefaultImage=!bmp;
	EnableWindow(m_bDefaultImage);
	int size=m_Size.cx*m_Size.cy;
	memcpy(&m_Source[0],m_Bits,size*4);

	HDC hdst=CreateCompatibleDC(NULL);
	RECT rc={0,0,m_Size.cx,m_Size.cy};
	HGDIOBJ bmp0=SelectObject(hdst,m_Bitmap);
	FillRect(hdst,&rc,(HBRUSH)GetStockObject(BLACK_BRUSH));
	HDC hsrc=CreateCompatibleDC(NULL);
	HGDIOBJ bmp01=GetCurrentObject(hsrc,OBJ_BITMAP);
	int iconSize=bmp?CItemManager::EXTRA_LARGE_ICON_SIZE:CMenuContainer::s_Skin.User_image_size;
	if (bmp)
	{
		SelectObject(hsrc,bmp);
		BitBlt(hdst,(m_Size.cx-iconSize)/2,(m_Size.cy-iconSize)/2,iconSize,iconSize,hsrc,0,0,SRCCOPY);
	}
	else
	{
		if (m_UserBitmap)
		{
			SelectObject(hsrc,m_UserBitmap);
			BitBlt(hdst,CMenuContainer::s_Skin.User_image_offset.x,CMenuContainer::s_Skin.User_image_offset.y,iconSize,iconSize,hsrc,0,0,SRCCOPY);
		}
		if (CMenuContainer::s_Skin.User_bitmap.GetBitmap())
		{
			SelectObject(hsrc,CMenuContainer::s_Skin.User_bitmap.GetBitmap());
			BLENDFUNCTION func={AC_SRC_OVER,0,255,AC_SRC_ALPHA};
			AlphaBlend(hdst,0,0,m_Size.cx,m_Size.cy,hsrc,0,0,m_Size.cx,m_Size.cy,func);
		}
	}
	SelectObject(hsrc,bmp01);
	DeleteDC(hsrc);
	SelectObject(hdst,bmp0);
	DeleteDC(hdst);

	memcpy(&m_Source[size],m_Bits,size*4);
	if (!bmp && !m_bUserBitmapMask)
	{
		int dx=CMenuContainer::s_Skin.User_image_offset.x;
		int dy=m_Size.cy-CMenuContainer::s_Skin.User_image_offset.y-1;
		for (int y=0;y<iconSize;y++)
			for (int x=0;x<iconSize;x++)
				m_Source[size+(dy-y)*m_Size.cx+x+dx]|=0xFF000000;
	}
	if (bAnimate)
	{
		m_Timer=0;
		SetTimer(TIMER_BLEND,15);
	}
	else
	{
		memcpy(m_Bits,&m_Source[size],size*4);
		Update();
	}
}

void CUserWindow::Update( int alpha )
{
	BLENDFUNCTION func={AC_SRC_OVER,0,(BYTE)alpha,AC_SRC_ALPHA};

	HDC hSrc=CreateCompatibleDC(NULL);
	HGDIOBJ bmp0=SelectObject(hSrc,m_Bitmap);
	POINT srcPos={0,0};
	UpdateLayeredWindow(m_hWnd,NULL,NULL,&m_Size,hSrc,&srcPos,0,&func,ULW_ALPHA);
	SelectObject(hSrc,bmp0);
	DeleteDC(hSrc);
}

void CUserWindow::UpdatePartial( POINT pos, const RECT *pClipRect )
{
	BLENDFUNCTION func={AC_SRC_OVER,0,255,AC_SRC_ALPHA};

	SIZE size=m_Size;
	POINT srcPos={0,0};
	if (pClipRect)
	{
		if (pos.x<pClipRect->left)
		{
			int dx=pClipRect->left-pos.x;
			pos.x+=dx;
			size.cx-=dx;
			srcPos.x+=dx;
		}
		if (pos.x+size.cx>pClipRect->right)
			size.cx=pClipRect->right-pos.x;

		if (pos.y<pClipRect->top)
		{
			int dy=pClipRect->top-pos.y;
			pos.y+=dy;
			size.cy-=dy;
			srcPos.y+=dy;
		}
		if (pos.y+size.cy>pClipRect->bottom)
			size.cy=pClipRect->bottom-pos.y;
	}
	if (size.cx<0) size.cx=0;
	if (size.cy<0) size.cy=0;

	HDC hSrc=CreateCompatibleDC(NULL);
	HGDIOBJ bmp0=SelectObject(hSrc,m_Bitmap);
	UpdateLayeredWindow(m_hWnd,NULL,&pos,&size,hSrc,&srcPos,0,&func,ULW_ALPHA);
	SelectObject(hSrc,bmp0);
	DeleteDC(hSrc);
}

LRESULT CUserWindow::OnDestroy( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_Bitmap) DeleteObject(m_Bitmap);
	m_Bitmap=NULL;
	if (m_UserBitmap) DeleteObject(m_UserBitmap);
	m_UserBitmap=NULL;
	return 0;
}

LRESULT CUserWindow::OnLButtonDown( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_bDefaultImage)
		m_pOwner->RunUserCommand(true);
	return 0;
}

LRESULT CUserWindow::OnSetCursor( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	if (m_bDefaultImage)
		SetCursor(LoadCursor(NULL,IDC_HAND));
	else
		bHandled=FALSE;
	return TRUE;
}

LRESULT CUserWindow::OnTimer( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
	const int BLEND_STEP=5;
	if (wParam==TIMER_BLEND)
	{
		m_Timer+=BLEND_STEP;
		if (m_Timer>100) m_Timer=100;

		// blend the two images
		int n=m_Size.cx*m_Size.cy;
		for (int i=0;i<n;i++)
		{
			unsigned int pixel1=m_Source[i];
			unsigned int pixel2=m_Source[i+n];
			int a1=(pixel1>>24);
			int r1=(pixel1>>16)&255;
			int g1=(pixel1>>8)&255;
			int b1=(pixel1)&255;
			int a2=(pixel2>>24);
			int r2=(pixel2>>16)&255;
			int g2=(pixel2>>8)&255;
			int b2=(pixel2)&255;
			int a=a1+(a2-a1)*m_Timer/100;
			int r=r1+(r2-r1)*m_Timer/100;
			int g=g1+(g2-g1)*m_Timer/100;
			int b=b1+(b2-b1)*m_Timer/100;
			m_Bits[i]=(a<<24)|(r<<16)|(g<<8)|b;
		}

		Update();
		if (m_Timer==100)
			KillTimer(TIMER_BLEND);
	}
	if (wParam==TIMER_SET)
	{
		SetImage(m_TimerBitmap,true);
		m_TimerBitmap=(HBITMAP)1;
		KillTimer(TIMER_SET);
	}
	return 0;
}

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

int CMenuContainer::s_MaxRecentDocuments=15;
int CMenuContainer::s_ScrollMenus=0;
bool CMenuContainer::s_bRTL=false;
bool CMenuContainer::s_bKeyboardCues=false;
bool CMenuContainer::s_bOverrideFirstDown=false;
bool CMenuContainer::s_bExpandRight=true;
TRecentPrograms CMenuContainer::s_RecentPrograms=RECENT_PROGRAMS_NONE;
bool CMenuContainer::s_bBehindTaskbar=true;
bool CMenuContainer::s_bShowTopEmpty=false;
bool CMenuContainer::s_bNoDragDrop=false;
bool CMenuContainer::s_bNoContextMenu=false;
bool CMenuContainer::s_bExpandLinks=false;
bool CMenuContainer::s_bLogicalSort=false;
bool CMenuContainer::s_bExtensionSort=false;
bool CMenuContainer::s_bAllPrograms=false;
bool CMenuContainer::s_bNoCommonFolders=false;
bool CMenuContainer::s_bNoRun=false;
bool CMenuContainer::s_bNoClose=false;
bool CMenuContainer::s_bHasTouch=false;
char CMenuContainer::s_bActiveDirectory=-1;
bool CMenuContainer::s_bPreventClosing=false;
bool CMenuContainer::s_bDragClosed=false;
bool CMenuContainer::s_bTempHidden=false;
bool CMenuContainer::s_bDisableHover=false;
bool CMenuContainer::s_bHasUpdates=false;
CMenuContainer *CMenuContainer::s_pDragSource=NULL;
bool CMenuContainer::s_bDragFromTree;
bool CMenuContainer::s_bDragMovable;
bool CMenuContainer::s_bRightDrag;
bool CMenuContainer::s_bLockWorkArea;
bool CMenuContainer::s_bPendingSearchEnter;
std::vector<CMenuContainer*> CMenuContainer::s_Menus;
volatile HWND CMenuContainer::s_FirstMenu, CMenuContainer::s_SearchMenu;
CSearchManager::SearchResults CMenuContainer::s_SearchResults;
std::map<unsigned int,int> CMenuContainer::s_MenuScrolls;
CString CMenuContainer::s_MRUShortcuts[MRU_PROGRAMS_COUNT];
bool CMenuContainer::s_bMRULoaded=false;
const CItemManager::ItemInfo *CMenuContainer::s_JumpAppInfo;
CJumpList CMenuContainer::s_JumpList;
int CMenuContainer::s_TaskBarId;
HWND CMenuContainer::s_TaskBar, CMenuContainer::s_StartButton;
UINT CMenuContainer::s_TaskBarEdge;
RECT CMenuContainer::s_StartRect;
HWND CMenuContainer::s_LastFGWindow;
HTHEME CMenuContainer::s_Theme;
HTHEME CMenuContainer::s_PagerTheme;
CWindow CMenuContainer::s_Tooltip;
CWindow CMenuContainer::s_TooltipBalloon;
int CMenuContainer::s_TipShowTime;
int CMenuContainer::s_TipHideTime;
int CMenuContainer::s_TipShowTimeFolder;
int CMenuContainer::s_TipHideTimeFolder;
DWORD CMenuContainer::s_HotPos;
int CMenuContainer::s_HotItem;
CMenuContainer *CMenuContainer::s_pHotMenu;
int CMenuContainer::s_TipItem;
CMenuContainer *CMenuContainer::s_pTipMenu;
RECT CMenuContainer::s_MenuLimits;
RECT CMenuContainer::s_MainMenuLimits;
DWORD CMenuContainer::s_TaskbarState;
DWORD CMenuContainer::s_HoverTime;
DWORD CMenuContainer::s_SplitHoverTime;
DWORD CMenuContainer::s_ProgramsHoverTime;
DWORD CMenuContainer::s_XMouse;
DWORD CMenuContainer::s_SubmenuStyle;
CLIPFORMAT CMenuContainer::s_ShellFormat;
CLIPFORMAT CMenuContainer::s_ShellUrlFormat;
CLIPFORMAT CMenuContainer::s_DescriptorFormat;
CLIPFORMAT CMenuContainer::s_ContentsFormat;
CLIPFORMAT CMenuContainer::s_MetroLinkFormat;
CLIPFORMAT CMenuContainer::s_PreferredEffectFormat;
CLIPFORMAT CMenuContainer::s_DropDescriptionFormat;
MenuSkin CMenuContainer::s_Skin;
CMenuContainer::StartMenuParams CMenuContainer::s_StartMenuParams;
UINT CMenuContainer::s_StartMenuMsg;
std::vector<CMenuFader*> CMenuFader::s_Faders;
bool CMenuContainer::s_bWin7Style;
CMenuContainer::TMenuMode CMenuContainer::s_MenuMode;
CMenuContainer::TMenuMode CMenuContainer::s_PreSearchMenuMode;
TMenuID CMenuContainer::s_ShutdownCommand;
int CMenuContainer::s_MenuHeight;
int CMenuContainer::s_MenuMaxHeight[2];
int CMenuContainer::s_MenuWidthNormal;
int CMenuContainer::s_MenuWidthJump;
int CMenuContainer::s_MenuWidthMax;
int CMenuContainer::s_BackgroundW1, CMenuContainer::s_BackgroundW2, CMenuContainer::s_BackgroundH1, CMenuContainer::s_BackgroundH2;
CMenuContainer::OldMenuState CMenuContainer::s_OldMenuState;
CUserWindow CMenuContainer::s_UserPicture;
RECT CMenuContainer::s_UserPictureRect;
int CMenuContainer::s_ProgramsScrollPos;
HBITMAP CMenuContainer::s_ArrowsBitmap;
unsigned int CMenuContainer::s_LastArrowColor;
char CMenuContainer::s_HasMoreResults;
int CMenuContainer::s_ProgramsWidth, CMenuContainer::s_JumplistWidth;
CComPtr<IFrameworkInputPane> CMenuContainer::s_pFrameworkInputPane;
CString CMenuContainer::s_PinFolder;

LRESULT CALLBACK CMenuContainer::SubclassSearchBox( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
	CMenuContainer *pParent=(CMenuContainer*)uIdSubclass;
	CWindow box(hWnd);
	if (uMsg==WM_PAINT && !pParent->m_bNoSearchDraw)
	{
		// use buffered paint to allow the edit box to appear on a glass background
		pParent->m_bNoSearchDraw=true;

		PAINTSTRUCT ps;
		HDC hdc=box.BeginPaint(&ps);

		BP_PAINTPARAMS paintParams={sizeof(paintParams)};
		HDC hdcPaint=NULL;
		HPAINTBUFFER hBufferedPaint=BeginBufferedPaint(hdc,&ps.rcPaint,BPBF_TOPDOWNDIB,&paintParams,&hdcPaint);
		if (hdcPaint)
		{
			SendMessage(hWnd,WM_PRINTCLIENT,(WPARAM)hdcPaint,PRF_CLIENT);
			BufferedPaintSetAlpha(hBufferedPaint,&ps.rcPaint,255);
			EndBufferedPaint(hBufferedPaint,TRUE);
		}
		box.EndPaint(&ps);

		pParent->m_bSearchDrawn=true;
		pParent->m_bNoSearchDraw=false;
		return 0;
	}
	if (uMsg==WM_PRINTCLIENT)
	{
		LRESULT res=DefSubclassProc(hWnd,uMsg,wParam,lParam);
		HDC hdc=(HDC)wParam;
		if ((lParam&PRF_CLIENT) && ::GetWindowTextLength(hWnd)==0 && ((GetSettingInt(L"SearchBox")==SEARCHBOX_NORMAL && GetSettingBool(L"SearchSelect")) || GetFocus()!=hWnd) && pParent->m_SearchIndex>=0)
		{
			RECT rc;
			::SendMessage(hWnd,EM_GETRECT,0,(LPARAM)&rc);
			if (s_bRTL)
				rc.right-=3;
			else
				rc.left+=3;
			HGDIOBJ font0=SelectObject(hdc,s_Skin.Search_hint_font);
			SetBkColor(hdc,GetSysColor(COLOR_WINDOW));
			SetBkMode(hdc,TRANSPARENT);
			SetTextColor(hdc,s_Skin.Search_text_colors[1]);
			DrawText(hdc,pParent->m_Items[pParent->m_SearchIndex].name,-1,&rc,DT_SINGLELINE|DT_EDITCONTROL|(s_bRTL?DT_RIGHT:DT_LEFT));
			SelectObject(hdc,font0);
		}
		return res;
	}
	if (uMsg==WM_KEYDOWN)
	{
		if (wParam==VK_TAB)
		{
			s_bPendingSearchEnter=false;
			// forward Tabs to the parent
			return pParent->SendMessage(uMsg,wParam,lParam);
		}
		if (wParam==VK_UP || wParam==VK_DOWN)
		{
			s_bPendingSearchEnter=false;
			// forward up/down keys
			CMenuContainer *pSearchMenu=s_Menus[s_Menus.size()-1];
			if (pSearchMenu->m_Options&CONTAINER_SEARCH)
				return pSearchMenu->SendMessage(uMsg,wParam,lParam); // forward to the search menu
			else
				return pParent->SendMessage(uMsg,wParam,lParam); // forward to the parent
		}
		if (wParam==VK_PRIOR || wParam==VK_NEXT)
		{
			s_bPendingSearchEnter=false;
			// forward page keys
			CMenuContainer *pSearchMenu=s_Menus[s_Menus.size()-1];
			if (pSearchMenu->m_Options&CONTAINER_SEARCH)
				return pSearchMenu->SendMessage(uMsg,wParam,lParam); // forward to the search menu
			else
				return pParent->SendMessage(uMsg,wParam,lParam); // forward to the parent
		}
		if (wParam==VK_LEFT || wParam==VK_RIGHT)
		{
			// forward left/right keys
			if (::GetWindowTextLength(hWnd)==0)
				return pParent->SendMessage(uMsg,wParam,lParam); // forward to the parent
		}
		if (wParam==VK_RETURN)
		{
			// forward Enter to the submenu, or execute the current string
			CMenuContainer *pSearchMenu=s_Menus[s_Menus.size()-1];
			bool bShift=GetKeyState(VK_SHIFT)<0;
			bool bCtrl=GetKeyState(VK_CONTROL)<0;
			if ((pSearchMenu->m_Options&CONTAINER_SEARCH) || (!pSearchMenu->m_bSubMenu && s_MenuMode==MODE_SEARCH))
			{
				if (pSearchMenu->m_HotItem>=0 && pSearchMenu->m_HotItem<(int)pSearchMenu->m_Items.size() &&
					pSearchMenu->m_Items[pSearchMenu->m_HotItem].id!=MENU_EMPTY && pSearchMenu->m_Items[pSearchMenu->m_HotItem].id!=MENU_SEARCH_EMPTY)
				{
					pSearchMenu->SendMessage(WM_KEYDOWN,VK_RETURN);
				}
				else if (!s_bNoRun && (!s_SearchResults.bSearching || s_SearchResults.bResults))
				{
					CString command;
					CWindow(hWnd).GetWindowText(command);
					if (!command.IsEmpty())
						pSearchMenu->ExecuteCommand(command,bShift && bCtrl,true);
				}
				else if (s_SearchResults.bSearching && !s_SearchResults.bResults)
				{
					s_bPendingSearchEnter=true;
				}
			}
			return 0;
		}
		if (wParam==VK_ESCAPE)
		{
			s_bPendingSearchEnter=false;
			// forward Esc to the parent or clear the string
			if (box.GetWindowTextLength()==0)
				pParent->PostMessage(WM_KEYDOWN,VK_ESCAPE);
			else
				box.SetWindowText(L"");
			return 0;
		}
		if (wParam==VK_BACK && GetKeyState(VK_CONTROL)<0)
		{
			wchar_t text[1024];
			::GetWindowText(hWnd,text,_countof(text));
			int len=Strlen(text);
			int pos=(int)::SendMessage(hWnd,EM_GETSEL,0,0);
			if (LOWORD(pos)==HIWORD(pos))
			{
				pos=LOWORD(pos);
				if (pos>len) pos=len;
				int start=0;
				for (int i=0;i<pos;i++)
				{
					if (i>0 && (text[i-1]==' ' || text[i-1]=='\\') && text[i]!=text[i-1])
						start=i;
				}
				pos=MAKELONG(start,pos);
			}
			int start=LOWORD(pos);
			int end=HIWORD(pos);
			if (start>len) start=len;
			if (end>len) end=len;
			memmove(text+start,text+end,(len-end+1)*2);
			::SetWindowText(hWnd,text);
			::SendMessage(hWnd,EM_SETSEL,start,start);
			return 0;
		}
	}
	if (uMsg==WM_SYSCHAR)
	{
		CMenuContainer *pSearchMenu=s_Menus[s_Menus.size()-1];
		if (pSearchMenu->m_Options&CONTAINER_SEARCH)
		{
			if (!pSearchMenu->SendMessage(WM_CHAR,wParam,lParam))
				return 0;
		}
		pParent->SendMessage(WM_CHAR,wParam,lParam);
	}
	if (uMsg==WM_SYSKEYDOWN)
	{
		if (s_bWin7Style)
		{
			pParent->SendMessage(WM_SYSKEYDOWN,wParam,lParam);
			if (wParam==VK_MENU)
				pParent->ShowKeyboardCues();
		}
		else
		{
			CMenuContainer *pSearchMenu=s_Menus[s_Menus.size()-1];
			if (pSearchMenu->m_Options&CONTAINER_SEARCH)
				pSearchMenu->SendMessage(WM_SYSKEYDOWN,wParam,lParam);
		}
	}
	if (uMsg==WM_CHAR && (wParam==VK_RETURN || wParam==10 || wParam==VK_ESCAPE || wParam==VK_TAB || wParam==127))
	{
		// prevent a beep when Enter, Esc or Tab is pressed
		return 0;
	}
	if (uMsg==WM_MOUSEACTIVATE)
	{
		pParent->ActivateItem(pParent->m_SearchIndex,ACTIVATE_SELECT,NULL);
		s_bDisableHover=!s_bWin7Style;
		// close all sub-menus
		CloseSubMenus(CLOSE_SKIP_SEARCH,pParent);
		::SetFocus(hWnd);
		if (s_bBehindTaskbar && s_TaskBar)
			pParent->SetWindowPos(s_TaskBar,0,0,0,0,SWP_NOSIZE|SWP_NOMOVE);
		return MA_NOACTIVATE;
	}
	if (uMsg==WM_SETFOCUS)
	{
		pParent->SetSearchState(::GetWindowTextLength(hWnd)>0?SEARCH_TEXT:SEARCH_BLANK);
	}
	if (uMsg==WM_KILLFOCUS)
	{
		s_bPendingSearchEnter=false;
		if (!s_bPreventClosing)
		{
#ifndef PREVENT_CLOSING
			box.SetWindowText(L"");
			pParent->SetSearchState(SEARCH_NONE);
#endif
		}
	}
	if (uMsg==WM_CONTEXTMENU && (lParam&0xFFFFFFFF)==0xFFFFFFFF)
	{
		if (s_bWin7Style)
			return pParent->SendMessage(WM_CONTEXTMENU,wParam,lParam);
		else
		{
			CMenuContainer *pSearchMenu=s_Menus[s_Menus.size()-1];
			if (pSearchMenu->m_Options&CONTAINER_SEARCH)
				return pSearchMenu->SendMessage(WM_CONTEXTMENU,wParam,lParam);
		}
	}
	if (uMsg==WM_MOUSEWHEEL)
	{
		if (s_bWin7Style)
			return pParent->SendMessage(WM_MOUSEWHEEL,wParam,lParam);
	}
	return DefSubclassProc(hWnd,uMsg,wParam,lParam);
}

LRESULT CALLBACK CMenuContainer::SubclassScrollbar( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData )
{
	CMenuContainer *pParent=(CMenuContainer*)uIdSubclass;
	if (!pParent->m_ScrollTheme)
	{
		return DefSubclassProc(hWnd,uMsg,wParam,lParam);
	}
	DWORD oldThread=g_CustomScrollbarThread;
	g_CustomScrollbarThread=GetCurrentThreadId();
	g_CustomScrollbarTheme=pParent->m_ScrollTheme;
	LRESULT res=DefSubclassProc(hWnd,uMsg,wParam,lParam);
	g_CustomScrollbarThread=oldThread;
	if (!oldThread)
		g_CustomScrollbarTheme=NULL;
	return res;
}

int CMenuContainer::CompareMenuString( const wchar_t *str1, const wchar_t *str2 )
{
	if (s_bExtensionSort)
	{
		const wchar_t *ext1=PathFindExtension(str1);
		const wchar_t *ext2=PathFindExtension(str2);
		int cmp=CompareString(LOCALE_USER_DEFAULT,LINGUISTIC_IGNORECASE,ext1,-1,ext2,-1)-CSTR_EQUAL;
		if (cmp) return cmp;
	}
	if (s_bLogicalSort)
		return StrCmpLogicalW(str1,str2);
	else
		return CompareString(LOCALE_USER_DEFAULT,LINGUISTIC_IGNORECASE,str1,-1,str2,-1)-CSTR_EQUAL;
}

CMenuContainer::CMenuContainer( CMenuContainer *pParent, int index, int options, const StdMenuItem *pStdItem, PIDLIST_ABSOLUTE path1, PIDLIST_ABSOLUTE path2 )
{
	m_RefCount=1;
	m_bSubMenu=(index>=0); // this may be true even if pParent is NULL (in case you want to show only sub-menus somewhere, use index=0 and pParent=NULL)
	m_HoverItem=m_ContextItem=m_HotItem=m_InsertMark=-1;
	m_DragHoverItem=m_DragIndex=-1;
	m_ClickIndex=GetKeyState(VK_LBUTTON)<0?-2:-1;
	m_bHoverArrow=m_bClickArrow=false;
	m_pParent=pParent;
	m_ParentIndex=pParent?index:-1;
	m_Options=options;
	m_pStdItem=pStdItem;
	m_Bitmap=NULL;
	m_BitmapOffset=0;
	m_Region=NULL;
	m_PaintOffset.x=m_PaintOffset.y=0;
	m_Path1[0].Clone(path1);
	if (!s_bNoCommonFolders)
		m_Path2[0].Clone(path2);

	if (options&CONTAINER_ALLPROGRAMS)
	{
		ShGetKnownFolderIDList(FOLDERID_Programs,&m_Path1[1]);
		if (!s_bNoCommonFolders)
			ShGetKnownFolderIDList(FOLDERID_CommonPrograms,&m_Path2[1]);
	}

	Assert(path1 || !path2);

	m_FolderHash[0]=m_FolderHash[1]=0;
	if (m_Options&CONTAINER_APPS)
		m_FolderHash[0]=CalcFNVHash(L"apps");

	InitializeSpecialFolders();

	m_bDestroyed=false;
	s_Menus.push_back(this);
	m_Submenu=-1;
	m_SubJumpItem=-1;
	m_bTrackMouse=false;
	m_RefreshPosted=0;

	m_SubShowTime=0;
	m_bInsertAfter=false;
	m_bHotArrow=false;

	m_DragHoverTime=0;

	m_MaxWidth=0;
	m_bTwoColumns=false;
	memset(&m_rMenu,0,sizeof(m_rMenu));
	memset(&m_rContent,0,sizeof(m_rContent));
	memset(&m_rContent2,0,sizeof(m_rContent2));
	memset(&m_rUser1,0,sizeof(m_rUser1));
	memset(&m_rUser2,0,sizeof(m_rUser2));
	memset(&m_rPadding,0,sizeof(m_rPadding));

	m_ExtraTop=m_ExtraBottom=m_ExtraBorder=0;
	m_MouseWheel=0;
	m_ScrollCount=m_ScrollHeight=m_ScrollOffset=m_ScrollButtonSize=0;
	m_bScrollUp=m_bScrollDown=m_bScrollUpHot=m_bScrollDownHot=false;
	m_SearchIndex=-1;
	m_SearchItemCount=0;
	m_SearchProvidersCount=0;
	m_bScrollTimerMouse=false;
	m_bScrollTimerTouch=false;
	m_bNoSearchDraw=false;
	m_bSearchDrawn=false;
	m_bInSearchUpdate=false;
	m_bDisableProgHover=false;
	m_bClosing=false;
	m_bRefreshItems=false;
	m_bWorkAreaPosted=false;
	m_SearchIcons=NULL;
	m_SearchState=SEARCH_NONE;
	m_SearchCategoryHash=CSearchManager::CATEGORY_INVALID;
	m_pProgramsTree=NULL;
	m_ProgramButtonIndex=m_ProgramTreeIndex=-1;
	m_OriginalCount=0;
	m_OriginalScrollCount=-1;
	m_SearchScrollCount=m_SearchScrollHeight=m_SearchScrollPos=0;
	m_SearchHash=0;
	m_pDropTargetInfo=NULL;
	m_DropTargetIndex=-1;
	m_PanPosY=m_Overpan=m_PointerId=0;
	m_InputCookie=0;
	m_ScrollTheme=NULL;

	CoCreateInstance(CLSID_DragDropHelper,NULL,CLSCTX_INPROC_SERVER,IID_IDropTargetHelper,(void**)&m_pDropTargetHelper);
	m_pDragSourceHelper=CComQIPtr<IDragSourceHelper2>(m_pDropTargetHelper);
	LOG_MENU(LOG_OPEN,L"Open Menu, ptr=%p, index=%d, options=%08X",this,index,options);
}

CMenuContainer::~CMenuContainer( void )
{
	ClearItems(m_Items.begin(),m_Items.end());
	if (std::find(s_Menus.begin(),s_Menus.end(),m_pParent)!=s_Menus.end()) // check if the parent is still alive
	{
		if (m_pParent->m_Submenu==m_ParentIndex)
		{
			if (!m_pParent->m_bDestroyed)
			{
				m_pParent->InvalidateItem(m_ParentIndex);
				if (m_pParent->m_HotItem<0 && !(m_Options&CONTAINER_SEARCH) && (!m_pParent->m_pProgramsTree || !m_pParent->m_pProgramsTree->m_hWnd || m_pParent->m_pProgramsTree->m_hWnd!=GetFocus()))
					m_pParent->SetHotItem(m_ParentIndex);
			}
			m_pParent->SetSubmenu(-1);
		}
	}
	if (m_Bitmap) DeleteObject(m_Bitmap);
	if (m_Region) DeleteObject(m_Region);

	// must be here and not in OnDestroy because during drag/drop a menu can close while still processing messages
	s_Menus.erase(std::find(s_Menus.begin(),s_Menus.end(),this));
	if (m_SearchIcons)
		DeleteObject(m_SearchIcons);
	if (m_pProgramsTree) m_pProgramsTree->Release();

	if (s_pFrameworkInputPane && m_InputCookie)
		s_pFrameworkInputPane->Unadvise(m_InputCookie);
}

void CMenuContainer::AddFirstFolder( IShellItem *pFolder, std::vector<MenuItem> &items, int options )
{
	CAbsolutePidl ignore;
	if (!m_pParent || (m_Options&CONTAINER_ALLPROGRAMS))
	{
		// remove the Programs subfolder from the main menu. it will be added separately
		ShGetKnownFolderIDList(FOLDERID_Programs,&ignore);
	}

	CShellItemEnumerator enumerator(pFolder);
	if (!enumerator.IsValid()) return;
	
	CComPtr<IShellItem> pChild;
	CAbsolutePidl childPidl;
	int refreshFlags=CItemManager::INFO_SMALL_ICON;
	if (!m_bSubMenu)
	{
		if (s_Skin.Main_icon_size==MenuSkin::ICON_SIZE_LARGE)
			refreshFlags=CItemManager::INFO_LARGE_ICON;
		else if (s_Skin.Main_icon_size==MenuSkin::ICON_SIZE_NONE)
			refreshFlags=0;
	}
	if (options&CONTAINER_PROGRAMS)
		refreshFlags|=CItemManager::INFO_LINK|CItemManager::INFO_METRO;
	if (options&CONTAINER_NOPATH)
		refreshFlags|=CItemManager::INFO_NO_PATH;
	while (enumerator.GetNext(pChild,childPidl))
	{
		SFGAOF flags=0;
		HRESULT hrFlags=pChild->GetAttributes(SFGAO_FOLDER|SFGAO_STREAM|SFGAO_LINK|SFGAO_HIDDEN,&flags);
		if (FAILED(hrFlags)) // check if the item is a folder, archive or a link
			flags=0;
		if (flags&SFGAO_HIDDEN)
			continue;
		CComString pName;
		if (SUCCEEDED(pChild->GetDisplayName(SIGDN_PARENTRELATIVEPARSING,&pName)))
		{
			LOG_MENU(LOG_OPEN,L"%s, 0x%08X, 0x%08X",(const wchar_t*)pName,flags,hrFlags);
			MenuItem item(MENU_NO);
			if (ignore && ILIsEqual(childPidl,ignore))
				continue;
			item.pItemInfo=g_ItemManager.GetItemInfo(pChild,childPidl,refreshFlags);
			bool bLibrary=_wcsicmp(PathFindExtension(pName),L".library-ms")==0;
			bool bStartScreen=(
#ifndef STARTSCREEN_WIN7
				GetWinVersion()>=WIN_VER_WIN8 &&
#endif
				wcscmp(pName,STARTSCREEN_COMMAND)==0);
			const wchar_t *pStr=pName;
			if (!(pStr[0]&0xFF00) && isalpha(pStr[0]) && pStr[1]==':' && Strlen(pStr)<=3)
				item.drive=(char)toupper(pStr[0]);
			if (bStartScreen)
			{
				if (GetWinVersion()>=WIN_VER_WIN10)
					item.name=FindTranslation(L"Menu.StartMenu",L"Start Menu");
				else
					item.name=FindTranslation(L"Menu.StartScreen",L"Start Screen");
				pName.MakeUpper();
				item.nameHash=CalcFNVHash(pName);
			}
			else
			{
				CComString pName2;
				if (SUCCEEDED(pChild->GetDisplayName(SIGDN_NORMALDISPLAY,&pName2)))
				{
					if ((options&CONTAINER_CONTROLPANEL) && (_wcsnicmp(pName2,L"::{26EE0668-A00A-44D7-9371-BEB064C98683}\\0",42)==0 || Strlen(pName2)==0))
						continue; // if the display name starts with the control panel GUID, something's wrong (like the Intel crap)
					pName.MakeUpper();
					item.nameHash=CalcFNVHash(pName);
					pName.Clear();
					item.SetName(pName2,(options&CONTAINER_NOEXTENSIONS)!=0);
				}
				else
				{
					if (options&CONTAINER_CONTROLPANEL)
						continue; // control panel items should have a normal name
					item.SetName(pName,(options&CONTAINER_NOEXTENSIONS)!=0);
					pName.MakeUpper();
					item.nameHash=CalcFNVHash(pName);
				}

				if (bLibrary) flags&=~SFGAO_STREAM;
				item.bLink=(flags&SFGAO_LINK)!=0;
				item.bFolder=(!(options&CONTAINER_CONTROLPANEL) && !(options&CONTAINER_NOSUBFOLDERS) && (flags&SFGAO_FOLDER) && (!(flags&(SFGAO_STREAM|SFGAO_LINK)) || (s_bExpandLinks && item.bLink)));
				{
					CItemManager::RWLock lock(&g_ItemManager,false,CItemManager::RWLOCK_ITEMS);
					if (item.pItemInfo->IsMetroLink())
					{
						if ((m_bSubMenu && GetSettingBool(L"HideProgramsMetro")) || _wcsicmp(item.pItemInfo->GetAppid(),DESKTOP_APP_ID)==0)
							continue;
						item.bLink=item.bMetroLink=true;
						if (!item.pItemInfo->GetMetroName().IsEmpty())
							item.name=item.pItemInfo->GetMetroName();
					}
					item.bMetroApp=item.pItemInfo->IsMetroApp();
				}
			}
			item.pItem1=childPidl.Detach();
			item.bStartScreen=bStartScreen;
			item.bPrograms=(options&CONTAINER_PROGRAMS)!=0;
			items.push_back(item);
#ifdef REPEAT_ITEMS
			for (int i=0;i<REPEAT_ITEMS;i++)
			{
				item.pItem1=ILCloneFull(item.pItem1);
				items.push_back(item);
			}
#endif
		}
	}
}

void CMenuContainer::AddSecondFolder( IShellItem *pFolder, std::vector<MenuItem> &items, int options )
{
	CAbsolutePidl ignore;
	if (!m_pParent || (m_Options&CONTAINER_ALLPROGRAMS))
	{
		// remove the Programs subfolder from the main menu. it will be added separately
		ShGetKnownFolderIDList(FOLDERID_CommonPrograms,&ignore);
	}

	CShellItemEnumerator enumerator(pFolder);
	if (!enumerator.IsValid()) return;
	
	CComPtr<IShellItem> pChild;
	CAbsolutePidl childPidl;
	int refreshFlags=CItemManager::INFO_SMALL_ICON;
	if (!m_bSubMenu)
	{
		if (s_Skin.Main_icon_size==MenuSkin::ICON_SIZE_LARGE)
			refreshFlags=CItemManager::INFO_LARGE_ICON;
		else if (s_Skin.Main_icon_size==MenuSkin::ICON_SIZE_NONE)
			refreshFlags=0;
	}
	if (options&CONTAINER_PROGRAMS)
		refreshFlags|=CItemManager::INFO_LINK|CItemManager::INFO_METRO;
	while (enumerator.GetNext(pChild,childPidl))
	{
		SFGAOF flags=0;
		HRESULT hrFlags=pChild->GetAttributes(SFGAO_FOLDER|SFGAO_STREAM|SFGAO_LINK|SFGAO_HIDDEN,&flags);
		if (FAILED(hrFlags)) // check if the item is a folder, archive or a link
			flags=0;
		if (flags&SFGAO_HIDDEN)
			continue;
		CComString pName;
		if (SUCCEEDED(pChild->GetDisplayName(SIGDN_PARENTRELATIVEPARSING,&pName)))
		{
			LOG_MENU(LOG_OPEN,L"%s, 0x%08X, 0x%08X",(const wchar_t*)pName,flags,hrFlags);
			bool bLibrary=_wcsicmp(PathFindExtension(pName),L".library-ms")==0;
			bool bStartScreen=(
#ifndef STARTSCREEN_WIN7
				GetWinVersion()>=WIN_VER_WIN8 &&
#endif
				wcscmp(pName,STARTSCREEN_COMMAND)==0);
			MenuItem item(MENU_NO);
			if (bStartScreen)
			{
				if (GetWinVersion()>=WIN_VER_WIN10)
					item.name=FindTranslation(L"Menu.StartMenu",L"Start Menu");
				else
					item.name=FindTranslation(L"Menu.StartScreen",L"Start Screen");
				pName.MakeUpper();
				item.nameHash=CalcFNVHash(pName);
			}
			else
			{
				CComString pName2;
				if (SUCCEEDED(pChild->GetDisplayName(SIGDN_NORMALDISPLAY,&pName2)))
				{
					pName.MakeUpper();
					item.nameHash=CalcFNVHash(pName);
					pName.Clear();
					item.SetName(pName2,(options&CONTAINER_NOEXTENSIONS)!=0);
				}
				else
				{
					item.SetName(pName,(options&CONTAINER_NOEXTENSIONS)!=0);
					pName.MakeUpper();
					item.nameHash=CalcFNVHash(pName);
				}
			}
			pName.Clear();

			if (ignore && ILIsEqual(childPidl,ignore))
				continue;

			// look for another item with the same name
			bool bFound=false;
			for (std::vector<MenuItem>::iterator it=items.begin();it!=items.end();++it)
			{
				if (item.nameHash==it->nameHash)
				{
					it->pItem2=childPidl.Detach();
					bFound=true;
					break;
				}
			}

			if (!bFound)
			{
				// new item
				if (!bStartScreen)
				{
					item.pItemInfo=g_ItemManager.GetItemInfo(pChild,childPidl,refreshFlags);

					if (bLibrary) flags&=~SFGAO_STREAM;
					item.bLink=(flags&SFGAO_LINK)!=0;
					item.bFolder=(!(options&CONTAINER_CONTROLPANEL) && !(options&CONTAINER_NOSUBFOLDERS) && (flags&SFGAO_FOLDER) && (!(flags&(SFGAO_STREAM|SFGAO_LINK)) || (s_bExpandLinks && item.bLink)));
					{
						CItemManager::RWLock lock(&g_ItemManager,false,CItemManager::RWLOCK_ITEMS);
						if (item.pItemInfo->IsMetroLink())
						{
							if ((m_bSubMenu && GetSettingBool(L"HideProgramsMetro")) || _wcsicmp(item.pItemInfo->GetAppid(),DESKTOP_APP_ID)==0)
								continue;
							item.bLink=item.bMetroLink=true;
							if (!item.pItemInfo->GetMetroName().IsEmpty())
								item.name=item.pItemInfo->GetMetroName();
							item.bMetroApp=item.pItemInfo->IsMetroApp();
						}
					}
				}
				item.pItem1=childPidl.Detach();
				item.bStartScreen=bStartScreen;
				item.bPrograms=(options&CONTAINER_PROGRAMS)!=0;