dlls/shell32/shlview.c

   1 /*
   2  *      ShellView
   3  *
   4  *      Copyright 1998  <juergen.schmied@metronet.de>
   5  */
   6
   7 #include <ctype.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include "ole.h"
  11 #include "ole2.h"
  12 #include "debug.h"
  13 #include "compobj.h"
  14 #include "interfaces.h"
  15 #include "shlobj.h"
  16 #include "shell.h"
  17 #include "winerror.h"
  18 #include "winnls.h"
  19 #include "winproc.h"
  20 #include "commctrl.h"
  21
  22 #include "shell32_main.h"
  23 #include "pidl.h"
  24 #include "shresdef.h"
  25 #include "if_macros.h"
  26
  27 /***********************************************************************
  28 *   IShellView implementation
  29 */
  30 static HRESULT WINAPI IShellView_QueryInterface(LPSHELLVIEW,REFIID, LPVOID *);
  31 static ULONG WINAPI IShellView_AddRef(LPSHELLVIEW) ;
  32 static ULONG WINAPI IShellView_Release(LPSHELLVIEW);
  33     /* IOleWindow methods */
  34 static HRESULT WINAPI IShellView_GetWindow(LPSHELLVIEW,HWND32 * lphwnd);
  35 static HRESULT WINAPI IShellView_ContextSensitiveHelp(LPSHELLVIEW,BOOL32 fEnterMode);
  36     /* IShellView methods */
  37 static HRESULT WINAPI IShellView_TranslateAccelerator(LPSHELLVIEW,LPMSG32 lpmsg);
  38 static HRESULT WINAPI IShellView_EnableModeless(LPSHELLVIEW,BOOL32 fEnable);
  39 static HRESULT WINAPI IShellView_UIActivate(LPSHELLVIEW,UINT32 uState);
  40 static HRESULT WINAPI IShellView_Refresh(LPSHELLVIEW);
  41 static HRESULT WINAPI IShellView_CreateViewWindow(LPSHELLVIEW, IShellView *lpPrevView,LPCFOLDERSETTINGS lpfs, IShellBrowser * psb,RECT32 * prcView, HWND32  *phWnd);
  42 static HRESULT WINAPI IShellView_DestroyViewWindow(LPSHELLVIEW);
  43 static HRESULT WINAPI IShellView_GetCurrentInfo(LPSHELLVIEW, LPFOLDERSETTINGS lpfs);
  44 static HRESULT WINAPI IShellView_AddPropertySheetPages(LPSHELLVIEW, DWORD dwReserved,LPFNADDPROPSHEETPAGE lpfn, LPARAM lparam);
  45 static HRESULT WINAPI IShellView_SaveViewState(LPSHELLVIEW);
  46 static HRESULT WINAPI IShellView_SelectItem(LPSHELLVIEW, LPCITEMIDLIST pidlItem, UINT32 uFlags);
  47 static HRESULT WINAPI IShellView_GetItemObject(LPSHELLVIEW, UINT32 uItem, REFIID riid,LPVOID *ppv);
  48
  49 static BOOL32 ShellView_CanDoIDockingWindow(LPSHELLVIEW);
  50
  51 static struct IShellView_VTable svvt =
  52 { IShellView_QueryInterface,
  53   IShellView_AddRef,
  54   IShellView_Release,
  55   IShellView_GetWindow,
  56   IShellView_ContextSensitiveHelp,
  57   IShellView_TranslateAccelerator,
  58   IShellView_EnableModeless,
  59   IShellView_UIActivate,
  60   IShellView_Refresh,
  61   IShellView_CreateViewWindow,
  62   IShellView_DestroyViewWindow,
  63   IShellView_GetCurrentInfo,
  64   IShellView_AddPropertySheetPages,
  65   IShellView_SaveViewState,
  66   IShellView_SelectItem,
  67   IShellView_GetItemObject
  68 };
  69
  70 //menu items
  71 #define IDM_VIEW_FILES  (FCIDM_SHVIEWFIRST + 0x500)
  72 #define IDM_VIEW_IDW    (FCIDM_SHVIEWFIRST + 0x501)
  73 #define IDM_MYFILEITEM  (FCIDM_SHVIEWFIRST + 0x502)
  74
  75 #define ID_LISTVIEW     2000
  76
  77 #define MENU_OFFSET  1
  78 #define MENU_MAX     100
  79
  80 #define TOOLBAR_ID   (L"SHELLDLL_DefView")
  81 //windowsx.h
  82 #define GET_WM_COMMAND_ID(wp, lp)               LOWORD(wp)
  83 #define GET_WM_COMMAND_HWND(wp, lp)             (HWND32)(lp)
  84 #define GET_WM_COMMAND_CMD(wp, lp)              HIWORD(wp)
  85 // winuser.h
  86 #define WM_SETTINGCHANGE                WM_WININICHANGE
  87 extern void WINAPI _InsertMenuItem (HMENU32 hmenu, UINT32 indexMenu, BOOL32 fByPosition,
  88                         UINT32 wID, UINT32 fType, LPSTR dwTypeData, UINT32 fState);
  89
  90 typedef struct
  91 {  int   idCommand;
  92    int   iImage;
  93    int   idButtonString;
  94    int   idMenuString;
  95    int   nStringOffset;
  96    BYTE  bState;
  97    BYTE  bStyle;
  98 } MYTOOLINFO, *LPMYTOOLINFO;
  99
 100 MYTOOLINFO g_Tools[] =
 101 { {IDM_VIEW_FILES, 0, IDS_TB_VIEW_FILES, IDS_MI_VIEW_FILES, 0, TBSTATE_ENABLED, TBSTYLE_BUTTON},
 102   {-1, 0, 0, 0, 0, 0, 0}
 103 };
 104 BOOL32 g_bViewKeys;
 105 BOOL32 g_bShowIDW;
 106
 107 typedef void (CALLBACK *PFNSHGETSETTINGSPROC)(LPSHELLFLAGSTATE lpsfs, DWORD dwMask);
 108
 109 /**************************************************************************
 110 *  IShellView_Constructor
 111 */
 112 LPSHELLVIEW IShellView_Constructor( LPSHELLFOLDER pFolder, LPCITEMIDLIST pidl)
 113 {       LPSHELLVIEW sv;
 114         sv=(LPSHELLVIEW)HeapAlloc(GetProcessHeap(),0,sizeof(IShellView));
 115         sv->ref=1;
 116         sv->lpvtbl=&svvt;
 117
 118         sv->mpidl       = ILClone(pidl);
 119         sv->hMenu       = 0;
 120         sv->pSFParent   = pFolder;
 121         sv->uSelected = 0;
 122         sv->aSelectedItems = NULL;
 123
 124         if(sv->pSFParent)
 125           sv->pSFParent->lpvtbl->fnAddRef(sv->pSFParent);
 126
 127         TRACE(shell,"(%p)->(%p pidl=%p)\n",sv, pFolder, pidl);
 128         return sv;
 129 }
 130 /**************************************************************************
 131 *  helperfunctions for communication with ICommDlgBrowser
 132 *
 133 */
 134 static BOOL32 IsInCommDlg(LPSHELLVIEW this)
 135 {       return(this->pCommDlgBrowser != NULL);
 136 }
 137 static HRESULT IncludeObject(LPSHELLVIEW this, LPCITEMIDLIST pidl)
 138 {       if ( IsInCommDlg(this) )
 139         { TRACE(shell,"ICommDlgBrowser::IncludeObject pidl=%p\n", pidl);
 140           return (this->pCommDlgBrowser->lpvtbl->fnIncludeObject(this->pCommDlgBrowser, this, pidl));
 141         }
 142         return S_OK;
 143 }
 144 static HRESULT OnDefaultCommand(LPSHELLVIEW this)
 145 {       if (IsInCommDlg(this))
 146         { TRACE(shell,"ICommDlgBrowser::OnDefaultCommand\n");
 147           return (this->pCommDlgBrowser->lpvtbl->fnOnDefaultCommand(this->pCommDlgBrowser, this));
 148         }
 149         return S_FALSE;
 150 }
 151 static HRESULT OnStateChange(LPSHELLVIEW this, UINT32 uFlags)
 152 {       if (IsInCommDlg(this))
 153         { TRACE(shell,"ICommDlgBrowser::OnStateChange flags=%x\n", uFlags);
 154           return (this->pCommDlgBrowser->lpvtbl->fnOnStateChange(this->pCommDlgBrowser, this, uFlags));
 155         }
 156         return S_FALSE;
 157 }
 158 static void SetStyle(LPSHELLVIEW this, DWORD dwAdd, DWORD dwRemove)
 159 {       DWORD tmpstyle;
 160
 161         TRACE(shell,"(%p)\n", this);
 162
 163         tmpstyle = GetWindowLong32A(this->hWndList, GWL_STYLE);
 164         SetWindowLong32A(this->hWndList, GWL_STYLE, dwAdd | (tmpstyle & ~dwRemove));
 165 }
 166
 167 static void CheckToolbar(LPSHELLVIEW this)
 168 {       LRESULT result;
 169
 170         TRACE(shell,"\n");
 171
 172         IShellBrowser_SendControlMsg(this->pShellBrowser, FCW_TOOLBAR, TB_CHECKBUTTON,
 173                 FCIDM_TB_SMALLICON, (this->FolderSettings.ViewMode==FVM_LIST)? TRUE : FALSE, &result);
 174         IShellBrowser_SendControlMsg(this->pShellBrowser, FCW_TOOLBAR, TB_CHECKBUTTON,
 175                 FCIDM_TB_REPORTVIEW, (this->FolderSettings.ViewMode==FVM_DETAILS)? TRUE : FALSE, &result);
 176         IShellBrowser_SendControlMsg(this->pShellBrowser, FCW_TOOLBAR, TB_ENABLEBUTTON,
 177                 FCIDM_TB_SMALLICON, TRUE, &result);
 178         IShellBrowser_SendControlMsg(this->pShellBrowser, FCW_TOOLBAR, TB_ENABLEBUTTON,
 179                 FCIDM_TB_REPORTVIEW, TRUE, &result);
 180         TRACE(shell,"--\n");
 181 }
 182
 183 static void MergeToolBar(LPSHELLVIEW this)
 184 {       LRESULT iStdBMOffset;
 185         LRESULT iViewBMOffset;
 186         TBADDBITMAP ab;
 187         TBBUTTON tbActual[6];
 188         int i;
 189         enum
 190         { IN_STD_BMP = 0x4000,
 191           IN_VIEW_BMP = 0x8000,
 192         } ;
 193         static const TBBUTTON c_tbDefault[] =
 194         { { STD_COPY | IN_STD_BMP, FCIDM_SHVIEW_COPY, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0, -1},
 195           { 0,  0,      TBSTATE_ENABLED, TBSTYLE_SEP, {0,0}, 0, -1 },
 196           { VIEW_LARGEICONS | IN_VIEW_BMP, FCIDM_SHVIEW_BIGICON,        TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
 197           { VIEW_SMALLICONS | IN_VIEW_BMP, FCIDM_SHVIEW_SMALLICON,      TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
 198           { VIEW_LIST       | IN_VIEW_BMP, FCIDM_SHVIEW_LISTVIEW,       TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
 199           { VIEW_DETAILS    | IN_VIEW_BMP, FCIDM_SHVIEW_REPORTVIEW,     TBSTATE_ENABLED, TBSTYLE_BUTTON, {0,0}, 0L, -1 },
 200         } ;
 201
 202         TRACE(shell,"\n");
 203
 204         ab.hInst = HINST_COMMCTRL;              // hinstCommctrl
 205         ab.nID   = IDB_STD_SMALL_COLOR; // std bitmaps
 206         IShellBrowser_SendControlMsg(this->pShellBrowser,FCW_TOOLBAR,
 207                                  TB_ADDBITMAP, 8, (LPARAM)&ab, &iStdBMOffset);
 208
 209         TRACE(shell,"TB_ADDBITMAP returns %x\n", iStdBMOffset);
 210
 211         ab.nID   = IDB_VIEW_SMALL_COLOR;        // std view bitmaps
 212         IShellBrowser_SendControlMsg(this->pShellBrowser,FCW_TOOLBAR,
 213                                  TB_ADDBITMAP, 8, (LPARAM)&ab, &iViewBMOffset);
 214
 215         TRACE(shell,"TB_ADDBITMAP returns %x\n", iViewBMOffset);
 216
 217         for (i=0; i<6; ++i)
 218         { tbActual[i] = c_tbDefault[i];
 219           if (!(tbActual[i].fsStyle & TBSTYLE_SEP))
 220           { if (tbActual[i].iBitmap & IN_VIEW_BMP)
 221             { tbActual[i].iBitmap = (tbActual[i].iBitmap & ~IN_VIEW_BMP) + iViewBMOffset;
 222             }
 223             else if (tbActual[i].iBitmap & IN_STD_BMP)
 224             { tbActual[i].iBitmap = (tbActual[i].iBitmap & ~IN_STD_BMP) + iStdBMOffset;
 225             }
 226           }
 227         }
 228
 229         IShellBrowser_SetToolbarItems(this->pShellBrowser,tbActual, 6, FCT_MERGE);
 230
 231         CheckToolbar(this);
 232         TRACE(shell,"--\n");
 233
 234 }
 235
 236 /**************************************************************************
 237 * ShellView_CreateList()
 238 *
 239 */
 240
 241 BOOL32 ShellView_CreateList (LPSHELLVIEW this)
 242 {       DWORD dwStyle;
 243
 244         TRACE(shell,"%p\n",this);
 245
 246         dwStyle = WS_TABSTOP | WS_VISIBLE | WS_CHILD | WS_BORDER |
 247                   LVS_SHAREIMAGELISTS | LVS_EDITLABELS;
 248         switch (this->FolderSettings.ViewMode)
 249         { case FVM_ICON:        dwStyle |= LVS_ICON;            break;
 250           case FVM_SMALLICON:   dwStyle |= LVS_SMALLICON;       break;
 251           case FVM_LIST:        dwStyle |= LVS_LIST;            break;
 252           case FVM_DETAILS:     dwStyle |= LVS_REPORT;          break;
 253         }
 254         if (this->FolderSettings.fFlags && FWF_AUTOARRANGE)     dwStyle |= LVS_AUTOARRANGE;
 255         /*if (this->FolderSettings.fFlags && FWF_DESKTOP); used from explorer*/
 256         if (this->FolderSettings.fFlags && FWF_SINGLESEL)       dwStyle |= LVS_SINGLESEL;
 257
 258         this->hWndList=CreateWindowEx32A( WS_EX_CLIENTEDGE,
 259                                           WC_LISTVIEW32A,
 260                                           NULL,
 261                                           dwStyle,
 262                                           0,0,0,0,
 263                                           this->hWnd,
 264                                           (HMENU32)ID_LISTVIEW,
 265                                           shell32_hInstance,
 266                                           NULL);
 267
 268         if(!this->hWndList)
 269           return FALSE;
 270
 271         //  UpdateShellSettings();
 272         return TRUE;
 273 }
 274 /**************************************************************************
 275 * ShellView_InitList()
 276 *
 277 * NOTES
 278 *  internal
 279 */
 280 int  nColumn1=100; /* width of column */
 281 int  nColumn2=100;
 282 int  nColumn3=100;
 283 int  nColumn4=100;
 284
 285 BOOL32 ShellView_InitList(LPSHELLVIEW this)
 286 {       LVCOLUMN32A lvColumn;
 287         CHAR        szString[50];
 288
 289         TRACE(shell,"%p\n",this);
 290
 291         ListView_DeleteAllItems(this->hWndList);
 292
 293         //initialize the columns
 294         lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;      /*  |  LVCF_SUBITEM;*/
 295         lvColumn.fmt = LVCFMT_LEFT;
 296         lvColumn.pszText = szString;
 297
 298         lvColumn.cx = nColumn1;
 299         strcpy(szString,"File");
 300         /*LoadString32A(shell32_hInstance, IDS_COLUMN1, szString, sizeof(szString));*/
 301         ListView_InsertColumn32A(this->hWndList, 0, &lvColumn);
 302
 303         lvColumn.cx = nColumn2;
 304         strcpy(szString,"Size");
 305         ListView_InsertColumn32A(this->hWndList, 1, &lvColumn);
 306
 307         lvColumn.cx = nColumn3;
 308         strcpy(szString,"Type");
 309         ListView_InsertColumn32A(this->hWndList, 2, &lvColumn);
 310
 311         lvColumn.cx = nColumn4;
 312         strcpy(szString,"Modified");
 313         ListView_InsertColumn32A(this->hWndList, 3, &lvColumn);
 314
 315         ListView_SetImageList(this->hWndList, ShellSmallIconList, LVSIL_SMALL);
 316         ListView_SetImageList(this->hWndList, ShellBigIconList, LVSIL_NORMAL);
 317
 318         return TRUE;
 319 }
 320 /**************************************************************************
 321 * ShellView_CompareItems()
 322 *
 323 * NOTES
 324 *  internal, CALLBACK for DSA_Sort
 325 */
 326 int CALLBACK ShellView_CompareItems(LPVOID lParam1, LPVOID lParam2, LPARAM lpData)
 327 {       int ret;
 328         TRACE(shell,"pidl1=%p pidl2=%p lpsf=%p\n", lParam1, lParam2, (LPVOID) lpData);
 329
 330         if(!lpData)
 331           return 0;
 332
 333         ret =  (int)((LPSHELLFOLDER)lpData)->lpvtbl->fnCompareIDs((LPSHELLFOLDER)lpData, 0, (LPITEMIDLIST)lParam1, (LPITEMIDLIST)lParam2);
 334         TRACE(shell,"ret=%i\n",ret);
 335         return ret;
 336 }
 337
 338 /**************************************************************************
 339 * ShellView_FillList()
 340 *
 341 * NOTES
 342 *  internal
 343 */
 344
 345 static HRESULT ShellView_FillList(LPSHELLVIEW this)
 346 {       LPENUMIDLIST    pEnumIDList;
 347         LPITEMIDLIST    pidl;
 348         DWORD           dwFetched;
 349         UINT32          i;
 350         LVITEM32A       lvItem;
 351         HRESULT         hRes;
 352         HDPA            hdpa;
 353
 354         TRACE(shell,"%p\n",this);
 355
 356         /* get the itemlist from the shfolder*/
 357         hRes = this->pSFParent->lpvtbl->fnEnumObjects(this->pSFParent,this->hWnd, SHCONTF_NONFOLDERS | SHCONTF_FOLDERS, &pEnumIDList);
 358         if (hRes != S_OK)
 359         { if (hRes==S_FALSE)
 360             return(NOERROR);
 361           return(hRes);
 362         }
 363
 364         /* create a pointer array */
 365         hdpa = pDPA_Create(16);
 366         if (!hdpa)
 367         { return(E_OUTOFMEMORY);
 368         }
 369
 370         /* copy the items into the array*/
 371         while((S_OK == pEnumIDList->lpvtbl->fnNext(pEnumIDList,1, &pidl, &dwFetched)) && dwFetched)
 372         { if (pDPA_InsertPtr(hdpa, 0x7fff, pidl) == -1)
 373           { SHFree(pidl);
 374           }
 375         }
 376
 377         /*sort the array*/
 378         pDPA_Sort(hdpa, ShellView_CompareItems, (LPARAM)this->pSFParent);
 379
 380         /*turn the listview's redrawing off*/
 381         SendMessage32A(this->hWndList, WM_SETREDRAW, FALSE, 0);
 382
 383         for (i=0; i < DPA_GetPtrCount(hdpa); ++i)       /* DPA_GetPtrCount is a macro*/
 384         { pidl = (LPITEMIDLIST)DPA_GetPtr(hdpa, i);
 385           if (IncludeObject(this, pidl) == S_OK)        /* in a commdlg this works as a filemask*/
 386           { ZeroMemory(&lvItem, sizeof(lvItem));        /* create the listviewitem*/
 387             lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;          /*set the mask*/
 388             lvItem.iItem = ListView_GetItemCount(this->hWndList);       /*add the item to the end of the list*/
 389             lvItem.lParam = (LPARAM)ILClone(pidl);                      /*set the item's data*/
 390             lvItem.pszText = LPSTR_TEXTCALLBACK32A;                     /*get text on a callback basis*/
 391             lvItem.iImage = I_IMAGECALLBACK;                            /*get the image on a callback basis*/
 392             ListView_InsertItem32A(this->hWndList, &lvItem);
 393           }
 394           else
 395             SHFree(pidl);       /* the listview has a COPY*/
 396         }
 397
 398         /*turn the listview's redrawing back on and force it to draw*/
 399         SendMessage32A(this->hWndList, WM_SETREDRAW, TRUE, 0);
 400         InvalidateRect32(this->hWndList, NULL, TRUE);
 401         UpdateWindow32(this->hWndList);
 402
 403         pEnumIDList->lpvtbl->fnRelease(pEnumIDList); /* destroy the list*/
 404         pDPA_Destroy(hdpa);
 405
 406         return S_OK;
 407 }
 408
 409 /**************************************************************************
 410 *  ShellView_OnCreate()
 411 *
 412 * NOTES
 413 *  internal
 414 */
 415 LRESULT ShellView_OnCreate(LPSHELLVIEW this)
 416 { TRACE(shell,"%p\n",this);
 417
 418   if(ShellView_CreateList(this))
 419   {  if(ShellView_InitList(this))
 420      { ShellView_FillList(this);
 421      }
 422   }
 423
 424   return S_OK;
 425 }
 426 /**************************************************************************
 427 *  ShellView_OnSize()
 428 */
 429 LRESULT ShellView_OnSize(LPSHELLVIEW this, WORD wWidth, WORD wHeight)
 430 {       TRACE(shell,"%p width=%u height=%u\n",this, wWidth,wHeight);
 431
 432         /*resize the ListView to fit our window*/
 433         if(this->hWndList)
 434         { MoveWindow32(this->hWndList, 0, 0, wWidth, wHeight, TRUE);
 435         }
 436
 437         return S_OK;
 438 }
 439 /**************************************************************************
 440 * ShellView_BuildFileMenu()
 441 */
 442 HMENU32 ShellView_BuildFileMenu(LPSHELLVIEW this)
 443 {       CHAR    szText[MAX_PATH];
 444         MENUITEMINFO32A mii;
 445         int     nTools,i;
 446         HMENU32 hSubMenu;
 447
 448         TRACE(shell,"(%p) semi-stub\n",this);
 449
 450         hSubMenu = CreatePopupMenu32();
 451         if(hSubMenu)
 452         { /*get the number of items in our global array*/
 453           for(nTools = 0; g_Tools[nTools].idCommand != -1; nTools++){}
 454
 455           /*add the menu items*/
 456           for(i = 0; i < nTools; i++)
 457           { strcpy(szText, "dummy BuildFileMenu");
 458
 459             ZeroMemory(&mii, sizeof(mii));
 460             mii.cbSize = sizeof(mii);
 461             mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
 462
 463             if(TBSTYLE_SEP != g_Tools[i].bStyle) /* no seperator*/
 464             { mii.fType = MFT_STRING;
 465               mii.fState = MFS_ENABLED;
 466               mii.dwTypeData = szText;
 467               mii.wID = g_Tools[i].idCommand;
 468             }
 469             else
 470             { mii.fType = MFT_SEPARATOR;
 471             }
 472             /* tack this item onto the end of the menu */
 473             InsertMenuItem32A(hSubMenu, (UINT32)-1, TRUE, &mii);
 474           }
 475         }
 476         TRACE(shell,"-- return (menu=0x%x)\n",hSubMenu);
 477         return hSubMenu;
 478 }
 479 /**************************************************************************
 480 * ShellView_MergeFileMenu()
 481 */
 482 void ShellView_MergeFileMenu(LPSHELLVIEW this, HMENU32 hSubMenu)
 483 {       TRACE(shell,"(%p)->(submenu=0x%08x) stub\n",this,hSubMenu);
 484
 485         if(hSubMenu)
 486         { /*insert this item at the beginning of the menu */
 487           _InsertMenuItem(hSubMenu, 0, TRUE, 0, MFT_SEPARATOR, NULL, MFS_ENABLED);
 488           _InsertMenuItem(hSubMenu, 0, TRUE, IDM_MYFILEITEM, MFT_STRING, TEXT("dummy45"), MFS_ENABLED);
 489
 490         }
 491         TRACE(shell,"--\n");
 492 }
 493
 494 /**************************************************************************
 495 * ShellView_MergeViewMenu()
 496 */
 497 void ShellView_MergeViewMenu(LPSHELLVIEW this, HMENU32 hSubMenu)
 498 {       TRACE(shell,"(%p)->(submenu=0x%08x) stub\n",this,hSubMenu);
 499         if(hSubMenu)
 500         { /*add a separator at the correct position in the menu*/
 501           _InsertMenuItem(hSubMenu, FCIDM_MENU_VIEW_SEP_OPTIONS, FALSE, 0, MFT_SEPARATOR, NULL, MFS_ENABLED);
 502           _InsertMenuItem(hSubMenu, FCIDM_MENU_VIEW_SEP_OPTIONS, FALSE, IDM_VIEW_FILES, MFT_STRING, TEXT("_View"), MFS_ENABLED);
 503         }
 504 }
 505 /**************************************************************************
 506 * ShellView_UpdateMenu()
 507 */
 508 LRESULT ShellView_UpdateMenu(LPSHELLVIEW this, HMENU32 hMenu)
 509 {       TRACE(shell,"(%p)->(menu=0x%08x)\n",this,hMenu);
 510         CheckMenuItem32(hMenu, IDM_VIEW_FILES, MF_BYCOMMAND | (g_bViewKeys ? MF_CHECKED: MF_UNCHECKED));
 511
 512         if(ShellView_CanDoIDockingWindow(this))
 513         { EnableMenuItem32(hMenu, IDM_VIEW_IDW, MF_BYCOMMAND | MF_ENABLED);
 514           CheckMenuItem32(hMenu, IDM_VIEW_IDW, MF_BYCOMMAND | (g_bShowIDW ? MF_CHECKED: MF_UNCHECKED));
 515         }
 516         else
 517         { EnableMenuItem32(hMenu, IDM_VIEW_IDW, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
 518           CheckMenuItem32(hMenu, IDM_VIEW_IDW, MF_BYCOMMAND | MF_UNCHECKED);
 519         }
 520         return S_OK;
 521 }
 522
 523 /**************************************************************************
 524 * ShellView_OnDeactivate()
 525 *
 526 * NOTES
 527 *  internal
 528 */
 529 void ShellView_OnDeactivate(LPSHELLVIEW this)
 530 { TRACE(shell,"%p\n",this);
 531   if(this->uState != SVUIA_DEACTIVATE)
 532   { if(this->hMenu)
 533     { IShellBrowser_SetMenuSB(this->pShellBrowser,0, 0, 0);
 534       IShellBrowser_RemoveMenusSB(this->pShellBrowser,this->hMenu);
 535       DestroyMenu32(this->hMenu);
 536       this->hMenu = 0;
 537       }
 538
 539    this->uState = SVUIA_DEACTIVATE;
 540    }
 541 }
 542
 543 /**************************************************************************
 544 * ShellView_OnActivate()
 545 */
 546 LRESULT ShellView_OnActivate(LPSHELLVIEW this, UINT32 uState)
 547 {       OLEMENUGROUPWIDTHS32   omw = { {0, 0, 0, 0, 0, 0} };
 548         MENUITEMINFO32A         mii;
 549         CHAR                szText[MAX_PATH];
 550
 551         TRACE(shell,"%p uState=%x\n",this,uState);
 552
 553         //don't do anything if the state isn't really changing
 554         if(this->uState == uState)
 555         { return S_OK;
 556         }
 557
 558         ShellView_OnDeactivate(this);
 559
 560         //only do this if we are active
 561         if(uState != SVUIA_DEACTIVATE)
 562         { //merge the menus
 563           this->hMenu = CreateMenu32();
 564
 565           if(this->hMenu)
 566           { IShellBrowser_InsertMenusSB(this->pShellBrowser, this->hMenu, &omw);
 567             TRACE(shell,"-- after fnInsertMenusSB\n");
 568             /*build the top level menu get the menu item's text*/
 569             strcpy(szText,"dummy 31");
 570
 571             ZeroMemory(&mii, sizeof(mii));
 572             mii.cbSize = sizeof(mii);
 573             mii.fMask = MIIM_SUBMENU | MIIM_TYPE | MIIM_STATE;
 574             mii.fType = MFT_STRING;
 575             mii.fState = MFS_ENABLED;
 576             mii.dwTypeData = szText;
 577             mii.hSubMenu = ShellView_BuildFileMenu(this);
 578
 579             /*insert our menu into the menu bar*/
 580             if(mii.hSubMenu)
 581             { InsertMenuItem32A(this->hMenu, FCIDM_MENU_HELP, FALSE, &mii);
 582             }
 583
 584             /*get the view menu so we can merge with it*/
 585             ZeroMemory(&mii, sizeof(mii));
 586             mii.cbSize = sizeof(mii);
 587             mii.fMask = MIIM_SUBMENU;
 588
 589             if(GetMenuItemInfo32A(this->hMenu, FCIDM_MENU_VIEW, FALSE, &mii))
 590             { ShellView_MergeViewMenu(this, mii.hSubMenu);
 591             }
 592
 593             /*add the items that should only be added if we have the focus*/
 594             if(SVUIA_ACTIVATE_FOCUS == uState)
 595             { //get the file menu so we can merge with it
 596               ZeroMemory(&mii, sizeof(mii));
 597               mii.cbSize = sizeof(mii);
 598               mii.fMask = MIIM_SUBMENU;
 599
 600               if(GetMenuItemInfo32A(this->hMenu, FCIDM_MENU_FILE, FALSE, &mii))
 601               { ShellView_MergeFileMenu(this, mii.hSubMenu);
 602               }
 603             }
 604           TRACE(shell,"-- before fnSetMenuSB\n");
 605           IShellBrowser_SetMenuSB(this->pShellBrowser, this->hMenu, 0, this->hWnd);
 606           }
 607         }
 608         this->uState = uState;
 609         TRACE(shell,"--\n");
 610         return S_OK;
 611 }
 612
 613 /**************************************************************************
 614 *  ShellView_OnSetFocus()
 615 *
 616 * NOTES
 617 *  internal
 618 */
 619 LRESULT ShellView_OnSetFocus(LPSHELLVIEW this)
 620 {       TRACE(shell,"%p\n",this);
 621         /* Tell the browser one of our windows has received the focus. This should always
 622         be done before merging menus (OnActivate merges the menus) if one of our
 623         windows has the focus.*/
 624         IShellBrowser_OnViewWindowActive(this->pShellBrowser,this);
 625         ShellView_OnActivate(this, SVUIA_ACTIVATE_FOCUS);
 626
 627         return 0;
 628 }
 629
 630 /**************************************************************************
 631 * ShellView_OnKillFocus()
 632 */
 633 LRESULT ShellView_OnKillFocus(LPSHELLVIEW this)
 634 {       TRACE(shell,"(%p) stub\n",this);
 635         ShellView_OnActivate(this, SVUIA_ACTIVATE_NOFOCUS);
 636         return 0;
 637 }
 638
 639 /**************************************************************************
 640 * ShellView_AddRemoveDockingWindow()
 641 */
 642 BOOL32 ShellView_AddRemoveDockingWindow(LPSHELLVIEW this, BOOL32 bAdd)
 643 {       BOOL32  bReturn = FALSE;
 644         HRESULT hr;
 645         LPSERVICEPROVIDER       pSP;
 646         LPDOCKINGWINDOWFRAME    pFrame;
 647
 648         WARN(shell,"(%p)->(badd=0x%08x) semi-stub\n",this,bAdd);
 649
 650         /* get the browser's IServiceProvider */
 651         hr = IShellBrowser_QueryInterface(this->pShellBrowser, (REFIID)&IID_IServiceProvider, (LPVOID*)&pSP);
 652         if(SUCCEEDED(hr))
 653         { /*get the IDockingWindowFrame pointer*/
 654           hr = pSP->lpvtbl->fnQueryService(pSP, (REFGUID)&SID_SShellBrowser, (REFIID)&IID_IDockingWindowFrame, (LPVOID*)&pFrame);
 655           if(SUCCEEDED(hr))
 656           { if(bAdd)
 657             { hr = S_OK;
 658               FIXME(shell,"no docking implemented\n");
 659               /*if(!this->pDockingWindow)
 660               { //create the toolbar object
 661                 this->pDockingWindow = DockingWindow_Constructor(this, this->hWnd);
 662               }
 663
 664               if(this->pDockingWindow)
 665               { //add the toolbar object
 666                 hr = pFrame->lpvtbl->fnAddToolbar(pFrame, (IDockingWindow*)this->pDockingWindow, TOOLBAR_ID, 0);
 667
 668                 if(SUCCEEDED(hr))
 669                 { bReturn = TRUE;
 670                 }
 671               }*/
 672             }
 673             else
 674             { FIXME(shell,"no docking implemented\n");
 675 /*            if(this->pDockingWindow)
 676               { hr = pFrame->lpvtbl->fnRemoveToolbar(pFrame, (IDockingWindow*)this->pDockingWindow, DWFRF_NORMAL);
 677
 678                 if(SUCCEEDED(hr))
 679                 { // RemoveToolbar should release the toolbar object which will cause
 680                   //it to destroy itself. Our toolbar object is no longer valid at
 681                   //this point.
 682
 683                   this->pDockingWindow = NULL;
 684                   bReturn = TRUE;
 685                 }
 686               }*/
 687             }
 688             pFrame->lpvtbl->fnRelease(pFrame);
 689           }
 690           pSP->lpvtbl->fnRelease(pSP);
 691         }
 692         return bReturn;
 693 }
 694
 695 /**************************************************************************
 696 * ShellView_CanDoIDockingWindow()
 697 */
 698 BOOL32 ShellView_CanDoIDockingWindow(LPSHELLVIEW this)
 699 {       BOOL32 bReturn = FALSE;
 700         HRESULT hr;
 701         LPSERVICEPROVIDER pSP;
 702         LPDOCKINGWINDOWFRAME pFrame;
 703
 704         FIXME(shell,"(%p) stub\n",this);
 705
 706         /*get the browser's IServiceProvider*/
 707         hr = IShellBrowser_QueryInterface(this->pShellBrowser, (REFIID)&IID_IServiceProvider, (LPVOID*)&pSP);
 708         if(hr==S_OK)
 709         { hr = pSP->lpvtbl->fnQueryService(pSP, (REFGUID)&SID_SShellBrowser, (REFIID)&IID_IDockingWindowFrame, (LPVOID*)&pFrame);
 710           if(SUCCEEDED(hr))
 711           { bReturn = TRUE;
 712             pFrame->lpvtbl->fnRelease(pFrame);
 713           }
 714           pSP->lpvtbl->fnRelease(pSP);
 715         }
 716         return bReturn;
 717 }
 718
 719 /**************************************************************************
 720 *  ShellView_UpdateShellSettings()
 721 */
 722 void ShellView_UpdateShellSettings(LPSHELLVIEW this)
 723 {       FIXME(shell,"(%p) stub\n",this);
 724         return ;
 725 /*
 726         SHELLFLAGSTATE       sfs;
 727         HINSTANCE            hinstShell32;
 728 */
 729         /* Since SHGetSettings is not implemented in all versions of the shell, get the
 730         function address manually at run time. This allows the code to run on all
 731         platforms.*/
 732 /*
 733         ZeroMemory(&sfs, sizeof(sfs));
 734 */
 735         /* The default, in case any of the following steps fails, is classic Windows 95
 736         style.*/
 737 /*
 738         sfs.fWin95Classic = TRUE;
 739
 740         hinstShell32 = LoadLibrary(TEXT("shell32.dll"));
 741         if(hinstShell32)
 742         { PFNSHGETSETTINGSPROC pfnSHGetSettings;
 743
 744       pfnSHGetSettings = (PFNSHGETSETTINGSPROC)GetProcAddress(hinstShell32, "SHGetSettings");
 745           if(pfnSHGetSettings)
 746       { (*pfnSHGetSettings)(&sfs, SSF_DOUBLECLICKINWEBVIEW | SSF_WIN95CLASSIC);
 747       }
 748           FreeLibrary(hinstShell32);
 749         }
 750
 751         DWORD dwExStyles = 0;
 752
 753         if(!sfs.fWin95Classic && !sfs.fDoubleClickInWebView)
 754           dwExStyles |= LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT | LVS_EX_UNDERLINEHOT;
 755
 756         ListView_SetExtendedListViewStyle(this->hWndList, dwExStyles);
 757 */
 758 }
 759
 760 /**************************************************************************
 761 *   ShellView_OnSettingChange()
 762 */
 763 LRESULT ShellView_OnSettingChange(LPSHELLVIEW this, LPCSTR lpszSection)
 764 {       TRACE(shell,"(%p) stub\n",this);
 765         //if(0 == lstrcmpi(lpszSection, TEXT("ShellState")))
 766         { ShellView_UpdateShellSettings(this);
 767           return 0;
 768         }
 769         return 0;
 770 }
 771 /**************************************************************************
 772 *   ShellView_GetSelections()
 773 *
 774 * RETURNS
 775 *  number of selected items
 776 */
 777 UINT32 ShellView_GetSelections(LPSHELLVIEW this)
 778 {       LVITEM32A       lvItem;
 779         UINT32  i;
 780
 781         this->uSelected = ListView_GetSelectedCount(this->hWndList);
 782         this->aSelectedItems = (LPITEMIDLIST*)SHAlloc(this->uSelected * sizeof(LPITEMIDLIST));
 783
 784         TRACE(shell,"selected=%i\n", this->uSelected);
 785
 786         if(this->aSelectedItems)
 787         { TRACE(shell,"-- Items selected =%u\n", this->uSelected);
 788           ZeroMemory(&lvItem, sizeof(lvItem));
 789           lvItem.mask = LVIF_STATE | LVIF_PARAM;
 790           lvItem.stateMask = LVIS_SELECTED;
 791           lvItem.iItem = 0;
 792
 793           i = 0;
 794
 795           while(ListView_GetItem32A(this->hWndList, &lvItem) && (i < this->uSelected))
 796           { if(lvItem.state & LVIS_SELECTED)
 797             { this->aSelectedItems[i] = (LPITEMIDLIST)lvItem.lParam;
 798               i++;
 799               TRACE(shell,"-- selected Item found\n");
 800             }
 801             lvItem.iItem++;
 802           }
 803         }
 804         return this->uSelected;
 805
 806 }
 807 /**************************************************************************
 808 *   ShellView_DoContextMenu()
 809 */
 810 void ShellView_DoContextMenu(LPSHELLVIEW this, WORD x, WORD y, BOOL32 fDefault)
 811 {       UINT32  uCommand;
 812         DWORD   wFlags;
 813         HMENU32 hMenu;
 814         BOOL32  fExplore = FALSE;
 815         HWND32  hwndTree = 0;
 816         INT32           nMenuIndex;
 817         MENUITEMINFO32A mii;
 818         LPCONTEXTMENU   pContextMenu = NULL;
 819         CMINVOKECOMMANDINFO32  cmi;
 820
 821         TRACE(shell,"(%p)->(0x%08x 0x%08x 0x%08x) stub\n",this, x, y, fDefault);
 822
 823         /* look, what's selected and create a context menu object of it*/
 824         if(ShellView_GetSelections(this))
 825         { this->pSFParent->lpvtbl->fnGetUIObjectOf(     this->pSFParent,
 826                                                         this->hWndParent,
 827                                                         this->uSelected,
 828                                                         this->aSelectedItems,
 829                                                         (REFIID)&IID_IContextMenu,
 830                                                         NULL,
 831                                                         (LPVOID *)&pContextMenu);
 832
 833           if(pContextMenu)
 834           { TRACE(shell,"-- pContextMenu\n");
 835             hMenu = CreatePopupMenu32();
 836
 837             /* See if we are in Explore or Open mode. If the browser's tree
 838              is present, then we are in Explore mode.*/
 839
 840             fExplore = FALSE;
 841             if(SUCCEEDED(IShellBrowser_GetControlWindow(this->pShellBrowser,FCW_TREE, &hwndTree)) && hwndTree)
 842             { TRACE(shell,"-- fExplore\n");
 843               fExplore = TRUE;
 844             }
 845
 846             if(hMenu && SUCCEEDED(pContextMenu->lpvtbl->fnQueryContextMenu( pContextMenu,
 847                                                                             hMenu,
 848                                                                             0,
 849                                                                             MENU_OFFSET,
 850                                                                             MENU_MAX,
 851                                                                             CMF_NORMAL | (this->uSelected != 1 ? 0 : CMF_CANRENAME) | (fExplore ? CMF_EXPLORE : 0))))
 852             { if(fDefault)
 853               { TRACE(shell,"-- fDefault\n");
 854                 uCommand = 0;
 855
 856                 ZeroMemory(&mii, sizeof(mii));
 857                 mii.cbSize = sizeof(mii);
 858                 mii.fMask = MIIM_STATE | MIIM_ID;
 859
 860                 nMenuIndex = 0;
 861
 862                 /*find the default item in the menu*/
 863                 while(GetMenuItemInfo32A(hMenu, nMenuIndex, TRUE, &mii))
 864                 { if(mii.fState & MFS_DEFAULT)
 865                   { uCommand = mii.wID;
 866                     break;
 867                   }
 868                   nMenuIndex++;
 869                 }
 870               }
 871               else
 872               { TRACE(shell,"-- ! fDefault\n");
 873                 uCommand = TrackPopupMenu32( hMenu,TPM_LEFTALIGN | TPM_RETURNCMD,x,y,0,this->hWnd,NULL);
 874               }
 875
 876               if(uCommand > 0)
 877               { TRACE(shell,"-- uCommand=%u\n", uCommand);
 878                 if (((uCommand-MENU_OFFSET) == IDM_EXPLORE) || ((uCommand-MENU_OFFSET)  == IDM_OPEN))
 879                 { if (IsInCommDlg(this))                        /* are we part of a commctrl? */
 880                   { TRACE(shell,"-- fnOnDefaultCommand\n");
 881                     OnDefaultCommand(this);
 882                   }
 883                   else                                  /* we are acting with a full featured IShellBrowser */
 884                   { TRACE(shell,"-- fnBrowseObject pidl =%p\n", this->aSelectedItems[0]);
 885                     wFlags = SBSP_SAMEBROWSER | SBSP_DEFMODE | SBSP_RELATIVE;
 886                     IShellBrowser_BrowseObject(this->pShellBrowser,
 887                                                                 this->aSelectedItems[0],
 888                                                                 wFlags);
 889                   }
 890                 }
 891                 else
 892                 { ZeroMemory(&cmi, sizeof(cmi));
 893                   cmi.cbSize = sizeof(cmi);
 894                   cmi.hwnd = this->hWndParent;
 895                   cmi.lpVerb = (LPCSTR)MAKEINTRESOURCE32A(uCommand - MENU_OFFSET);
 896                         pContextMenu->lpvtbl->fnInvokeCommand(pContextMenu, &cmi);
 897                 }
 898               }
 899               DestroyMenu32(hMenu);
 900             }
 901             pContextMenu->lpvtbl->fnRelease(pContextMenu);
 902           }
 903           SHFree(this->aSelectedItems);
 904           this->aSelectedItems=NULL;
 905           this->uSelected=0;
 906         }
 907 }
 908
 909 /**************************************************************************
 910 * ShellView_OnCommand()
 911 */
 912 LRESULT ShellView_OnCommand(LPSHELLVIEW this,DWORD dwCmdID, DWORD dwCmd, HWND32 hwndCmd)
 913 {       TRACE(shell,"(%p)->(0x%08lx 0x%08lx 0x%08x) stub\n",this, dwCmdID, dwCmd, hwndCmd);
 914         switch(dwCmdID)
 915         { case IDM_VIEW_FILES:
 916             g_bViewKeys = ! g_bViewKeys;
 917             IShellView_Refresh(this);
 918             break;
 919
 920           case IDM_VIEW_IDW:
 921             g_bShowIDW = ! g_bShowIDW;
 922             ShellView_AddRemoveDockingWindow(this, g_bShowIDW);
 923             break;
 924
 925           case IDM_MYFILEITEM:
 926             MessageBeep32(MB_OK);
 927             break;
 928
 929           case FCIDM_SHVIEW_SMALLICON:
 930             this->FolderSettings.ViewMode = FVM_SMALLICON;
 931             SetStyle (this, LVS_SMALLICON, LVS_TYPEMASK);
 932             break;
 933
 934           case FCIDM_SHVIEW_BIGICON:
 935             this->FolderSettings.ViewMode = FVM_ICON;
 936             SetStyle (this, LVS_ICON, LVS_TYPEMASK);
 937             break;
 938
 939           case FCIDM_SHVIEW_LISTVIEW:
 940             this->FolderSettings.ViewMode = FVM_LIST;
 941             SetStyle (this, LVS_LIST, LVS_TYPEMASK);
 942             break;
 943
 944           case FCIDM_SHVIEW_REPORTVIEW:
 945             this->FolderSettings.ViewMode = FVM_DETAILS;
 946             SetStyle (this, LVS_REPORT, LVS_TYPEMASK);
 947             break;
 948
 949           default:
 950             FIXME(shell,"-- COMMAND unhandled\n");
 951         }
 952         return 0;
 953 }
 954
 955 /**************************************************************************
 956 * ShellView_OnNotify()
 957 */
 958
 959 LRESULT ShellView_OnNotify(LPSHELLVIEW this, UINT32 CtlID, LPNMHDR lpnmh)
 960 {       NM_LISTVIEW *lpnmlv = (NM_LISTVIEW*)lpnmh;
 961         NMLVDISPINFO32A *lpdi = (NMLVDISPINFO32A *)lpnmh;
 962         LPITEMIDLIST pidl;
 963         DWORD dwCursor;
 964         STRRET   str;
 965         UINT32  uFlags;
 966         IExtractIcon *pei;
 967
 968         TRACE(shell,"%p CtlID=%u lpnmh->code=%x\n",this,CtlID,lpnmh->code);
 969
 970         switch(lpnmh->code)
 971         { case NM_SETFOCUS:
 972             TRACE(shell,"-- NM_SETFOCUS %p\n",this);
 973             ShellView_OnSetFocus(this);
 974             break;
 975
 976           case NM_KILLFOCUS:
 977             TRACE(shell,"-- NM_KILLFOCUS %p\n",this);
 978             ShellView_OnDeactivate(this);
 979             break;
 980
 981           case HDN_ENDTRACK32A:
 982             TRACE(shell,"-- HDN_ENDTRACK32A %p\n",this);
 983             /*nColumn1 = ListView_GetColumnWidth(this->hWndList, 0);
 984             nColumn2 = ListView_GetColumnWidth(this->hWndList, 1);*/
 985             break;
 986
 987           case LVN_DELETEITEM:
 988             TRACE(shell,"-- LVN_DELETEITEM %p\n",this);
 989             SHFree((LPITEMIDLIST)lpnmlv->lParam);     /*delete the pidl because we made a copy of it*/
 990             break;
 991
 992           case NM_DBLCLK:
 993           case NM_RETURN:
 994             TRACE(shell,"-- NM_RETURN|NM_DBLCLK ignored, waiting for LVN_ITEMACTIVATE\n");
 995             break;
 996
 997           case LVN_ITEMACTIVATE:
 998             TRACE(shell,"-- LVN_ITEMACTIVATE %p\n",this);
 999             ShellView_DoContextMenu(this, 0, 0, TRUE);
1000             break;
1001
1002           case NM_RCLICK:
1003             TRACE(shell,"-- NM_RCLICK %p\n",this);
1004             dwCursor = GetMessagePos();
1005             ShellView_DoContextMenu(this, LOWORD(dwCursor), HIWORD(dwCursor), FALSE);
1006             break;
1007
1008           case LVN_GETDISPINFO32A:
1009             TRACE(shell,"-- LVN_GETDISPINFO32A %p\n",this);
1010             pidl = (LPITEMIDLIST)lpdi->item.lParam;
1011
1012
1013             if(lpdi->item.iSubItem)               /*is the sub-item information being requested?*/
1014             { if(lpdi->item.mask & LVIF_TEXT)    /*is the text being requested?*/
1015               { if(_ILIsValue(pidl))    /*is this a value or a folder?*/
1016                 { switch (lpdi->item.iSubItem)
1017                   { case 1:
1018                       _ILGetFileSize (pidl, lpdi->item.pszText, lpdi->item.cchTextMax);
1019                       break;
1020                     case 2:
1021                       strncpy (lpdi->item.pszText, "File", lpdi->item.cchTextMax);
1022                       break;
1023                     case 3:
1024                       _ILGetFileDate (pidl, lpdi->item.pszText, lpdi->item.cchTextMax);
1025                       break;
1026                   }
1027                 }
1028                 else  /*its a folder*/
1029                 { switch (lpdi->item.iSubItem)
1030                   { case 1:
1031                       sprintf(lpdi->item.pszText, "fixme");
1032                       break;
1033                     case 2:
1034                       strncpy (lpdi->item.pszText, "Folder", lpdi->item.cchTextMax);
1035                       break;
1036                     case 3:
1037                       _ILGetFileDate (pidl, lpdi->item.pszText, lpdi->item.cchTextMax);
1038                       break;
1039                   }
1040                 }
1041               }
1042             }
1043             else           /*the item text is being requested*/
1044             { if(lpdi->item.mask & LVIF_TEXT)      /*is the text being requested?*/
1045               { if(SUCCEEDED(this->pSFParent->lpvtbl->fnGetDisplayNameOf(this->pSFParent,pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &str)))
1046                 { if(STRRET_WSTR == str.uType)
1047                   { WideCharToLocal32(lpdi->item.pszText, str.u.pOleStr, lpdi->item.cchTextMax);
1048                     SHFree(str.u.pOleStr);
1049                   }
1050                   else if(STRRET_CSTRA == str.uType)
1051                   { strncpy(lpdi->item.pszText, str.u.cStr, lpdi->item.cchTextMax);
1052                   }
1053                   else
1054                   { FIXME(shell,"type wrong\n");
1055                   }
1056                   TRACE(shell,"-- text=%s\n",lpdi->item.pszText);
1057                 }
1058               }
1059
1060               if(lpdi->item.mask & LVIF_IMAGE)          /*is the image being requested?*/
1061               { if(SUCCEEDED(this->pSFParent->lpvtbl->fnGetUIObjectOf(this->pSFParent,this->hWnd,1,
1062                                 (LPCITEMIDLIST*)&pidl, (REFIID)&IID_IExtractIcon, NULL, (LPVOID*)&pei)))
1063                 { pei->lpvtbl->fnGetIconLocation(pei, GIL_FORSHELL, NULL, 0, &lpdi->item.iImage, &uFlags);
1064                   pei->lpvtbl->fnRelease(pei);
1065                   TRACE(shell,"-- image=%x\n",lpdi->item.iImage);
1066                 }
1067               }
1068             }
1069             break;
1070
1071           case NM_CLICK:
1072             WARN(shell,"-- NM_CLICK %p\n",this);
1073             break;
1074
1075           case LVN_ITEMCHANGING:
1076             WARN(shell,"-- LVN_ITEMCHANGING %p\n",this);
1077             break;
1078
1079           case LVN_ITEMCHANGED:
1080             TRACE(shell,"-- LVN_ITEMCHANGED %p\n",this);
1081             ShellView_GetSelections(this);
1082             OnStateChange(this, CDBOSC_SELCHANGE);  /* the browser will get the IDataObject now */
1083             break;
1084
1085           case LVN_DELETEALLITEMS:
1086             WARN(shell,"-- LVN_DELETEALLITEMS %p\n",this);
1087             break;
1088
1089           case LVN_INSERTITEM:
1090             WARN(shell,"-- LVN_INSERTITEM %p\n",this);
1091             break;
1092
1093           case LVN_BEGINDRAG:
1094             WARN(shell,"-- LVN_BEGINDRAG %p\n",this);
1095             break;
1096
1097           case NM_CUSTOMDRAW:
1098             WARN(shell,"NM_CUSTOMDRAW %p\n",this);
1099             break;
1100
1101           default:
1102             FIXME (shell,"-- WM_NOTIFY unhandled\n");
1103             break;;
1104         }
1105         return 0;
1106 }
1107
1108 /**************************************************************************
1109 *  ShellView_WndProc
1110 */
1111
1112 LRESULT CALLBACK ShellView_WndProc(HWND32 hWnd, UINT32 uMessage, WPARAM32 wParam, LPARAM lParam)
1113 { LPSHELLVIEW pThis = (LPSHELLVIEW)GetWindowLong32A(hWnd, GWL_USERDATA);
1114   LPCREATESTRUCT32A lpcs;
1115   DWORD dwCursor;
1116
1117   TRACE(shell,"(hwnd=%x msg=%x wparm=%x lparm=%lx)\n",hWnd, uMessage, wParam, lParam);
1118
1119   switch (uMessage)
1120   { case WM_NCCREATE:
1121       { TRACE(shell,"-- WM_NCCREATE\n");
1122         lpcs = (LPCREATESTRUCT32A)lParam;
1123         pThis = (LPSHELLVIEW)(lpcs->lpCreateParams);
1124         SetWindowLong32A(hWnd, GWL_USERDATA, (LONG)pThis);
1125         pThis->hWnd = hWnd;        /*set the window handle*/
1126       }
1127       break;
1128
1129    case WM_SIZE:
1130       TRACE(shell,"-- WM_SIZE\n");
1131       return ShellView_OnSize(pThis,LOWORD(lParam), HIWORD(lParam));
1132
1133    case WM_SETFOCUS:
1134       TRACE(shell,"-- WM_SETFOCUS\n");
1135       return ShellView_OnSetFocus(pThis);
1136
1137    case WM_KILLFOCUS:
1138       TRACE(shell,"-- WM_KILLFOCUS\n");
1139           return ShellView_OnKillFocus(pThis);
1140
1141    case WM_CREATE:
1142       TRACE(shell,"-- WM_CREATE\n");
1143       return ShellView_OnCreate(pThis);
1144
1145    case WM_SHOWWINDOW:
1146       TRACE(shell,"-- WM_SHOWWINDOW\n");
1147       UpdateWindow32(pThis->hWndList);
1148       break;
1149
1150    case WM_ACTIVATE:
1151       TRACE(shell,"-- WM_ACTIVATE\n");
1152       return ShellView_OnActivate(pThis, SVUIA_ACTIVATE_FOCUS);
1153
1154    case WM_COMMAND:
1155       TRACE(shell,"-- WM_COMMAND\n");
1156       return ShellView_OnCommand(pThis, GET_WM_COMMAND_ID(wParam, lParam),
1157                                   GET_WM_COMMAND_CMD(wParam, lParam),
1158                                   GET_WM_COMMAND_HWND(wParam, lParam));
1159
1160    case WM_INITMENUPOPUP:
1161       TRACE(shell,"-- WM_INITMENUPOPUP\n");
1162       return ShellView_UpdateMenu(pThis, (HMENU32)wParam);
1163
1164    case WM_NOTIFY:
1165       TRACE(shell,"-- WM_NOTIFY\n");
1166       return ShellView_OnNotify(pThis,(UINT32)wParam, (LPNMHDR)lParam);
1167
1168    case WM_SETTINGCHANGE:
1169       TRACE(shell,"-- WM_SETTINGCHANGE\n");
1170       return ShellView_OnSettingChange(pThis,(LPCSTR)lParam);
1171
1172    case WM_PARENTNOTIFY:
1173       TRACE(shell,"-- WM_PARENTNOTIFY\n");
1174       if ( LOWORD(wParam) == WM_RBUTTONDOWN ) /* fixme: should not be handled here*/
1175       { dwCursor = GetMessagePos();
1176         ShellView_DoContextMenu(pThis, LOWORD(dwCursor), HIWORD(dwCursor), FALSE);
1177         return TRUE;
1178       }
1179       break;
1180
1181 /* -------------*/
1182    case WM_MOVE:
1183       WARN(shell,"-- WM_MOVE\n");
1184       break;
1185
1186    case WM_ACTIVATEAPP:
1187       WARN(shell,"-- WM_ACTIVATEAPP\n");
1188       break;
1189
1190    case WM_NOTIFYFORMAT:
1191       WARN(shell,"-- WM_NOTIFYFORMAT\n");
1192       break;
1193
1194    case WM_NCPAINT:
1195       WARN(shell,"-- WM_NCPAINT\n");
1196       break;
1197
1198    case WM_ERASEBKGND:
1199       WARN(shell,"-- WM_ERASEBKGND\n");
1200       break;
1201
1202    case WM_PAINT:
1203       WARN(shell,"-- WM_PAINT\n");
1204       break;
1205
1206    case WM_NCCALCSIZE:
1207       WARN(shell,"-- WM_NCCALCSIZE\n");
1208       break;
1209
1210    case WM_WINDOWPOSCHANGING:
1211       WARN(shell,"-- WM_WINDOWPOSCHANGING\n");
1212       break;
1213
1214    case WM_WINDOWPOSCHANGED:
1215       WARN(shell,"-- WM_WINDOWPOSCHANGED\n");
1216       break;
1217
1218    case WM_MOUSEACTIVATE:
1219       WARN(shell,"-- WM_MOUSEACTIVATE\n");
1220       break;
1221
1222    case WM_SETCURSOR:
1223       WARN(shell,"-- WM_SETCURSOR\n");
1224       break;
1225
1226    case WM_DESTROY:
1227       WARN(shell,"-- WM_DESTROY\n");
1228       break;
1229
1230    case WM_NCDESTROY:
1231       WARN(shell,"-- WM_NCDESTROY\n");
1232       break;
1233
1234    case WM_CONTEXTMENU:
1235       WARN(shell,"-- WM_CONTEXTMENU\n");
1236       break;
1237
1238    case WM_MENUSELECT:
1239       WARN(shell,"-- WM_MENUSELECT\n");
1240       break;
1241
1242    case WM_CAPTURECHANGED:
1243       WARN(shell,"-- WM_CAPTURECHANGED\n");
1244       break;
1245
1246    case WM_CHILDACTIVATE:
1247       WARN(shell,"-- WM_CHILDACTIVATE\n");
1248       break;
1249
1250    case WM_ENTERIDLE:
1251       WARN(shell,"-- WM_ENTERIDLE\n");
1252       break;
1253
1254    default:
1255       FIXME(shell,"-- MESSAGE unhandled\n");
1256       break;
1257   }
1258   return DefWindowProc32A (hWnd, uMessage, wParam, lParam);
1259 }
1260 /**************************************************************************
1261 *
1262 *
1263 *  The INTERFACE of the IShellView object
1264 *
1265 *
1266 ***************************************************************************
1267 *  IShellView_QueryInterface
1268 */
1269 static HRESULT WINAPI IShellView_QueryInterface(LPSHELLVIEW this,REFIID riid, LPVOID *ppvObj)
1270 { char    xriid[50];
1271   WINE_StringFromCLSID((LPCLSID)riid,xriid);
1272   TRACE(shell,"(%p)->(\n\tIID:\t%s,%p)\n",this,xriid,ppvObj);
1273
1274   *ppvObj = NULL;
1275
1276   if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
1277   { *ppvObj = this;
1278   }
1279   else if(IsEqualIID(riid, &IID_IShellView))  /*IShellView*/
1280   { *ppvObj = (IShellView*)this;
1281   }
1282
1283   if(*ppvObj)
1284   { (*(LPSHELLVIEW*)ppvObj)->lpvtbl->fnAddRef(this);
1285     TRACE(shell,"-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
1286     return S_OK;
1287   }
1288   TRACE(shell,"-- Interface: E_NOINTERFACE\n");
1289   return E_NOINTERFACE;
1290 }
1291 /**************************************************************************
1292 *  IShellView::AddRef
1293 */
1294 static ULONG WINAPI IShellView_AddRef(LPSHELLVIEW this)
1295 { TRACE(shell,"(%p)->(count=%lu)\n",this,(this->ref)+1);
1296   return ++(this->ref);
1297 }
1298 /**************************************************************************
1299 *  IShellView_Release
1300 */
1301 static ULONG WINAPI IShellView_Release(LPSHELLVIEW this)
1302 { TRACE(shell,"(%p)->()\n",this);
1303   if (!--(this->ref))
1304   { TRACE(shell," destroying IShellView(%p)\n",this);
1305
1306     if(this->pSFParent)
1307        this->pSFParent->lpvtbl->fnRelease(this->pSFParent);
1308
1309     HeapFree(GetProcessHeap(),0,this);
1310     return 0;
1311   }
1312   return this->ref;
1313 }
1314 /**************************************************************************
1315 *  ShellView_GetWindow
1316 */
1317 static HRESULT WINAPI IShellView_GetWindow(LPSHELLVIEW this,HWND32 * phWnd)
1318 {       TRACE(shell,"(%p) stub\n",this);
1319         *phWnd = this->hWnd;
1320
1321         return S_OK;
1322 }
1323 static HRESULT WINAPI IShellView_ContextSensitiveHelp(LPSHELLVIEW this,BOOL32 fEnterMode)
1324 { FIXME(shell,"(%p) stub\n",this);
1325   return E_NOTIMPL;
1326 }
1327 /**************************************************************************
1328 * IShellView_TranslateAccelerator
1329 *
1330 * FIXME:
1331 *  use the accel functions
1332 */
1333 static HRESULT WINAPI IShellView_TranslateAccelerator(LPSHELLVIEW this,LPMSG32 lpmsg)
1334 {       FIXME(shell,"(%p)->(%p: hwnd=%x msg=%x lp=%lx wp=%x) stub\n",this,lpmsg, lpmsg->hwnd, lpmsg->message, lpmsg->lParam, lpmsg->wParam);
1335
1336
1337         switch (lpmsg->message)
1338         { case WM_KEYDOWN:      TRACE(shell,"-- key=0x04%x",lpmsg->wParam) ;
1339         }
1340         return S_FALSE;
1341 }
1342 static HRESULT WINAPI IShellView_EnableModeless(LPSHELLVIEW this,BOOL32 fEnable)
1343 { FIXME(shell,"(%p) stub\n",this);
1344   return E_NOTIMPL;
1345 }
1346 static HRESULT WINAPI IShellView_UIActivate(LPSHELLVIEW this,UINT32 uState)
1347 {       CHAR    szName[MAX_PATH];
1348         LRESULT lResult;
1349         int     nPartArray[1] = {-1};
1350
1351         TRACE(shell,"(%p)->(state=%x) stub\n",this, uState);
1352         /*don't do anything if the state isn't really changing*/
1353         if(this->uState == uState)
1354         { return S_OK;
1355         }
1356
1357         /*OnActivate handles the menu merging and internal state*/
1358         ShellView_OnActivate(this, uState);
1359
1360         /*remove the docking window*/
1361         if(g_bShowIDW)
1362         { ShellView_AddRemoveDockingWindow(this, FALSE);
1363         }
1364
1365         /*only do this if we are active*/
1366         if(uState != SVUIA_DEACTIVATE)
1367         { //update the status bar
1368            strcpy(szName, "dummy32");
1369
1370           this->pSFParent->lpvtbl->fnGetFolderPath( this->pSFParent,
1371                                                     szName + strlen(szName),
1372                                                     sizeof(szName) - strlen(szName));
1373
1374           /* set the number of parts */
1375           IShellBrowser_SendControlMsg(this->pShellBrowser, FCW_STATUS, SB_SETPARTS, 1,
1376                                                         (LPARAM)nPartArray, &lResult);
1377
1378           /* set the text for the parts */
1379           IShellBrowser_SendControlMsg(this->pShellBrowser, FCW_STATUS, SB_SETTEXT32A,
1380                                                         0, (LPARAM)szName, &lResult);
1381
1382           //add the docking window if necessary
1383           if(g_bShowIDW)
1384           { ShellView_AddRemoveDockingWindow(this, TRUE);
1385           }
1386         }
1387         return S_OK;
1388 }
1389 static HRESULT WINAPI IShellView_Refresh(LPSHELLVIEW this)
1390 {       TRACE(shell,"(%p)\n",this);
1391
1392         ListView_DeleteAllItems(this->hWndList);
1393         ShellView_FillList(this);
1394
1395         return S_OK;
1396 }
1397 static HRESULT WINAPI IShellView_CreateViewWindow(LPSHELLVIEW this, IShellView *lpPrevView,
1398                      LPCFOLDERSETTINGS lpfs, IShellBrowser * psb, RECT32 * prcView, HWND32  *phWnd)
1399 {       WNDCLASS32A wc;
1400 /*      LRESULT dwResult;*/
1401         *phWnd = 0;
1402
1403
1404         TRACE(shell,"(%p)->(shlview=%p set=%p shlbrs=%p rec=%p hwnd=%p) incomplete\n",this, lpPrevView,lpfs, psb, prcView, phWnd);
1405         TRACE(shell,"-- vmode=%x flags=%x left=%i top=%i right=%i bottom=%i\n",lpfs->ViewMode, lpfs->fFlags ,prcView->left,prcView->top, prcView->right, prcView->bottom);
1406
1407         /*set up the member variables*/
1408         this->pShellBrowser = psb;
1409         this->FolderSettings = *lpfs;
1410
1411         /*get our parent window*/
1412         IShellBrowser_AddRef(this->pShellBrowser);
1413         IShellBrowser_GetWindow(this->pShellBrowser, &(this->hWndParent));
1414
1415 /*      IShellBrowser_SendControlMsg(this->pShellBrowser, FCW_TOOLBAR, TB_ENABLEBUTTON, 0xa004, TRUE, &dwResult);
1416 */
1417         /* try to get the ICommDlgBrowserInterface */
1418         this->pCommDlgBrowser=NULL;
1419         if ( SUCCEEDED (IShellBrowser_QueryInterface( this->pShellBrowser,
1420                                                                         (REFIID)&IID_ICommDlgBrowser,
1421                                                                         (LPVOID*) &this->pCommDlgBrowser)))
1422         { TRACE(shell,"-- CommDlgBrowser\n");
1423         }
1424
1425         /*if our window class has not been registered, then do so*/
1426         if(!GetClassInfo32A(shell32_hInstance, SV_CLASS_NAME, &wc))
1427         { ZeroMemory(&wc, sizeof(wc));
1428           wc.style          = CS_HREDRAW | CS_VREDRAW;
1429           wc.lpfnWndProc    = (WNDPROC32) ShellView_WndProc;
1430           wc.cbClsExtra     = 0;
1431           wc.cbWndExtra     = 0;
1432           wc.hInstance      = shell32_hInstance;
1433           wc.hIcon          = 0;
1434           wc.hCursor        = LoadCursor32A (0, IDC_ARROW32A);
1435           wc.hbrBackground  = (HBRUSH32) (COLOR_WINDOW + 1);
1436           wc.lpszMenuName   = NULL;
1437           wc.lpszClassName  = SV_CLASS_NAME;
1438
1439           if(!RegisterClass32A(&wc))
1440             return E_FAIL;
1441         }
1442
1443         *phWnd = CreateWindowEx32A(0, SV_CLASS_NAME, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
1444                            prcView->left, prcView->top, prcView->right - prcView->left, prcView->bottom - prcView->top,
1445                            this->hWndParent, 0, shell32_hInstance, (LPVOID)this);
1446
1447         MergeToolBar(this);
1448
1449         if(!*phWnd)
1450           return E_FAIL;
1451
1452         return S_OK;
1453 }
1454
1455 static HRESULT WINAPI IShellView_DestroyViewWindow(LPSHELLVIEW this)
1456 {       TRACE(shell,"(%p)\n",this);
1457
1458         /*Make absolutely sure all our UI is cleaned up.*/
1459         IShellView_UIActivate(this, SVUIA_DEACTIVATE);
1460         if(this->hMenu)
1461         { DestroyMenu32(this->hMenu);
1462         }
1463         DestroyWindow32(this->hWnd);
1464         IShellBrowser_Release(this->pShellBrowser);
1465         return S_OK;
1466 }
1467 static HRESULT WINAPI IShellView_GetCurrentInfo(LPSHELLVIEW this, LPFOLDERSETTINGS lpfs)
1468 {       TRACE(shell,"(%p)->(%p) vmode=%x flags=%x\n",this, lpfs,
1469                 this->FolderSettings.ViewMode, this->FolderSettings.fFlags);
1470
1471         if (lpfs)
1472         { *lpfs = this->FolderSettings;
1473           return NOERROR;
1474         }
1475         else
1476           return E_INVALIDARG;
1477 }
1478 static HRESULT WINAPI IShellView_AddPropertySheetPages(LPSHELLVIEW this, DWORD dwReserved,LPFNADDPROPSHEETPAGE lpfn, LPARAM lparam)
1479 { FIXME(shell,"(%p) stub\n",this);
1480   return E_NOTIMPL;
1481 }
1482 static HRESULT WINAPI IShellView_SaveViewState(LPSHELLVIEW this)
1483 { FIXME(shell,"(%p) stub\n",this);
1484   return S_OK;
1485 }
1486 static HRESULT WINAPI IShellView_SelectItem(LPSHELLVIEW this, LPCITEMIDLIST pidlItem, UINT32 uFlags)
1487 { FIXME(shell,"(%p)->(pidl=%p, 0x%08x) stub\n",this, pidlItem, uFlags);
1488   return E_NOTIMPL;
1489 }
1490 static HRESULT WINAPI IShellView_GetItemObject(LPSHELLVIEW this, UINT32 uItem, REFIID riid, LPVOID *ppvOut)
1491 {       LPUNKNOWN       pObj = NULL;
1492         char    xriid[50];
1493
1494         WINE_StringFromCLSID((LPCLSID)riid,xriid);
1495         TRACE(shell,"(%p)->(uItem=0x%08x,\n\tIID=%s, ppv=%p)\n",this, uItem, xriid, ppvOut);
1496
1497         *ppvOut = NULL;
1498         if(IsEqualIID(riid, &IID_IContextMenu))
1499         { pObj =(LPUNKNOWN)IContextMenu_Constructor(this->pSFParent,this->aSelectedItems,this->uSelected);
1500         }
1501         else if (IsEqualIID(riid, &IID_IDataObject))
1502         { pObj =(LPUNKNOWN)IDataObject_Constructor(this->hWndParent, this->pSFParent,this->aSelectedItems,this->uSelected);
1503         }
1504
1505         TRACE(shell,"-- (%p)->(interface=%p)\n",this, ppvOut);
1506
1507         if(!pObj)
1508           return E_OUTOFMEMORY;
1509         *ppvOut = pObj;
1510         return S_OK;
1511 }