include/reactos/undocshell.h

   1 /*
   2  * Copyright 1999, 2000 Juergen Schmied
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef __WINE_UNDOCSHELL_H
  20 #define __WINE_UNDOCSHELL_H
  21
  22 #ifdef __cplusplus
  23 extern "C" {
  24 #endif /* defined(__cplusplus) */
  25
  26 /****************************************************************************
  27  *      IDList Functions
  28  */
  29 BOOL WINAPI ILGetDisplayName(
  30         LPCITEMIDLIST pidl,
  31         LPVOID path);
  32
  33 /* type parameter for ILGetDisplayNameEx() */
  34 #define ILGDN_FORPARSING  0
  35 #define ILGDN_NORMAL      1
  36 #define ILGDN_INFOLDER    2
  37
  38 BOOL WINAPI ILGetDisplayNameEx(
  39         LPSHELLFOLDER psf,
  40         LPCITEMIDLIST pidl,
  41         LPVOID path,
  42         DWORD type);
  43
  44 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl);
  45 void WINAPI ILGlobalFree(LPITEMIDLIST pidl);
  46 LPITEMIDLIST WINAPI SHSimpleIDListFromPathA (LPCSTR lpszPath); //FIXME
  47 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW (LPCWSTR lpszPath);
  48
  49 HRESULT WINAPI SHILCreateFromPathA (
  50         LPCSTR path,
  51         LPITEMIDLIST * ppidl,
  52         DWORD *attributes);
  53
  54 HRESULT WINAPI SHILCreateFromPathW (
  55         LPCWSTR path,
  56         LPITEMIDLIST * ppidl,
  57         DWORD *attributes);
  58
  59 /*
  60         string functions
  61 */
  62 BOOL WINAPI StrRetToStrNA(LPSTR,DWORD,LPSTRRET,const ITEMIDLIST*);
  63 BOOL WINAPI StrRetToStrNW(LPWSTR,DWORD,LPSTRRET,const ITEMIDLIST*);
  64
  65
  66 /****************************************************************************
  67 * SHChangeNotifyRegister API
  68 */
  69 #define SHCNRF_InterruptLevel           0x0001
  70 #define SHCNRF_ShellLevel               0x0002
  71 #define SHCNRF_RecursiveInterrupt       0x1000  /* Must be combined with SHCNRF_InterruptLevel */
  72 #define SHCNRF_NewDelivery              0x8000  /* Messages use shared memory */
  73
  74
  75 /****************************************************************************
  76  * Shell Common Dialogs
  77  */
  78
  79 /* RunFileDlg flags */
  80 #define RFF_NOBROWSE       0x01
  81 #define RFF_NODEFAULT      0x02
  82 #define RFF_CALCDIRECTORY  0x04
  83 #define RFF_NOLABEL        0x08
  84 #define RFF_NOSEPARATEMEM  0x20  /* NT only */
  85
  86 #define DE_SAMEFILE 0x71
  87
  88 /* RunFileFlg notification structure */
  89 typedef struct
  90 {
  91   NMHDR   hdr;
  92   LPCSTR  lpFile;
  93   LPCSTR  lpDirectory;
  94   int     nShow;
  95 } NM_RUNFILEDLG, * LPNM_RUNFILEDLG;
  96
  97 /* RunFileDlg notification return values */
  98 #define RF_OK      0x00
  99 #define RF_CANCEL  0x01
 100 #define RF_RETRY   0x02
 101
 102 void WINAPI RunFileDlg(
 103         HWND hwndOwner,
 104         HICON hIcon,
 105         LPCWSTR lpstrDirectory,
 106         LPCWSTR lpstrTitle,
 107         LPCWSTR lpstrDescription,
 108         UINT uFlags);
 109
 110 void WINAPI ExitWindowsDialog(HWND hwndOwner);
 111
 112 BOOL WINAPI SHFindComputer(
 113         LPCITEMIDLIST pidlRoot,
 114         LPCITEMIDLIST pidlSavedSearch);
 115
 116 void WINAPI SHHandleDiskFull(HWND hwndOwner,
 117         UINT uDrive);
 118
 119 int  WINAPI SHOutOfMemoryMessageBox(
 120         HWND hwndOwner,
 121         LPCSTR lpCaption,
 122         UINT uType);
 123
 124 DWORD WINAPI SHNetConnectionDialog(
 125         HWND hwndOwner,
 126         LPCWSTR lpstrRemoteName,
 127         DWORD dwType);
 128
 129 /****************************************************************************
 130  * Cabinet Window Messages
 131  */
 132
 133 #define CWM_SETPATH           (WM_USER + 2)
 134 #define CWM_WANTIDLE          (WM_USER + 3)
 135 #define CWM_GETSETCURRENTINFO (WM_USER + 4)
 136 #define CWM_SELECTITEM        (WM_USER + 5)
 137 #define CWM_SELECTITEMSTR     (WM_USER + 6)
 138 #define CWM_GETISHELLBROWSER  (WM_USER + 7)
 139 #define CWM_TESTPATH          (WM_USER + 9)
 140 #define CWM_STATECHANGE       (WM_USER + 10)
 141 #define CWM_GETPATH           (WM_USER + 12)
 142
 143 /* CWM_TESTPATH types */
 144 #define CWTP_ISEQUAL  0
 145 #define CWTP_ISCHILD  1
 146
 147 /* CWM_TESTPATH structure */
 148 typedef struct
 149 {
 150         DWORD dwType;
 151         ITEMIDLIST idl;
 152 } CWTESTPATHSTRUCT,* LPCWTESTPATHSTRUCT;
 153
 154 /****************************************************************************
 155  * System Imagelist Routines
 156  */
 157
 158 int WINAPI Shell_GetCachedImageIndexA(
 159         LPCSTR lpszFileName,
 160         int nIconIndex,
 161         UINT bSimulateDoc);
 162
 163 BOOL WINAPI Shell_GetImageLists(
 164         HIMAGELIST *lphimlLarge,
 165         HIMAGELIST *lphimlSmall);
 166
 167 HICON WINAPI SHGetFileIcon(
 168         DWORD dwReserved,
 169         LPCSTR lpszPath,
 170         DWORD dwFileAttributes,
 171         UINT uFlags);
 172
 173 BOOL WINAPI FileIconInit(BOOL bFullInit);
 174
 175 /****************************************************************************
 176  * File Menu Routines
 177  */
 178 /* FileMenu_Create nSelHeight constants */
 179 #define FM_DEFAULT_SELHEIGHT  -1
 180 #define FM_FULL_SELHEIGHT     0
 181
 182 /* FileMenu_Create flags */
 183 #define FMF_SMALL_ICONS      0x00
 184 #define FMF_LARGE_ICONS      0x08
 185 #define FMF_NO_COLUMN_BREAK  0x10
 186
 187 HMENU WINAPI FileMenu_Create(
 188         COLORREF crBorderColor,
 189         int nBorderWidth,
 190         HBITMAP hBorderBmp,
 191         int nSelHeight,
 192         UINT uFlags);
 193
 194 void WINAPI FileMenu_Destroy(HMENU hMenu);
 195
 196 /* FileMenu_AppendItem constants */
 197 #define FM_SEPARATOR       (LPCSTR)1
 198 #define FM_BLANK_ICON      -1
 199 #define FM_DEFAULT_HEIGHT  0
 200
 201 BOOL WINAPI FileMenu_AppendItem(
 202         HMENU hMenu,
 203         LPCSTR lpszText,
 204         UINT uID,
 205         int iIcon,
 206         HMENU hMenuPopup,
 207         int nItemHeight);
 208
 209 /* FileMenu_InsertUsingPidl flags */
 210 #define FMF_NO_EMPTY_ITEM      0x01
 211 #define FMF_NO_PROGRAM_GROUPS  0x04
 212
 213 /* FileMenu_InsertUsingPidl callback function */
 214 typedef void (CALLBACK *LPFNFMCALLBACK)(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlFile);
 215
 216 int WINAPI FileMenu_InsertUsingPidl(
 217         HMENU hMenu,
 218         UINT uID,
 219         LPCITEMIDLIST pidl,
 220         UINT uFlags,
 221         UINT uEnumFlags,
 222         LPFNFMCALLBACK lpfnCallback);
 223
 224 int WINAPI FileMenu_ReplaceUsingPidl(
 225         HMENU hMenu,
 226         UINT uID,
 227         LPCITEMIDLIST pidl,
 228         UINT uEnumFlags,
 229         LPFNFMCALLBACK lpfnCallback);
 230
 231 void WINAPI FileMenu_Invalidate(HMENU hMenu);
 232
 233 HMENU WINAPI FileMenu_FindSubMenuByPidl(
 234         HMENU hMenu,
 235         LPCITEMIDLIST pidl);
 236
 237 BOOL WINAPI FileMenu_TrackPopupMenuEx(
 238         HMENU hMenu,
 239         UINT uFlags,
 240         int x,
 241         int y,
 242         HWND hWnd,
 243         LPTPMPARAMS lptpm);
 244
 245 BOOL WINAPI FileMenu_GetLastSelectedItemPidls(
 246         UINT uReserved,
 247         LPCITEMIDLIST *ppidlFolder,
 248         LPCITEMIDLIST *ppidlItem);
 249
 250 LRESULT WINAPI FileMenu_MeasureItem(
 251         HWND hWnd,
 252         LPMEASUREITEMSTRUCT lpmis);
 253
 254 LRESULT WINAPI FileMenu_DrawItem(
 255         HWND hWnd,
 256         LPDRAWITEMSTRUCT lpdis);
 257
 258 BOOL WINAPI FileMenu_InitMenuPopup(HMENU hMenu);
 259
 260 void WINAPI FileMenu_AbortInitMenu(void);
 261
 262 LRESULT WINAPI FileMenu_HandleMenuChar(
 263         HMENU hMenu,
 264         WPARAM wParam);
 265
 266 BOOL WINAPI FileMenu_DeleteAllItems(HMENU hMenu);
 267
 268 BOOL WINAPI FileMenu_DeleteItemByCmd(
 269         HMENU hMenu,
 270         UINT uID);
 271
 272 BOOL WINAPI FileMenu_DeleteItemByIndex(
 273         HMENU hMenu,
 274         UINT uPos);
 275
 276 BOOL WINAPI FileMenu_DeleteMenuItemByFirstID(
 277         HMENU hMenu,
 278         UINT uID);
 279
 280 BOOL WINAPI FileMenu_DeleteSeparator(HMENU hMenu);
 281
 282 BOOL WINAPI FileMenu_EnableItemByCmd(
 283         HMENU hMenu,
 284         UINT uID,
 285         BOOL bEnable);
 286
 287 DWORD WINAPI FileMenu_GetItemExtent(
 288         HMENU hMenu,
 289         UINT uPos);
 290
 291 int WINAPI FileMenu_AppendFilesForPidl(
 292         HMENU hMenu,
 293         LPCITEMIDLIST pidl,
 294         BOOL bAddSeparator);
 295
 296 int WINAPI FileMenu_AddFilesForPidl(
 297         HMENU hMenu,
 298         UINT uReserved,
 299         UINT uID,
 300         LPCITEMIDLIST pidl,
 301         UINT uFlags,
 302         UINT uEnumFlags,
 303         LPFNFMCALLBACK lpfnCallback);
 304
 305 /****************************************************************************
 306  * Drag And Drop Routines
 307  */
 308
 309 HRESULT WINAPI SHRegisterDragDrop(
 310         HWND hWnd,
 311         LPDROPTARGET lpDropTarget);
 312
 313 HRESULT WINAPI SHRevokeDragDrop(HWND hWnd);
 314
 315 BOOL WINAPI DAD_DragEnter(HWND hWnd);
 316
 317 BOOL WINAPI DAD_SetDragImageFromListView(
 318         HWND hWnd,
 319         POINT pt);
 320
 321 BOOL WINAPI DAD_ShowDragImage(BOOL bShow);
 322
 323 /****************************************************************************
 324  * Path Manipulation Routines
 325  */
 326
 327 BOOL WINAPI PathAppendAW(LPVOID lpszPath1, LPCVOID lpszPath2);
 328
 329 LPVOID WINAPI PathCombineAW(LPVOID szDest, LPCVOID lpszDir, LPCVOID lpszFile);
 330
 331 LPVOID  WINAPI PathAddBackslashAW(LPVOID path);
 332
 333 LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive);
 334
 335 LPVOID WINAPI PathFindExtensionAW(LPCVOID path);
 336
 337 LPVOID WINAPI PathFindFileNameAW(LPCVOID path);
 338
 339 LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath,  DWORD void1, DWORD void2);
 340
 341 LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath);
 342
 343 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath);
 344
 345 void WINAPI PathRemoveBlanksAW(LPVOID lpszPath);
 346
 347 VOID  WINAPI PathQuoteSpacesAW(LPVOID path);
 348
 349 void WINAPI PathUnquoteSpacesAW(LPVOID lpszPath);
 350
 351 BOOL WINAPI PathIsUNCAW(LPCVOID lpszPath);
 352
 353 BOOL WINAPI PathIsRelativeAW(LPCVOID lpszPath);
 354
 355 BOOL WINAPI PathIsRootAW(LPCVOID x);
 356
 357 BOOL WINAPI PathIsExeAW(LPCVOID lpszPath);
 358
 359 BOOL WINAPI PathIsDirectoryAW(LPCVOID lpszPath);
 360
 361 BOOL WINAPI PathFileExistsAW(LPCVOID lpszPath);
 362
 363 BOOL WINAPI PathMatchSpecAW(LPVOID lpszPath, LPVOID lpszSpec);
 364
 365 BOOL WINAPI PathMakeUniqueNameAW(
 366         LPVOID lpszBuffer,
 367         DWORD dwBuffSize,
 368         LPCVOID lpszShortName,
 369         LPCVOID lpszLongName,
 370         LPCVOID lpszPathName);
 371
 372 BOOL WINAPI PathYetAnotherMakeUniqueName(
 373         LPWSTR lpszBuffer,
 374         LPCWSTR lpszPathName,
 375         LPCWSTR lpszShortName,
 376         LPCWSTR lpszLongName);
 377
 378 BOOL  WINAPI PathQualifyAW(LPCVOID path);
 379
 380
 381 /* PathResolve flags */
 382 #define PRF_CHECKEXISTANCE  0x01
 383 #define PRF_EXECUTABLE      0x02
 384 #define PRF_QUALIFYONPATH   0x04
 385 #define PRF_WINDOWS31       0x08
 386
 387 BOOL WINAPI PathResolveAW(LPVOID lpszPath, LPCVOID *alpszPaths, DWORD dwFlags);
 388
 389 VOID WINAPI PathSetDlgItemPathAW(HWND hDlg, int nIDDlgItem, LPCVOID lpszPath);
 390
 391 /* PathProcessCommand flags */
 392 #define PPCF_QUOTEPATH        0x01 /* implies PPCF_INCLUDEARGS */
 393 #define PPCF_INCLUDEARGS      0x02
 394 //#define PPCF_NODIRECTORIES    0x10 move to shlobj
 395 #define PPCF_DONTRESOLVE      0x20
 396 #define PPCF_PATHISRELATIVE   0x40
 397
 398 HRESULT WINAPI PathProcessCommandAW(LPCVOID lpszPath, LPVOID lpszBuff,
 399                                 DWORD dwBuffSize, DWORD dwFlags);
 400
 401 void WINAPI PathStripPathAW(LPVOID lpszPath);
 402
 403 BOOL WINAPI PathStripToRootAW(LPVOID lpszPath);
 404
 405 void WINAPI PathRemoveArgsAW(LPVOID lpszPath);
 406
 407 void WINAPI PathRemoveExtensionAW(LPVOID lpszPath);
 408
 409 int WINAPI PathParseIconLocationAW(LPVOID lpszPath);
 410
 411 BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2);
 412
 413 BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID *sOtherDirs);
 414
 415 /****************************************************************************
 416  * Shell Namespace Routines
 417  */
 418
 419 /* Generic structure used by several messages */
 420 typedef struct
 421 {
 422   DWORD          dwReserved;
 423   DWORD          dwReserved2;
 424   LPCITEMIDLIST  pidl;
 425   LPDWORD        lpdwUser;
 426 } SFVCBINFO, * LPSFVCBINFO;
 427 typedef const SFVCBINFO * LPCSFVCBINFO;
 428
 429 /* SFVCB_SELECTIONCHANGED structure */
 430 typedef struct
 431 {
 432   UINT           uOldState;
 433   UINT           uNewState;
 434   LPCITEMIDLIST  pidl;
 435   LPDWORD        lpdwUser;
 436 } SFVSELECTSTATE, * LPSFVSELECTSTATE;
 437 typedef const SFVSELECTSTATE * LPCSFVSELECTSTATE;
 438
 439 /* SFVCB_COPYHOOKCALLBACK structure */
 440 typedef struct
 441 {
 442   HWND    hwnd;
 443   UINT    wFunc;
 444   UINT    wFlags;
 445   LPCSTR  pszSrcFile;
 446   DWORD   dwSrcAttribs;
 447   LPCSTR  pszDestFile;
 448   DWORD   dwDestAttribs;
 449 } SFVCOPYHOOKINFO, * LPSFVCOPYHOOKINFO;
 450 typedef const SFVCOPYHOOKINFO * LPCSFVCOPYHOOKINFO;
 451
 452 /* SFVCB_GETDETAILSOF structure */
 453 typedef struct
 454 {
 455   LPCITEMIDLIST  pidl;
 456   int            fmt;
 457   int            cx;
 458   STRRET         lpText;
 459 } SFVCOLUMNINFO, * LPSFVCOLUMNINFO;
 460
 461 /****************************************************************************
 462  * Misc Stuff
 463  */
 464
 465 /* SHWaitForFileToOpen flags */
 466 #define SHWFF_ADD     0x01
 467 #define SHWFF_REMOVE  0x02
 468 #define SHWFF_WAIT    0x04
 469
 470 BOOL WINAPI SHWaitForFileToOpen(
 471         LPCITEMIDLIST pidl,
 472         DWORD dwFlags,
 473         DWORD dwTimeout);
 474
 475 WORD WINAPI ArrangeWindows(
 476         HWND hwndParent,
 477         DWORD dwReserved,
 478         LPCRECT lpRect,
 479         WORD cKids,
 480         CONST HWND * lpKids);
 481
 482 /* RegisterShellHook types */
 483 #define RSH_DEREGISTER        0
 484 #define RSH_REGISTER          1
 485 #define RSH_REGISTER_PROGMAN  2
 486 #define RSH_REGISTER_TASKMAN  3
 487
 488 BOOL WINAPI RegisterShellHook(
 489         HWND hWnd,
 490         DWORD dwType);
 491
 492 /* SHCreateDefClassObject callback function */
 493 typedef HRESULT (CALLBACK *LPFNCDCOCALLBACK)(
 494         LPUNKNOWN pUnkOuter,
 495         REFIID riidObject,
 496         LPVOID *ppvObject);
 497
 498 HRESULT WINAPI SHCreateDefClassObject(
 499         REFIID riidFactory,
 500         LPVOID *ppvFactory,
 501         LPFNCDCOCALLBACK lpfnCallback,
 502         LPDWORD lpdwUsage,
 503         REFIID riidObject);
 504
 505 void WINAPI SHFreeUnusedLibraries(void);
 506
 507 /* SHCreateLinks flags */
 508 #define SHCLF_PREFIXNAME       0x01
 509 #define SHCLF_CREATEONDESKTOP  0x02
 510
 511 HRESULT WINAPI SHCreateLinks(
 512         HWND hWnd,
 513         LPCSTR lpszDir,
 514         LPDATAOBJECT lpDataObject,
 515         UINT uFlags,
 516         LPITEMIDLIST *lppidlLinks);
 517
 518 DWORD WINAPI CheckEscapesA(LPSTR string, DWORD len);
 519 DWORD WINAPI CheckEscapesW(LPWSTR string, DWORD len);
 520
 521 /* policy functions */
 522 BOOL WINAPI SHInitRestricted(LPCVOID unused, LPCVOID inpRegKey);
 523
 524 /* Shell Desktop functions */
 525
 526 #define WM_GETISHELLBROWSER (WM_USER+7)
 527
 528 BOOL WINAPI SHDesktopMessageLoop(HANDLE);
 529
 530 #define CSIDL_FOLDER_MASK       0x00ff
 531
 532 /* Utility functions */
 533 #include <stdio.h>
 534
 535 #define SMC_EXEC 4
 536 extern "C" INT WINAPI Shell_GetCachedImageIndex(LPCWSTR szPath, INT nIndex, UINT bSimulateDoc);
 537
 538 static inline ULONG
 539 Win32DbgPrint(const char *filename, int line, const char *lpFormat, ...)
 540 {
 541     char szMsg[512];
 542     char *szMsgStart;
 543     const char *fname;
 544     va_list vl;
 545     ULONG uRet;
 546
 547     fname = strrchr(filename, '\\');
 548     if (fname == NULL)
 549     {
 550         fname = strrchr(filename, '/');
 551         if (fname != NULL)
 552             fname++;
 553     }
 554     else
 555         fname++;
 556
 557     if (fname == NULL)
 558         fname = filename;
 559
 560     szMsgStart = szMsg + sprintf(szMsg, "%s:%d: ", fname, line);
 561
 562     va_start(vl, lpFormat);
 563     uRet = (ULONG) vsprintf(szMsgStart, lpFormat, vl);
 564     va_end(vl);
 565
 566     OutputDebugStringA(szMsg);
 567
 568     return uRet;
 569 }
 570
 571 #define DbgPrint(fmt, ...) \
 572     Win32DbgPrint(__FILE__, __LINE__, fmt, ##__VA_ARGS__)
 573
 574 static inline void DbgDumpMenuInternal(HMENU hmenu, char* padding, int padlevel)
 575 {
 576     WCHAR label[128];
 577
 578     padding[padlevel] = '.';
 579     padding[padlevel + 1] = '.';
 580     padding[padlevel + 2] = 0;
 581
 582     int count = GetMenuItemCount(hmenu);
 583     for (int i = 0; i < count; i++)
 584     {
 585         MENUITEMINFOW mii = { 0 };
 586
 587         mii.cbSize = sizeof(mii);
 588         mii.fMask = MIIM_STRING | MIIM_FTYPE | MIIM_SUBMENU | MIIM_STATE | MIIM_ID;
 589         mii.dwTypeData = label;
 590         mii.cch = _countof(label);
 591
 592         GetMenuItemInfo(hmenu, i, TRUE, &mii);
 593
 594         if (mii.fType & MFT_BITMAP)
 595             DbgPrint("%s%2d - %08x: BITMAP %08p (state=%d, has submenu=%s)\n", padding, i, mii.wID, mii.hbmpItem, mii.fState, mii.hSubMenu ? "TRUE" : "FALSE");
 596         else if (mii.fType & MFT_SEPARATOR)
 597             DbgPrint("%s%2d - %08x ---SEPARATOR---\n", padding, i, mii.wID);
 598         else
 599             DbgPrint("%s%2d - %08x: %S (state=%d, has submenu=%s)\n", padding, i, mii.wID, mii.dwTypeData, mii.fState, mii.hSubMenu ? "TRUE" : "FALSE");
 600
 601         if (mii.hSubMenu)
 602             DbgDumpMenuInternal(mii.hSubMenu, padding, padlevel + 2);
 603
 604     }
 605
 606     padding[padlevel] = 0;
 607 }
 608
 609 static __inline void DbgDumpMenu(HMENU hmenu)
 610 {
 611     char padding[128];
 612     DbgDumpMenuInternal(hmenu, padding, 0);
 613 }
 614
 615 #if 1
 616 #define FAILED_UNEXPECTEDLY(hr) (FAILED(hr) && (DbgPrint("Unexpected failure %08x.\n", hr), TRUE))
 617 #else
 618 #define FAILED_UNEXPECTEDLY(hr) FAILED(hr)
 619 #endif
 620
 621 #ifdef __cplusplus
 622 } /* extern "C" */
 623 #endif /* defined(__cplusplus) */
 624
 625 #ifdef __cplusplus
 626 template <class Base>
 627 class CComDebugObject : public Base
 628 {
 629 public:
 630     CComDebugObject(void * = NULL)
 631     {
 632 #if DEBUG_CCOMOBJECT_CREATION
 633         DbgPrint("%S, this=%08p\n", __FUNCTION__, static_cast<Base*>(this));
 634 #endif
 635         _pAtlModule->Lock();
 636     }
 637
 638     virtual ~CComDebugObject()
 639     {
 640         this->FinalRelease();
 641         _pAtlModule->Unlock();
 642     }
 643
 644     STDMETHOD_(ULONG, AddRef)()
 645     {
 646         int rc = this->InternalAddRef();
 647 #if DEBUG_CCOMOBJECT_REFCOUNTING
 648         DbgPrint("%s, RefCount is now %d(--)! \n", __FUNCTION__, rc);
 649 #endif
 650         return rc;
 651     }
 652
 653     STDMETHOD_(ULONG, Release)()
 654     {
 655         int rc = this->InternalRelease();
 656
 657 #if DEBUG_CCOMOBJECT_REFCOUNTING
 658         DbgPrint("%s, RefCount is now %d(--)! \n", __FUNCTION__, rc);
 659 #endif
 660
 661         if (rc == 0)
 662         {
 663 #if DEBUG_CCOMOBJECT_DESTRUCTION
 664             DbgPrint("%s, RefCount reached 0 Deleting!\n", __FUNCTION__);
 665 #endif
 666             delete this;
 667         }
 668         return rc;
 669     }
 670
 671     STDMETHOD(QueryInterface)(REFIID iid, void **ppvObject)
 672     {
 673         return this->_InternalQueryInterface(iid, ppvObject);
 674     }
 675
 676     static HRESULT WINAPI CreateInstance(CComDebugObject<Base> **pp)
 677     {
 678         CComDebugObject<Base>                           *newInstance;
 679         HRESULT                                                         hResult;
 680
 681         ATLASSERT(pp != NULL);
 682         if (pp == NULL)
 683             return E_POINTER;
 684
 685         hResult = E_OUTOFMEMORY;
 686         newInstance = NULL;
 687         ATLTRY(newInstance = new CComDebugObject<Base>());
 688         if (newInstance != NULL)
 689         {
 690             newInstance->SetVoid(NULL);
 691             newInstance->InternalFinalConstructAddRef();
 692             hResult = newInstance->_AtlInitialConstruct();
 693             if (SUCCEEDED(hResult))
 694                 hResult = newInstance->FinalConstruct();
 695             if (SUCCEEDED(hResult))
 696                 hResult = newInstance->_AtlFinalConstruct();
 697             newInstance->InternalFinalConstructRelease();
 698             if (hResult != S_OK)
 699             {
 700                 delete newInstance;
 701                 newInstance = NULL;
 702             }
 703         }
 704         *pp = newInstance;
 705         return hResult;
 706     }
 707 };
 708
 709 #ifdef DEBUG_CCOMOBJECT
 710 #   define _CComObject CComDebugObject
 711 #else
 712 #   define _CComObject CComObject
 713 #endif
 714
 715 template<class T>
 716 void ReleaseCComPtrExpectZero(CComPtr<T>& cptr, BOOL forceRelease = FALSE)
 717 {
 718     if (cptr.p != NULL)
 719     {
 720         int nrc = cptr->Release();
 721         if (nrc > 0)
 722         {
 723             DbgPrint("WARNING: Unexpected RefCount > 0 (%d)!\n", nrc);
 724             if (forceRelease)
 725             {
 726                 while (nrc > 0)
 727                 {
 728                     nrc = cptr->Release();
 729                 }
 730             }
 731         }
 732         cptr.Detach();
 733     }
 734 }
 735
 736 template<class T, class R>
 737 HRESULT inline ShellDebugObjectCreator(REFIID riid, R ** ppv)
 738 {
 739     CComPtr<T>       obj;
 740     HRESULT          hResult;
 741
 742     if (ppv == NULL)
 743         return E_POINTER;
 744     *ppv = NULL;
 745     ATLTRY(obj = new CComDebugObject<T>);
 746     if (obj.p == NULL)
 747         return E_OUTOFMEMORY;
 748     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(ppv));
 749     if (FAILED(hResult))
 750         return hResult;
 751     return S_OK;
 752 }
 753
 754 template<class T, class R>
 755 HRESULT inline ShellObjectCreator(REFIID riid, R ** ppv)
 756 {
 757     CComPtr<T>       obj;
 758     HRESULT          hResult;
 759
 760     if (ppv == NULL)
 761         return E_POINTER;
 762     *ppv = NULL;
 763 ATLTRY(obj = new _CComObject<T>);
 764     if (obj.p == NULL)
 765         return E_OUTOFMEMORY;
 766     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(ppv));
 767     if (FAILED(hResult))
 768         return hResult;
 769     return S_OK;
 770 }
 771
 772 template<class T, class R>
 773 HRESULT inline ShellObjectCreatorInit(REFIID riid, R ** ppv)
 774 {
 775     CComPtr<T>  obj;
 776     CComPtr<R>  result;
 777     HRESULT     hResult;
 778
 779     if (ppv == NULL)
 780         return E_POINTER;
 781     *ppv = NULL;
 782     ATLTRY(obj = new _CComObject<T>);
 783     if (obj.p == NULL)
 784         return E_OUTOFMEMORY;
 785     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(&result));
 786     if (FAILED(hResult))
 787         return hResult;
 788
 789     hResult = obj->Initialize();
 790     if (FAILED(hResult))
 791         return hResult;
 792
 793     *ppv = result.Detach();
 794
 795     return S_OK;
 796 }
 797
 798 template<class T>
 799 HRESULT inline ShellObjectCreatorInit(REFIID riid, void ** ppv)
 800 {
 801     CComPtr<T>  obj;
 802     CComPtr<IUnknown>  result;
 803     HRESULT     hResult;
 804
 805     if (ppv == NULL)
 806         return E_POINTER;
 807     *ppv = NULL;
 808     ATLTRY(obj = new _CComObject<T>);
 809     if (obj.p == NULL)
 810         return E_OUTOFMEMORY;
 811     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(&result));
 812     if (FAILED(hResult))
 813         return hResult;
 814
 815     hResult = obj->Initialize();
 816     if (FAILED(hResult))
 817         return hResult;
 818
 819     *ppv = result.Detach();
 820
 821     return S_OK;
 822 }
 823
 824 template<class T, class T1, class R>
 825 HRESULT inline ShellObjectCreatorInit(T1 initArg1, REFIID riid, R ** ppv)
 826 {
 827     CComPtr<T>  obj;
 828     CComPtr<R>  result;
 829     HRESULT     hResult;
 830
 831     if (ppv == NULL)
 832         return E_POINTER;
 833     *ppv = NULL;
 834     ATLTRY(obj = new _CComObject<T>);
 835     if (obj.p == NULL)
 836         return E_OUTOFMEMORY;
 837     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(&result));
 838     if (FAILED(hResult))
 839         return hResult;
 840
 841     hResult = obj->Initialize(initArg1);
 842     if (FAILED(hResult))
 843         return hResult;
 844
 845     *ppv = result.Detach();
 846
 847     return S_OK;
 848 }
 849
 850 template<class T, class T1, class T2, class R>
 851 HRESULT inline ShellObjectCreatorInit(T1 initArg1, T2 initArg2, REFIID riid, R ** ppv)
 852 {
 853     CComPtr<T>  obj;
 854     CComPtr<R>  result;
 855     HRESULT     hResult;
 856
 857     if (ppv == NULL)
 858         return E_POINTER;
 859     *ppv = NULL;
 860     ATLTRY(obj = new _CComObject<T>);
 861     if (obj.p == NULL)
 862         return E_OUTOFMEMORY;
 863     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(&result));
 864     if (FAILED(hResult))
 865         return hResult;
 866
 867     hResult = obj->Initialize(initArg1, initArg2);
 868     if (FAILED(hResult))
 869         return hResult;
 870
 871     *ppv = result.Detach();
 872
 873     return S_OK;
 874 }
 875
 876 template<class T, class T1, class T2, class T3, class R>
 877 HRESULT inline ShellObjectCreatorInit(T1 initArg1, T2 initArg2, T3 initArg3, REFIID riid, R ** ppv)
 878 {
 879     CComPtr<T>  obj;
 880     CComPtr<R>  result;
 881     HRESULT     hResult;
 882
 883     if (ppv == NULL)
 884         return E_POINTER;
 885     *ppv = NULL;
 886     ATLTRY(obj = new _CComObject<T>);
 887     if (obj.p == NULL)
 888         return E_OUTOFMEMORY;
 889     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(&result));
 890     if (FAILED(hResult))
 891         return hResult;
 892
 893     hResult = obj->Initialize(initArg1, initArg2, initArg3);
 894     if (FAILED(hResult))
 895         return hResult;
 896
 897     *ppv = result.Detach();
 898
 899     return S_OK;
 900 }
 901
 902 template<class T, class T1, class T2, class T3, class T4, class R>
 903 HRESULT inline ShellObjectCreatorInit(T1 initArg1, T2 initArg2, T3 initArg3, T4 initArg4, REFIID riid, R ** ppv)
 904 {
 905     CComPtr<T>  obj;
 906     CComPtr<R>  result;
 907     HRESULT     hResult;
 908
 909     if (ppv == NULL)
 910         return E_POINTER;
 911     *ppv = NULL;
 912     ATLTRY(obj = new _CComObject<T>);
 913     if (obj.p == NULL)
 914         return E_OUTOFMEMORY;
 915     hResult = obj->QueryInterface(riid, reinterpret_cast<void **>(&result));
 916     if (FAILED(hResult))
 917         return hResult;
 918
 919     hResult = obj->Initialize(initArg1, initArg2, initArg3, initArg4);
 920     if (FAILED(hResult))
 921         return hResult;
 922
 923     *ppv = result.Detach();
 924
 925     return S_OK;
 926 }
 927 #endif /* __cplusplus */
 928
 929 #endif /* __WINE_UNDOCSHELL_H */