Changeset 1145 for trunk/src/shell32


Ignore:
Timestamp:
Oct 5, 1999, 9:33:37 PM (26 years ago)
Author:
phaller
Message:

Add: debug information

Location:
trunk/src/shell32/new
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/new/brsfolder.cpp

    r1122 r1145  
     1/* $Id: brsfolder.cpp,v 1.5 1999-10-05 19:33:36 phaller Exp $ */
     2
     3/*
     4 * Win32 SHELL32 for OS/2
     5 *
     6 * Copyright 1997 Marcus Meissner
     7 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
     8 * Project Odin Software License can be found in LICENSE.TXT
     9 *
     10 */
     11
     12
     13/*****************************************************************************
     14 * Includes                                                                  *
     15 *****************************************************************************/
     16
    117#include <stdlib.h>
    218#include <string.h>
    319#include <odin.h>
     20#include <odinwrap.h>
     21#include <os2sel.h>
    422
    523#define ICOM_CINTERFACE 1
    … …  
    3149
    3250
    33 DEFAULT_DEBUG_CHANNEL(shell)
    34 
    35 #define         IDD_TREEVIEW 99
    36 
    37 static HWND             hwndTreeView;
     51/*****************************************************************************
     52 * Local Variables                                                           *
     53 *****************************************************************************/
     54
     55ODINDEBUGCHANNEL(shell32-brsfolder)
     56
     57#define         IDD_TREEVIEW 99
     58
     59static HWND             hwndTreeView;
    3860static LPBROWSEINFOA  lpBrowseInfo;
    39 static LPITEMIDLIST     pidlRet;
     61static LPITEMIDLIST     pidlRet;
    4062
    4163static void FillTreeView(LPSHELLFOLDER lpsf, LPITEMIDLIST  lpifq, HTREEITEM hParent);
    4264
     65
     66/*****************************************************************************
     67 * Implementation                                                            *
     68 *****************************************************************************/
     69
    4370static void InitializeTreeView(HWND hwndParent)
    4471{
    45         HIMAGELIST      hImageList;
    46         IShellFolder *  lpsf;
    47         HRESULT hr;
    48 
    49         hwndTreeView = GetDlgItem (hwndParent, IDD_TREEVIEW);
    50         Shell_GetImageList(NULL, &hImageList);
    51        
    52         TRACE("dlg=%x tree=%x\n", hwndParent, hwndTreeView );
    53 
    54         if (hImageList && hwndTreeView)
    55         { TreeView_SetImageList(hwndTreeView, hImageList, 0);
    56         }
    57 
    58         hr = SHGetDesktopFolder(&lpsf);
    59 
    60         if (SUCCEEDED(hr) && hwndTreeView)
    61         { TreeView_DeleteAllItems(hwndTreeView);
    62           FillTreeView(lpsf, NULL, TVI_ROOT);
    63         }
    64        
    65         if (SUCCEEDED(hr))
    66         { IShellFolder_Release(lpsf);
    67         }
     72        HIMAGELIST      hImageList;
     73        IShellFolder *  lpsf;
     74        HRESULT hr;
     75
     76  dprintf(("SHELL32:brsfolder:InitializeTreeView(%08xh)\n",
     77           hwndParent));
     78
     79        hwndTreeView = GetDlgItem (hwndParent, IDD_TREEVIEW);
     80        Shell_GetImageList(NULL, &hImageList);
     81
     82        if (hImageList && hwndTreeView)
     83        { TreeView_SetImageList(hwndTreeView, hImageList, 0);
     84        }
     85
     86        hr = SHGetDesktopFolder(&lpsf);
     87
     88        if (SUCCEEDED(hr) && hwndTreeView)
     89        { TreeView_DeleteAllItems(hwndTreeView);
     90          FillTreeView(lpsf, NULL, TVI_ROOT);
     91        }
     92
     93        if (SUCCEEDED(hr))
     94        { IShellFolder_Release(lpsf);
     95        }
    6896}
    6997
    7098static int GetIcon(LPITEMIDLIST lpi, UINT uFlags)
    71 {       SHFILEINFOA    sfi;
    72         SHGetFileInfoA((LPCSTR)lpi,0,&sfi, sizeof(SHFILEINFOA), uFlags);
    73         return sfi.iIcon;
     99{
     100        SHFILEINFOA    sfi;
     101
     102  dprintf(("SHELL32:brsfolder:GetIcon(%08xh,%08xh)\n",
     103           lpi,
     104           uFlags));
     105
     106        SHGetFileInfoA((LPCSTR)lpi,0,&sfi, sizeof(SHFILEINFOA), uFlags);
     107        return sfi.iIcon;
    74108}
    75109
    76110static void GetNormalAndSelectedIcons(LPITEMIDLIST lpifq,LPTVITEMA lpTV_ITEM)
    77 {       TRACE("%p %p\n",lpifq, lpTV_ITEM);
    78 
    79         lpTV_ITEM->iImage = GetIcon(lpifq, SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
    80         lpTV_ITEM->iSelectedImage = GetIcon(lpifq, SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_OPENICON);
    81 
    82         return;
     111{
     112  dprintf(("SHELL32:brsfolder:GetNormalAndSelectedIcons(%08xh,%08xh)\n",
     113           lpifq,
     114           lpTV_ITEM));
     115
     116        lpTV_ITEM->iImage = GetIcon(lpifq, SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
     117        lpTV_ITEM->iSelectedImage = GetIcon(lpifq, SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_OPENICON);
     118
     119        return;
    83120}
    84121
    … …  
    92129static BOOL GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST lpi, DWORD dwFlags, LPSTR lpFriendlyName)
    93130{
    94         BOOL   bSuccess=TRUE;
    95         STRRET str;
    96 
    97         TRACE("%p %p %lx %p\n", lpsf, lpi, dwFlags, lpFriendlyName);
    98         if (SUCCEEDED(IShellFolder_GetDisplayNameOf(lpsf, lpi, dwFlags, &str)))
    99         {
    100           if(FAILED(StrRetToStrNA (lpFriendlyName, MAX_PATH, &str, lpi)))
    101           {
    102               bSuccess = FALSE;
    103           }
    104         }
    105         else
    106           bSuccess = FALSE;
    107 
    108         TRACE("-- %s\n",lpFriendlyName);
    109         return bSuccess;
     131        BOOL   bSuccess=TRUE;
     132        STRRET str;
     133
     134  dprintf(("SHELL32:brsfolder:GetName(%08xh,%08xh,%08xh,%08xh)\n",
     135           lpsf,
     136           lpi,
     137           dwFlags,
     138           lpFriendlyName));
     139
     140        if (SUCCEEDED(IShellFolder_GetDisplayNameOf(lpsf, lpi, dwFlags, &str)))
     141        {
     142          if(FAILED(StrRetToStrNA (lpFriendlyName, MAX_PATH, &str, lpi)))
     143          {
     144              bSuccess = FALSE;
     145          }
     146        }
     147        else
     148          bSuccess = FALSE;
     149
     150        TRACE("-- %s\n",lpFriendlyName);
     151        return bSuccess;
    110152}
    111153
    112154static void FillTreeView(IShellFolder * lpsf, LPITEMIDLIST  pidl, HTREEITEM hParent)
    113155{
    114         TVITEMA         tvi;
    115         TVINSERTSTRUCTA tvins;
    116         HTREEITEM       hPrev = 0;
    117         LPENUMIDLIST    lpe=0;
    118         LPITEMIDLIST    pidlTemp=0;
    119         LPTV_ITEMDATA   lptvid=0;
    120         ULONG           ulFetched;
    121         HRESULT         hr;
    122         char            szBuff[256];
    123         HWND            hwnd=GetParent(hwndTreeView);
    124 
    125         TRACE("%p %p %x\n",lpsf, pidl, (INT)hParent);   
    126         SetCapture(GetParent(hwndTreeView));
    127         SetCursor(LoadCursorA(0, IDC_WAITA));
    128 
    129         hr=IShellFolder_EnumObjects(lpsf,hwnd, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS,&lpe);
    130 
    131         if (SUCCEEDED(hr))
    132         { while (NOERROR == IEnumIDList_Next(lpe,1,&pidlTemp,&ulFetched))
    133           { ULONG ulAttrs = SFGAO_HASSUBFOLDER | SFGAO_FOLDER;
    134             IShellFolder_GetAttributesOf(lpsf, 1, &pidlTemp, &ulAttrs);
    135             if (ulAttrs & (SFGAO_HASSUBFOLDER | SFGAO_FOLDER))
    136             { if (ulAttrs & SFGAO_FOLDER)
    137               { tvi.mask  = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
    138 
    139                 if (ulAttrs & SFGAO_HASSUBFOLDER)
    140                 {  tvi.cChildren=1;
    141                    tvi.mask |= TVIF_CHILDREN;
    142                 }
    143 
    144                 if (! ( lptvid = (LPTV_ITEMDATA)SHAlloc(sizeof(TV_ITEMDATA)) ) )
    145                   goto Done;
    146 
    147                 if (!GetName(lpsf, pidlTemp, SHGDN_NORMAL, szBuff))
    148                   goto Done;
    149 
    150                 tvi.pszText    = szBuff;
    151                 tvi.cchTextMax = MAX_PATH;
    152                 tvi.lParam = (LPARAM)lptvid;
    153 
    154                 IShellFolder_AddRef(lpsf);
    155                 lptvid->lpsfParent = lpsf;
    156                 lptvid->lpi     = ILClone(pidlTemp);
    157                 lptvid->lpifq   = ILCombine(pidl, pidlTemp);
    158                 GetNormalAndSelectedIcons(lptvid->lpifq, &tvi);
    159 
    160                 tvins.DUMMYUNIONNAME.item         = tvi;
    161                 tvins.hInsertAfter = hPrev;
    162                 tvins.hParent      = hParent;
    163 
    164                 hPrev = (HTREEITEM)TreeView_InsertItemA (hwndTreeView, &tvins);
    165 
    166               }
    167             }
    168             SHFree(pidlTemp);  /* Finally, free the pidl that the shell gave us... */
    169             pidlTemp=0;
    170           }
    171         }
     156        TVITEMA         tvi;
     157        TVINSERTSTRUCTA tvins;
     158        HTREEITEM       hPrev = 0;
     159        LPENUMIDLIST    lpe=0;
     160        LPITEMIDLIST    pidlTemp=0;
     161        LPTV_ITEMDATA   lptvid=0;
     162        ULONG           ulFetched;
     163        HRESULT         hr;
     164        char            szBuff[256];
     165        HWND            hwnd=GetParent(hwndTreeView);
     166
     167  dprintf(("SHELL32:brsfolder:FillTreeView(%08xh,%08xh,%08xh)\n",
     168           lpsf,
     169           pidl,
     170           hParent));
     171
     172        SetCapture(GetParent(hwndTreeView));
     173        SetCursor(LoadCursorA(0, IDC_WAITA));
     174
     175        hr=IShellFolder_EnumObjects(lpsf,hwnd, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS,&lpe);
     176
     177        if (SUCCEEDED(hr))
     178        { while (NOERROR == IEnumIDList_Next(lpe,1,&pidlTemp,&ulFetched))
     179          { ULONG ulAttrs = SFGAO_HASSUBFOLDER | SFGAO_FOLDER;
     180            IShellFolder_GetAttributesOf(lpsf, 1, &pidlTemp, &ulAttrs);
     181            if (ulAttrs & (SFGAO_HASSUBFOLDER | SFGAO_FOLDER))
     182            { if (ulAttrs & SFGAO_FOLDER)
     183              { tvi.mask  = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
     184
     185                if (ulAttrs & SFGAO_HASSUBFOLDER)
     186                {  tvi.cChildren=1;
     187                   tvi.mask |= TVIF_CHILDREN;
     188                }
     189
     190                if (! ( lptvid = (LPTV_ITEMDATA)SHAlloc(sizeof(TV_ITEMDATA)) ) )
     191                  goto Done;
     192
     193                if (!GetName(lpsf, pidlTemp, SHGDN_NORMAL, szBuff))
     194                  goto Done;
     195
     196                tvi.pszText    = szBuff;
     197                tvi.cchTextMax = MAX_PATH;
     198                tvi.lParam = (LPARAM)lptvid;
     199
     200                IShellFolder_AddRef(lpsf);
     201                lptvid->lpsfParent = lpsf;
     202                lptvid->lpi     = ILClone(pidlTemp);
     203                lptvid->lpifq   = ILCombine(pidl, pidlTemp);
     204                GetNormalAndSelectedIcons(lptvid->lpifq, &tvi);
     205
     206                tvins.DUMMYUNIONNAME.item         = tvi;
     207                tvins.hInsertAfter = hPrev;
     208                tvins.hParent      = hParent;
     209
     210                hPrev = (HTREEITEM)TreeView_InsertItemA (hwndTreeView, &tvins);
     211
     212              }
     213            }
     214            SHFree(pidlTemp);  /* Finally, free the pidl that the shell gave us... */
     215            pidlTemp=0;
     216          }
     217        }
    172218
    173219Done:
    174         ReleaseCapture();
    175         SetCursor(LoadCursorA(0, IDC_ARROWA));
    176 
    177         if (lpe)
    178           lpe->lpvtbl->fnRelease(lpe);
    179         if (pidlTemp )
    180           SHFree(pidlTemp);
     220        ReleaseCapture();
     221        SetCursor(LoadCursorA(0, IDC_ARROWA));
     222
     223        if (lpe)
     224          lpe->lpvtbl->fnRelease(lpe);
     225        if (pidlTemp )
     226          SHFree(pidlTemp);
    181227}
    182228
    183229static LRESULT MsgNotify(HWND hWnd,  UINT CtlID, LPNMHDR lpnmh)
    184 {       
    185         NMTREEVIEWA     *pnmtv   = (NMTREEVIEWA *)lpnmh;
    186         LPTV_ITEMDATA   lptvid;  /* Long pointer to TreeView item data */
    187         IShellFolder *  lpsf2=0;
    188        
    189 
    190         TRACE("%x %x %p msg=%x\n", hWnd,  CtlID, lpnmh, pnmtv->hdr.code);
    191 
    192         switch (pnmtv->hdr.idFrom)
    193         { case IDD_TREEVIEW:
    194             switch (pnmtv->hdr.code)
    195             { case TVN_DELETEITEM:
    196                 { FIXME("TVN_DELETEITEM\n");
    197                   lptvid=(LPTV_ITEMDATA)pnmtv->itemOld.lParam;
    198                   IShellFolder_Release(lptvid->lpsfParent);
    199                   SHFree(lptvid->lpi);
    200                   SHFree(lptvid->lpifq);
    201                   SHFree(lptvid);
    202                 }
    203                 break;
    204                        
    205               case TVN_ITEMEXPANDING:
    206                 { FIXME("TVN_ITEMEXPANDING\n");
    207                   if ((pnmtv->itemNew.state & TVIS_EXPANDEDONCE))
    208                     break;
    209                
    210                   lptvid=(LPTV_ITEMDATA)pnmtv->itemNew.lParam;
    211                   if (SUCCEEDED(IShellFolder_BindToObject(lptvid->lpsfParent, lptvid->lpi,0,(REFIID)&IID_IShellFolder,(LPVOID *)&lpsf2)))
    212                   { FillTreeView( lpsf2, lptvid->lpifq, pnmtv->itemNew.hItem );
    213                   }
    214                   TreeView_SortChildren(hwndTreeView, pnmtv->itemNew.hItem, FALSE);
    215                 }
    216                 break;
    217               case TVN_SELCHANGED:
    218                 lptvid=(LPTV_ITEMDATA)pnmtv->itemNew.lParam;
    219                 pidlRet = lptvid->lpifq;
    220                 break;
    221 
    222               default:
    223                 FIXME("unhandled\n");
    224                 break;
    225             }
    226             break;
    227 
    228           default:
    229             break;
    230         }
    231 
    232         return 0;
     230{
     231        NMTREEVIEWA     *pnmtv   = (NMTREEVIEWA *)lpnmh;
     232        LPTV_ITEMDATA   lptvid;  /* Long pointer to TreeView item data */
     233        IShellFolder *  lpsf2=0;
     234
     235
     236  dprintf(("SHELL32:brsfolder:MsgNotify(%08xh,%08xh,%08xh)\n",
     237           hWnd,
     238           CtlID,
     239           lpnmh));
     240
     241        switch (pnmtv->hdr.idFrom)
     242        { case IDD_TREEVIEW:
     243            switch (pnmtv->hdr.code)
     244            { case TVN_DELETEITEM:
     245                { FIXME("TVN_DELETEITEM\n");
     246                  lptvid=(LPTV_ITEMDATA)pnmtv->itemOld.lParam;
     247                  IShellFolder_Release(lptvid->lpsfParent);
     248                  SHFree(lptvid->lpi);
     249                  SHFree(lptvid->lpifq);
     250                  SHFree(lptvid);
     251                }
     252                break;
     253
     254              case TVN_ITEMEXPANDING:
     255                { FIXME("TVN_ITEMEXPANDING\n");
     256                  if ((pnmtv->itemNew.state & TVIS_EXPANDEDONCE))
     257                    break;
     258
     259                  lptvid=(LPTV_ITEMDATA)pnmtv->itemNew.lParam;
     260                  if (SUCCEEDED(IShellFolder_BindToObject(lptvid->lpsfParent, lptvid->lpi,0,(REFIID)&IID_IShellFolder,(LPVOID *)&lpsf2)))
     261                  { FillTreeView( lpsf2, lptvid->lpifq, pnmtv->itemNew.hItem );
     262                  }
     263                  TreeView_SortChildren(hwndTreeView, pnmtv->itemNew.hItem, FALSE);
     264                }
     265                break;
     266              case TVN_SELCHANGED:
     267                lptvid=(LPTV_ITEMDATA)pnmtv->itemNew.lParam;
     268                pidlRet = lptvid->lpifq;
     269                break;
     270
     271              default:
     272                FIXME("unhandled\n");
     273                break;
     274            }
     275            break;
     276
     277          default:
     278            break;
     279        }
     280
     281        return 0;
    233282}
    234283
    … …  
    237286 *             BrsFolderDlgProc32  (not an exported API function)
    238287 */
    239 static BOOL WINAPI BrsFolderDlgProc( HWND hWnd, UINT msg, WPARAM wParam,
    240                                      LPARAM lParam )
    241 {    TRACE("hwnd=%i msg=%i 0x%08x 0x%08lx\n", hWnd,  msg, wParam, lParam );
    242 
    243         switch(msg)
    244         { case WM_INITDIALOG:
    245             pidlRet = NULL;
    246             lpBrowseInfo = (LPBROWSEINFOA) lParam;
    247             if (lpBrowseInfo->lpfn)
    248               FIXME("Callbacks not implemented\n");
    249             if (lpBrowseInfo->ulFlags)
    250               FIXME("flag %x not implemented\n", lpBrowseInfo->ulFlags);
    251             if (lpBrowseInfo->lpszTitle)
    252               FIXME("title %s not displayed\n", lpBrowseInfo->lpszTitle);
    253             if ( lpBrowseInfo->pidlRoot )
    254               FIXME("root is desktop\n");
    255 
    256             InitializeTreeView ( hWnd);
    257             return 1;
    258 
    259           case WM_NOTIFY:
    260             MsgNotify( hWnd, (UINT)wParam, (LPNMHDR)lParam);
    261             break;
    262        
    263           case WM_COMMAND:
    264             switch (wParam)
    265             { case IDOK:
    266                 pdump ( pidlRet );
    267                 SHGetPathFromIDListA(pidlRet, lpBrowseInfo->pszDisplayName);
    268                 EndDialog(hWnd, (DWORD) ILClone(pidlRet));
    269                 return TRUE;
    270 
    271               case IDCANCEL:
    272                 EndDialog(hWnd, 0);
    273                 return TRUE;
    274             }
    275             break;
    276         }
    277         return 0;
     288ODINFUNCTION4(BOOL, BrsFolderDlgProc, HWND,   hWnd,
     289                                      UINT,   msg,
     290                                      WPARAM, wParam,
     291                                      LPARAM, lParam)
     292{
     293        switch(msg)
     294        { case WM_INITDIALOG:
     295            pidlRet = NULL;
     296            lpBrowseInfo = (LPBROWSEINFOA) lParam;
     297            if (lpBrowseInfo->lpfn)
     298              FIXME("Callbacks not implemented\n");
     299            if (lpBrowseInfo->ulFlags)
     300              FIXME("flag %x not implemented\n", lpBrowseInfo->ulFlags);
     301            if (lpBrowseInfo->lpszTitle)
     302              FIXME("title %s not displayed\n", lpBrowseInfo->lpszTitle);
     303            if ( lpBrowseInfo->pidlRoot )
     304              FIXME("root is desktop\n");
     305
     306            InitializeTreeView ( hWnd);
     307            return 1;
     308
     309          case WM_NOTIFY:
     310            MsgNotify( hWnd, (UINT)wParam, (LPNMHDR)lParam);
     311            break;
     312
     313          case WM_COMMAND:
     314            switch (wParam)
     315            { case IDOK:
     316                pdump ( pidlRet );
     317                SHGetPathFromIDListA(pidlRet, lpBrowseInfo->pszDisplayName);
     318                EndDialog(hWnd, (DWORD) ILClone(pidlRet));
     319                return TRUE;
     320
     321              case IDCANCEL:
     322                EndDialog(hWnd, 0);
     323                return TRUE;
     324            }
     325            break;
     326        }
     327        return 0;
    278328}
    279329
    … …  
    282332 *
    283333 */
    284 LPITEMIDLIST WINAPI SHBrowseForFolderA (LPBROWSEINFOA lpbi)
    285 {
    286         TRACE("(%lx,%s) empty stub!\n", (DWORD)lpbi, lpbi->lpszTitle);
    287 
    288         return (LPITEMIDLIST) DialogBoxParamA( shell32_hInstance,
    289                         "SHBRSFORFOLDER_MSGBOX", 0,
    290                         BrsFolderDlgProc, (INT)lpbi );
    291 }
     334ODINFUNCTION1(LPITEMIDLIST, SHBrowseForFolderA, LPBROWSEINFOA, lpbi)
     335{
     336        TRACE("(%lx,%s) empty stub!\n", (DWORD)lpbi, lpbi->lpszTitle);
     337
     338        return (LPITEMIDLIST) DialogBoxParamA( shell32_hInstance,
     339                        "SHBRSFORFOLDER_MSGBOX", 0,
     340                        BrsFolderDlgProc, (INT)lpbi );
     341}

  • trunk/src/shell32/new/classes.cpp

    r791 r1145  
     1/* $Id: classes.cpp,v 1.2 1999-10-05 19:33:36 phaller Exp $ */
     2
    13/*
    2  *      file type mapping
    3  *      (HKEY_CLASSES_ROOT - Stuff)
     4 * Win32 SHELL32 for OS/2
    45 *
     6 * Copyright 1997 Marcus Meissner
     7 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
     8 * Project Odin Software License can be found in LICENSE.TXT
    59 *
    610 */
     11
     12/*
     13 *      file type mapping
     14 *      (HKEY_CLASSES_ROOT - Stuff)
     15 */
     16
     17
     18/*****************************************************************************
     19 * Includes                                                                  *
     20 *****************************************************************************/
     21
    722#include <stdlib.h>
    823#include <string.h>
    924#include <odin.h>
     25#include <odinwrap.h>
     26#include <os2sel.h>
    1027
    1128#define ICOM_CINTERFACE 1
    … …  
    2340#include <misc.h>
    2441
    25 DEFAULT_DEBUG_CHANNEL(shell)
     42
     43/*****************************************************************************
     44 * Local Variables                                                           *
     45 *****************************************************************************/
     46
     47ODINDEBUGCHANNEL(shell32-classes)
    2648
    2749#define MAX_EXTENSION_LENGTH 20
    2850
     51
     52/*****************************************************************************
     53 * Implementation                                                            *
     54 *****************************************************************************/
     55
    2956BOOL HCR_MapTypeToValue ( LPCSTR szExtension, LPSTR szFileType, LONG len, BOOL bPrependDot)
    30 {       HKEY    hkey;
    31         char    szTemp[MAX_EXTENSION_LENGTH + 2];
    32 
    33         TRACE("%s %p\n",szExtension, szFileType );
    34 
    35         if (bPrependDot)
    36           strcpy(szTemp, ".");
    37 
    38         lstrcpynA(szTemp+((bPrependDot)?1:0), szExtension, MAX_EXTENSION_LENGTH);
    39        
    40         if (RegOpenKeyExA(HKEY_CLASSES_ROOT,szTemp,0,0x02000000,&hkey))
    41         { return FALSE;
    42         }
    43 
    44         if (RegQueryValueA(hkey,NULL,szFileType,&len))
    45         { RegCloseKey(hkey);
    46           return FALSE;
    47         }       
    48 
    49         RegCloseKey(hkey);
    50 
    51         TRACE("-- %s\n", szFileType );
    52 
    53         return TRUE;
     57{
     58        HKEY    hkey;
     59        char    szTemp[MAX_EXTENSION_LENGTH + 2];
     60
     61  dprintf(("SHELL32:classes:HCR_MapTypeToValue(%s,%08xh,%08xh,%08xh)\n",
     62           szExtension,
     63           szFileType,
     64           len,
     65           bPrependDot));
     66
     67        if (bPrependDot)
     68          strcpy(szTemp, ".");
     69
     70        lstrcpynA(szTemp+((bPrependDot)?1:0), szExtension, MAX_EXTENSION_LENGTH);
     71
     72        if (RegOpenKeyExA(HKEY_CLASSES_ROOT,szTemp,0,0x02000000,&hkey))
     73        { return FALSE;
     74        }
     75
     76        if (RegQueryValueA(hkey,NULL,szFileType,&len))
     77        { RegCloseKey(hkey);
     78          return FALSE;
     79        }
     80
     81        RegCloseKey(hkey);
     82
     83        TRACE("-- %s\n", szFileType );
     84
     85        return TRUE;
    5486}
    5587
    5688
    5789BOOL HCR_GetExecuteCommand ( LPCSTR szClass, LPCSTR szVerb, LPSTR szDest, LONG len )
    58 {       HKEY    hkey;
    59         char    sTemp[256];
    60        
    61         TRACE("%s %s\n",szClass, szVerb );
    62 
    63         sprintf(sTemp, "%s\\shell\\%s\\command",szClass, szVerb);
    64 
    65         if (RegOpenKeyExA(HKEY_CLASSES_ROOT,sTemp,0,0x02000000,&hkey))
    66         { return FALSE;
    67         }
    68 
    69         if (RegQueryValueA(hkey,NULL,szDest,&len))
    70         { RegCloseKey(hkey);
    71           return FALSE;
    72         }       
    73         RegCloseKey(hkey);
    74 
    75         TRACE("-- %s\n", szDest );
    76 
    77         return TRUE;
     90{
     91        HKEY    hkey;
     92        char    sTemp[256];
     93
     94  dprintf(("SHELL32:classes:HCR_GetExecuteCommand(%s,%s,%08xh,%08xh)\n",
     95           szClass,
     96           szVerb,
     97           szDest,
     98           len));
     99
     100        sprintf(sTemp, "%s\\shell\\%s\\command",szClass, szVerb);
     101
     102        if (RegOpenKeyExA(HKEY_CLASSES_ROOT,sTemp,0,0x02000000,&hkey))
     103        { return FALSE;
     104        }
     105
     106        if (RegQueryValueA(hkey,NULL,szDest,&len))
     107        { RegCloseKey(hkey);
     108          return FALSE;
     109        }
     110        RegCloseKey(hkey);
     111
     112        TRACE("-- %s\n", szDest );
     113
     114        return TRUE;
    78115
    79116}
    80117/***************************************************************************************
    81 *       HCR_GetDefaultIcon      [internal]
     118*       HCR_GetDefaultIcon      [internal]
    82119*
    83120* Gets the icon for a filetype
    84121*/
    85122BOOL HCR_GetDefaultIcon (LPCSTR szClass, LPSTR szDest, LONG len, LPDWORD dwNr)
    86 {       HKEY    hkey;
    87         char    sTemp[256];
    88         char    sNum[5];
    89 
    90         TRACE("%s\n",szClass );
    91 
    92         sprintf(sTemp, "%s\\DefaultIcon",szClass);
    93 
    94         if (RegOpenKeyExA(HKEY_CLASSES_ROOT,sTemp,0,0x02000000,&hkey))
    95         { return FALSE;
    96         }
    97 
    98         if (RegQueryValueA(hkey,NULL,szDest,&len))
    99         { RegCloseKey(hkey);
    100           return FALSE;
    101         }       
    102 
    103         RegCloseKey(hkey);
    104 
    105         if (ParseFieldA (szDest, 2, sNum, 5))
    106         { *dwNr=atoi(sNum);
    107         }
    108        
    109         ParseFieldA (szDest, 1, szDest, len);
    110        
    111         TRACE("-- %s %li\n", szDest, *dwNr );
    112 
    113         return TRUE;
     123{
     124        HKEY    hkey;
     125        char    sTemp[256];
     126        char    sNum[5];
     127
     128  dprintf(("SHELL32:classes:HCR_GetDefaultIcon(%s,%08xh,%08xh,%08xh)\n",
     129           szClass,
     130           szDest,
     131           len,
     132           dwNr));
     133
     134        sprintf(sTemp, "%s\\DefaultIcon",szClass);
     135
     136        if (RegOpenKeyExA(HKEY_CLASSES_ROOT,sTemp,0,0x02000000,&hkey))
     137        { return FALSE;
     138        }
     139
     140        if (RegQueryValueA(hkey,NULL,szDest,&len))
     141        { RegCloseKey(hkey);
     142          return FALSE;
     143        }
     144
     145        RegCloseKey(hkey);
     146
     147        if (ParseFieldA (szDest, 2, sNum, 5))
     148        { *dwNr=atoi(sNum);
     149        }
     150
     151        ParseFieldA (szDest, 1, szDest, len);
     152
     153        TRACE("-- %s %li\n", szDest, *dwNr );
     154
     155        return TRUE;
    114156}
    115157
    116158/***************************************************************************************
    117 *       HCR_GetClassName        [internal]
     159*       HCR_GetClassName        [internal]
    118160*
    119161* Gets the name of a registred class
    120162*/
    121163BOOL HCR_GetClassName (REFIID riid, LPSTR szDest, DWORD len)
    122 {       HKEY    hkey;
    123         char    xriid[50];
    124         BOOL ret = FALSE;
    125         DWORD buflen = len;
    126 
    127         strcpy(xriid,"CLSID\\");
    128         WINE_StringFromCLSID(riid,&xriid[strlen(xriid)]);
    129 
    130         TRACE("%s\n",xriid );
    131 
    132         if (!RegOpenKeyExA(HKEY_CLASSES_ROOT,xriid,0,KEY_READ,&hkey))
    133         {
    134           if (!RegQueryValueExA(hkey,"",0,NULL,(LPBYTE)szDest,&len))
    135           {
    136             ret = TRUE;
    137           }
    138           RegCloseKey(hkey);
    139         }
    140 
    141         if (!ret || !szDest[0])
    142         {
    143           if(IsEqualIID(riid, &CLSID_ShellDesktop))
    144           {
    145             LoadStringA(shell32_hInstance, IDS_DESKTOP, szDest, buflen);
    146             ret = TRUE;
    147           }
    148           else if (IsEqualIID(riid, &IID_MyComputer))
    149           {
    150             LoadStringA(shell32_hInstance, IDS_MYCOMPUTER, szDest, buflen);
    151             ret = TRUE;
    152           }     
    153         }
    154 
    155         TRACE("-- %s\n", szDest);
    156 
    157         return ret;
     164{
     165        HKEY    hkey;
     166        char    xriid[50];
     167        BOOL ret = FALSE;
     168        DWORD buflen = len;
     169
     170  dprintf(("SHELL32:classes:HCR_GetClassName(%08xh,%08xh,%08xh)\n",
     171           riid,
     172           szDest,
     173           len));
     174
     175        strcpy(xriid,"CLSID\\");
     176        WINE_StringFromCLSID(riid,&xriid[strlen(xriid)]);
     177
     178        TRACE("%s\n",xriid );
     179
     180        if (!RegOpenKeyExA(HKEY_CLASSES_ROOT,xriid,0,KEY_READ,&hkey))
     181        {
     182          if (!RegQueryValueExA(hkey,"",0,NULL,(LPBYTE)szDest,&len))
     183          {
     184            ret = TRUE;
     185          }
     186          RegCloseKey(hkey);
     187        }
     188
     189        if (!ret || !szDest[0])
     190        {
     191          if(IsEqualIID(riid, &CLSID_ShellDesktop))
     192          {
     193            LoadStringA(shell32_hInstance, IDS_DESKTOP, szDest, buflen);
     194            ret = TRUE;
     195          }
     196          else if (IsEqualIID(riid, &IID_MyComputer))
     197          {
     198            LoadStringA(shell32_hInstance, IDS_MYCOMPUTER, szDest, buflen);
     199            ret = TRUE;
     200          }
     201        }
     202
     203        TRACE("-- %s\n", szDest);
     204
     205        return ret;
    158206}
    159207
    160208/***************************************************************************************
    161 *       HCR_GetFolderAttributes [internal]
     209*       HCR_GetFolderAttributes [internal]
    162210*
    163211* gets the folder attributes of a class
    164212*/
    165213BOOL HCR_GetFolderAttributes (REFIID riid, LPDWORD szDest)
    166 {       HKEY    hkey;
    167         char    xriid[60];
    168         DWORD   attributes;
    169         DWORD   len = 4;
    170 
    171         strcpy(xriid,"CLSID\\");
    172         WINE_StringFromCLSID(riid,&xriid[strlen(xriid)]);
    173         TRACE("%s\n",xriid );
    174 
    175         strcat (xriid, "\\ShellFolder");
    176 
    177         if (RegOpenKeyExA(HKEY_CLASSES_ROOT,xriid,0,KEY_READ,&hkey))
    178         {
    179           return FALSE;
    180         }
    181 
    182         if (RegQueryValueExA(hkey,"Attributes",0,NULL,(LPBYTE)&attributes,&len))
    183         {
    184           RegCloseKey(hkey);
    185           return FALSE;
    186         }
    187 
    188         RegCloseKey(hkey);
    189 
    190         TRACE("-- 0x%08lx\n", attributes);
    191 
    192         *szDest = attributes;
    193 
    194         return TRUE;
    195 }
    196 
     214{
     215        HKEY    hkey;
     216        char    xriid[60];
     217        DWORD   attributes;
     218        DWORD   len = 4;
     219
     220  dprintf(("SHELL32:classes:HCR_GetFolderAttributes(%08xh,%08xh)\n",
     221           riid,
     222           szDest));
     223
     224        strcpy(xriid,"CLSID\\");
     225        WINE_StringFromCLSID(riid,&xriid[strlen(xriid)]);
     226        TRACE("%s\n",xriid );
     227
     228        strcat (xriid, "\\ShellFolder");
     229
     230        if (RegOpenKeyExA(HKEY_CLASSES_ROOT,xriid,0,KEY_READ,&hkey))
     231        {
     232          return FALSE;
     233        }
     234
     235        if (RegQueryValueExA(hkey,"Attributes",0,NULL,(LPBYTE)&attributes,&len))
     236        {
     237          RegCloseKey(hkey);
     238          return FALSE;
     239        }
     240
     241        RegCloseKey(hkey);
     242
     243        TRACE("-- 0x%08lx\n", attributes);
     244
     245        *szDest = attributes;
     246
     247        return TRUE;
     248}
     249

  • trunk/src/shell32/new/contmenu.cpp

    r791 r1145  
     1/* $Id: contmenu.cpp,v 1.2 1999-10-05 19:33:36 phaller Exp $ */
     2
    13/*
    2  *      IContextMenu
     4 * Win32 SHELL32 for OS/2
    35 *
    4  *      Copyright 1998  Juergen Schmied <juergen.schmied@metronet.de>
     6 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
     7 * Project Odin Software License can be found in LICENSE.TXT
     8 *
    59 */
     10
     11/*
     12 *      IContextMenu
     13 *
     14 *      Copyright 1998  Juergen Schmied <juergen.schmied@metronet.de>
     15 */
     16
     17
     18/*****************************************************************************
     19 * Includes                                                                  *
     20 *****************************************************************************/
     21
    622#include <string.h>
    723#include <odin.h>
     24#include <odinwrap.h>
     25#include <os2sel.h>
    826
    927#define ICOM_CINTERFACE 1
    … …  
    2644#include <misc.h>
    2745
    28 DEFAULT_DEBUG_CHANNEL(shell)
     46
     47/*****************************************************************************
     48 * Local Variables                                                           *
     49 *****************************************************************************/
     50
     51ODINDEBUGCHANNEL(shell-contmenu)
     52
    2953
    3054/**************************************************************************
    … …  
    4266
    4367static struct ICOM_VTABLE(IContextMenu) cmvt =
    44 {       
    45         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    46         IContextMenu_fnQueryInterface,
    47         IContextMenu_fnAddRef,
    48         IContextMenu_fnRelease,
    49         IContextMenu_fnQueryContextMenu,
    50         IContextMenu_fnInvokeCommand,
    51         IContextMenu_fnGetCommandString,
    52         IContextMenu_fnHandleMenuMsg,
    53         (void *) 0xdeadbabe     /* just paranoia */
     68{
     69        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     70        IContextMenu_fnQueryInterface,
     71        IContextMenu_fnAddRef,
     72        IContextMenu_fnRelease,
     73        IContextMenu_fnQueryContextMenu,
     74        IContextMenu_fnInvokeCommand,
     75        IContextMenu_fnGetCommandString,
     76        IContextMenu_fnHandleMenuMsg,
     77        (void *) 0xdeadbabe     /* just paranoia */
    5478};
    5579
    … …  
    5882*/
    5983typedef struct
    60 {       ICOM_VTABLE(IContextMenu)* lpvtbl;
    61         DWORD           ref;
    62         IShellFolder*   pSFParent;
    63         LPITEMIDLIST    pidl;           /* root pidl */
    64         LPITEMIDLIST    *aPidls;        /* array of child pidls */
    65         BOOL            bAllValues;
     84{       ICOM_VTABLE(IContextMenu)* lpvtbl;
     85        DWORD           ref;
     86        IShellFolder*   pSFParent;
     87        LPITEMIDLIST    pidl;           /* root pidl */
     88        LPITEMIDLIST    *aPidls;        /* array of child pidls */
     89        BOOL            bAllValues;
    6690} IContextMenuImpl;
    6791
    … …  
    7498static BOOL IContextMenu_AllocPidlTable(IContextMenuImpl *This, DWORD dwEntries)
    7599{
    76         TRACE("(%p)->(entrys=%lu)\n",This, dwEntries);
    77 
    78         /*add one for NULL terminator */
    79         dwEntries++;
    80 
    81         This->aPidls = (LPITEMIDLIST*)SHAlloc(dwEntries * sizeof(LPITEMIDLIST));
    82 
    83         if(This->aPidls)
    84         { ZeroMemory(This->aPidls, dwEntries * sizeof(LPITEMIDLIST));   /*set all of the entries to NULL*/
    85         }
    86         return (This->aPidls != NULL);
     100  dprintf(("SHELL32:contmenu:IContextMenu_AllocPidlTable(%08xh,%08xh)\n",
     101           This,
     102           dwEntries));
     103
     104        /*add one for NULL terminator */
     105        dwEntries++;
     106
     107        This->aPidls = (LPITEMIDLIST*)SHAlloc(dwEntries * sizeof(LPITEMIDLIST));
     108
     109        if(This->aPidls)
     110        { ZeroMemory(This->aPidls, dwEntries * sizeof(LPITEMIDLIST));   /*set all of the entries to NULL*/
     111        }
     112        return (This->aPidls != NULL);
    87113}
    88114
    … …  
    92118static void IContextMenu_FreePidlTable(IContextMenuImpl *This)
    93119{
    94         int   i;
    95 
    96         TRACE("(%p)->()\n",This);
    97 
    98         if(This->aPidls)
    99         { for(i = 0; This->aPidls[i]; i++)
    100           { SHFree(This->aPidls[i]);
    101           }
    102 
    103           SHFree(This->aPidls);
    104           This->aPidls = NULL;
    105         }
     120        int   i;
     121
     122  dprintf(("SHELL32:contmenu:IContextMenu_FreePidlTable(%08xh)\n",
     123           This));
     124
     125        if(This->aPidls)
     126        { for(i = 0; This->aPidls[i]; i++)
     127          { SHFree(This->aPidls[i]);
     128          }
     129
     130          SHFree(This->aPidls);
     131          This->aPidls = NULL;
     132        }
    106133}
    107134
    … …  
    111138static BOOL IContextMenu_FillPidlTable(IContextMenuImpl *This, LPCITEMIDLIST *aPidls, UINT uItemCount)
    112139{
    113         UINT  i;
    114 
    115         TRACE("(%p)->(apidl=%p count=%u)\n",This, aPidls, uItemCount);
    116 
    117         if(This->aPidls)
    118         { for(i = 0; i < uItemCount; i++)
    119           { This->aPidls[i] = ILClone(aPidls[i]);
    120           }
    121           return TRUE;
    122         }
    123         return FALSE;
     140        UINT  i;
     141
     142  dprintf(("SHELL32:contmenu:IContectMenu_FillPidlTable(%08xh,%08xh,%08xh)\n",
     143           This,
     144           aPidls,
     145           uItemCount));
     146
     147        if(This->aPidls)
     148        { for(i = 0; i < uItemCount; i++)
     149          { This->aPidls[i] = ILClone(aPidls[i]);
     150          }
     151          return TRUE;
     152        }
     153        return FALSE;
    124154}
    125155
    … …  
    128158*/
    129159static BOOL IContextMenu_CanRenameItems(IContextMenuImpl *This)
    130 {       UINT  i;
    131         DWORD dwAttributes;
    132 
    133         TRACE("(%p)->()\n",This);
    134 
    135         if(This->aPidls)
    136         {
    137           for(i = 0; This->aPidls[i]; i++){} /*get the number of items assigned to This object*/
    138           { if(i > 1)   /*you can't rename more than one item at a time*/
    139             { return FALSE;
    140             }
    141           }
    142           dwAttributes = SFGAO_CANRENAME;
    143           IShellFolder_GetAttributesOf(This->pSFParent, i, (LPCITEMIDLIST*)This->aPidls, &dwAttributes);
    144 
    145           return dwAttributes & SFGAO_CANRENAME;
    146         }
    147         return FALSE;
     160{       UINT  i;
     161        DWORD dwAttributes;
     162
     163  dprintf(("SHELL32:contmenu:IContectMenu_CanRenameItems(%08xh)\n",
     164           This));
     165
     166        if(This->aPidls)
     167        {
     168          for(i = 0; This->aPidls[i]; i++){} /*get the number of items assigned to This object*/
     169          { if(i > 1)   /*you can't rename more than one item at a time*/
     170            { return FALSE;
     171            }
     172          }
     173          dwAttributes = SFGAO_CANRENAME;
     174          IShellFolder_GetAttributesOf(This->pSFParent, i, (LPCITEMIDLIST*)This->aPidls, &dwAttributes);
     175
     176          return dwAttributes & SFGAO_CANRENAME;
     177        }
     178        return FALSE;
    148179}
    149180
    … …  
    152183*/
    153184IContextMenu *IContextMenu_Constructor(LPSHELLFOLDER pSFParent, LPCITEMIDLIST pidl, LPCITEMIDLIST *aPidls, UINT uItemCount)
    154 {       IContextMenuImpl* cm;
    155         UINT  u;
    156 
    157         cm = (IContextMenuImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IContextMenuImpl));
    158         cm->lpvtbl=&cmvt;
    159         cm->ref = 1;
    160         cm->pidl = ILClone(pidl);
    161 
    162         cm->pSFParent = pSFParent;
    163 
    164         if(pSFParent)
    165            IShellFolder_AddRef(pSFParent);
    166 
    167         cm->aPidls = NULL;
    168 
    169         IContextMenu_AllocPidlTable(cm, uItemCount);
    170 
    171         if(cm->aPidls)
    172         { IContextMenu_FillPidlTable(cm, aPidls, uItemCount);
    173         }
    174 
    175         cm->bAllValues = 1;
    176         for(u = 0; u < uItemCount; u++)
    177         { cm->bAllValues &= (_ILIsValue(aPidls[u]) ? 1 : 0);
    178         }
    179         TRACE("(%p)->()\n",cm);
    180         shell32_ObjCount++;
    181         return (IContextMenu*)cm;
     185{
     186        IContextMenuImpl* cm;
     187        UINT  u;
     188
     189  dprintf(("SHELL32:contmenu:IContectMenu_Constructor(%08xh,%08xh,%08xh)\n",
     190           pSFParent,
     191           aPidls,
     192           uItemCount));
     193
     194        cm = (IContextMenuImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IContextMenuImpl));
     195        cm->lpvtbl=&cmvt;
     196        cm->ref = 1;
     197        cm->pidl = ILClone(pidl);
     198
     199        cm->pSFParent = pSFParent;
     200
     201        if(pSFParent)
     202           IShellFolder_AddRef(pSFParent);
     203
     204        cm->aPidls = NULL;
     205
     206        IContextMenu_AllocPidlTable(cm, uItemCount);
     207
     208        if(cm->aPidls)
     209        { IContextMenu_FillPidlTable(cm, aPidls, uItemCount);
     210        }
     211
     212        cm->bAllValues = 1;
     213        for(u = 0; u < uItemCount; u++)
     214        { cm->bAllValues &= (_ILIsValue(aPidls[u]) ? 1 : 0);
     215        }
     216        TRACE("(%p)->()\n",cm);
     217        shell32_ObjCount++;
     218        return (IContextMenu*)cm;
    182219}
    183220
    … …  
    187224static HRESULT WINAPI IContextMenu_fnQueryInterface(IContextMenu *iface, REFIID riid, LPVOID *ppvObj)
    188225{
    189         ICOM_THIS(IContextMenuImpl, iface);
    190 
    191         char    xriid[50];
    192         WINE_StringFromCLSID((LPCLSID)riid,xriid);
    193 
    194         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,xriid,ppvObj);
    195 
    196         *ppvObj = NULL;
    197 
    198         if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
    199         { *ppvObj = This;
    200         }
    201         else if(IsEqualIID(riid, &IID_IContextMenu))  /*IContextMenu*/
    202         { *ppvObj = This;
    203         }
    204         else if(IsEqualIID(riid, &IID_IShellExtInit))  /*IShellExtInit*/
    205         { FIXME("-- LPSHELLEXTINIT pointer requested\n");
    206         }
    207 
    208         if(*ppvObj)
    209         {
    210           IContextMenu_AddRef((IContextMenu*)*ppvObj);
    211           TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
    212           return S_OK;
    213         }
    214         TRACE("-- Interface: E_NOINTERFACE\n");
    215         return E_NOINTERFACE;
     226        ICOM_THIS(IContextMenuImpl, iface);
     227
     228        char    xriid[50];
     229        WINE_StringFromCLSID((LPCLSID)riid,xriid);
     230
     231  dprintf(("SHELL32:contmenu:IContectMenu_fnQueryInterface(%08xh,%08xh,%08xh,%08xh)\n",
     232           This,
     233           iface,
     234           riid,
     235           ppvObj));
     236
     237        *ppvObj = NULL;
     238
     239        if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
     240        { *ppvObj = This;
     241        }
     242        else if(IsEqualIID(riid, &IID_IContextMenu))  /*IContextMenu*/
     243        { *ppvObj = This;
     244        }
     245        else if(IsEqualIID(riid, &IID_IShellExtInit))  /*IShellExtInit*/
     246        { FIXME("-- LPSHELLEXTINIT pointer requested\n");
     247        }
     248
     249        if(*ppvObj)
     250        {
     251          IContextMenu_AddRef((IContextMenu*)*ppvObj);
     252          TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
     253          return S_OK;
     254        }
     255        TRACE("-- Interface: E_NOINTERFACE\n");
     256        return E_NOINTERFACE;
    216257}
    217258
    … …  
    221262static ULONG WINAPI IContextMenu_fnAddRef(IContextMenu *iface)
    222263{
    223         ICOM_THIS(IContextMenuImpl, iface);
    224 
    225         TRACE("(%p)->(count=%lu)\n",This, This->ref);
    226 
    227         shell32_ObjCount++;
    228         return ++(This->ref);
     264        ICOM_THIS(IContextMenuImpl, iface);
     265
     266  dprintf(("SHELL32:contmenu:IContectMenu_fnAddRef(%08xh,%08xh,%08xh)\n",
     267           This,
     268           iface,
     269           This->ref));
     270
     271        shell32_ObjCount++;
     272        return ++(This->ref);
    229273}
    230274
    … …  
    234278static ULONG WINAPI IContextMenu_fnRelease(IContextMenu *iface)
    235279{
    236         ICOM_THIS(IContextMenuImpl, iface);
    237 
    238         TRACE("(%p)->()\n",This);
    239 
    240         shell32_ObjCount--;
    241 
    242         if (!--(This->ref))
    243         { TRACE(" destroying IContextMenu(%p)\n",This);
    244 
    245           if(This->pSFParent)
    246             IShellFolder_Release(This->pSFParent);
    247 
    248           if(This->pidl)
    249             SHFree(This->pidl);
    250        
    251           /*make sure the pidl is freed*/
    252           if(This->aPidls)
    253           { IContextMenu_FreePidlTable(This);
    254           }
    255 
    256           HeapFree(GetProcessHeap(),0,This);
    257           return 0;
    258         }
    259         return This->ref;
     280        ICOM_THIS(IContextMenuImpl, iface);
     281
     282  dprintf(("SHELL32:contmenu:IContectMenu_fnRelease(%08xh,%08xh)\n",
     283           This,
     284           iface));
     285
     286        shell32_ObjCount--;
     287
     288        if (!--(This->ref))
     289        { TRACE(" destroying IContextMenu(%p)\n",This);
     290
     291          if(This->pSFParent)
     292            IShellFolder_Release(This->pSFParent);
     293
     294          if(This->pidl)
     295            SHFree(This->pidl);
     296
     297          /*make sure the pidl is freed*/
     298          if(This->aPidls)
     299          { IContextMenu_FreePidlTable(This);
     300          }
     301
     302          HeapFree(GetProcessHeap(),0,This);
     303          return 0;
     304        }
     305        return This->ref;
    260306}
    261307
    … …  
    264310*/
    265311void WINAPI _InsertMenuItem (
    266         HMENU hmenu,
    267         UINT indexMenu,
    268         BOOL fByPosition,
    269         UINT wID,
    270         UINT fType,
    271         LPSTR dwTypeData,
    272         UINT fState)
    273 {
    274         MENUITEMINFOA   mii;
    275 
    276         ZeroMemory(&mii, sizeof(mii));
    277         mii.cbSize = sizeof(mii);
    278         if (fType == MFT_SEPARATOR)
    279         { mii.fMask = MIIM_ID | MIIM_TYPE;
    280         }
    281         else
    282         { mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE;
    283           mii.dwTypeData = dwTypeData;
    284           mii.fState = fState;
    285         }
    286         mii.wID = wID;
    287         mii.fType = fType;
    288         InsertMenuItemA( hmenu, indexMenu, fByPosition, &mii);
     312        HMENU hmenu,
     313        UINT indexMenu,
     314        BOOL fByPosition,
     315        UINT wID,
     316        UINT fType,
     317        LPSTR dwTypeData,
     318        UINT fState)
     319{
     320        MENUITEMINFOA   mii;
     321
     322  dprintf(("SHELL32:contmenu:_InsertMenuItem(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     323           hmenu,
     324           indexMenu,
     325           fByPosition,
     326           wID,
     327           fType,
     328           dwTypeData,
     329           fState));
     330
     331        ZeroMemory(&mii, sizeof(mii));
     332        mii.cbSize = sizeof(mii);
     333        if (fType == MFT_SEPARATOR)
     334        { mii.fMask = MIIM_ID | MIIM_TYPE;
     335        }
     336        else
     337        { mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE;
     338          mii.dwTypeData = dwTypeData;
     339          mii.fState = fState;
     340        }
     341        mii.wID = wID;
     342        mii.fType = fType;
     343        InsertMenuItemA( hmenu, indexMenu, fByPosition, &mii);
    289344}
    290345/**************************************************************************
    … …  
    293348
    294349static HRESULT WINAPI IContextMenu_fnQueryContextMenu(
    295         IContextMenu *iface,
    296         HMENU hmenu,
    297         UINT indexMenu,
    298         UINT idCmdFirst,
    299         UINT idCmdLast,
    300         UINT uFlags)
    301 {
    302         ICOM_THIS(IContextMenuImpl, iface);
    303 
    304         BOOL    fExplore ;
    305 
    306         TRACE("(%p)->(hmenu=%x indexmenu=%x cmdfirst=%x cmdlast=%x flags=%x )\n",This, hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
    307 
    308         if(!(CMF_DEFAULTONLY & uFlags))
    309         { if(!This->bAllValues)
    310           { /* folder menu */
    311             fExplore = uFlags & CMF_EXPLORE;
    312             if(fExplore)
    313             { _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_EXPLORE, MFT_STRING, "&Explore", MFS_ENABLED|MFS_DEFAULT);
    314               _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_OPEN, MFT_STRING, "&Open", MFS_ENABLED);
    315             }
    316             else
    317             { _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_OPEN, MFT_STRING, "&Open", MFS_ENABLED|MFS_DEFAULT);
    318               _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_EXPLORE, MFT_STRING, "&Explore", MFS_ENABLED);
    319             }
    320 
    321             if(uFlags & CMF_CANRENAME)
    322             { _InsertMenuItem(hmenu, indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
    323               _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_RENAME, MFT_STRING, "&Rename", (IContextMenu_CanRenameItems(This) ? MFS_ENABLED : MFS_DISABLED));
    324             }
    325           }
    326           else  /* file menu */
    327           { _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_OPEN, MFT_STRING, "&Open", MFS_ENABLED|MFS_DEFAULT);
    328             if(uFlags & CMF_CANRENAME)
    329             { _InsertMenuItem(hmenu, indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
    330               _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_RENAME, MFT_STRING, "&Rename", (IContextMenu_CanRenameItems(This) ? MFS_ENABLED : MFS_DISABLED));
    331             }
    332           }
    333           return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (IDM_LAST + 1));
    334         }
    335         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
     350        IContextMenu *iface,
     351        HMENU hmenu,
     352        UINT indexMenu,
     353        UINT idCmdFirst,
     354        UINT idCmdLast,
     355        UINT uFlags)
     356{
     357        ICOM_THIS(IContextMenuImpl, iface);
     358
     359        BOOL    fExplore ;
     360
     361  dprintf(("SHELL32:contmenu:IContextMenu_fnQueryContextMenu(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     362           hmenu,
     363           indexMenu,
     364           idCmdFirst,
     365           idCmdLast,
     366           uFlags));
     367
     368        if(!(CMF_DEFAULTONLY & uFlags))
     369        { if(!This->bAllValues)
     370          { /* folder menu */
     371            fExplore = uFlags & CMF_EXPLORE;
     372            if(fExplore)
     373            { _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_EXPLORE, MFT_STRING, "&Explore", MFS_ENABLED|MFS_DEFAULT);
     374              _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_OPEN, MFT_STRING, "&Open", MFS_ENABLED);
     375            }
     376            else
     377            { _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_OPEN, MFT_STRING, "&Open", MFS_ENABLED|MFS_DEFAULT);
     378              _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_EXPLORE, MFT_STRING, "&Explore", MFS_ENABLED);
     379            }
     380
     381            if(uFlags & CMF_CANRENAME)
     382            { _InsertMenuItem(hmenu, indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
     383              _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_RENAME, MFT_STRING, "&Rename", (IContextMenu_CanRenameItems(This) ? MFS_ENABLED : MFS_DISABLED));
     384            }
     385          }
     386          else  /* file menu */
     387          { _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_OPEN, MFT_STRING, "&Open", MFS_ENABLED|MFS_DEFAULT);
     388            if(uFlags & CMF_CANRENAME)
     389            { _InsertMenuItem(hmenu, indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
     390              _InsertMenuItem(hmenu, indexMenu++, TRUE, idCmdFirst+IDM_RENAME, MFT_STRING, "&Rename", (IContextMenu_CanRenameItems(This) ? MFS_ENABLED : MFS_DISABLED));
     391            }
     392          }
     393          return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (IDM_LAST + 1));
     394        }
     395        return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
    336396}
    337397
    … …  
    340400*/
    341401static HRESULT WINAPI IContextMenu_fnInvokeCommand(
    342         IContextMenu *iface,
    343         LPCMINVOKECOMMANDINFO lpcmi)
    344 {
    345         ICOM_THIS(IContextMenuImpl, iface);
    346 
    347         LPITEMIDLIST    pidlFQ;
    348         SHELLEXECUTEINFOA       sei;
    349         int   i;
    350 
    351         TRACE("(%p)->(invcom=%p verb=%p wnd=%x)\n",This,lpcmi,lpcmi->lpVerb, lpcmi->hwnd);
    352 
    353         if(LOWORD(lpcmi->lpVerb) > IDM_LAST)
    354           return E_INVALIDARG;
    355 
    356         switch(LOWORD(lpcmi->lpVerb))
    357         { case IDM_EXPLORE:
    358           case IDM_OPEN:
    359           /* Find the first item in the list that is not a value. These commands
    360             should never be invoked if there isn't at least one folder item in the list.*/
    361 
    362             for(i = 0; This->aPidls[i]; i++)
    363             { if(!_ILIsValue(This->aPidls[i]))
    364                  break;
    365             }
    366 
    367             pidlFQ = ILCombine(This->pidl, This->aPidls[i]);
    368 
    369             ZeroMemory(&sei, sizeof(sei));
    370             sei.cbSize = sizeof(sei);
    371             sei.fMask = SEE_MASK_IDLIST | SEE_MASK_CLASSNAME;
    372             sei.lpIDList = pidlFQ;
    373             sei.lpClass = "folder";
    374             sei.hwnd = lpcmi->hwnd;
    375             sei.nShow = SW_SHOWNORMAL;
    376 
    377             if(LOWORD(lpcmi->lpVerb) == IDM_EXPLORE)
    378             { sei.lpVerb = "explore";
    379             }
    380             else
    381             { sei.lpVerb = "open";
    382             }
    383             ShellExecuteExA(&sei);
    384             SHFree(pidlFQ);
    385             break;
    386                
    387           case IDM_RENAME:
    388             MessageBeep(MB_OK);
    389             /*handle rename for the view here*/
    390             break;     
    391         }
    392         return NOERROR;
     402        IContextMenu *iface,
     403        LPCMINVOKECOMMANDINFO lpcmi)
     404{
     405        ICOM_THIS(IContextMenuImpl, iface);
     406
     407        LPITEMIDLIST    pidlFQ;
     408        SHELLEXECUTEINFOA       sei;
     409        int   i;
     410
     411  dprintf(("SHELL32:contmenu:IContextMenu_fnInvokeCommand(%08xh,%08xh,%08xh,%08xh)\n",
     412           This,
     413           lpcmi,
     414           lpcmi->lpVerb,
     415           lpcmi->hwnd));
     416
     417        if(LOWORD(lpcmi->lpVerb) > IDM_LAST)
     418          return E_INVALIDARG;
     419
     420        switch(LOWORD(lpcmi->lpVerb))
     421        { case IDM_EXPLORE:
     422          case IDM_OPEN:
     423          /* Find the first item in the list that is not a value. These commands
     424            should never be invoked if there isn't at least one folder item in the list.*/
     425
     426            for(i = 0; This->aPidls[i]; i++)
     427            { if(!_ILIsValue(This->aPidls[i]))
     428                 break;
     429            }
     430
     431            pidlFQ = ILCombine(This->pidl, This->aPidls[i]);
     432
     433            ZeroMemory(&sei, sizeof(sei));
     434            sei.cbSize = sizeof(sei);
     435            sei.fMask = SEE_MASK_IDLIST | SEE_MASK_CLASSNAME;
     436            sei.lpIDList = pidlFQ;
     437            sei.lpClass = "folder";
     438            sei.hwnd = lpcmi->hwnd;
     439            sei.nShow = SW_SHOWNORMAL;
     440
     441            if(LOWORD(lpcmi->lpVerb) == IDM_EXPLORE)
     442            { sei.lpVerb = "explore";
     443            }
     444            else
     445            { sei.lpVerb = "open";
     446            }
     447            ShellExecuteExA(&sei);
     448            SHFree(pidlFQ);
     449            break;
     450
     451          case IDM_RENAME:
     452            MessageBeep(MB_OK);
     453            /*handle rename for the view here*/
     454            break;
     455        }
     456        return NOERROR;
    393457}
    394458
    … …  
    397461*/
    398462static HRESULT WINAPI IContextMenu_fnGetCommandString(
    399         IContextMenu *iface,
    400         UINT idCommand,
    401         UINT uFlags,
    402         LPUINT lpReserved,
    403         LPSTR lpszName,
    404         UINT uMaxNameLen)
    405 {       
    406         ICOM_THIS(IContextMenuImpl, iface);
    407 
    408         HRESULT  hr = E_INVALIDARG;
    409 
    410         TRACE("(%p)->(idcom=%x flags=%x %p name=%p len=%x)\n",This, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
    411 
    412         switch(uFlags)
    413         { case GCS_HELPTEXT:
    414             hr = E_NOTIMPL;
    415             break;
    416 
    417           case GCS_VERBA:
    418             switch(idCommand)
    419             { case IDM_RENAME:
    420                 strcpy((LPSTR)lpszName, "rename");
    421                 hr = NOERROR;
    422                 break;
    423             }
    424             break;
    425 
    426              /* NT 4.0 with IE 3.0x or no IE will always call This with GCS_VERBW. In This
    427              case, you need to do the lstrcpyW to the pointer passed.*/
    428           case GCS_VERBW:
    429             switch(idCommand)
    430             { case IDM_RENAME:
    431                 lstrcpyAtoW((LPWSTR)lpszName, "rename");
    432                 hr = NOERROR;
    433                 break;
    434             }
    435             break;
    436 
    437           case GCS_VALIDATE:
    438             hr = NOERROR;
    439             break;
    440         }
    441         TRACE("-- (%p)->(name=%s)\n",This, lpszName);
    442         return hr;
     463        IContextMenu *iface,
     464        UINT idCommand,
     465        UINT uFlags,
     466        LPUINT lpReserved,
     467        LPSTR lpszName,
     468        UINT uMaxNameLen)
     469{
     470        ICOM_THIS(IContextMenuImpl, iface);
     471
     472        HRESULT  hr = E_INVALIDARG;
     473
     474  dprintf(("SHELL32:contmenu:IContextMenu_fnGetCommandString(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     475           This,
     476           idCommand,
     477           uFlags,
     478           lpReserved,
     479           lpszName,
     480           uMaxNameLen));
     481
     482        switch(uFlags)
     483        { case GCS_HELPTEXT:
     484            hr = E_NOTIMPL;
     485            break;
     486
     487          case GCS_VERBA:
     488            switch(idCommand)
     489            { case IDM_RENAME:
     490                strcpy((LPSTR)lpszName, "rename");
     491                hr = NOERROR;
     492                break;
     493            }
     494            break;
     495
     496             /* NT 4.0 with IE 3.0x or no IE will always call This with GCS_VERBW. In This
     497             case, you need to do the lstrcpyW to the pointer passed.*/
     498          case GCS_VERBW:
     499            switch(idCommand)
     500            { case IDM_RENAME:
     501                lstrcpyAtoW((LPWSTR)lpszName, "rename");
     502                hr = NOERROR;
     503                break;
     504            }
     505            break;
     506
     507          case GCS_VALIDATE:
     508            hr = NOERROR;
     509            break;
     510        }
     511        TRACE("-- (%p)->(name=%s)\n",This, lpszName);
     512        return hr;
    443513}
    444514
    … …  
    450520*/
    451521static HRESULT WINAPI IContextMenu_fnHandleMenuMsg(
    452         IContextMenu *iface,
    453         UINT uMsg,
    454         WPARAM wParam,
    455         LPARAM lParam)
    456 {
    457         ICOM_THIS(IContextMenuImpl, iface);
    458 
    459         TRACE("(%p)->(msg=%x wp=%x lp=%lx)\n",This, uMsg, wParam, lParam);
    460 
    461         return E_NOTIMPL;
    462 }
    463 
     522        IContextMenu *iface,
     523        UINT uMsg,
     524        WPARAM wParam,
     525        LPARAM lParam)
     526{
     527        ICOM_THIS(IContextMenuImpl, iface);
     528
     529  dprintf(("SHELL32:contmenu:IContextMenu_fnHandleMenuMsg(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     530           This,
     531           uMsg,
     532           wParam,
     533           lParam));
     534
     535        return E_NOTIMPL;
     536}
     537

  • trunk/src/shell32/new/dataobject.cpp

    r791 r1145  
     1/* $Id: dataobject.cpp,v 1.2 1999-10-05 19:33:37 phaller Exp $ */
     2
     3/*
     4 * Win32 SHELL32 for OS/2
     5 *
     6 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
     7 * Project Odin Software License can be found in LICENSE.TXT
     8 *
     9 */
     10
    111/*
    212 *      IEnumFORMATETC, IDataObject
    … …  
    616 *      Copyright 1998, 1999    <juergen.schmied@metronet.de>
    717 */
     18
     19
     20/*****************************************************************************
     21 * Includes                                                                  *
     22 *****************************************************************************/
     23
     24#include <stdlib.h>
    825#include <string.h>
    926#include <odin.h>
     27#include <odinwrap.h>
     28#include <os2sel.h>
    1029
    1130#define ICOM_CINTERFACE 1
    … …  
    2544#include <misc.h>
    2645
    27 DEFAULT_DEBUG_CHANNEL(shell)
     46
     47ODINDEBUGCHANNEL(shell32-dataobject)
     48
    2849
    2950/***********************************************************************
    … …  
    6687        IEnumFORMATETCImpl* ef;
    6788        DWORD size=cfmt * sizeof(FORMATETC);
    68        
     89
     90  dprintf(("SHELL32:dataobject:IEnumFORMATETC_Constructor(%08xh,%08xh)\n",
     91           cfmt,
     92           afmt));
     93
    6994        ef=(IEnumFORMATETCImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumFORMATETCImpl));
    7095
    … …  
    88113        return (LPENUMFORMATETC)ef;
    89114}
     115
     116
    90117static HRESULT WINAPI IEnumFORMATETC_fnQueryInterface(LPENUMFORMATETC iface, REFIID riid, LPVOID* ppvObj)
    91118{
    … …  
    93120        char    xriid[50];
    94121        WINE_StringFromCLSID((LPCLSID)riid,xriid);
    95         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,xriid,ppvObj);
     122
     123  dprintf(("SHELL32:dataobject:IEnumFORMATETC_fnQueryInterface(%08xh,%08xh,%08xh)\n",
     124           This,
     125           riid,
     126           xriid));
    96127
    97128                        *ppvObj = NULL;
    … …  
    113144
    114145}
     146
     147
    115148static ULONG WINAPI IEnumFORMATETC_fnAddRef(LPENUMFORMATETC iface)
    116149{
    117150        ICOM_THIS(IEnumFORMATETCImpl,iface);
    118         TRACE("(%p)->(count=%lu)\n",This, This->ref);
     151
     152  dprintf(("SHELL32:dataobject:IEnumFORMATETC_fnAddRef(%08xh,%08xh)\n",
     153           This,
     154           This->ref));
     155
    119156        shell32_ObjCount++;
    120157        return ++(This->ref);
    121158}
     159
     160
    122161static ULONG WINAPI IEnumFORMATETC_fnRelease(LPENUMFORMATETC iface)
    123162{
    124163        ICOM_THIS(IEnumFORMATETCImpl,iface);
    125         TRACE("(%p)->()\n",This);
     164
     165  dprintf(("SHELL32:dataobject:IEnumFORMATETC_fnRelease(%08xh)\n",
     166           This));
    126167
    127168        shell32_ObjCount--;
    … …  
    137178        return This->ref;
    138179}
     180
     181
    139182static HRESULT WINAPI IEnumFORMATETC_fnNext(LPENUMFORMATETC iface, ULONG celt, FORMATETC *rgelt, ULONG *pceltFethed)
    140183{
    … …  
    143186        HRESULT hres = S_FALSE;
    144187
    145         TRACE("(%p)->()\n", This);
     188  dprintf(("SHELL32:dataobject:IEnumFORMATETC_fnNext(%08xh,%08xh,%08xh,%08xh)\n",
     189           This,
     190           celt,
     191           rgelt,
     192           pceltFethed));
    146193
    147194        if (This->posFmt < This->countFmt)
    … …  
    168215        return hres;
    169216}
     217
     218
    170219static HRESULT WINAPI IEnumFORMATETC_fnSkip(LPENUMFORMATETC iface, ULONG celt)
    171220{
    172221        ICOM_THIS(IEnumFORMATETCImpl,iface);
    173         FIXME("(%p)->(num=%lu)\n", This, celt);
     222
     223  dprintf(("SHELL32:dataobject:IEnumFORMATETC_fnSkip(%08xh,%08xh) to be fixed\n",
     224           This,
     225           celt));
    174226
    175227        This->posFmt += celt;
    … …  
    184236{
    185237        ICOM_THIS(IEnumFORMATETCImpl,iface);
    186         FIXME("(%p)->()\n", This);
     238
     239  dprintf(("SHELL32:dataobject:IEnumFORMATETC_fnReset(%08xh) to be fixed\n",
     240           This));
    187241
    188242        This->posFmt = 0;
    189243        return S_OK;
    190244}
     245
     246
    191247static HRESULT WINAPI IEnumFORMATETC_fnClone(LPENUMFORMATETC iface, LPENUMFORMATETC* ppenum)
    192248{
    193249        ICOM_THIS(IEnumFORMATETCImpl,iface);
    194         FIXME("(%p)->(ppenum=%p)\n", This, ppenum);
     250
     251  dprintf(("SHELL32:dataobject:IEnumFORMATETC_fnClone(%08xh) not implemented\n",
     252           This,
     253           ppenum));
     254
    195255        return E_NOTIMPL;
    196256}
    … …  
    264324        lpidll = (LPIDLLIST)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDLList));
    265325
     326  dprintf(("SHELL32:dataobject:IDLList_Constructor(%08xh, %08xh) not implemented\n",
     327           lpidll,
     328           uStep));
     329
    266330        if (lpidll)
    267331        {
    … …  
    270334        }
    271335
    272         TRACE("(%p)\n",lpidll);
    273336        return lpidll;
    274337}
     338
     339
    275340void IDLList_Destructor(LPIDLLIST THIS)
    276 {       TRACE("(%p)\n",THIS);
     341{
     342  dprintf(("SHELL32:dataobject:IDLList_Destructor(%08xh) not implemented\n",
     343           THIS));
     344
    277345        IDLList_CleanList(THIS);
    278346}

  • trunk/src/shell32/new/shresdef.h

    r791 r1145  
     1/* $Id: shresdef.h,v 1.2 1999-10-05 19:33:37 phaller Exp $ */
     2
     3/*
     4 * Win32 SHELL32 for OS/2
     5 *
     6 * Copyright 1997 Marcus Meissner
     7 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
     8 * Project Odin Software License can be found in LICENSE.TXT
     9 *
     10 */
     11
     12
     13/*****************************************************************************
     14 * Includes                                                                  *
     15 *****************************************************************************/
     16
    117#ifndef __WINE_SHELL_RES_H
    218#define __WINE_SHELL_RES_H
    319
    420/*
    5         columntitles for the shellview
    6 */
     21 * columntitles for the shellview
     22 */
    723#define IDS_SHV_COLUMN1         7
    824#define IDS_SHV_COLUMN2         8
    … …  
    2238#define IDS_VIEW_DETAILS        27
    2339
    24 #endif
     40
     41#endif /* __WINE_SHELL_RES_H */
     42
Note: See TracChangeset for help on using the changeset viewer.