dll/win32/shell32/folders/printers.cpp

   1 /*
   2  *    Virtual Printers Folder
   3  *
   4  *    Copyright 1997                Marcus Meissner
   5  *    Copyright 1998, 1999, 2002    Juergen Schmied
   6  *    Copyright 2005                Huw Davies
   7  *    Copyright 2009                Andrew Hill
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  22  */
  23
  24 #include <precomp.h>
  25
  26 #include <winspool.h>
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL (shell);
  29
  30 /***********************************************************************
  31  *   Printers_IExtractIconW implementation
  32  */
  33 class CPrintersExtractIconW :
  34     public CComObjectRootEx<CComMultiThreadModelNoCS>,
  35     public IExtractIconW,
  36     public IExtractIconA
  37 {
  38     private:
  39         LPITEMIDLIST                        pidl;
  40     public:
  41         CPrintersExtractIconW();
  42         ~CPrintersExtractIconW();
  43         HRESULT WINAPI Initialize(LPCITEMIDLIST pidl);
  44
  45         // IExtractIconW
  46         virtual HRESULT STDMETHODCALLTYPE GetIconLocation(UINT uFlags, LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags);
  47         virtual HRESULT STDMETHODCALLTYPE Extract(LPCWSTR pszFile, UINT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize);
  48
  49         // IExtractIconA
  50         virtual HRESULT STDMETHODCALLTYPE GetIconLocation(UINT uFlags, LPSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags);
  51         virtual HRESULT STDMETHODCALLTYPE Extract(LPCSTR pszFile, UINT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize);
  52
  53         BEGIN_COM_MAP(CPrintersExtractIconW)
  54         COM_INTERFACE_ENTRY_IID(IID_IExtractIconW, IExtractIconW)
  55         COM_INTERFACE_ENTRY_IID(IID_IExtractIconA, IExtractIconA)
  56         END_COM_MAP()
  57 };
  58
  59 static shvheader PrinterSFHeader[] = {
  60     {IDS_SHV_COLUMN8, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
  61     {IDS_SHV_COLUMN_DOCUMENTS , SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
  62     {IDS_SHV_COLUMN_STATUS, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
  63     {IDS_SHV_COLUMN_COMMENTS, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
  64     {IDS_SHV_COLUMN_LOCATION, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
  65     {IDS_SHV_COLUMN_MODEL, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15}
  66 };
  67
  68 #define COLUMN_NAME          0
  69 #define COLUMN_DOCUMENTS     1
  70 #define COLUMN_STATUS        2
  71 #define COLUMN_COMMENTS      3
  72 #define COLUMN_LOCATION      4
  73 #define COLUMN_MODEL         5
  74
  75
  76 #define PrinterSHELLVIEWCOLUMNS (6)
  77
  78 CPrintersExtractIconW::CPrintersExtractIconW()
  79 {
  80     pidl = NULL;
  81 }
  82
  83 CPrintersExtractIconW::~CPrintersExtractIconW()
  84 {
  85     TRACE(" destroying IExtractIcon(%p)\n", this);
  86     SHFree(pidl);
  87 }
  88
  89 HRESULT WINAPI CPrintersExtractIconW::Initialize(LPCITEMIDLIST pidl)
  90 {
  91     pidl = ILClone(pidl);
  92
  93     pdump(pidl);
  94     return S_OK;
  95 }
  96
  97 /**************************************************************************
  98  *  CPrintersExtractIconW::GetIconLocation
  99  *
 100  * mapping filetype to icon
 101  */
 102 HRESULT WINAPI CPrintersExtractIconW::GetIconLocation(UINT uFlags,        /* GIL_ flags */
 103         LPWSTR szIconFile,
 104         UINT cchMax,
 105         int *piIndex,
 106         UINT *pwFlags)        /* returned GIL_ flags */
 107 {
 108     TRACE("(%p) (flags=%u %p %u %p %p)\n", this, uFlags, szIconFile, cchMax, piIndex, pwFlags);
 109
 110     if (pwFlags)
 111         *pwFlags = 0;
 112
 113     lstrcpynW(szIconFile, swShell32Name, cchMax);
 114     *piIndex = -IDI_SHELL_PRINTERS_FOLDER; /* FIXME: other icons for default, network, print to file */
 115
 116     TRACE("-- %s %x\n", debugstr_w(szIconFile), *piIndex);
 117     return S_OK;
 118 }
 119
 120 /**************************************************************************
 121  *  CPrintersExtractIconW::Extract
 122  */
 123 HRESULT WINAPI CPrintersExtractIconW::Extract(LPCWSTR pszFile,
 124         UINT nIconIndex, HICON *phiconLarge,
 125         HICON *phiconSmall, UINT nIconSize)
 126 {
 127     int index;
 128
 129     FIXME("(%p) (file=%p index=%d %p %p size=%x) semi-stub\n", this, debugstr_w(pszFile),
 130           (signed)nIconIndex, phiconLarge, phiconSmall, nIconSize);
 131
 132     index = SIC_GetIconIndex(pszFile, nIconIndex, 0);
 133
 134     if (phiconLarge)
 135         *phiconLarge = ImageList_GetIcon(ShellBigIconList, index, ILD_TRANSPARENT);
 136
 137     if (phiconSmall)
 138         *phiconSmall = ImageList_GetIcon(ShellSmallIconList, index, ILD_TRANSPARENT);
 139
 140     return S_OK;
 141 }
 142
 143 /**************************************************************************
 144  *  CPrintersExtractIconW::GetIconLocation
 145  */
 146 HRESULT WINAPI CPrintersExtractIconW::GetIconLocation(UINT uFlags,
 147         LPSTR szIconFile,
 148         UINT cchMax,
 149         int * piIndex,
 150         UINT * pwFlags)
 151 {
 152     HRESULT ret;
 153     LPWSTR lpwstrFile = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, cchMax * sizeof(WCHAR));
 154
 155     TRACE("(%p) (flags=%u %p %u %p %p)\n", this, uFlags, szIconFile, cchMax, piIndex, pwFlags);
 156
 157     ret = GetIconLocation(uFlags, lpwstrFile, cchMax, piIndex, pwFlags);
 158     WideCharToMultiByte(CP_ACP, 0, lpwstrFile, -1, szIconFile, cchMax, NULL, NULL);
 159     HeapFree(GetProcessHeap(), 0, lpwstrFile);
 160
 161     TRACE("-- %s %x\n", szIconFile, *piIndex);
 162     return ret;
 163 }
 164 /**************************************************************************
 165  *  CPrintersExtractIconW::Extract
 166  */
 167 HRESULT WINAPI CPrintersExtractIconW::Extract(LPCSTR pszFile,
 168         UINT nIconIndex, HICON *phiconLarge,
 169         HICON *phiconSmall, UINT nIconSize)
 170 {
 171     HRESULT ret;
 172     INT len = MultiByteToWideChar(CP_ACP, 0, pszFile, -1, NULL, 0);
 173     LPWSTR lpwstrFile = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 174
 175     TRACE("(%p) (file=%p index=%u %p %p size=%u)\n", this, pszFile, nIconIndex, phiconLarge, phiconSmall, nIconSize);
 176
 177     MultiByteToWideChar(CP_ACP, 0, pszFile, -1, lpwstrFile, len);
 178     ret = Extract(lpwstrFile, nIconIndex, phiconLarge, phiconSmall, nIconSize);
 179     HeapFree(GetProcessHeap(), 0, lpwstrFile);
 180     return ret;
 181 }
 182
 183 /**************************************************************************
 184  *  IExtractIcon_Constructor
 185  */
 186 static HRESULT WINAPI IEI_Printers_Constructor(LPCITEMIDLIST pidl, REFIID riid, IUnknown **ppv)
 187 {
 188     CComObject<CPrintersExtractIconW> *theExtractor;
 189     CComPtr<IUnknown>                 result;
 190     HRESULT                           hResult;
 191
 192     if (ppv == NULL)
 193         return E_POINTER;
 194     *ppv = NULL;
 195     ATLTRY (theExtractor = new CComObject<CPrintersExtractIconW>);
 196     if (theExtractor == NULL)
 197         return E_OUTOFMEMORY;
 198     hResult = theExtractor->QueryInterface(riid, (void **)&result);
 199     if (FAILED (hResult))
 200     {
 201         delete theExtractor;
 202         return hResult;
 203     }
 204     hResult = theExtractor->Initialize(pidl);
 205     if (FAILED (hResult))
 206         return hResult;
 207     *ppv = result.Detach();
 208     return S_OK;
 209 }
 210
 211 /***********************************************************************
 212  *     Printers folder implementation
 213  */
 214
 215 class CPrintersEnum: public IEnumIDListImpl
 216 {
 217     public:
 218         CPrintersEnum();
 219         ~CPrintersEnum();
 220         HRESULT WINAPI Initialize(HWND hwndOwner, DWORD dwFlags);
 221         BOOL CreatePrintersEnumList(DWORD dwFlags);
 222
 223         BEGIN_COM_MAP(CPrintersEnum)
 224         COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
 225         END_COM_MAP()
 226 };
 227
 228 CPrintersEnum::CPrintersEnum()
 229 {
 230 }
 231
 232 CPrintersEnum::~CPrintersEnum()
 233 {
 234 }
 235
 236 HRESULT WINAPI CPrintersEnum::Initialize(HWND hwndOwner, DWORD dwFlags)
 237 {
 238     if (CreatePrintersEnumList(dwFlags) == FALSE)
 239         return E_FAIL;
 240     return S_OK;
 241 }
 242
 243 static LPITEMIDLIST _ILCreatePrinterItem(PRINTER_INFO_4W *pi)
 244 {
 245     PIDLDATA tmp;
 246     LPITEMIDLIST pidl;
 247     PIDLPrinterStruct * p;
 248     int size0 = (char*)&tmp.u.cprinter.szName - (char*)&tmp.u.cprinter;
 249     int size = size0;
 250
 251     tmp.type = 0x00;
 252     tmp.u.cprinter.dummy = 0xFF;
 253     if (pi->pPrinterName)
 254         tmp.u.cprinter.offsServer = wcslen(pi->pPrinterName) + 1;
 255     else
 256         tmp.u.cprinter.offsServer = 1;
 257
 258     size += tmp.u.cprinter.offsServer * sizeof(WCHAR);
 259     if (pi->pServerName)
 260         size += (wcslen(pi->pServerName) + 1) * sizeof(WCHAR);
 261     else
 262         size += sizeof(WCHAR);
 263
 264     pidl = (LPITEMIDLIST)SHAlloc(size + 4);
 265     if (!pidl)
 266         return pidl;
 267
 268     pidl->mkid.cb = size + 2;
 269     memcpy(pidl->mkid.abID, &tmp, 2 + size0);
 270
 271     p = &((PIDLDATA*)pidl->mkid.abID)->u.cprinter;
 272
 273     p->Attributes = pi->Attributes;
 274     if (pi->pPrinterName)
 275         wcscpy(p->szName, pi->pPrinterName);
 276     else
 277         p->szName[0] = L'\0';
 278
 279     if (pi->pServerName)
 280         wcscpy(p->szName + p->offsServer, pi->pServerName);
 281     else
 282         p->szName[p->offsServer] = L'\0';
 283
 284     *(WORD*)((char*)pidl + (size + 2)) = 0;
 285     return pidl;
 286 }
 287
 288 /**************************************************************************
 289  *  CPrintersEnum::CreatePrintersEnumList()
 290  */
 291 BOOL CPrintersEnum::CreatePrintersEnumList(DWORD dwFlags)
 292 {
 293     BOOL ret = TRUE;
 294
 295     TRACE("(%p)->(flags=0x%08lx) \n", this, dwFlags);
 296
 297     /* enumerate the folders */
 298     if (dwFlags & SHCONTF_NONFOLDERS)
 299     {
 300         DWORD needed = 0, num = 0, i;
 301         PRINTER_INFO_4W *pi;
 302
 303         EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 4, NULL, 0, &needed, &num);
 304         if (!needed)
 305             return ret;
 306
 307         pi = (PRINTER_INFO_4W *)HeapAlloc(GetProcessHeap(), 0, needed);
 308         if(!EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 4, (LPBYTE)pi, needed, &needed, &num)) {
 309             HeapFree(GetProcessHeap(), 0, pi);
 310             return FALSE;
 311         }
 312
 313         for(i = 0; i < num; i++) {
 314             LPITEMIDLIST pidl = _ILCreatePrinterItem(&pi[i]);
 315             if (pidl)
 316             {
 317                 if (!AddToEnumList(pidl))
 318                     SHFree(pidl);
 319             }
 320         }
 321         HeapFree(GetProcessHeap(), 0, pi);
 322     }
 323     return ret;
 324 }
 325
 326 CPrinterFolder::CPrinterFolder()
 327 {
 328     pidlRoot = NULL;
 329     dwAttributes = 0;
 330     pclsid = NULL;
 331 }
 332
 333 CPrinterFolder::~CPrinterFolder()
 334 {
 335     TRACE("-- destroying IShellFolder(%p)\n", this);
 336     if (pidlRoot)
 337         SHFree(pidlRoot);
 338 }
 339
 340 HRESULT WINAPI CPrinterFolder::FinalConstruct()
 341 {
 342     pidlRoot = _ILCreatePrinters();    /* my qualified pidl */
 343     if (pidlRoot == NULL)
 344         return E_OUTOFMEMORY;
 345     return S_OK;
 346 }
 347
 348 /**************************************************************************
 349  *    CPrinterFolder::ParseDisplayName
 350  *
 351  * This is E_NOTIMPL in Windows too.
 352  */
 353 HRESULT WINAPI CPrinterFolder::ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName,
 354         DWORD *pchEaten, PIDLIST_RELATIVE *ppidl, DWORD *pdwAttributes)
 355 {
 356     TRACE("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n",
 357           this, hwndOwner, pbc, lpszDisplayName, debugstr_w(lpszDisplayName),
 358           pchEaten, ppidl, pdwAttributes);
 359
 360     *ppidl = 0;
 361     if (pchEaten)
 362         *pchEaten = 0;
 363
 364     return E_NOTIMPL;
 365 }
 366
 367 static PIDLPrinterStruct * _ILGetPrinterStruct(LPCITEMIDLIST pidl)
 368 {
 369     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
 370
 371     if (pdata && pdata->type == 0x00)
 372         return (PIDLPrinterStruct*) & (pdata->u.cfont);
 373
 374     return NULL;
 375 }
 376
 377 /**************************************************************************
 378  *        CPrinterFolder::EnumObjects
 379  */
 380 HRESULT WINAPI CPrinterFolder::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST * ppEnumIDList)
 381 {
 382     CComObject<CPrintersEnum> *theEnumerator;
 383     CComPtr<IEnumIDList>      result;
 384     HRESULT                   hResult;
 385
 386     TRACE ("(%p)->(HWND=%p flags=0x%08x pplist=%p)\n", this, hwndOwner, dwFlags, ppEnumIDList);
 387
 388     if (ppEnumIDList == NULL)
 389         return E_POINTER;
 390     *ppEnumIDList = NULL;
 391     ATLTRY (theEnumerator = new CComObject<CPrintersEnum>);
 392     if (theEnumerator == NULL)
 393         return E_OUTOFMEMORY;
 394     hResult = theEnumerator->QueryInterface(IID_PPV_ARG(IEnumIDList, &result));
 395     if (FAILED (hResult))
 396     {
 397         delete theEnumerator;
 398         return hResult;
 399     }
 400     hResult = theEnumerator->Initialize(hwndOwner, dwFlags);
 401     if (FAILED (hResult))
 402         return hResult;
 403     *ppEnumIDList = result.Detach();
 404
 405     TRACE ("-- (%p)->(new ID List: %p)\n", this, *ppEnumIDList);
 406
 407     return S_OK;
 408 }
 409
 410 /**************************************************************************
 411  *        CPrinterFolder::BindToObject
 412  */
 413 HRESULT WINAPI CPrinterFolder::BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
 414 {
 415     TRACE ("(%p)->(pidl=%p,%p,%s,%p)\n", this,
 416            pidl, pbcReserved, shdebugstr_guid (&riid), ppvOut);
 417
 418     return SHELL32_BindToChild(pidlRoot, NULL, pidl, riid, ppvOut);
 419 }
 420
 421 /**************************************************************************
 422  *    ISF_Printers_fnBindToStorage
 423  */
 424 HRESULT WINAPI CPrinterFolder::BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
 425 {
 426     FIXME ("(%p)->(pidl=%p,%p,%s,%p) stub\n",
 427            this, pidl, pbcReserved, shdebugstr_guid (&riid), ppvOut);
 428
 429     *ppvOut = NULL;
 430     return E_NOTIMPL;
 431 }
 432
 433 /**************************************************************************
 434  *     CPrinterFolder::CompareIDs
 435  */
 436 HRESULT WINAPI CPrinterFolder::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
 437 {
 438     int nReturn;
 439
 440     TRACE ("(%p)->(0x%08lx,pidl1=%p,pidl2=%p)\n", this, lParam, pidl1, pidl2);
 441     nReturn = SHELL32_CompareIDs (this, lParam, pidl1, pidl2);
 442     TRACE ("-- %i\n", nReturn);
 443     return nReturn;
 444 }
 445
 446 /**************************************************************************
 447  *    CPrinterFolder::CreateViewObject
 448  */
 449 HRESULT WINAPI CPrinterFolder::CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID * ppvOut)
 450 {
 451     CComPtr<IShellView> pShellView;
 452     HRESULT hr = E_INVALIDARG;
 453
 454     TRACE("(%p)->(hwnd=%p,%s,%p)\n", this,
 455           hwndOwner, shdebugstr_guid (&riid), ppvOut);
 456
 457     if (!ppvOut)
 458         return hr;
 459
 460     *ppvOut = NULL;
 461
 462     if (IsEqualIID(riid, IID_IDropTarget))
 463     {
 464         WARN("IDropTarget not implemented\n");
 465         hr = E_NOTIMPL;
 466     }
 467     else if(IsEqualIID(riid, IID_IContextMenu))
 468     {
 469         WARN("IContextMenu not implemented\n");
 470         hr = E_NOTIMPL;
 471     }
 472     else if(IsEqualIID(riid, IID_IShellView))
 473     {
 474         hr = IShellView_Constructor((IShellFolder *)this, &pShellView);
 475         if (pShellView)
 476         {
 477             hr = pShellView->QueryInterface(riid, ppvOut);
 478             pShellView->Release();
 479         }
 480     }
 481     TRACE ("-- (%p)->(interface=%p)\n", this, ppvOut);
 482     return hr;
 483 }
 484
 485 /**************************************************************************
 486  *  CPrinterFolder::GetAttributesOf
 487  */
 488 HRESULT WINAPI CPrinterFolder::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut)
 489 {
 490     static const DWORD dwPrintersAttributes =
 491         SFGAO_HASPROPSHEET | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_CANRENAME | SFGAO_CANDELETE;
 492     HRESULT hr = S_OK;
 493
 494     FIXME ("(%p)->(cidl=%d apidl=%p mask=0x%08lx): stub\n",
 495            this, cidl, apidl, *rgfInOut);
 496
 497     *rgfInOut &= dwPrintersAttributes;
 498
 499     *rgfInOut &= ~SFGAO_VALIDATE;
 500
 501     TRACE ("-- result=0x%08x\n", *rgfInOut);
 502     return hr;
 503 }
 504
 505 /**************************************************************************
 506  *    CPrinterFolder::GetUIObjectOf
 507  *
 508  * PARAMETERS
 509  *  HWND           hwndOwner, //[in ] Parent window for any output
 510  *  UINT           cidl,      //[in ] array size
 511  *  LPCITEMIDLIST* apidl,     //[in ] simple pidl array
 512  *  REFIID         riid,      //[in ] Requested Interface
 513  *  UINT*          prgfInOut, //[   ] reserved
 514  *  LPVOID*        ppvObject) //[out] Resulting Interface
 515  *
 516  */
 517 HRESULT WINAPI CPrinterFolder::GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
 518         REFIID riid, UINT * prgfInOut, LPVOID * ppvOut)
 519 {
 520     IUnknown *pObj = NULL;
 521     HRESULT hr = E_INVALIDARG;
 522
 523     TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
 524            this, hwndOwner, cidl, apidl, shdebugstr_guid (&riid), prgfInOut, ppvOut);
 525
 526     if (!ppvOut)
 527         return hr;
 528
 529     *ppvOut = NULL;
 530
 531     if ((IsEqualIID (riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW)) && cidl == 1)
 532         hr = IEI_Printers_Constructor(apidl[0], riid, &pObj);
 533     else
 534         hr = E_NOINTERFACE;
 535
 536     if (SUCCEEDED(hr) && !pObj)
 537         hr = E_OUTOFMEMORY;
 538
 539     *ppvOut = pObj;
 540     TRACE ("(%p)->hr=0x%08lx\n", this, hr);
 541     return hr;
 542 }
 543
 544 /**************************************************************************
 545  *    CPrinterFolder::GetDisplayNameOf
 546  *
 547  */
 548 HRESULT WINAPI CPrinterFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
 549 {
 550     LPWSTR pszName;
 551     PIDLPrinterStruct * p;
 552
 553     TRACE ("(%p)->(pidl=%p,0x%08lx,%p)\n", this, pidl, dwFlags, strRet);
 554     pdump (pidl);
 555
 556     if (!strRet)
 557     {
 558         WARN("no strRet\n");
 559         return E_INVALIDARG;
 560     }
 561
 562     if (!pidl->mkid.cb)
 563     {
 564         pszName = (LPWSTR)CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR));
 565         if (!pszName)
 566             return E_OUTOFMEMORY;
 567
 568         if (LoadStringW(shell32_hInstance, IDS_PRINTERS, pszName, MAX_PATH))
 569         {
 570             pszName[MAX_PATH-1] = L'\0';
 571             strRet->uType = STRRET_WSTR;
 572             strRet->pOleStr = pszName;
 573             return S_OK;
 574         }
 575         CoTaskMemFree(pszName);
 576         return E_FAIL;
 577     }
 578
 579     p = _ILGetPrinterStruct(pidl);
 580     if (!p)
 581     {
 582         WARN("no printer struct\n");
 583         return E_INVALIDARG;
 584     }
 585     strRet->pOleStr = (LPWSTR)SHAlloc(p->offsServer * sizeof(WCHAR));
 586     if (!strRet->pOleStr)
 587         return E_OUTOFMEMORY;
 588
 589     memcpy((LPVOID)strRet->pOleStr, (LPVOID)p->szName, p->offsServer * sizeof(WCHAR));
 590     TRACE("ret %s\n", debugstr_w(strRet->pOleStr));
 591
 592     return S_OK;
 593 }
 594
 595 /**************************************************************************
 596  *  CPrinterFolder::SetNameOf
 597  *  Changes the name of a file object or subfolder, possibly changing its item
 598  *  identifier in the process.
 599  *
 600  * PARAMETERS
 601  *  HWND          hwndOwner,  //[in ] Owner window for output
 602  *  LPCITEMIDLIST pidl,       //[in ] simple pidl of item to change
 603  *  LPCOLESTR     lpszName,   //[in ] the items new display name
 604  *  DWORD         dwFlags,    //[in ] SHGNO formatting flags
 605  *  LPITEMIDLIST* ppidlOut)   //[out] simple pidl returned
 606  */
 607 HRESULT WINAPI CPrinterFolder::SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl,    /* simple pidl */
 608         LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
 609 {
 610     FIXME("(%p)->(%p,pidl=%p,%s,%lu,%p)\n", this, hwndOwner, pidl,
 611           debugstr_w (lpName), dwFlags, pPidlOut);
 612
 613     return E_FAIL;
 614 }
 615
 616 HRESULT WINAPI CPrinterFolder::GetDefaultSearchGUID(GUID *pguid)
 617 {
 618     FIXME("(%p)\n", this);
 619     return E_NOTIMPL;
 620 }
 621
 622 HRESULT WINAPI CPrinterFolder::EnumSearches(IEnumExtraSearch **ppenum)
 623 {
 624     FIXME("(%p)\n", this);
 625     return E_NOTIMPL;
 626 }
 627
 628 HRESULT WINAPI CPrinterFolder::GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
 629 {
 630     if (pSort)
 631         *pSort = 0;
 632     if (pDisplay)
 633         *pDisplay = 0;
 634
 635     return S_OK;
 636 }
 637
 638 HRESULT WINAPI CPrinterFolder::GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags)
 639 {
 640     if (!pcsFlags || iColumn >= PrinterSHELLVIEWCOLUMNS)
 641         return E_INVALIDARG;
 642     *pcsFlags = PrinterSFHeader[iColumn].pcsFlags;
 643     return S_OK;
 644
 645 }
 646
 647 HRESULT WINAPI CPrinterFolder::GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv)
 648 {
 649     FIXME("(%p): stub\n", this);
 650
 651     return E_NOTIMPL;
 652 }
 653
 654 HRESULT WINAPI CPrinterFolder::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
 655 {
 656     WCHAR buffer[MAX_PATH] = {0};
 657     HRESULT hr = E_FAIL;
 658
 659     TRACE("(%p)->(%p %i %p): stub\n", this, pidl, iColumn, psd);
 660
 661     if (iColumn >= PrinterSHELLVIEWCOLUMNS)
 662         return E_FAIL;
 663
 664     psd->fmt = PrinterSFHeader[iColumn].fmt;
 665     psd->cxChar = PrinterSFHeader[iColumn].cxChar;
 666     if (pidl == NULL)
 667     {
 668         psd->str.uType = STRRET_WSTR;
 669         if (LoadStringW(shell32_hInstance, PrinterSFHeader[iColumn].colnameid, buffer, MAX_PATH))
 670             hr = SHStrDupW(buffer, &psd->str.pOleStr);
 671
 672         return hr;
 673     }
 674
 675     if (iColumn == COLUMN_NAME)
 676     {
 677         psd->str.uType = STRRET_WSTR;
 678         return GetDisplayNameOf(pidl, SHGDN_NORMAL, &psd->str);
 679     }
 680
 681     psd->str.uType = STRRET_CSTR;
 682     psd->str.cStr[0] = '\0';
 683
 684     return E_NOTIMPL;
 685 }
 686
 687 HRESULT WINAPI CPrinterFolder::MapColumnToSCID(UINT column, SHCOLUMNID *pscid)
 688 {
 689     FIXME ("(%p): stub\n", this);
 690     return E_NOTIMPL;
 691 }
 692
 693 /************************************************************************
 694  *    CPrinterFolder::GetClassID
 695  */
 696 HRESULT WINAPI CPrinterFolder::GetClassID(CLSID *lpClassId)
 697 {
 698     TRACE ("(%p)\n", this);
 699
 700     *lpClassId = CLSID_Printers;
 701
 702     return S_OK;
 703 }
 704
 705 /************************************************************************
 706  *    CPrinterFolder::Initialize
 707  */
 708 HRESULT WINAPI CPrinterFolder::Initialize(LPCITEMIDLIST pidl)
 709 {
 710     if (pidlRoot)
 711         SHFree((LPVOID)pidlRoot);
 712
 713     pidlRoot = ILClone(pidl);
 714     return S_OK;
 715 }
 716
 717 /**************************************************************************
 718  *    CPrinterFolder::GetCurFolder
 719  */
 720 HRESULT WINAPI CPrinterFolder::GetCurFolder(LPITEMIDLIST * pidl)
 721 {
 722     TRACE ("(%p)->(%p)\n", this, pidl);
 723
 724     *pidl = ILClone (pidlRoot);
 725     return S_OK;
 726 }