reactos/dll/win32/shell32/folders/CControlPanelFolder.cpp

   1 /*
   2  * Control panel folder
   3  *
   4  * Copyright 2003 Martin Fuchs
   5  * Copyright 2009 Andrew Hill
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <precomp.h>
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  25
  26 /***********************************************************************
  27 *   control panel implementation in shell namespace
  28 */
  29
  30 class CControlPanelEnum :
  31     public CEnumIDListBase
  32 {
  33     public:
  34         CControlPanelEnum();
  35         ~CControlPanelEnum();
  36         HRESULT WINAPI Initialize(DWORD dwFlags);
  37         BOOL RegisterCPanelApp(LPCWSTR path);
  38         int RegisterRegistryCPanelApps(HKEY hkey_root, LPCWSTR szRepPath);
  39         int RegisterCPanelFolders(HKEY hkey_root, LPCWSTR szRepPath);
  40         BOOL CreateCPanelEnumList(DWORD dwFlags);
  41
  42         BEGIN_COM_MAP(CControlPanelEnum)
  43         COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
  44         END_COM_MAP()
  45 };
  46
  47 /***********************************************************************
  48 *   IShellFolder [ControlPanel] implementation
  49 */
  50
  51 static const shvheader ControlPanelSFHeader[] = {
  52     {IDS_SHV_COLUMN8, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 20},/*FIXME*/
  53     {IDS_SHV_COLUMN9, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 80},/*FIXME*/
  54 };
  55
  56 #define CONROLPANELSHELLVIEWCOLUMNS 2
  57
  58 CControlPanelEnum::CControlPanelEnum()
  59 {
  60 }
  61
  62 CControlPanelEnum::~CControlPanelEnum()
  63 {
  64 }
  65
  66 HRESULT WINAPI CControlPanelEnum::Initialize(DWORD dwFlags)
  67 {
  68     if (CreateCPanelEnumList(dwFlags) == FALSE)
  69         return E_FAIL;
  70     return S_OK;
  71 }
  72
  73 static LPITEMIDLIST _ILCreateCPanelApplet(LPCWSTR pszName, LPCWSTR pszDisplayName, LPCWSTR pszComment, int iIconIdx)
  74 {
  75     PIDLCPanelStruct *pCP;
  76     LPITEMIDLIST pidl;
  77     LPPIDLDATA pData;
  78     int cchName, cchDisplayName, cchComment, cbData;
  79
  80     /* Calculate lengths of given strings */
  81     cchName = wcslen(pszName);
  82     cchDisplayName = wcslen(pszDisplayName);
  83     cchComment = wcslen(pszComment);
  84
  85     /* Allocate PIDL */
  86     cbData = sizeof(pidl->mkid.cb) + sizeof(pData->type) + sizeof(pData->u.cpanel) - sizeof(pData->u.cpanel.szName)
  87              + (cchName + cchDisplayName + cchComment + 3) * sizeof(WCHAR);
  88     pidl = (LPITEMIDLIST)SHAlloc(cbData + sizeof(WORD));
  89     if (!pidl)
  90         return NULL;
  91
  92     /* Copy data to allocated memory */
  93     pidl->mkid.cb = cbData;
  94     pData = (PIDLDATA *)pidl->mkid.abID;
  95     pData->type = PT_CPLAPPLET;
  96
  97     pCP = &pData->u.cpanel;
  98     pCP->dummy = 0;
  99     pCP->iconIdx = iIconIdx;
 100     wcscpy(pCP->szName, pszName);
 101     pCP->offsDispName = cchName + 1;
 102     wcscpy(pCP->szName + pCP->offsDispName, pszDisplayName);
 103     pCP->offsComment = pCP->offsDispName + cchDisplayName + 1;
 104     wcscpy(pCP->szName + pCP->offsComment, pszComment);
 105
 106     /* Add PIDL NULL terminator */
 107     *(WORD*)(pCP->szName + pCP->offsComment + cchComment + 1) = 0;
 108
 109     pcheck(pidl);
 110
 111     return pidl;
 112 }
 113
 114 /**************************************************************************
 115  *  _ILGetCPanelPointer()
 116  * gets a pointer to the control panel struct stored in the pidl
 117  */
 118 static PIDLCPanelStruct *_ILGetCPanelPointer(LPCITEMIDLIST pidl)
 119 {
 120     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
 121
 122     if (pdata && pdata->type == PT_CPLAPPLET)
 123         return (PIDLCPanelStruct *) & (pdata->u.cpanel);
 124
 125     return NULL;
 126 }
 127
 128 HRESULT CCPLExtractIcon_CreateInstance(IShellFolder * psf, LPCITEMIDLIST pidl, REFIID riid, LPVOID * ppvOut)
 129 {
 130     PIDLCPanelStruct *pData = _ILGetCPanelPointer(pidl);
 131     if (!pData)
 132     {
 133         return CGuidItemExtractIcon_CreateInstance(psf, pidl, riid, ppvOut);
 134     }
 135
 136     CComPtr<IDefaultExtractIconInit> initIcon;
 137     HRESULT hr = SHCreateDefaultExtractIcon(IID_PPV_ARG(IDefaultExtractIconInit, &initIcon));
 138     if (FAILED(hr))
 139         return NULL;
 140
 141     initIcon->SetNormalIcon(pData->szName, (int)pData->iconIdx != -1 ? pData->iconIdx : 0);
 142
 143     return initIcon->QueryInterface(riid, ppvOut);
 144 }
 145
 146 BOOL CControlPanelEnum::RegisterCPanelApp(LPCWSTR wpath)
 147 {
 148     CPlApplet* applet = Control_LoadApplet(0, wpath, NULL);
 149     int iconIdx;
 150
 151     if (applet)
 152     {
 153         for (UINT i = 0; i < applet->count; ++i)
 154         {
 155             if (applet->info[i].idIcon > 0)
 156                 iconIdx = -applet->info[i].idIcon; /* negative icon index instead of icon number */
 157             else
 158                 iconIdx = 0;
 159
 160             LPITEMIDLIST pidl = _ILCreateCPanelApplet(wpath,
 161                                                       applet->info[i].name,
 162                                                       applet->info[i].info,
 163                                                       iconIdx);
 164
 165             if (pidl)
 166                 AddToEnumList(pidl);
 167         }
 168         Control_UnloadApplet(applet);
 169     }
 170     return TRUE;
 171 }
 172
 173 int CControlPanelEnum::RegisterRegistryCPanelApps(HKEY hkey_root, LPCWSTR szRepPath)
 174 {
 175     WCHAR name[MAX_PATH];
 176     WCHAR value[MAX_PATH];
 177     HKEY hkey;
 178
 179     int cnt = 0;
 180
 181     if (RegOpenKeyW(hkey_root, szRepPath, &hkey) == ERROR_SUCCESS)
 182     {
 183         int idx = 0;
 184
 185         for(; ; idx++)
 186         {
 187             DWORD nameLen = MAX_PATH;
 188             DWORD valueLen = MAX_PATH;
 189             WCHAR buffer[MAX_PATH];
 190
 191             if (RegEnumValueW(hkey, idx, name, &nameLen, NULL, NULL, (LPBYTE)&value, &valueLen) != ERROR_SUCCESS)
 192                 break;
 193
 194             if (ExpandEnvironmentStringsW(value, buffer, MAX_PATH))
 195             {
 196                 wcscpy(value, buffer);
 197             }
 198
 199             if (RegisterCPanelApp(value))
 200                 ++cnt;
 201         }
 202         RegCloseKey(hkey);
 203     }
 204
 205     return cnt;
 206 }
 207
 208 int CControlPanelEnum::RegisterCPanelFolders(HKEY hkey_root, LPCWSTR szRepPath)
 209 {
 210     WCHAR name[MAX_PATH];
 211     HKEY hkey;
 212
 213     int cnt = 0;
 214
 215     if (RegOpenKeyW(hkey_root, szRepPath, &hkey) == ERROR_SUCCESS)
 216     {
 217         for (int idx = 0; ; idx++)
 218         {
 219             if (RegEnumKeyW(hkey, idx, name, MAX_PATH) != ERROR_SUCCESS)
 220                 break;
 221
 222             if (*name == '{')
 223             {
 224                 LPITEMIDLIST pidl = _ILCreateGuidFromStrW(name);
 225
 226                 if (pidl && AddToEnumList(pidl))
 227                     ++cnt;
 228             }
 229         }
 230
 231         RegCloseKey(hkey);
 232     }
 233
 234     return cnt;
 235 }
 236
 237 /**************************************************************************
 238  *  CControlPanelEnum::CreateCPanelEnumList()
 239  */
 240 BOOL CControlPanelEnum::CreateCPanelEnumList(DWORD dwFlags)
 241 {
 242     WCHAR szPath[MAX_PATH];
 243     WIN32_FIND_DATAW wfd;
 244     HANDLE hFile;
 245
 246     TRACE("(%p)->(flags=0x%08x)\n", this, dwFlags);
 247
 248     /* enumerate control panel folders */
 249     if (dwFlags & SHCONTF_FOLDERS)
 250         RegisterCPanelFolders(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ControlPanel\\NameSpace");
 251
 252     /* enumerate the control panel applets */
 253     if (dwFlags & SHCONTF_NONFOLDERS)
 254     {
 255         LPWSTR p;
 256
 257         GetSystemDirectoryW(szPath, MAX_PATH);
 258         p = PathAddBackslashW(szPath);
 259         wcscpy(p, L"*.cpl");
 260
 261         hFile = FindFirstFileW(szPath, &wfd);
 262
 263         if (hFile != INVALID_HANDLE_VALUE)
 264         {
 265             do
 266             {
 267                 if (!(dwFlags & SHCONTF_INCLUDEHIDDEN) && (wfd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
 268                     continue;
 269
 270                 if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 271                     wcscpy(p, wfd.cFileName);
 272                     if (wcscmp(wfd.cFileName, L"ncpa.cpl"))
 273                         RegisterCPanelApp(szPath);
 274                 }
 275             } while(FindNextFileW(hFile, &wfd));
 276             FindClose(hFile);
 277         }
 278
 279         RegisterRegistryCPanelApps(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Control Panel\\Cpls");
 280         RegisterRegistryCPanelApps(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Control Panel\\Cpls");
 281     }
 282     return TRUE;
 283 }
 284
 285 CControlPanelFolder::CControlPanelFolder()
 286 {
 287     pidlRoot = NULL;    /* absolute pidl */
 288 }
 289
 290 CControlPanelFolder::~CControlPanelFolder()
 291 {
 292     TRACE("-- destroying IShellFolder(%p)\n", this);
 293     SHFree(pidlRoot);
 294 }
 295
 296 /**************************************************************************
 297 *    CControlPanelFolder::ParseDisplayName
 298 */
 299 HRESULT WINAPI CControlPanelFolder::ParseDisplayName(
 300     HWND hwndOwner,
 301     LPBC pbc,
 302     LPOLESTR lpszDisplayName,
 303     DWORD *pchEaten,
 304     PIDLIST_RELATIVE *ppidl,
 305     DWORD *pdwAttributes)
 306 {
 307     /* We only support parsing guid names */
 308     return SH_ParseGuidDisplayName(this, hwndOwner, pbc, lpszDisplayName, pchEaten, ppidl, pdwAttributes);
 309 }
 310
 311 /**************************************************************************
 312 *        CControlPanelFolder::EnumObjects
 313 */
 314 HRESULT WINAPI CControlPanelFolder::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
 315 {
 316     return ShellObjectCreatorInit<CControlPanelEnum>(dwFlags, IID_IEnumIDList, ppEnumIDList);
 317 }
 318
 319 /**************************************************************************
 320 *        CControlPanelFolder::BindToObject
 321 */
 322 HRESULT WINAPI CControlPanelFolder::BindToObject(
 323     PCUIDLIST_RELATIVE pidl,
 324     LPBC pbcReserved,
 325     REFIID riid,
 326     LPVOID *ppvOut)
 327 {
 328     return SHELL32_BindToGuidItem(pidlRoot, pidl, pbcReserved, riid, ppvOut);
 329 }
 330
 331 /**************************************************************************
 332 *    CControlPanelFolder::BindToStorage
 333 */
 334 HRESULT WINAPI CControlPanelFolder::BindToStorage(
 335     PCUIDLIST_RELATIVE pidl,
 336     LPBC pbcReserved,
 337     REFIID riid,
 338     LPVOID *ppvOut)
 339 {
 340     FIXME("(%p)->(pidl=%p,%p,%s,%p) stub\n", this, pidl, pbcReserved, shdebugstr_guid(&riid), ppvOut);
 341
 342     *ppvOut = NULL;
 343     return E_NOTIMPL;
 344 }
 345
 346 /**************************************************************************
 347 *     CControlPanelFolder::CompareIDs
 348 */
 349 HRESULT WINAPI CControlPanelFolder::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
 350 {
 351     /* Dont use SHELL32_CompareGuidItems because it would cause guid items to come first */
 352     if (_ILIsSpecialFolder(pidl1) || _ILIsSpecialFolder(pidl2))
 353     {
 354         return SHELL32_CompareDetails(this, lParam, pidl1, pidl2);
 355     }
 356     PIDLCPanelStruct *pData1 = _ILGetCPanelPointer(pidl1);
 357     PIDLCPanelStruct *pData2 = _ILGetCPanelPointer(pidl2);
 358
 359     if (!pData1 || !pData2 || LOWORD(lParam)>= CONROLPANELSHELLVIEWCOLUMNS)
 360         return E_INVALIDARG;
 361
 362     int result;
 363     switch(LOWORD(lParam))
 364     {
 365         case 0:        /* name */
 366             result = wcsicmp(pData1->szName + pData1->offsDispName, pData2->szName + pData2->offsDispName);
 367             break;
 368         case 1:        /* comment */
 369             result = wcsicmp(pData1->szName + pData1->offsComment, pData2->szName + pData2->offsComment);
 370             break;
 371         default:
 372             ERR("Got wrong lParam!\n");
 373             return E_INVALIDARG;
 374     }
 375
 376     return MAKE_COMPARE_HRESULT(result);
 377 }
 378
 379 /**************************************************************************
 380 *    CControlPanelFolder::CreateViewObject
 381 */
 382 HRESULT WINAPI CControlPanelFolder::CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID * ppvOut)
 383 {
 384     CComPtr<IShellView>                    pShellView;
 385     HRESULT hr = E_INVALIDARG;
 386
 387     TRACE("(%p)->(hwnd=%p,%s,%p)\n", this, hwndOwner, shdebugstr_guid(&riid), ppvOut);
 388
 389     if (ppvOut) {
 390         *ppvOut = NULL;
 391
 392         if (IsEqualIID(riid, IID_IDropTarget)) {
 393             WARN("IDropTarget not implemented\n");
 394             hr = E_NOTIMPL;
 395         } else if (IsEqualIID(riid, IID_IContextMenu)) {
 396             WARN("IContextMenu not implemented\n");
 397             hr = E_NOTIMPL;
 398         } else if (IsEqualIID(riid, IID_IShellView)) {
 399             hr = CDefView_Constructor(this, riid, ppvOut);
 400         }
 401     }
 402     TRACE("--(%p)->(interface=%p)\n", this, ppvOut);
 403     return hr;
 404 }
 405
 406 /**************************************************************************
 407 *  CControlPanelFolder::GetAttributesOf
 408 */
 409 HRESULT WINAPI CControlPanelFolder::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD * rgfInOut)
 410 {
 411     HRESULT hr = S_OK;
 412     static const DWORD dwControlPanelAttributes =
 413         SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_CANLINK;
 414
 415     TRACE("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
 416           this, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
 417
 418     if (!rgfInOut)
 419         return E_INVALIDARG;
 420     if (cidl && !apidl)
 421         return E_INVALIDARG;
 422
 423     if (*rgfInOut == 0)
 424         *rgfInOut = ~0;
 425
 426     if (!cidl)
 427     {
 428         *rgfInOut &= dwControlPanelAttributes;
 429     }
 430     else
 431     {
 432         while(cidl > 0 && *apidl)
 433         {
 434             pdump(*apidl);
 435             if (_ILIsCPanelStruct(*apidl))
 436                 *rgfInOut &= SFGAO_CANLINK;
 437             else if (_ILIsSpecialFolder(*apidl))
 438                 SHELL32_GetGuidItemAttributes(this, *apidl, rgfInOut);
 439             else
 440                 ERR("Got an unkown pidl here!\n");
 441             apidl++;
 442             cidl--;
 443         }
 444     }
 445     /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
 446     *rgfInOut &= ~SFGAO_VALIDATE;
 447
 448     TRACE("-- result=0x%08x\n", *rgfInOut);
 449     return hr;
 450 }
 451
 452 /**************************************************************************
 453 *    CControlPanelFolder::GetUIObjectOf
 454 *
 455 * PARAMETERS
 456 *  HWND           hwndOwner, //[in ] Parent window for any output
 457 *  UINT           cidl,      //[in ] array size
 458 *  LPCITEMIDLIST* apidl,     //[in ] simple pidl array
 459 *  REFIID         riid,      //[in ] Requested Interface
 460 *  UINT*          prgfInOut, //[   ] reserved
 461 *  LPVOID*        ppvObject) //[out] Resulting Interface
 462 *
 463 */
 464 HRESULT WINAPI CControlPanelFolder::GetUIObjectOf(HWND hwndOwner,
 465         UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT * prgfInOut, LPVOID * ppvOut)
 466 {
 467     LPVOID pObj = NULL;
 468     HRESULT hr = E_INVALIDARG;
 469
 470     TRACE("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
 471           this, hwndOwner, cidl, apidl, shdebugstr_guid(&riid), prgfInOut, ppvOut);
 472
 473     if (ppvOut) {
 474         *ppvOut = NULL;
 475
 476         if (IsEqualIID(riid, IID_IContextMenu) && (cidl >= 1)) {
 477
 478             /* HACK: We should use callbacks from CDefaultContextMenu instead of creating one on our own */
 479             BOOL bHasCpl = FALSE;
 480             for (UINT i = 0; i < cidl; i++)
 481             {
 482                 if(_ILIsCPanelStruct(apidl[i]))
 483                 {
 484                     bHasCpl = TRUE;
 485                 }
 486             }
 487
 488             if (bHasCpl)
 489                 hr = ShellObjectCreatorInit<CCPLItemMenu>(cidl, apidl, riid, &pObj);
 490             else
 491                 hr = CDefFolderMenu_Create2(pidlRoot, hwndOwner, cidl, apidl, (IShellFolder*)this, NULL, 0, NULL, (IContextMenu**)&pObj);
 492         } else if (IsEqualIID(riid, IID_IDataObject) && (cidl >= 1)) {
 493             hr = IDataObject_Constructor(hwndOwner, pidlRoot, apidl, cidl, (IDataObject **)&pObj);
 494         } else if ((IsEqualIID(riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW)) && (cidl == 1)) {
 495             hr = CCPLExtractIcon_CreateInstance(this, apidl[0], riid, &pObj);
 496         } else {
 497             hr = E_NOINTERFACE;
 498         }
 499
 500         if (SUCCEEDED(hr) && !pObj)
 501             hr = E_OUTOFMEMORY;
 502
 503         *ppvOut = pObj;
 504     }
 505     TRACE("(%p)->hr=0x%08x\n", this, hr);
 506     return hr;
 507 }
 508
 509 /**************************************************************************
 510 *    CControlPanelFolder::GetDisplayNameOf
 511 */
 512 HRESULT WINAPI CControlPanelFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
 513 {
 514     if (!pidl)
 515         return S_FALSE;
 516
 517     PIDLCPanelStruct *pCPanel = _ILGetCPanelPointer(pidl);
 518
 519     if (pCPanel)
 520     {
 521         return SHSetStrRet(strRet, pCPanel->szName + pCPanel->offsDispName);
 522     }
 523     else if (_ILIsSpecialFolder(pidl))
 524     {
 525         static const WCHAR* pszCPanelPath = L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}";
 526         return SHELL32_GetDisplayNameOfGUIDItem(this, pszCPanelPath, pidl, dwFlags, strRet);
 527     }
 528
 529     return S_OK;
 530 }
 531
 532 /**************************************************************************
 533 *  CControlPanelFolder::SetNameOf
 534 *  Changes the name of a file object or subfolder, possibly changing its item
 535 *  identifier in the process.
 536 *
 537 * PARAMETERS
 538 *  HWND          hwndOwner,  //[in ] Owner window for output
 539 *  LPCITEMIDLIST pidl,       //[in ] simple pidl of item to change
 540 *  LPCOLESTR     lpszName,   //[in ] the items new display name
 541 *  DWORD         dwFlags,    //[in ] SHGNO formatting flags
 542 *  LPITEMIDLIST* ppidlOut)   //[out] simple pidl returned
 543 */
 544 HRESULT WINAPI CControlPanelFolder::SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl,    /*simple pidl */
 545         LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
 546 {
 547     FIXME("(%p)->(%p,pidl=%p,%s,%u,%p)\n", this, hwndOwner, pidl, debugstr_w(lpName), dwFlags, pPidlOut);
 548     return E_FAIL;
 549 }
 550
 551 HRESULT WINAPI CControlPanelFolder::GetDefaultSearchGUID(GUID *pguid)
 552 {
 553     FIXME("(%p)\n", this);
 554     return E_NOTIMPL;
 555 }
 556
 557 HRESULT WINAPI CControlPanelFolder::EnumSearches(IEnumExtraSearch **ppenum)
 558 {
 559     FIXME("(%p)\n", this);
 560     return E_NOTIMPL;
 561 }
 562
 563 HRESULT WINAPI CControlPanelFolder::GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
 564 {
 565     TRACE("(%p)\n", this);
 566
 567     if (pSort) *pSort = 0;
 568     if (pDisplay) *pDisplay = 0;
 569     return S_OK;
 570 }
 571
 572 HRESULT WINAPI CControlPanelFolder::GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags)
 573 {
 574     TRACE("(%p)\n", this);
 575
 576     if (!pcsFlags || iColumn >= CONROLPANELSHELLVIEWCOLUMNS) return E_INVALIDARG;
 577     *pcsFlags = ControlPanelSFHeader[iColumn].pcsFlags;
 578     return S_OK;
 579 }
 580
 581 HRESULT WINAPI CControlPanelFolder::GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv)
 582 {
 583     FIXME("(%p)\n", this);
 584     return E_NOTIMPL;
 585 }
 586
 587 HRESULT WINAPI CControlPanelFolder::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
 588 {
 589     if (!psd || iColumn >= CONROLPANELSHELLVIEWCOLUMNS)
 590         return E_INVALIDARG;
 591
 592     if (!pidl)
 593     {
 594         psd->fmt = ControlPanelSFHeader[iColumn].fmt;
 595         psd->cxChar = ControlPanelSFHeader[iColumn].cxChar;
 596         return SHSetStrRet(&psd->str, shell32_hInstance, ControlPanelSFHeader[iColumn].colnameid);
 597     }
 598     else if (_ILIsSpecialFolder(pidl))
 599     {
 600         return SHELL32_GetDetailsOfGuidItem(this, pidl, iColumn, psd);
 601     }
 602     else
 603     {
 604         PIDLCPanelStruct *pCPanel = _ILGetCPanelPointer(pidl);
 605
 606         if (!pCPanel)
 607             return E_FAIL;
 608
 609         switch(iColumn)
 610         {
 611             case 0:        /* name */
 612                 return SHSetStrRet(&psd->str, pCPanel->szName + pCPanel->offsDispName);
 613             case 1:        /* comment */
 614                 return SHSetStrRet(&psd->str, pCPanel->szName + pCPanel->offsComment);
 615         }
 616     }
 617
 618     return S_OK;
 619 }
 620
 621 HRESULT WINAPI CControlPanelFolder::MapColumnToSCID(UINT column, SHCOLUMNID *pscid)
 622 {
 623     FIXME("(%p)\n", this);
 624     return E_NOTIMPL;
 625 }
 626
 627 /************************************************************************
 628  *    CControlPanelFolder::GetClassID
 629  */
 630 HRESULT WINAPI CControlPanelFolder::GetClassID(CLSID *lpClassId)
 631 {
 632     TRACE("(%p)\n", this);
 633
 634     if (!lpClassId)
 635         return E_POINTER;
 636     *lpClassId = CLSID_ControlPanel;
 637
 638     return S_OK;
 639 }
 640
 641 /************************************************************************
 642  *    CControlPanelFolder::Initialize
 643  *
 644  * NOTES: it makes no sense to change the pidl
 645  */
 646 HRESULT WINAPI CControlPanelFolder::Initialize(LPCITEMIDLIST pidl)
 647 {
 648     if (pidlRoot)
 649         SHFree((LPVOID)pidlRoot);
 650
 651     pidlRoot = ILClone(pidl);
 652     return S_OK;
 653 }
 654
 655 /**************************************************************************
 656  *    CControlPanelFolder::GetCurFolder
 657  */
 658 HRESULT WINAPI CControlPanelFolder::GetCurFolder(LPITEMIDLIST * pidl)
 659 {
 660     TRACE("(%p)->(%p)\n", this, pidl);
 661
 662     if (!pidl)
 663         return E_POINTER;
 664     *pidl = ILClone(pidlRoot);
 665     return S_OK;
 666 }
 667
 668 CCPLItemMenu::CCPLItemMenu()
 669 {
 670     m_apidl = NULL;
 671     m_cidl = 0;
 672 }
 673
 674 HRESULT WINAPI CCPLItemMenu::Initialize(UINT cidl, PCUITEMID_CHILD_ARRAY apidl)
 675 {
 676     m_cidl = cidl;
 677     m_apidl = _ILCopyaPidl(apidl, m_cidl);
 678     if (m_cidl && !m_apidl)
 679         return E_OUTOFMEMORY;
 680
 681     return S_OK;
 682 }
 683
 684 CCPLItemMenu::~CCPLItemMenu()
 685 {
 686     _ILFreeaPidl(m_apidl, m_cidl);
 687 }
 688
 689 HRESULT WINAPI CCPLItemMenu::QueryContextMenu(
 690     HMENU hMenu,
 691     UINT indexMenu,
 692     UINT idCmdFirst,
 693     UINT idCmdLast,
 694     UINT uFlags)
 695 {
 696     _InsertMenuItemW(hMenu, indexMenu++, TRUE, IDS_OPEN, MFT_STRING, MAKEINTRESOURCEW(IDS_OPEN), MFS_DEFAULT);
 697     _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + 1, MFT_SEPARATOR, NULL, MFS_ENABLED);
 698     _InsertMenuItemW(hMenu, indexMenu++, TRUE, IDS_CREATELINK, MFT_STRING, MAKEINTRESOURCEW(IDS_CREATELINK), MFS_ENABLED);
 699
 700     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 2);
 701 }
 702
 703 EXTERN_C
 704 void WINAPI Control_RunDLLW(HWND hWnd, HINSTANCE hInst, LPCWSTR cmd, DWORD nCmdShow);
 705
 706 /**************************************************************************
 707 * ICPanel_IContextMenu_InvokeCommand()
 708 */
 709 HRESULT WINAPI CCPLItemMenu::InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
 710 {
 711     HRESULT hResult;
 712
 713     PIDLCPanelStruct *pCPanel = _ILGetCPanelPointer(m_apidl[0]);
 714     if(!pCPanel)
 715         return E_FAIL;
 716
 717     TRACE("(%p)->(invcom=%p verb=%p wnd=%p)\n", this, lpcmi, lpcmi->lpVerb, lpcmi->hwnd);
 718
 719     if (lpcmi->lpVerb == MAKEINTRESOURCEA(IDS_OPEN)) //FIXME
 720     {
 721         /* Hardcode the command here; Executing a cpl file would be fine but we also need to run things like console.dll */
 722         WCHAR wszParams[MAX_PATH];
 723         PCWSTR wszFile = L"rundll32.exe";
 724         PCWSTR wszFormat = L"shell32.dll,Control_RunDLL %s,%s";
 725
 726         wsprintfW(wszParams, wszFormat, pCPanel->szName, pCPanel->szName + pCPanel->offsDispName);
 727
 728         /* Note: we pass the applet name to Control_RunDLL to distinguish between multiple applets in one .cpl file */
 729         ShellExecuteW(NULL, NULL, wszFile, wszParams, NULL, 0);
 730     }
 731     else if (lpcmi->lpVerb == MAKEINTRESOURCEA(IDS_CREATELINK)) //FIXME
 732     {
 733         CComPtr<IDataObject> pDataObj;
 734         LPITEMIDLIST pidl = _ILCreateControlPanel();
 735
 736         hResult = SHCreateDataObject(pidl, m_cidl, m_apidl, NULL, IID_PPV_ARG(IDataObject, &pDataObj));
 737         if (FAILED(hResult))
 738             return hResult;
 739
 740         SHFree(pidl);
 741
 742         //FIXME: Use SHCreateLinks
 743         CComPtr<IShellFolder> psf;
 744         CComPtr<IDropTarget> pDT;
 745
 746         hResult = SHGetDesktopFolder(&psf);
 747         if (FAILED(hResult))
 748             return hResult;
 749
 750         hResult = psf->CreateViewObject(NULL, IID_PPV_ARG(IDropTarget, &pDT));
 751         if (FAILED(hResult))
 752             return hResult;
 753
 754         SHSimulateDrop(pDT, pDataObj, MK_CONTROL|MK_SHIFT, NULL, NULL);
 755     }
 756     return S_OK;
 757 }
 758
 759 /**************************************************************************
 760  *  ICPanel_IContextMenu_GetCommandString()
 761  *
 762  */
 763 HRESULT WINAPI CCPLItemMenu::GetCommandString(
 764     UINT_PTR idCommand,
 765     UINT uFlags,
 766     UINT* lpReserved,
 767     LPSTR lpszName,
 768     UINT uMaxNameLen)
 769 {
 770     TRACE("(%p)->(idcom=%lx flags=%x %p name=%p len=%x)\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
 771
 772     FIXME("unknown command string\n");
 773     return E_FAIL;
 774 }
 775
 776 /**************************************************************************
 777 * ICPanel_IContextMenu_HandleMenuMsg()
 778 */
 779 HRESULT WINAPI CCPLItemMenu::HandleMenuMsg(
 780     UINT uMsg,
 781     WPARAM wParam,
 782     LPARAM lParam)
 783 {
 784     TRACE("ICPanel_IContextMenu_HandleMenuMsg (%p)->(msg=%x wp=%lx lp=%lx)\n", this, uMsg, wParam, lParam);
 785
 786     return E_NOTIMPL;
 787 }