dll/win32/shell32/newmenu.cpp

   1 /*
   2  * provides new shell item service
   3  *
   4  * Copyright 2007 Johannes Anderwald (janderwald@reactos.org)
   5  * Copyright 2009 Andrew Hill
   6  * Copyright 2012 Rafal Harabien
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <precomp.h>
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  26
  27 CNewMenu::CNewMenu()
  28 {
  29     m_wszPath = NULL;
  30     m_pItems = NULL;
  31     m_pLinkItem = NULL;
  32     m_pSite = NULL;
  33     m_hbmFolder = NULL;
  34     m_hbmLink = NULL;
  35 }
  36
  37 CNewMenu::~CNewMenu()
  38 {
  39     UnloadAllItems();
  40     if (m_hbmFolder)
  41         DeleteObject(m_hbmFolder);
  42     if (m_hbmLink)
  43         DeleteObject(m_hbmLink);
  44 }
  45
  46 void CNewMenu::UnloadItem(SHELLNEW_ITEM *pItem)
  47 {
  48     /* Note: free allows NULL as argument */
  49     free(pItem->pData);
  50     free(pItem->pwszDesc);
  51     free(pItem->pwszExt);
  52
  53     if (pItem->hBitmap)
  54         DeleteObject(pItem->hBitmap);
  55
  56     HeapFree(GetProcessHeap(), 0, pItem);
  57 }
  58
  59 void CNewMenu::UnloadAllItems()
  60 {
  61     SHELLNEW_ITEM *pCurItem;
  62
  63     /* Unload normal items */
  64     while (m_pItems)
  65     {
  66         pCurItem = m_pItems;
  67         m_pItems = m_pItems->pNext;
  68
  69         UnloadItem(pCurItem);
  70     }
  71
  72     /* Unload link item */
  73     if (m_pLinkItem)
  74         UnloadItem(m_pLinkItem);
  75     m_pLinkItem = NULL;
  76 }
  77
  78 static HBITMAP IconToBitmap(HICON hIcon)
  79 {
  80     HDC hdc, hdcScr;
  81     HBITMAP hbm, hbmOld;
  82     RECT rc;
  83
  84     hdcScr = GetDC(NULL);
  85     hdc = CreateCompatibleDC(hdcScr);
  86     SetRect(&rc, 0, 0, GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK));
  87     hbm = CreateCompatibleBitmap(hdcScr, rc.right, rc.bottom);
  88     ReleaseDC(NULL, hdcScr);
  89
  90     hbmOld = (HBITMAP)SelectObject(hdc, hbm);
  91     FillRect(hdc, &rc, (HBRUSH)(COLOR_MENU + 1));
  92     if (!DrawIconEx(hdc, 0, 0, hIcon, rc.right, rc.bottom, 0, NULL, DI_NORMAL))
  93         ERR("DrawIcon failed: %x\n", GetLastError());
  94     SelectObject(hdc, hbmOld);
  95
  96     DeleteDC(hdc);
  97
  98     return hbm;
  99 }
 100
 101 CNewMenu::SHELLNEW_ITEM *CNewMenu::LoadItem(LPCWSTR pwszExt)
 102 {
 103     HKEY hKey;
 104     WCHAR wszBuf[MAX_PATH];
 105     BYTE *pData = NULL;
 106     DWORD cbData;
 107
 108     StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s\\ShellNew", pwszExt);
 109
 110     TRACE("LoadItem Keyname %s Name %s\n", debugstr_w(pwszExt), debugstr_w(wszBuf));
 111
 112     if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszBuf, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
 113     {
 114         TRACE("Failed to open key\n");
 115         return NULL;
 116     }
 117
 118     /* Find first valid value */
 119     struct
 120     {
 121         LPCWSTR pszName;
 122         SHELLNEW_TYPE Type;
 123         BOOL bNeedData;
 124         BOOL bStr;
 125     } Types[] = {
 126         {L"FileName", SHELLNEW_TYPE_FILENAME, TRUE, TRUE},
 127         {L"Command", SHELLNEW_TYPE_COMMAND, TRUE, TRUE},
 128         {L"Data", SHELLNEW_TYPE_DATA, TRUE, FALSE},
 129         {L"NullFile", SHELLNEW_TYPE_NULLFILE, FALSE},
 130         {NULL}
 131     };
 132     UINT i;
 133
 134     for (i = 0; Types[i].pszName; ++i)
 135     {
 136         /* Note: We are using ANSI function because strings can be treated as data */
 137         cbData = 0;
 138         DWORD dwFlags = Types[i].bStr ? RRF_RT_REG_SZ : RRF_RT_ANY;
 139         DWORD dwType;
 140         if (RegGetValueW(hKey, NULL, Types[i].pszName, dwFlags, NULL, NULL, &cbData) == ERROR_SUCCESS)
 141         {
 142             if (Types[i].bNeedData && cbData > 0)
 143             {
 144                 pData = (BYTE*)malloc(cbData);
 145                 RegGetValueW(hKey, NULL, Types[i].pszName, dwFlags, &dwType, pData, &cbData);
 146                 if (!Types[i].bStr && (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
 147                 {
 148                     PBYTE pData2 = (PBYTE)malloc(cbData);
 149                     cbData = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)pData, -1, (LPSTR)pData2, cbData, NULL, NULL);
 150                     free(pData);
 151                     pData = pData2;
 152                 }
 153             }
 154             break;
 155         }
 156     }
 157     RegCloseKey(hKey);
 158
 159     /* Was any key found? */
 160     if (!Types[i].pszName)
 161         return NULL;
 162
 163     SHFILEINFO fi;
 164     if (!SHGetFileInfoW(pwszExt, FILE_ATTRIBUTE_NORMAL, &fi, sizeof(fi), SHGFI_USEFILEATTRIBUTES|SHGFI_TYPENAME|SHGFI_ICON|SHGFI_SMALLICON))
 165         return NULL;
 166
 167     /* Create new item */
 168     SHELLNEW_ITEM *pNewItem = (SHELLNEW_ITEM *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHELLNEW_ITEM));
 169     if (!pNewItem)
 170     {
 171         free(pData);
 172         return NULL;
 173     }
 174
 175     TRACE("new item %ls\n", fi.szTypeName);
 176     pNewItem->Type = Types[i].Type;
 177     pNewItem->pData = pData;
 178     pNewItem->cbData = pData ? cbData : 0;
 179     pNewItem->pwszExt = _wcsdup(pwszExt);
 180     pNewItem->pwszDesc = _wcsdup(fi.szTypeName);
 181     if (fi.hIcon)
 182         pNewItem->hBitmap = IconToBitmap(fi.hIcon);
 183
 184     return pNewItem;
 185 }
 186
 187 BOOL
 188 CNewMenu::LoadAllItems()
 189 {
 190     DWORD dwIndex = 0;
 191     WCHAR wszName[MAX_PATH];
 192     SHELLNEW_ITEM *pNewItem;
 193     SHELLNEW_ITEM *pCurItem = NULL;
 194
 195     /* If there are any unload them */
 196     UnloadAllItems();
 197
 198     /* Enumerate all extesions */
 199     while (RegEnumKeyW(HKEY_CLASSES_ROOT, dwIndex++, wszName, _countof(wszName)) == ERROR_SUCCESS)
 200     {
 201         if (wszName[0] != L'.')
 202             continue;
 203
 204         pNewItem = LoadItem(wszName);
 205         if (pNewItem)
 206         {
 207             if (wcsicmp(pNewItem->pwszExt, L".lnk") == 0)
 208             {
 209                 /* Link handler */
 210                 m_pLinkItem = pNewItem;
 211             }
 212             else
 213             {
 214                 /* Add at the end of list */
 215                 if (pCurItem)
 216                 {
 217                     pCurItem->pNext = pNewItem;
 218                     pCurItem = pNewItem;
 219                 }
 220                 else
 221                     pCurItem = m_pItems = pNewItem;
 222             }
 223         }
 224     }
 225
 226     if (!m_pLinkItem)
 227     {
 228         m_pLinkItem = (SHELLNEW_ITEM *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHELLNEW_ITEM));
 229         if (m_pLinkItem)
 230         {
 231             m_pLinkItem->Type = SHELLNEW_TYPE_NULLFILE;
 232             m_pLinkItem->pwszDesc = _wcsdup(L"Link");
 233             m_pLinkItem->pwszExt = _wcsdup(L".lnk");
 234         }
 235     }
 236
 237     if (m_pItems == NULL)
 238         return FALSE;
 239     else
 240         return TRUE;
 241 }
 242
 243 UINT
 244 CNewMenu::InsertShellNewItems(HMENU hMenu, UINT idCmdFirst, UINT Pos)
 245 {
 246     MENUITEMINFOW mii;
 247     WCHAR wszBuf[256];
 248     UINT idCmd = idCmdFirst;
 249
 250     if (m_pItems == NULL)
 251     {
 252         if (!LoadAllItems())
 253             return 0;
 254     }
 255
 256     ZeroMemory(&mii, sizeof(mii));
 257     mii.cbSize = sizeof(mii);
 258
 259     /* Insert new folder action */
 260     if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWFOLDER, wszBuf, _countof(wszBuf)))
 261         wszBuf[0] = 0;
 262     mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
 263     mii.fType = MFT_STRING;
 264     mii.dwTypeData = wszBuf;
 265     mii.cch = wcslen(mii.dwTypeData);
 266     mii.wID = idCmd;
 267     if (m_hbmFolder)
 268     {
 269         mii.fMask |= MIIM_CHECKMARKS;
 270         mii.hbmpChecked = mii.hbmpUnchecked = m_hbmFolder;
 271     }
 272     if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
 273         ++idCmd;
 274
 275     /* Insert new shortcut action */
 276     if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWLINK, wszBuf, _countof(wszBuf)))
 277         wszBuf[0] = 0;
 278     mii.dwTypeData = wszBuf;
 279     mii.cch = wcslen(mii.dwTypeData);
 280     mii.wID = idCmd;
 281     if (m_hbmLink)
 282     {
 283         mii.fMask |= MIIM_CHECKMARKS;
 284         mii.hbmpChecked = mii.hbmpUnchecked = m_hbmLink;
 285     }
 286     if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
 287         ++idCmd;
 288
 289     /* Insert seperator for custom new action */
 290     mii.fMask = MIIM_TYPE | MIIM_ID;
 291     mii.fType = MFT_SEPARATOR;
 292     mii.wID = -1;
 293     InsertMenuItemW(hMenu, Pos++, TRUE, &mii);
 294
 295     /* Insert rest of items */
 296     mii.fType = MFT_STRING;
 297     mii.fState = MFS_ENABLED;
 298
 299     SHELLNEW_ITEM *pCurItem = m_pItems;
 300     while (pCurItem)
 301     {
 302         TRACE("szDesc %s\n", debugstr_w(pCurItem->pwszDesc));
 303         mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
 304         mii.dwTypeData = pCurItem->pwszDesc;
 305         mii.cch = wcslen(mii.dwTypeData);
 306         mii.wID = idCmd;
 307         if (pCurItem->hBitmap)
 308         {
 309             mii.fMask |= MIIM_CHECKMARKS;
 310             mii.hbmpChecked = mii.hbmpUnchecked = pCurItem->hBitmap;
 311         }
 312         if (InsertMenuItemW(hMenu, Pos++, TRUE, &mii))
 313             ++idCmd;
 314         pCurItem = pCurItem->pNext;
 315     }
 316
 317     return idCmd - idCmdFirst;
 318 }
 319
 320 CNewMenu::SHELLNEW_ITEM *CNewMenu::FindItemFromIdOffset(UINT IdOffset)
 321 {
 322     if (IdOffset == 0)
 323         return NULL; /* Folder */
 324
 325     if (IdOffset == 1)
 326         return m_pLinkItem; /* shortcut */
 327
 328     /* Find shell new item */
 329     SHELLNEW_ITEM *pItem = m_pItems;
 330     for (UINT i = 2; pItem; ++i)
 331     {
 332         if (i == IdOffset)
 333             break;
 334
 335         pItem = pItem->pNext;
 336     }
 337
 338     return pItem;
 339 }
 340
 341 HRESULT CNewMenu::CreateNewFolder(IShellView *psv)
 342 {
 343     WCHAR wszName[MAX_PATH];
 344     CComPtr<ISFHelper> psfhlp;
 345     CComPtr<IFolderView> pFolderView;
 346     CComPtr<IShellFolder> pParentFolder;
 347     HRESULT hr;
 348
 349     //if (m_pSite == NULL)
 350     //    return E_FAIL;
 351
 352     /* Get current folder */
 353     hr = IUnknown_QueryService(psv, SID_IFolderView, IID_IFolderView, (void **)&pFolderView);
 354     if (FAILED(hr))
 355         return hr;
 356
 357     hr = pFolderView->GetFolder(IID_IShellFolder, (void **)&pParentFolder);
 358     if (FAILED(hr))
 359         return hr;
 360
 361     hr = pParentFolder->QueryInterface(IID_ISFHelper, (LPVOID*)&psfhlp);
 362     if (FAILED(hr))
 363         return hr;
 364
 365     LPITEMIDLIST pidl;
 366
 367     /* Get unique name and create a folder */
 368     hr = psfhlp->GetUniqueName(wszName, _countof(wszName));
 369     if (hr != S_OK)
 370         return hr;
 371     hr = psfhlp->AddFolder(0, wszName, &pidl);
 372     if (hr != S_OK)
 373     {
 374         WCHAR wszBuf[256];
 375         StringCbPrintfW(wszBuf, sizeof(wszBuf), L"Cannot create folder: %s", wszName);
 376         MessageBoxW(NULL, wszBuf, L"Cannot create folder", MB_OK|MB_ICONERROR);
 377         return hr;
 378     }
 379
 380     /* Do a labeledit */
 381     psv->Refresh();
 382     psv->SelectItem(pidl, SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE |
 383                           SVSI_FOCUSED | SVSI_SELECT);
 384
 385     SHFree(pidl);
 386     return S_OK;
 387 }
 388
 389 HRESULT CNewMenu::CreateNewItem(SHELLNEW_ITEM *pItem, LPCMINVOKECOMMANDINFO lpcmi, IShellView *psv)
 390 {
 391     LPITEMIDLIST pidl;
 392     STRRET strTemp;
 393     WCHAR wszBuf[MAX_PATH];
 394     WCHAR wszPath[MAX_PATH];
 395     CComPtr<IFolderView> pFolderView;
 396     CComPtr<IShellFolder> pParentFolder;
 397     CComPtr<IPersistFolder3> psf;
 398     HRESULT hr;
 399
 400     /* Get current folder */
 401     hr = IUnknown_QueryService(psv, SID_IFolderView, IID_IFolderView, (void **)&pFolderView);
 402     if (FAILED(hr))
 403         return hr;
 404
 405     hr = pFolderView->GetFolder(IID_IShellFolder, (void **)&pParentFolder);
 406     if (FAILED(hr))
 407         return hr;
 408
 409     if (pParentFolder->QueryInterface(IID_IPersistFolder2, (LPVOID*)&psf) != S_OK)
 410     {
 411         ERR("Failed to get interface IID_IPersistFolder2\n");
 412         return E_FAIL;
 413     }
 414
 415     if (psf->GetCurFolder(&pidl) != S_OK)
 416     {
 417         ERR("IPersistFolder2_GetCurFolder failed\n");
 418         return E_FAIL;
 419     }
 420
 421     /* Get folder path */
 422     if (pParentFolder == NULL || pParentFolder->GetDisplayNameOf(pidl, SHGDN_FORPARSING, &strTemp) != S_OK)
 423     {
 424         ERR("IShellFolder_GetDisplayNameOf failed\n");
 425         return E_FAIL;
 426     }
 427     StrRetToBufW(&strTemp, pidl, wszPath, _countof(wszPath));
 428
 429     switch (pItem->Type)
 430     {
 431         case SHELLNEW_TYPE_COMMAND:
 432         {
 433             LPWSTR Ptr, pwszCmd;
 434             WCHAR wszTemp[MAX_PATH];
 435             STARTUPINFOW si;
 436             PROCESS_INFORMATION pi;
 437
 438             if (!ExpandEnvironmentStringsW((LPWSTR)pItem->pData, wszBuf, MAX_PATH))
 439             {
 440                 TRACE("ExpandEnvironmentStrings failed\n");
 441                 break;
 442             }
 443
 444             /* Expand command parameter, FIXME: there can be more modifiers */
 445             Ptr = wcsstr(wszBuf, L"%1");
 446             if (Ptr)
 447             {
 448                 Ptr[1] = 's';
 449                 StringCbPrintfW(wszTemp, sizeof(wszTemp), wszBuf, wszPath);
 450                 pwszCmd = wszTemp;
 451             }
 452             else
 453                 pwszCmd = wszBuf;
 454
 455             /* Create process */
 456             ZeroMemory(&si, sizeof(si));
 457             si.cb = sizeof(si);
 458             if (CreateProcessW(NULL, pwszCmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
 459             {
 460                 CloseHandle(pi.hProcess);
 461                 CloseHandle(pi.hThread);
 462             } else
 463                 ERR("Failed to create process\n");
 464             break;
 465         }
 466         case SHELLNEW_TYPE_DATA:
 467         case SHELLNEW_TYPE_FILENAME:
 468         case SHELLNEW_TYPE_NULLFILE:
 469         {
 470             BOOL bSuccess = TRUE;
 471             LPWSTR pwszFilename = NULL;
 472             size_t cchFilenameMax = 0;
 473
 474             /* Build new file name */
 475             LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEW, wszBuf, _countof(wszBuf));
 476             StringCchCatExW(wszPath, _countof(wszPath), L"\\", &pwszFilename, &cchFilenameMax, 0);
 477             StringCchPrintfW(pwszFilename, cchFilenameMax, L"%s %s%s", wszBuf, pItem->pwszDesc, pItem->pwszExt);
 478
 479             /* Find unique name */
 480             for (UINT i = 2; PathFileExistsW(wszPath); ++i)
 481             {
 482                 StringCchPrintfW(pwszFilename, cchFilenameMax, L"%s %s (%u)%s", wszBuf, pItem->pwszDesc, i, pItem->pwszExt);
 483                 TRACE("New Filename %ls\n", pwszFilename);
 484             }
 485
 486             /* Create new file */
 487             HANDLE hFile = CreateFileW(wszPath, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
 488             if (hFile != INVALID_HANDLE_VALUE)
 489             {
 490                 if (pItem->Type == SHELLNEW_TYPE_DATA)
 491                 {
 492                     /* Write a content */
 493                     DWORD cbWritten;
 494                     WriteFile(hFile, pItem->pData, pItem->cbData, &cbWritten, NULL);
 495                 }
 496
 497                 /* Close file now */
 498                 CloseHandle(hFile);
 499             } else
 500                 bSuccess = FALSE;
 501
 502             if (pItem->Type == SHELLNEW_TYPE_FILENAME)
 503             {
 504                 /* Copy file */
 505                 if (!CopyFileW((LPWSTR)pItem->pData, wszPath, FALSE))
 506                     ERR("Copy file failed: %ls\n", (LPWSTR)pItem->pData);
 507             }
 508
 509             /* Show message if we failed */
 510             if (bSuccess)
 511             {
 512                 TRACE("Notifying fs %s\n", debugstr_w(wszPath));
 513                 SHChangeNotify(SHCNE_CREATE, SHCNF_PATHW, (LPCVOID)wszPath, NULL);
 514                 psv->Refresh();
 515
 516                 LPITEMIDLIST pidl;
 517                 hr = _ILCreateFromPathW(wszPath, &pidl);
 518                 if (SUCCEEDED(hr))
 519                 {
 520                     psv->SelectItem(pidl, SVSI_DESELECTOTHERS|SVSI_EDIT|SVSI_ENSUREVISIBLE|SVSI_FOCUSED|SVSI_SELECT);
 521                     ILFree(pidl);
 522                 }
 523             }
 524             else
 525             {
 526                 StringCbPrintfW(wszBuf, sizeof(wszBuf), L"Cannot create file: %s", pwszFilename);
 527                 MessageBoxW(NULL, wszBuf, L"Cannot create file", MB_OK|MB_ICONERROR); // FIXME
 528             }
 529             break;
 530         }
 531         case SHELLNEW_TYPE_INVALID:
 532             ERR("Invalid type\n");
 533             break;
 534     }
 535
 536     return S_OK;
 537 }
 538
 539 HRESULT STDMETHODCALLTYPE CNewMenu::SetSite(IUnknown *pUnkSite)
 540 {
 541     m_pSite = pUnkSite;
 542     return S_OK;
 543 }
 544
 545 HRESULT STDMETHODCALLTYPE CNewMenu::GetSite(REFIID riid, void **ppvSite)
 546 {
 547     if (ppvSite == NULL)
 548         return E_POINTER;
 549     *ppvSite = m_pSite;
 550     if (m_pSite != NULL)
 551         m_pSite->AddRef();
 552     return S_OK;
 553 }
 554
 555 HRESULT
 556 WINAPI
 557 CNewMenu::QueryContextMenu(HMENU hMenu,
 558                            UINT indexMenu,
 559                            UINT idCmdFirst,
 560                            UINT idCmdLast,
 561                            UINT uFlags)
 562 {
 563     WCHAR wszNew[200];
 564     MENUITEMINFOW mii;
 565     UINT cItems = 0;
 566
 567     TRACE("%p %p %u %u %u %u\n", this,
 568           hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
 569
 570     if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEW, wszNew, _countof(wszNew)))
 571         return E_FAIL;
 572
 573     m_hSubMenu = CreateMenu();
 574     if (!m_hSubMenu)
 575         return E_FAIL;
 576
 577     cItems = InsertShellNewItems(m_hSubMenu, idCmdFirst, 0);
 578
 579     memset(&mii, 0, sizeof(mii));
 580     mii.cbSize = sizeof(mii);
 581     mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE | MIIM_SUBMENU;
 582     mii.fType = MFT_STRING;
 583     mii.wID = -1;
 584     mii.dwTypeData = wszNew;
 585     mii.cch = wcslen(mii.dwTypeData);
 586     mii.fState = MFS_ENABLED;
 587     mii.hSubMenu = m_hSubMenu;
 588
 589     if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
 590         return E_FAIL;
 591
 592     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, cItems);
 593 }
 594
 595 HRESULT
 596 WINAPI
 597 CNewMenu::InvokeCommand(LPCMINVOKECOMMANDINFO lpici)
 598 {
 599     IShellBrowser *lpSB = NULL;
 600     CComPtr<IShellView> lpSV = NULL;
 601     HRESULT hr = E_FAIL;
 602
 603     /* Note: CWM_GETISHELLBROWSER returns shell browser without adding reference */
 604     lpSB = (LPSHELLBROWSER)SendMessageA(lpici->hwnd, CWM_GETISHELLBROWSER, 0, 0);
 605     if (lpSB)
 606         lpSB->QueryActiveShellView(&lpSV);
 607
 608     if (LOWORD(lpici->lpVerb) == 0)
 609         hr = CreateNewFolder(lpSV);
 610     else
 611     {
 612         SHELLNEW_ITEM *pItem = FindItemFromIdOffset(LOWORD(lpici->lpVerb));
 613         if (pItem)
 614             hr = CreateNewItem(pItem, lpici, lpSV);
 615     }
 616
 617     TRACE("CNewMenu::InvokeCommand %x\n", hr);
 618     return hr;
 619 }
 620
 621 HRESULT
 622 WINAPI
 623 CNewMenu::GetCommandString(UINT_PTR idCmd,
 624                            UINT uType,
 625                            UINT *pwReserved,
 626                            LPSTR pszName,
 627                            UINT cchMax)
 628 {
 629     FIXME("%p %lu %u %p %p %u\n", this,
 630           idCmd, uType, pwReserved, pszName, cchMax );
 631
 632     return E_NOTIMPL;
 633 }
 634
 635 HRESULT
 636 WINAPI
 637 CNewMenu::HandleMenuMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
 638 {
 639     return S_OK;
 640 }
 641
 642 HRESULT WINAPI
 643 CNewMenu::Initialize(LPCITEMIDLIST pidlFolder,
 644                      IDataObject *pdtobj, HKEY hkeyProgID)
 645 {
 646     /* Load folder and shortcut icons */
 647     HICON hIcon = (HICON)LoadImage(shell32_hInstance, MAKEINTRESOURCE(IDI_SHELL_FOLDER), IMAGE_ICON, 0, 0, LR_SHARED);
 648     m_hbmFolder = hIcon ? IconToBitmap(hIcon) : NULL;
 649     hIcon = (HICON)LoadImage(shell32_hInstance, MAKEINTRESOURCE(IDI_SHELL_SHORTCUT), IMAGE_ICON, 0, 0, LR_SHARED);
 650     m_hbmLink = hIcon ? IconToBitmap(hIcon) : NULL;
 651
 652     return S_OK;
 653 }