MenuContainer.cpp

// Classic Shell (c) 2009-2017, Ivo Beltchev
// Open-Shell (c) 2017-2018, The Open-Shell Team
// 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"StartMenuDLL.h"
#include"StartButton.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>
#defineSECURITY_WIN32
#include<Security.h>
#include<algorithm>
#include<wuapi.h>

structStdMenuOption
{
 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_LOCK,MENU_ENABLED}, // check power settings
 {MENU_SWITCHUSER,MENU_ENABLED}, // check group policy
 {MENU_APPS,MENU_ENABLED}, // enable on Win8+
 {MENU_PCSETTINGS,MENU_ENABLED}, // enable on Win8+
};

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

voidCUserWindow::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);
}

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

voidCUserWindow::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();
 }
}

voidCUserWindow::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);
}

voidCUserWindow::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;
return0;
}

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

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

LRESULT CUserWindow::OnTimer( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
constint 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++)
 {
unsignedint pixel1=m_Source[i];
unsignedint 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);
 }
return0;
}

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

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_bSingleClickFolders=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<unsignedint,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;
HWND CMenuContainer::s_StartButton; // custom start button (if any)
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;
unsignedint 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;
return0;
 }
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]);
if (GetSettingBool(L"SearchHint"))
DrawText(hdc,GetSettingString(L"SearchHintText"),-1,&rc,DT_SINGLELINE|DT_EDITCONTROL|(s_bRTL?DT_RIGHT:DT_LEFT));
else
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);
 }
elseif (!s_bNoRun && (!s_SearchResults.bSearching || s_SearchResults.bResults))
 {
 CString command;
CWindow(hWnd).GetWindowText(command);
if (!command.IsEmpty())
 pSearchMenu->ExecuteCommand(command,bShift && bCtrl,true);
 }
elseif (s_SearchResults.bSearching && !s_SearchResults.bResults)
 {
 s_bPendingSearchEnter=true;
 }
 }
return0;
 }
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"");
return0;
 }
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);
return0;
 }
 }
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))
return0;
 }
 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(true);
 }
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
return0;
 }
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);
 }
returnDefSubclassProc(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)
 {
returnDefSubclassProc(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;
}

intCMenuContainer::CompareMenuString( constwchar_t *str1, constwchar_t *str2 )
{
if (s_bExtensionSort)
 {
constwchar_t *ext1=PathFindExtension(str1);
constwchar_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)
returnStrCmpLogicalW(str1,str2);
else
returnCompareString(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();
}

voidCMenuContainer::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;
elseif (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",(constwchar_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);
constwchar_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
 }
 }
}

voidCMenuContainer::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;
elseif (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",(constwchar_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();
 }
 }