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