git.oblomov.eu Git - wine/blob - dlls/commdlg/filedlg95.c

   1 /*
   2  * COMMDLG - File Open Dialogs Win95 look and feel
   3  *
   4  * FIXME: lpstrCustomFilter not handeled
   5  *
   6  * FIXME: if the size of lpstrFile (nMaxFile) is to small the first
   7  * two bytes of lpstrFile should contain the needed size
   8  *
   9  * FIXME: algorithm for selecting the initial directory is to simple
  10  *
  11  * FIXME: add to recent docs
  12  *
  13  * FIXME: flags not implemented: OFN_CREATEPROMPT, OFN_DONTADDTORECENT,
  14  * OFN_ENABLEINCLUDENOTIFY, OFN_ENABLESIZING, OFN_EXTENSIONDIFFERENT,
  15  * OFN_NOCHANGEDIR, OFN_NODEREFERENCELINKS, OFN_READONLYRETURN,
  16  * OFN_NOTESTFILECREATE, OFN_OVERWRITEPROMPT, OFN_USEMONIKERS
  17  *
  18  * FIXME: lCustData for lpfnHook (WM_INITDIALOG)
  19  *
  20  *
  21  */
  22 #include <ctype.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27 #include "winbase.h"
  28 #include "crtdll.h"
  29 #include "ldt.h"
  30 #include "heap.h"
  31 #include "commdlg.h"
  32 #include "dlgs.h"
  33 #include "cdlg.h"
  34 #include "debugtools.h"
  35 #include "cderr.h"
  36 #include "tweak.h"
  37 #include "winnls.h"
  38 #include "shellapi.h"
  39 #include "filedlgbrowser.h"
  40 #include "shlwapi.h"
  41 #include "wine/obj_contextmenu.h"
  42
  43 DEFAULT_DEBUG_CHANNEL(commdlg);
  44
  45 /***********************************************************************
  46  * Data structure and global variables
  47  */
  48 typedef struct SFolder
  49 {
  50   int m_iImageIndex;    /* Index of picture in image list */
  51   HIMAGELIST hImgList;
  52   int m_iIndent;      /* Indentation index */
  53   LPITEMIDLIST pidlItem;  /* absolute pidl of the item */
  54
  55 } SFOLDER,*LPSFOLDER;
  56
  57 typedef struct tagLookInInfo
  58 {
  59   int iMaxIndentation;
  60   UINT uSelectedItem;
  61 } LookInInfos;
  62
  63
  64 /***********************************************************************
  65  * Defines and global variables
  66  */
  67
  68 /* Draw item constant */
  69 #define ICONWIDTH 18
  70 #define YTEXTOFFSET 2
  71 #define XTEXTOFFSET 3
  72
  73 /* AddItem flags*/
  74 #define LISTEND -1
  75
  76 /* SearchItem methods */
  77 #define SEARCH_PIDL 1
  78 #define SEARCH_EXP  2
  79 #define ITEM_NOTFOUND -1
  80
  81 /* Undefined windows message sent by CreateViewObject*/
  82 #define WM_GETISHELLBROWSER  WM_USER+7
  83
  84 /* NOTE
  85  * Those macros exist in windowsx.h. However, you can't really use them since
  86  * they rely on the UNICODE defines and can't be use inside Wine itself.
  87  */
  88
  89 /* Combo box macros */
  90 #define CBAddString(hwnd,str) \
  91   SendMessageA(hwnd,CB_ADDSTRING,0,(LPARAM)str);
  92
  93 #define CBInsertString(hwnd,str,pos) \
  94   SendMessageA(hwnd,CB_INSERTSTRING,(WPARAM)pos,(LPARAM)str);
  95
  96 #define CBDeleteString(hwnd,pos) \
  97   SendMessageA(hwnd,CB_DELETESTRING,(WPARAM)pos,0);
  98
  99 #define CBSetItemDataPtr(hwnd,iItemId,dataPtr) \
 100   SendMessageA(hwnd,CB_SETITEMDATA,(WPARAM)iItemId,(LPARAM)dataPtr);
 101
 102 #define CBGetItemDataPtr(hwnd,iItemId) \
 103   SendMessageA(hwnd,CB_GETITEMDATA,(WPARAM)iItemId,0)
 104
 105 #define CBGetLBText(hwnd,iItemId,str) \
 106   SendMessageA(hwnd,CB_GETLBTEXT,(WPARAM)iItemId,(LPARAM)str);
 107
 108 #define CBGetCurSel(hwnd) \
 109   SendMessageA(hwnd,CB_GETCURSEL,0,0);
 110
 111 #define CBSetCurSel(hwnd,pos) \
 112   SendMessageA(hwnd,CB_SETCURSEL,(WPARAM)pos,0);
 113
 114 #define CBGetCount(hwnd) \
 115     SendMessageA(hwnd,CB_GETCOUNT,0,0);
 116 #define CBShowDropDown(hwnd,show) \
 117   SendMessageA(hwnd,CB_SHOWDROPDOWN,(WPARAM)show,0);
 118 #define CBSetItemHeight(hwnd,index,height) \
 119   SendMessageA(hwnd,CB_SETITEMHEIGHT,(WPARAM)index,(LPARAM)height);
 120
 121
 122 const char *FileOpenDlgInfosStr = "FileOpenDlgInfos"; /* windows property description string */
 123 const char *LookInInfosStr = "LookInInfos"; /* LOOKIN combo box property */
 124
 125 static const char defaultFilter[] = "*.*";
 126
 127 /***********************************************************************
 128  * Prototypes
 129  */
 130
 131 /* Internal functions used by the dialog */
 132 static LRESULT FILEDLG95_OnWMInitDialog(HWND hwnd, WPARAM wParam, LPARAM lParam);
 133 static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam);
 134 static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd);
 135        BOOL    FILEDLG95_OnOpen(HWND hwnd);
 136 static LRESULT FILEDLG95_InitUI(HWND hwnd);
 137 static void    FILEDLG95_Clean(HWND hwnd);
 138
 139 /* Functions used by the shell object */
 140 static LRESULT FILEDLG95_SHELL_Init(HWND hwnd);
 141 static BOOL    FILEDLG95_SHELL_UpFolder(HWND hwnd);
 142 static BOOL    FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb);
 143 static void    FILEDLG95_SHELL_Clean(HWND hwnd);
 144
 145 /* Functions used by the filetype combo box */
 146 static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd);
 147 static BOOL    FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode);
 148 static int     FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPCSTR lpstrExt);
 149 static void    FILEDLG95_FILETYPE_Clean(HWND hwnd);
 150
 151 /* Functions used by the Look In combo box */
 152 static HRESULT FILEDLG95_LOOKIN_Init(HWND hwndCombo);
 153 static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct);
 154 static BOOL    FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode);
 155 static int     FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId);
 156 static int     FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod);
 157 static int     FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl);
 158 static int     FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd);
 159        int     FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl);
 160 static void    FILEDLG95_LOOKIN_Clean(HWND hwnd);
 161
 162 /* Miscellaneous tool functions */
 163 HRESULT       GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPSTR lpstrFileName);
 164 HRESULT       GetFileName(HWND hwnd, LPITEMIDLIST pidl, LPSTR lpstrFileName);
 165 IShellFolder* GetShellFolderFromPidl(LPITEMIDLIST pidlAbs);
 166 LPITEMIDLIST  GetParentPidl(LPITEMIDLIST pidl);
 167 LPITEMIDLIST  GetPidlFromName(IShellFolder *psf,LPCSTR lpcstrFileName);
 168
 169 /* Shell memory allocation */
 170 static void *MemAlloc(UINT size);
 171 static void MemFree(void *mem);
 172
 173 BOOL WINAPI GetFileName95(FileOpenDlgInfos *fodInfos);
 174 HRESULT WINAPI FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 175 HRESULT SendCustomDlgNotificationMessage(HWND hwndParentDlg, UINT uCode);
 176 HRESULT FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 177 BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPSTR lpstrFileList, UINT nFileCount, UINT sizeUsed);
 178 static BOOL BrowseSelectedFolder(HWND hwnd);
 179
 180 /***********************************************************************
 181  *      GetFileName95
 182  *
 183  * Creates an Open common dialog box that lets the user select
 184  * the drive, directory, and the name of a file or set of files to open.
 185  *
 186  * IN  : The FileOpenDlgInfos structure associated with the dialog
 187  * OUT : TRUE on success
 188  *       FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
 189  */
 190 BOOL WINAPI GetFileName95(FileOpenDlgInfos *fodInfos)
 191 {
 192
 193     LRESULT lRes;
 194     LPCVOID template;
 195     HRSRC hRes;
 196     HANDLE hDlgTmpl = 0;
 197
 198     /* Create the dialog from a template */
 199
 200     if(!(hRes = FindResourceA(COMMDLG_hInstance32,MAKEINTRESOURCEA(NEWFILEOPENORD),RT_DIALOGA)))
 201     {
 202         COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 203         return FALSE;
 204     }
 205     if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hRes )) ||
 206         !(template = LockResource( hDlgTmpl )))
 207     {
 208         COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 209         return FALSE;
 210     }
 211     lRes = DialogBoxIndirectParamA(COMMDLG_hInstance32,
 212                                   (LPDLGTEMPLATEA) template,
 213                                   fodInfos->ofnInfos->hwndOwner,
 214                                   (DLGPROC) FileOpenDlgProc95,
 215                                   (LPARAM) fodInfos);
 216
 217     /* Unable to create the dialog*/
 218     if( lRes == -1)
 219         return FALSE;
 220
 221     return lRes;
 222 }
 223
 224 /***********************************************************************
 225  *      GetFileDialog95A
 226  *
 227  * Call GetFileName95 with this structure and clean the memory.
 228  *
 229  * IN  : The OPENFILENAMEA initialisation structure passed to
 230  *       GetOpenFileNameA win api function (see filedlg.c)
 231  */
 232 BOOL  WINAPI GetFileDialog95A(LPOPENFILENAMEA ofn,UINT iDlgType)
 233 {
 234
 235   BOOL ret;
 236   FileOpenDlgInfos *fodInfos;
 237   HINSTANCE hInstance;
 238   LPCSTR lpstrInitialDir = NULL;
 239   DWORD dwFlags = 0;
 240
 241   /* Initialise FileOpenDlgInfos structure*/
 242   fodInfos = (FileOpenDlgInfos*)MemAlloc(sizeof(FileOpenDlgInfos));
 243   ZeroMemory(fodInfos, sizeof(FileOpenDlgInfos));
 244
 245   /* Pass in the original ofn */
 246   fodInfos->ofnInfos = ofn;
 247
 248   /* Save original hInstance value */
 249   hInstance = ofn->hInstance;
 250   fodInfos->ofnInfos->hInstance = MapHModuleLS(ofn->hInstance);
 251
 252   dwFlags = ofn->Flags;
 253   ofn->Flags = ofn->Flags|OFN_WINE;
 254
 255   /* Replace the NULL lpstrInitialDir by the current folder */
 256   if(!ofn->lpstrInitialDir)
 257   {
 258     lpstrInitialDir = ofn->lpstrInitialDir;
 259     ofn->lpstrInitialDir = MemAlloc(MAX_PATH);
 260     GetCurrentDirectoryA(MAX_PATH,(LPSTR)ofn->lpstrInitialDir);
 261   }
 262
 263   /* Initialise the dialog property */
 264   fodInfos->DlgInfos.dwDlgProp = 0;
 265   fodInfos->DlgInfos.hwndCustomDlg = (HWND)NULL;
 266
 267   switch(iDlgType)
 268   {
 269     case OPEN_DIALOG :
 270       ret = GetFileName95(fodInfos);
 271       break;
 272     case SAVE_DIALOG :
 273       fodInfos->DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
 274       ret = GetFileName95(fodInfos);
 275       break;
 276     default :
 277       ret = 0;
 278   }
 279
 280   if (lpstrInitialDir)
 281   {
 282     MemFree((LPVOID)(ofn->lpstrInitialDir));
 283     ofn->lpstrInitialDir = lpstrInitialDir;
 284   }
 285
 286   ofn->Flags = dwFlags;
 287   ofn->hInstance = hInstance;
 288   MemFree((LPVOID)(fodInfos));
 289   return ret;
 290 }
 291
 292 /***********************************************************************
 293  *      GetFileDialog95W
 294  *
 295  * Copy the OPENFILENAMEW structure in a FileOpenDlgInfos structure.
 296  * Call GetFileName95 with this structure and clean the memory.
 297  *
 298  * IN  : The OPENFILENAMEW initialisation structure passed to
 299  *       GetOpenFileNameW win api function (see filedlg.c)
 300  *
 301  * FIXME:
 302  *   some more strings are needing to be convertet AtoW
 303  */
 304 BOOL  WINAPI GetFileDialog95W(LPOPENFILENAMEW ofn,UINT iDlgType)
 305 {
 306   BOOL ret;
 307   FileOpenDlgInfos *fodInfos;
 308   HINSTANCE hInstance;
 309   LPCSTR lpstrFilter = NULL;
 310   LPSTR lpstrCustomFilter = NULL;
 311   LPWSTR lpstrFile = NULL;
 312   DWORD dwFlags;
 313
 314   /* Initialise FileOpenDlgInfos structure*/
 315   fodInfos = (FileOpenDlgInfos*)MemAlloc(sizeof(FileOpenDlgInfos));
 316   ZeroMemory(fodInfos, sizeof(FileOpenDlgInfos));
 317
 318   /*  Pass in the original ofn */
 319   fodInfos->ofnInfos = (LPOPENFILENAMEA) ofn;
 320
 321   /* Save hInstance */
 322   hInstance = fodInfos->ofnInfos->hInstance;
 323   fodInfos->ofnInfos->hInstance = MapHModuleLS(ofn->hInstance);
 324
 325   /* Save lpstrFilter */
 326   if (ofn->lpstrFilter)
 327   {
 328     LPWSTR  s;
 329     LPSTR x,y;
 330     int n;
 331
 332     lpstrFilter = fodInfos->ofnInfos->lpstrFilter;
 333
 334     /* filter is a list...  title\0ext\0......\0\0 */
 335     s = (LPWSTR)ofn->lpstrFilter;
 336
 337     while (*s)
 338       s = s+lstrlenW(s)+1;
 339     s++;
 340     n = s - ofn->lpstrFilter; /* already divides by 2. ptr magic */
 341     x = y = (LPSTR)MemAlloc(n);
 342     s = (LPWSTR)ofn->lpstrFilter;
 343     while (*s) {
 344       lstrcpyWtoA(x,s);
 345       x+=lstrlenA(x)+1;
 346       s+=lstrlenW(s)+1;
 347     }
 348     *x=0;
 349     fodInfos->ofnInfos->lpstrFilter = (LPSTR)y;
 350   }
 351   /* Save lpstrCustomFilter */
 352   if (ofn->lpstrCustomFilter)
 353   {
 354     LPWSTR  s;
 355     LPSTR x,y;
 356     int n;
 357
 358     lpstrCustomFilter = fodInfos->ofnInfos->lpstrCustomFilter;
 359     /* filter is a list...  title\0ext\0......\0\0 */
 360     s = (LPWSTR)ofn->lpstrCustomFilter;
 361     while (*s)
 362       s = s+lstrlenW(s)+1;
 363     s++;
 364     n = s - ofn->lpstrCustomFilter;
 365     x = y = (LPSTR)MemAlloc(n);
 366     s = (LPWSTR)ofn->lpstrCustomFilter;
 367     while (*s) {
 368       lstrcpyWtoA(x,s);
 369       x+=lstrlenA(x)+1;
 370       s+=lstrlenW(s)+1;
 371     }
 372     *x=0;
 373     fodInfos->ofnInfos->lpstrCustomFilter = (LPSTR)y;
 374   }
 375
 376   /* Save Flags */
 377   dwFlags = fodInfos->ofnInfos->Flags;
 378   fodInfos->ofnInfos->Flags = ofn->Flags|OFN_WINE|OFN_UNICODE;
 379
 380   /* Initialise the dialog property */
 381   fodInfos->DlgInfos.dwDlgProp = 0;
 382
 383   /* allocate ansi filename buffer */
 384   lpstrFile = ofn->lpstrFile;
 385   ofn->lpstrFile = MemAlloc(ofn->nMaxFile);
 386
 387   switch(iDlgType)
 388   {
 389   case OPEN_DIALOG :
 390       ret = GetFileName95(fodInfos);
 391       break;
 392   case SAVE_DIALOG :
 393       fodInfos->DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
 394       ret = GetFileName95(fodInfos);
 395       break;
 396   default :
 397       ret = 0;
 398   }
 399
 400   /* Cleaning */
 401   /* Restore Flags */
 402   fodInfos->ofnInfos->Flags = dwFlags;
 403
 404   /* Restore lpstrFilter */
 405   if (fodInfos->ofnInfos->lpstrFilter)
 406   {
 407     MemFree((LPVOID)(fodInfos->ofnInfos->lpstrFilter));
 408     fodInfos->ofnInfos->lpstrFilter = lpstrFilter;
 409   }
 410   if (fodInfos->ofnInfos->lpstrCustomFilter)
 411   {
 412     MemFree((LPVOID)(fodInfos->ofnInfos->lpstrCustomFilter));
 413     fodInfos->ofnInfos->lpstrCustomFilter = lpstrCustomFilter;
 414   }
 415
 416   /* Restore hInstance */
 417   fodInfos->ofnInfos->hInstance = hInstance;
 418   MemFree((LPVOID)(fodInfos));
 419
 420   /* filename */
 421   lstrcpynAtoW(lpstrFile, (LPCSTR)ofn->lpstrFile, ofn->nMaxFile);
 422   MemFree(ofn->lpstrFile);
 423   ofn->lpstrFile = lpstrFile;
 424
 425   return ret;
 426 }
 427
 428 void ArrangeCtrlPositions( HWND hwndChildDlg, HWND hwndParentDlg)
 429 {
 430
 431         HWND hwndChild,hwndStc32;
 432         RECT rectParent, rectChild, rectCtrl, rectStc32, rectTemp;
 433         POINT ptMoveCtl;
 434         POINT ptParentClient;
 435
 436         ptMoveCtl.x = ptMoveCtl.y = 0;
 437         hwndStc32=GetDlgItem(hwndChildDlg,stc32);
 438         GetClientRect(hwndParentDlg,&rectParent);
 439         GetClientRect(hwndChildDlg,&rectChild);
 440         if(hwndStc32)
 441         {
 442                 GetWindowRect(hwndStc32,&rectStc32);
 443                 MapWindowPoints(0, hwndChildDlg,(LPPOINT)&rectStc32,2);
 444                 CopyRect(&rectTemp,&rectStc32);
 445
 446                 SetRect(&rectStc32,rectStc32.left,rectStc32.top,rectStc32.left + (rectParent.right-rectParent.left),rectStc32.top+(rectParent.bottom-rectParent.top));
 447                 SetWindowPos(hwndStc32,0,rectStc32.left,rectStc32.top,rectStc32.right-rectStc32.left,rectStc32.bottom-rectStc32.top,SWP_NOMOVE|SWP_NOZORDER | SWP_NOACTIVATE);
 448
 449                 if(rectStc32.right < rectTemp.right)
 450                 {
 451                         ptParentClient.x = max((rectParent.right-rectParent.left),(rectChild.right-rectChild.left));
 452                         ptMoveCtl.x = 0;
 453                 }
 454                 else
 455                 {
 456                         ptMoveCtl.x = (rectStc32.right - rectTemp.right);
 457                         ptParentClient.x = max((rectParent.right-rectParent.left),((rectChild.right-rectChild.left)+rectStc32.right-rectTemp.right));
 458                 }
 459                 if(rectStc32.bottom < rectTemp.bottom)
 460                 {
 461                         ptParentClient.y = max((rectParent.bottom-rectParent.top),(rectChild.bottom-rectChild.top));
 462                         ptMoveCtl.y = 0;
 463                 }
 464                 else
 465                 {
 466                         ptMoveCtl.y = (rectStc32.bottom - rectTemp.bottom);
 467                         ptParentClient.y = max((rectParent.bottom-rectParent.top),((rectChild.bottom-rectChild.top)+rectStc32.bottom-rectTemp.bottom));
 468                 }
 469         }
 470         else
 471         {
 472                 if( (GetWindow(hwndChildDlg,GW_CHILD)) == (HWND) NULL)
 473                    return;
 474                 SetRectEmpty(&rectTemp);
 475                 ptParentClient.x = max((rectParent.right-rectParent.left),(rectChild.right-rectChild.left));
 476                 ptParentClient.y = (rectParent.bottom-rectParent.top) + (rectChild.bottom-rectChild.top);
 477                 ptMoveCtl.y = rectParent.bottom-rectParent.top;
 478                 ptMoveCtl.x=0;
 479         }
 480         SetRect(&rectParent,rectParent.left,rectParent.top,rectParent.left+ptParentClient.x,rectParent.top+ptParentClient.y);
 481         AdjustWindowRectEx( &rectParent,GetWindowLongA(hwndParentDlg,GWL_STYLE),FALSE,GetWindowLongA(hwndParentDlg,GWL_EXSTYLE));
 482
 483         SetWindowPos(hwndChildDlg, 0, 0,0, ptParentClient.x,ptParentClient.y,
 484                  SWP_NOZORDER );
 485         SetWindowPos(hwndParentDlg, 0, rectParent.left,rectParent.top, (rectParent.right- rectParent.left),
 486                 (rectParent.bottom-rectParent.top),SWP_NOMOVE | SWP_NOZORDER);
 487
 488         hwndChild = GetWindow(hwndChildDlg,GW_CHILD);
 489         if(hwndStc32)
 490         {
 491                 GetWindowRect(hwndStc32,&rectStc32);
 492                 MapWindowPoints( 0, hwndChildDlg,(LPPOINT)&rectStc32,2);
 493         }
 494         else
 495                 SetRect(&rectStc32,0,0,0,0);
 496
 497         if (hwndChild )
 498         {
 499                 do
 500                 {
 501                         if(hwndChild != hwndStc32)
 502                         {
 503                         if (GetWindowLongA( hwndChild, GWL_STYLE ) & WS_MAXIMIZE)
 504                                 continue;
 505                         GetWindowRect(hwndChild,&rectCtrl);
 506                         MapWindowPoints( 0, hwndParentDlg,(LPPOINT)&rectCtrl,2);
 507
 508                                 /*
 509                                    Check the initial position of the controls relative to the initial
 510                                    position and size of stc32 (before it is expanded).
 511                                 */
 512                 if (rectCtrl.left >= rectTemp.right && rectCtrl.top >= rectTemp.bottom)
 513                                 {
 514                                         rectCtrl.left += ptMoveCtl.x;
 515                                 rectCtrl.top  += ptMoveCtl.y;
 516                                 }
 517                                 else if (rectCtrl.left >= rectTemp.right)
 518                                         rectCtrl.left += ptMoveCtl.x;
 519                                 else if (rectCtrl.top >= rectTemp.bottom)
 520                                         rectCtrl.top  += ptMoveCtl.y;
 521
 522                                 SetWindowPos( hwndChild, 0, rectCtrl.left, rectCtrl.top,
 523                                 rectCtrl.right-rectCtrl.left,rectCtrl.bottom-rectCtrl.top,
 524                                 SWP_NOSIZE | SWP_NOZORDER );
 525                                 }
 526                         }
 527                 while ((hwndChild=GetWindow( hwndChild, GW_HWNDNEXT )) != (HWND)NULL);
 528         }
 529         hwndChild = GetWindow(hwndParentDlg,GW_CHILD);
 530
 531         if(hwndStc32)
 532         {
 533                 GetWindowRect(hwndStc32,&rectStc32);
 534                 MapWindowPoints( 0, hwndChildDlg,(LPPOINT)&rectStc32,2);
 535                 ptMoveCtl.x = rectStc32.left - 0;
 536                 ptMoveCtl.y = rectStc32.top - 0;
 537                 if (hwndChild )
 538                 {
 539                         do
 540                         {
 541                                 if(hwndChild != hwndChildDlg)
 542                                 {
 543
 544                                         if (GetWindowLongA( hwndChild, GWL_STYLE ) & WS_MAXIMIZE)
 545                                                 continue;
 546                                         GetWindowRect(hwndChild,&rectCtrl);
 547                                         MapWindowPoints( 0, hwndParentDlg,(LPPOINT)&rectCtrl,2);
 548
 549                                         rectCtrl.left += ptMoveCtl.x;
 550                                         rectCtrl.top += ptMoveCtl.y;
 551
 552                                         SetWindowPos( hwndChild, 0, rectCtrl.left, rectCtrl.top,
 553                                         rectCtrl.right-rectCtrl.left,rectCtrl.bottom-rectCtrl.top,
 554                                         SWP_NOSIZE |SWP_NOZORDER );
 555                                 }
 556                         }
 557                         while ((hwndChild=GetWindow( hwndChild, GW_HWNDNEXT )) != (HWND)NULL);
 558                 }
 559         }
 560
 561 }
 562
 563
 564 HRESULT WINAPI FileOpenDlgProcUserTemplate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 565 {
 566     FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(GetParent(hwnd),FileOpenDlgInfosStr);
 567   switch(uMsg)
 568   {
 569         case WM_INITDIALOG:
 570         {
 571             fodInfos = (FileOpenDlgInfos *)lParam;
 572                 lParam = (LPARAM) fodInfos->ofnInfos;
 573                 ArrangeCtrlPositions(hwnd,GetParent(hwnd));
 574             if(fodInfos && (fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK) && fodInfos->ofnInfos->lpfnHook)
 575                  return CallWindowProcA((WNDPROC)fodInfos->ofnInfos->lpfnHook,hwnd,uMsg,wParam,lParam);
 576                 return 0;
 577         }
 578     }
 579     if(fodInfos && (fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK) && fodInfos->ofnInfos->lpfnHook )
 580         return CallWindowProcA((WNDPROC)fodInfos->ofnInfos->lpfnHook,hwnd,uMsg,wParam,lParam);
 581   return DefWindowProcA(hwnd,uMsg,wParam,lParam);
 582 }
 583
 584 HWND CreateTemplateDialog(FileOpenDlgInfos *fodInfos,HWND hwnd)
 585 {
 586     LPCVOID template;
 587     HRSRC hRes;
 588     HANDLE hDlgTmpl = 0;
 589     HWND hChildDlg = 0;
 590    if (fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATE || fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATEHANDLE)
 591    {
 592         if (fodInfos->ofnInfos->Flags  & OFN_ENABLETEMPLATEHANDLE)
 593         {
 594            if( !(template = LockResource( fodInfos->ofnInfos->hInstance)))
 595                 {
 596                 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 597                 return (HWND)NULL;
 598                 }
 599
 600         }
 601         else
 602         {
 603          if (!(hRes = FindResourceA(MapHModuleSL(fodInfos->ofnInfos->hInstance),
 604             (fodInfos->ofnInfos->lpTemplateName), RT_DIALOGA)))
 605         {
 606                 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 607                  return (HWND)NULL;
 608         }
 609         if (!(hDlgTmpl = LoadResource( MapHModuleSL(fodInfos->ofnInfos->hInstance),
 610              hRes )) ||
 611                  !(template = LockResource( hDlgTmpl )))
 612         {
 613                 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 614                 return (HWND)NULL;
 615         }
 616         }
 617
 618         hChildDlg= CreateDialogIndirectParamA(fodInfos->ofnInfos->hInstance,template,hwnd,(DLGPROC)FileOpenDlgProcUserTemplate,(LPARAM)fodInfos);
 619         if(hChildDlg)
 620         {
 621                 ShowWindow(hChildDlg,SW_SHOW);
 622                 return hChildDlg;
 623         }
 624  }
 625  else if(fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK && fodInfos->ofnInfos->lpfnHook)
 626  {
 627         RECT rectHwnd;
 628         DLGTEMPLATE tmplate;
 629         GetClientRect(hwnd,&rectHwnd);
 630         tmplate.style = WS_CHILD | WS_CLIPSIBLINGS;
 631         tmplate.dwExtendedStyle = 0;
 632         tmplate.cdit = 0;
 633         tmplate.x = 0;
 634         tmplate.y = 0;
 635         tmplate.cx = rectHwnd.right-rectHwnd.left;
 636         tmplate.cy = rectHwnd.bottom-rectHwnd.top;
 637
 638         return CreateDialogIndirectParamA(fodInfos->ofnInfos->hInstance,&tmplate,hwnd,(DLGPROC)FileOpenDlgProcUserTemplate,(LPARAM)fodInfos);
 639  }
 640 return (HWND)NULL;
 641 }
 642
 643 /***********************************************************************
 644 *          SendCustomDlgNotificationMessage
 645 *
 646 * Send CustomDialogNotification (CDN_FIRST -- CDN_LAST) message to the custom template dialog
 647 */
 648
 649 HRESULT SendCustomDlgNotificationMessage(HWND hwndParentDlg, UINT uCode)
 650 {
 651     FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwndParentDlg,FileOpenDlgInfosStr);
 652     if(!fodInfos)
 653         return 0;
 654     if(fodInfos->DlgInfos.hwndCustomDlg)
 655     {
 656         OFNOTIFYA ofnNotify;
 657         ofnNotify.hdr.hwndFrom=hwndParentDlg;
 658         ofnNotify.hdr.idFrom=0;
 659         ofnNotify.hdr.code = uCode;
 660         ofnNotify.lpOFN = fodInfos->ofnInfos;
 661         return SendMessageA(fodInfos->DlgInfos.hwndCustomDlg,WM_NOTIFY,0,(LPARAM)&ofnNotify);
 662     }
 663     return TRUE;
 664 }
 665
 666 /***********************************************************************
 667 *         FILEDLG95_HandleCustomDialogMessages
 668 *
 669 * Handle Custom Dialog Messages (CDM_FIRST -- CDM_LAST) messages
 670 */
 671 HRESULT FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 672 {
 673     LPSTR lpstrFileSpec;
 674     int reqSize;
 675     char lpstrPath[MAX_PATH];
 676     FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
 677     if(!fodInfos) return -1;
 678
 679     switch(uMsg)
 680     {
 681         case CDM_GETFILEPATH:
 682             GetDlgItemTextA(hwnd,IDC_FILENAME,lpstrPath, sizeof(lpstrPath));
 683             lpstrFileSpec = (LPSTR)COMDLG32_PathFindFileNameA(lpstrPath);
 684             if (lpstrFileSpec==lpstrPath)
 685             {
 686                 char lpstrCurrentDir[MAX_PATH];
 687                 /* Prepend the current path */
 688                 COMDLG32_SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent,lpstrCurrentDir);
 689                 if ((LPSTR)lParam!=NULL)
 690                     wsnprintfA((LPSTR)lParam,(int)wParam,"%s\\%s",lpstrCurrentDir,lpstrPath);
 691                 reqSize=strlen(lpstrCurrentDir)+1+strlen(lpstrPath)+1;
 692             }
 693             else
 694             {
 695                 lstrcpynA((LPSTR)lParam,(LPSTR)lpstrPath,(int)wParam);
 696                 reqSize=strlen(lpstrPath);
 697             }
 698             /* return the required buffer size */
 699             return reqSize;
 700
 701         case CDM_GETFOLDERPATH:
 702             COMDLG32_SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent,lpstrPath);
 703             if ((LPSTR)lParam!=NULL)
 704                 lstrcpynA((LPSTR)lParam,lpstrPath,(int)wParam);
 705             return strlen(lpstrPath);
 706
 707         case CDM_GETSPEC:
 708             reqSize=GetDlgItemTextA(hwnd,IDC_FILENAME,lpstrPath, sizeof(lpstrPath));
 709             lpstrFileSpec = (LPSTR)COMDLG32_PathFindFileNameA(lpstrPath);
 710             if ((LPSTR)lParam!=NULL)
 711                 lstrcpynA((LPSTR)lParam, lpstrFileSpec, (int)wParam);
 712             return strlen(lpstrFileSpec);
 713
 714         case CDM_SETCONTROLTEXT:
 715             if ( 0 != lParam )
 716                 SetDlgItemTextA( hwnd, (UINT) wParam, (LPSTR) lParam );
 717             return TRUE;
 718
 719         case CDM_HIDECONTROL:
 720         case CDM_SETDEFEXT:
 721             FIXME("CDM_HIDECONTROL,CDM_SETCONTROLTEXT,CDM_SETDEFEXT not implemented\n");
 722             return -1;
 723     }
 724     return TRUE;
 725 }
 726
 727 /***********************************************************************
 728  *          FileOpenDlgProc95
 729  *
 730  * File open dialog procedure
 731  */
 732 HRESULT WINAPI FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 733 {
 734   switch(uMsg)
 735   {
 736     case WM_INITDIALOG :
 737          /* Adds the FileOpenDlgInfos in the property list of the dialog
 738             so it will be easily accessible through a GetPropA(...) */
 739          SetPropA(hwnd, FileOpenDlgInfosStr, (HANDLE) lParam);
 740
 741          FILEDLG95_OnWMInitDialog(hwnd, wParam, lParam);
 742          ((FileOpenDlgInfos *)lParam)->DlgInfos.hwndCustomDlg =
 743         CreateTemplateDialog((FileOpenDlgInfos *)lParam,hwnd);
 744          SendCustomDlgNotificationMessage(hwnd,CDN_INITDONE);
 745          return 0;
 746     case WM_COMMAND:
 747       return FILEDLG95_OnWMCommand(hwnd, wParam, lParam);
 748     case WM_DRAWITEM:
 749       {
 750         switch(((LPDRAWITEMSTRUCT)lParam)->CtlID)
 751         {
 752         case IDC_LOOKIN:
 753           FILEDLG95_LOOKIN_DrawItem((LPDRAWITEMSTRUCT) lParam);
 754           return TRUE;
 755         }
 756       }
 757       return FALSE;
 758
 759     case WM_GETISHELLBROWSER:
 760       return FILEDLG95_OnWMGetIShellBrowser(hwnd);
 761
 762   case WM_DESTROY:
 763       RemovePropA(hwnd, FileOpenDlgInfosStr);
 764         return FALSE;
 765
 766     case WM_NOTIFY:
 767     {
 768         LPNMHDR lpnmh = (LPNMHDR)lParam;
 769         UINT stringId = -1;
 770
 771         /* set up the button tooltips strings */
 772         if(TTN_GETDISPINFOA == lpnmh->code )
 773         {
 774             LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
 775             switch(lpnmh->idFrom )
 776             {
 777                 /* Up folder button */
 778                 case FCIDM_TB_UPFOLDER:
 779                     stringId = IDS_UPFOLDER;
 780                     break;
 781                 /* New folder button */
 782                 case FCIDM_TB_NEWFOLDER:
 783                     stringId = IDS_NEWFOLDER;
 784                     break;
 785                 /* List option button */
 786                 case FCIDM_TB_SMALLICON:
 787                     stringId = IDS_LISTVIEW;
 788                     break;
 789                 /* Details option button */
 790                 case FCIDM_TB_REPORTVIEW:
 791                     stringId = IDS_REPORTVIEW;
 792                     break;
 793             }
 794             lpdi->hinst = COMMDLG_hInstance32;
 795             lpdi->lpszText =  (LPSTR) stringId;
 796         }
 797         return FALSE;
 798     }
 799     default :
 800       if(uMsg >= CDM_FIRST && uMsg <= CDM_LAST)
 801         return FILEDLG95_HandleCustomDialogMessages(hwnd, uMsg, wParam, lParam);
 802       return FALSE;
 803   }
 804 }
 805
 806 /***********************************************************************
 807  *      FILEDLG95_OnWMInitDialog
 808  *
 809  * WM_INITDIALOG message handler
 810  */
 811 static LRESULT FILEDLG95_OnWMInitDialog(HWND hwnd, WPARAM wParam, LPARAM lParam)
 812 {
 813   LPITEMIDLIST pidlItemId;
 814   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) lParam;
 815
 816   TRACE("\n");
 817
 818   /* Initialise shell objects */
 819   FILEDLG95_SHELL_Init(hwnd);
 820
 821   /* Initialise dialog UI */
 822   FILEDLG95_InitUI(hwnd);
 823
 824   /* Initialize the Look In combo box*/
 825   FILEDLG95_LOOKIN_Init(fodInfos->DlgInfos.hwndLookInCB);
 826
 827   /* Initialize the filter combo box */
 828   FILEDLG95_FILETYPE_Init(hwnd);
 829
 830   /* Get the initial directory pidl */
 831
 832   if(!(pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder,fodInfos->ofnInfos->lpstrInitialDir)))
 833   {
 834     char path[MAX_PATH];
 835
 836     GetCurrentDirectoryA(MAX_PATH,path);
 837     pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder,
 838                      path);
 839
 840   }
 841
 842   /* Browse to the initial directory */
 843   IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,pidlItemId, SBSP_ABSOLUTE);
 844
 845   /* Free pidlItem memory */
 846   COMDLG32_SHFree(pidlItemId);
 847
 848   return TRUE;
 849 }
 850 /***********************************************************************
 851  *      FILEDLG95_Clean
 852  *
 853  * Regroups all the cleaning functions of the filedlg
 854  */
 855 void FILEDLG95_Clean(HWND hwnd)
 856 {
 857       FILEDLG95_FILETYPE_Clean(hwnd);
 858       FILEDLG95_LOOKIN_Clean(hwnd);
 859       FILEDLG95_SHELL_Clean(hwnd);
 860 }
 861 /***********************************************************************
 862  *      FILEDLG95_OnWMCommand
 863  *
 864  * WM_COMMAND message handler
 865  */
 866 static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
 867 {
 868   WORD wNotifyCode = HIWORD(wParam); /* notification code */
 869   WORD wID = LOWORD(wParam);         /* item, control, or accelerator identifier */
 870   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
 871
 872   switch(wID)
 873   {
 874     /* OK button */
 875   case IDOK:
 876       if(FILEDLG95_OnOpen(hwnd))
 877         SendCustomDlgNotificationMessage(hwnd,CDN_FILEOK);
 878     break;
 879     /* Cancel button */
 880   case IDCANCEL:
 881       FILEDLG95_Clean(hwnd);
 882       EndDialog(hwnd, FALSE);
 883     break;
 884     /* Filetype combo box */
 885   case IDC_FILETYPE:
 886     FILEDLG95_FILETYPE_OnCommand(hwnd,wNotifyCode);
 887     break;
 888     /* LookIn combo box */
 889   case IDC_LOOKIN:
 890     FILEDLG95_LOOKIN_OnCommand(hwnd,wNotifyCode);
 891     break;
 892
 893   /* --- toolbar --- */
 894     /* Up folder button */
 895   case FCIDM_TB_UPFOLDER:
 896     FILEDLG95_SHELL_UpFolder(hwnd);
 897     break;
 898     /* New folder button */
 899   case FCIDM_TB_NEWFOLDER:
 900     FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_NEWFOLDER);
 901     break;
 902     /* List option button */
 903   case FCIDM_TB_SMALLICON:
 904     FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWLIST);
 905     break;
 906     /* Details option button */
 907   case FCIDM_TB_REPORTVIEW:
 908     FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWDETAILS);
 909     break;
 910
 911   case IDC_FILENAME:
 912     break;
 913
 914   }
 915   /* Do not use the listview selection anymore */
 916   fodInfos->DlgInfos.dwDlgProp &= ~FODPROP_USEVIEW;
 917   return 0;
 918 }
 919
 920 /***********************************************************************
 921  *      FILEDLG95_OnWMGetIShellBrowser
 922  *
 923  * WM_GETISHELLBROWSER message handler
 924  */
 925 static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd)
 926 {
 927
 928   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
 929
 930   TRACE("\n");
 931
 932   SetWindowLongA(hwnd,DWL_MSGRESULT,(LONG)fodInfos->Shell.FOIShellBrowser);
 933
 934   return TRUE;
 935 }
 936
 937
 938 /***********************************************************************
 939  *      FILEDLG95_InitUI
 940  *
 941  */
 942 static LRESULT FILEDLG95_InitUI(HWND hwnd)
 943 {
 944   TBBUTTON tbb[] =
 945   {{VIEW_PARENTFOLDER, FCIDM_TB_UPFOLDER,   TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
 946    {0,                 0,                   TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
 947    {VIEW_NEWFOLDER,    FCIDM_TB_NEWFOLDER,  TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
 948    {0,                 0,                   TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
 949    {VIEW_LIST,         FCIDM_TB_SMALLICON,  TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
 950    {VIEW_DETAILS,      FCIDM_TB_REPORTVIEW, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
 951   };
 952   TBADDBITMAP tba = { HINST_COMMCTRL, IDB_VIEW_SMALL_COLOR };
 953   RECT rectTB;
 954
 955   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
 956
 957   TRACE("%p\n", fodInfos);
 958
 959   /* Get the hwnd of the controls */
 960   fodInfos->DlgInfos.hwndFileName = GetDlgItem(hwnd,IDC_FILENAME);
 961   fodInfos->DlgInfos.hwndFileTypeCB = GetDlgItem(hwnd,IDC_FILETYPE);
 962   fodInfos->DlgInfos.hwndLookInCB = GetDlgItem(hwnd,IDC_LOOKIN);
 963
 964   /* construct the toolbar */
 965   GetWindowRect(GetDlgItem(hwnd,IDC_TOOLBARSTATIC),&rectTB);
 966   MapWindowPoints( 0, hwnd,(LPPOINT)&rectTB,2);
 967
 968   fodInfos->DlgInfos.hwndTB = CreateWindowExA(0, TOOLBARCLASSNAMEA, (LPSTR) NULL,
 969         WS_CHILD | WS_GROUP | TBSTYLE_TOOLTIPS | CCS_NODIVIDER | CCS_NORESIZE,
 970         0, 0, 150, 26,
 971         hwnd, (HMENU) IDC_TOOLBAR, COMMDLG_hInstance32, NULL);
 972
 973   SetWindowPos(fodInfos->DlgInfos.hwndTB, 0,
 974         rectTB.left,rectTB.top, rectTB.right-rectTB.left, rectTB.bottom-rectTB.top,
 975         SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOZORDER );
 976
 977   SendMessageA(fodInfos->DlgInfos.hwndTB, TB_BUTTONSTRUCTSIZE, (WPARAM) sizeof(TBBUTTON), 0);
 978
 979 /* fixme: use TB_LOADIMAGES when implemented */
 980 /*  SendMessageA(fodInfos->DlgInfos.hwndTB, TB_LOADIMAGES, (WPARAM) IDB_VIEW_SMALL_COLOR, HINST_COMMCTRL);*/
 981   SendMessageA(fodInfos->DlgInfos.hwndTB, TB_ADDBITMAP, (WPARAM) 12, (LPARAM) &tba);
 982
 983   SendMessageA(fodInfos->DlgInfos.hwndTB, TB_ADDBUTTONSA, (WPARAM) 6,(LPARAM) &tbb);
 984   SendMessageA(fodInfos->DlgInfos.hwndTB, TB_AUTOSIZE, 0, 0);
 985
 986   /* Set the window text with the text specified in the OPENFILENAME structure */
 987   if(fodInfos->ofnInfos->lpstrTitle)
 988   {
 989       SetWindowTextA(hwnd,fodInfos->ofnInfos->lpstrTitle);
 990   }
 991   else if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
 992   {
 993       SetWindowTextA(hwnd,"Save");
 994   }
 995
 996   /* Initialise the file name edit control */
 997   if(fodInfos->ofnInfos->lpstrFile)
 998   {
 999       SetDlgItemTextA(hwnd,IDC_FILENAME,fodInfos->ofnInfos->lpstrFile);
1000   }
1001
1002   /* Must the open as read only check box be checked ?*/
1003   if(fodInfos->ofnInfos->Flags & OFN_READONLY)
1004   {
1005     SendDlgItemMessageA(hwnd,IDC_OPENREADONLY,BM_SETCHECK,(WPARAM)TRUE,0);
1006   }
1007
1008   /* Must the open as read only check box be hid ?*/
1009   if(fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY)
1010   {
1011     ShowWindow(GetDlgItem(hwnd,IDC_OPENREADONLY),SW_HIDE);
1012   }
1013
1014   /* Must the help button be hid ?*/
1015   if (!(fodInfos->ofnInfos->Flags & OFN_SHOWHELP))
1016   {
1017     ShowWindow(GetDlgItem(hwnd, pshHelp), SW_HIDE);
1018   }
1019
1020   /* Resize the height, if open as read only checkbox ad help button
1021      are hidden */
1022   if ( (fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY) &&
1023        (!(fodInfos->ofnInfos->Flags & OFN_SHOWHELP)) )
1024   {
1025     RECT rectDlg, rectHelp, rectCancel;
1026     GetWindowRect(hwnd, &rectDlg);
1027     GetWindowRect(GetDlgItem(hwnd, pshHelp), &rectHelp);
1028     GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rectCancel);
1029     /* subtract the height of the help button plus the space between
1030        the help button and the cancel button to the height of the dialog */
1031     SetWindowPos(hwnd, 0, 0, 0, rectDlg.right-rectDlg.left,
1032                  (rectDlg.bottom-rectDlg.top) - (rectHelp.bottom - rectCancel.bottom),
1033                  SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
1034   }
1035
1036   /* change Open to Save FIXME: use resources */
1037   if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
1038   {
1039       SetDlgItemTextA(hwnd,IDOK,"Save");
1040       SetDlgItemTextA(hwnd,IDC_LOOKINSTATIC,"Save &in");
1041   }
1042   return 0;
1043 }
1044
1045 /***********************************************************************
1046  *      FILEDLG95_OnOpenMultipleFiles
1047  *
1048  * Handles the opening of multiple files.
1049  *
1050  * FIXME
1051  *  check destination buffer size
1052  */
1053 BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPSTR lpstrFileList, UINT nFileCount, UINT sizeUsed)
1054 {
1055   CHAR   lpstrPathSpec[MAX_PATH] = "";
1056   LPSTR  lpstrFile;
1057   UINT   nCount, nSizePath;
1058   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1059
1060   TRACE("\n");
1061
1062   lpstrFile = fodInfos->ofnInfos->lpstrFile;
1063   lpstrFile[0] = '\0';
1064
1065   COMDLG32_SHGetPathFromIDListA( fodInfos->ShellInfos.pidlAbsCurrent, lpstrPathSpec );
1066
1067   if ( !(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE) &&
1068       ( fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST))
1069   {
1070     LPSTR lpstrTemp = lpstrFileList;
1071
1072     for ( nCount = 0; nCount < nFileCount; nCount++ )
1073     {
1074       LPITEMIDLIST pidl;
1075
1076       pidl = GetPidlFromName(fodInfos->Shell.FOIShellFolder, lpstrTemp);
1077       if (!pidl)
1078       {
1079         CHAR lpstrNotFound[100];
1080         CHAR lpstrMsg[100];
1081         CHAR tmp[400];
1082
1083         LoadStringA(COMMDLG_hInstance32, IDS_FILENOTFOUND, lpstrNotFound, 100);
1084         LoadStringA(COMMDLG_hInstance32, IDS_VERIFYFILE, lpstrMsg, 100);
1085
1086         strcpy(tmp, lpstrTemp);
1087         strcat(tmp, "\n");
1088         strcat(tmp, lpstrNotFound);
1089         strcat(tmp, "\n");
1090         strcat(tmp, lpstrMsg);
1091
1092         MessageBoxA(hwnd, tmp, fodInfos->ofnInfos->lpstrTitle, MB_OK | MB_ICONEXCLAMATION);
1093         return FALSE;
1094       }
1095
1096       lpstrTemp += strlen(lpstrFileList) + 1;
1097       COMDLG32_SHFree(pidl);
1098     }
1099   }
1100
1101   nSizePath = lstrlenA(lpstrPathSpec);
1102   lstrcpyA( lpstrFile, lpstrPathSpec);
1103   memcpy( lpstrFile + nSizePath + 1, lpstrFileList, sizeUsed );
1104
1105   fodInfos->ofnInfos->nFileOffset = nSizePath + 1;
1106   fodInfos->ofnInfos->nFileExtension = 0;
1107
1108   /* clean and exit */
1109   FILEDLG95_Clean(hwnd);
1110   return EndDialog(hwnd,TRUE);
1111 }
1112
1113 /***********************************************************************
1114  *      FILEDLG95_OnOpen
1115  *
1116  * Ok button WM_COMMAND message handler
1117  *
1118  * If the function succeeds, the return value is nonzero.
1119  */
1120 #define ONOPEN_BROWSE 1
1121 #define ONOPEN_OPEN   2
1122 #define ONOPEN_SEARCH 3
1123 static void FILEDLG95_OnOpenMessage(HWND hwnd, int idCaption, int idText)
1124 {
1125   char strMsgTitle[MAX_PATH];
1126   char strMsgText [MAX_PATH];
1127   if (idCaption)
1128     LoadStringA(COMDLG32_hInstance, idCaption, strMsgTitle, sizeof(strMsgTitle));
1129   else
1130     strMsgTitle[0] = '\0';
1131   LoadStringA(COMDLG32_hInstance, idText, strMsgText, sizeof(strMsgText));
1132   MessageBoxA(hwnd,strMsgText, strMsgTitle, MB_OK | MB_ICONHAND);
1133 }
1134
1135 BOOL FILEDLG95_OnOpen(HWND hwnd)
1136 {
1137   char * lpstrFileList;
1138   UINT nFileCount = 0;
1139   UINT sizeUsed = 0;
1140   BOOL ret = TRUE;
1141   char lpstrPathAndFile[MAX_PATH];
1142   char lpstrTemp[MAX_PATH];
1143   LPSHELLFOLDER lpsf = NULL;
1144   int nOpenAction;
1145   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1146
1147
1148   TRACE("hwnd=0x%04x\n", hwnd);
1149
1150   /* get the files from the edit control */
1151   nFileCount = FILEDLG95_FILENAME_GetFileNames(hwnd, &lpstrFileList, &sizeUsed);
1152
1153   /* try if the user selected a folder in the shellview */
1154   if(nFileCount == 0)
1155   {
1156     if (BrowseSelectedFolder(hwnd))
1157       return FALSE;
1158   }
1159
1160   if(nFileCount > 1)
1161   {
1162       ret = FILEDLG95_OnOpenMultipleFiles(hwnd, lpstrFileList, nFileCount, sizeUsed);
1163       goto ret;
1164   }
1165
1166   TRACE("count=%u len=%u file=%s\n", nFileCount, sizeUsed, lpstrFileList);
1167
1168 /*
1169   Step 1:  Build a complete path name from the current folder and
1170   the filename or path in the edit box.
1171   Special cases:
1172   - the path in the edit box is a root path
1173     (with or without drive letter)
1174   - the edit box contains ".." (or a path with ".." in it)
1175 */
1176
1177   /* Get the current directory name */
1178   if (!COMDLG32_SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent, lpstrPathAndFile))
1179   {
1180     /* we are in a special folder, default to desktop */
1181     COMDLG32_SHGetSpecialFolderPathA(hwnd, lpstrPathAndFile, CSIDL_DESKTOPDIRECTORY, FALSE);
1182     FIXME("special folder not handled, use desktop\n");
1183   }
1184   COMDLG32_PathAddBackslashA(lpstrPathAndFile);
1185
1186   TRACE("current directory=%s\n", lpstrPathAndFile);
1187
1188   /* if the user specifyed a fully qualified path use it */
1189   if(COMDLG32_PathIsRelativeA(lpstrFileList))
1190   {
1191     strcat(lpstrPathAndFile, lpstrFileList);
1192   }
1193   else
1194   {
1195     /* does the path have a drive letter? */
1196     if (COMDLG32_PathGetDriveNumberA(lpstrFileList) == -1)
1197       strcpy(lpstrPathAndFile+2, lpstrFileList);
1198     else
1199       strcpy(lpstrPathAndFile, lpstrFileList);
1200   }
1201
1202   /* resolve "." and ".." */
1203   COMDLG32_PathCanonicalizeA(lpstrTemp, lpstrPathAndFile );
1204   strcpy(lpstrPathAndFile, lpstrTemp);
1205   TRACE("canon=%s\n", lpstrPathAndFile);
1206
1207   MemFree(lpstrFileList);
1208
1209 /*
1210   Step 2: here we have a cleaned up path
1211
1212   We have to parse the path step by step to see if we have to browse
1213   to a folder if the path points to a directory or the last
1214   valid element is a directory.
1215
1216   valid variables:
1217     lpstrPathAndFile: cleaned up path
1218  */
1219
1220   nOpenAction = ONOPEN_BROWSE;
1221
1222   /* dont apply any checks with OFN_NOVALIDATE */
1223   if(!(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE))
1224   {
1225     LPSTR lpszTemp, lpszTemp1;
1226     LPITEMIDLIST pidl = NULL;
1227
1228     /* check for invalid chars */
1229     if(strpbrk(lpstrPathAndFile+3, "/:<>|") != NULL)
1230     {
1231       FILEDLG95_OnOpenMessage(hwnd, IDS_INVALID_FILENAME_TITLE, IDS_INVALID_FILENAME);
1232       ret = FALSE;
1233       goto ret;
1234     }
1235
1236     if (FAILED (COMDLG32_SHGetDesktopFolder(&lpsf))) return FALSE;
1237
1238     lpszTemp1 = lpszTemp = lpstrPathAndFile;
1239     while (lpszTemp1)
1240     {
1241       LPSHELLFOLDER lpsfChild;
1242       WCHAR lpwstrTemp[MAX_PATH];
1243       DWORD dwEaten, dwAttributes;
1244
1245       if ((lpszTemp = COMDLG32_PathFindNextComponentA(lpszTemp)))
1246         lstrcpynAtoW(lpwstrTemp, lpszTemp1, lpszTemp - lpszTemp1);
1247       else
1248       {
1249         lstrcpyAtoW(lpwstrTemp, lpszTemp1);     /* last element */
1250         if(strpbrk(lpszTemp1, "*?") != NULL)
1251         {
1252           nOpenAction = ONOPEN_SEARCH;
1253           break;
1254         }
1255       }
1256       lpszTemp1 = lpszTemp;
1257
1258       TRACE("parse now=%s next=%s sf=%p\n",debugstr_w(lpwstrTemp), debugstr_a(lpszTemp), lpsf);
1259
1260       if(lstrlenW(lpwstrTemp)==2) COMDLG32_PathAddBackslashW(lpwstrTemp);
1261
1262       dwAttributes = SFGAO_FOLDER;
1263       if(FAILED(IShellFolder_ParseDisplayName(lpsf, hwnd, NULL, lpwstrTemp, &dwEaten, &pidl, &dwAttributes)))
1264       {
1265         if(lpszTemp)    /* is null for last path element */
1266         {
1267           if(fodInfos->ofnInfos->Flags & OFN_PATHMUSTEXIST)
1268           {
1269             FILEDLG95_OnOpenMessage(hwnd, 0, IDS_PATHNOTEXISTING);
1270             break;
1271           }
1272         }
1273         else
1274         {
1275           if(fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST)
1276           {
1277             FILEDLG95_OnOpenMessage(hwnd, 0, IDS_FILENOTEXISTING);
1278             break;
1279           }
1280         }
1281         /* change to the current folder */
1282         nOpenAction = ONOPEN_OPEN;
1283         break;
1284       }
1285       else
1286       {
1287         /* the path component is valid */
1288         TRACE("parse OK attr=0x%08lx pidl=%p\n", dwAttributes, pidl);
1289         if(dwAttributes & SFGAO_FOLDER)
1290         {
1291           if(FAILED(IShellFolder_BindToObject(lpsf, pidl, 0, &IID_IShellFolder, (LPVOID*)&lpsfChild)))
1292           {
1293             ERR("bind to failed\n"); /* should not fail */
1294             break;
1295           }
1296           IShellFolder_Release(lpsf);
1297           lpsf = lpsfChild;
1298           lpsfChild = NULL;
1299         }
1300         else
1301         {
1302           TRACE("value\n");
1303
1304           /* end dialog, return value */
1305           nOpenAction = ONOPEN_OPEN;
1306           break;
1307         }
1308         COMDLG32_SHFree(pidl);
1309         pidl = NULL;
1310       }
1311     }
1312     if(pidl) COMDLG32_SHFree(pidl);
1313   }
1314
1315   /* path is valid, clean the edit box */
1316   SetDlgItemTextA(hwnd,IDC_FILENAME,"");
1317
1318 /*
1319   Step 3: here we have a cleaned up and validated path
1320
1321   valid variables:
1322    lpsf:             ShellFolder bound to the rightmost valid path component
1323    lpstrPathAndFile: cleaned up path
1324    nOpenAction:      action to do
1325 */
1326   TRACE("end validate sf=%p\n", lpsf);
1327
1328   switch(nOpenAction)
1329   {
1330     case ONOPEN_SEARCH:   /* set the current filter to the file mask and refresh */
1331       TRACE("ONOPEN_SEARCH %s\n", lpstrPathAndFile);
1332       {
1333         int iPos;
1334         LPSTR lpszTemp = COMDLG32_PathFindFileNameA(lpstrPathAndFile);
1335
1336         /* replace the current filter */
1337         if(fodInfos->ShellInfos.lpstrCurrentFilter)
1338           MemFree((LPVOID)fodInfos->ShellInfos.lpstrCurrentFilter);
1339         fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc((strlen(lpszTemp)+1)*sizeof(WCHAR));
1340         lstrcpyAtoW(fodInfos->ShellInfos.lpstrCurrentFilter, lpszTemp);
1341
1342         /* set the filter cb to the extension when possible */
1343         if(-1 < (iPos = FILEDLG95_FILETYPE_SearchExt(fodInfos->DlgInfos.hwndFileTypeCB, lpszTemp)))
1344         CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB, iPos);
1345       }
1346       /* fall through */
1347     case ONOPEN_BROWSE:   /* browse to the highest folder we could bind to */
1348       TRACE("ONOPEN_BROWSE\n");
1349       {
1350         IPersistFolder2 * ppf2;
1351         if(SUCCEEDED(IShellFolder_QueryInterface( lpsf, &IID_IPersistFolder2, (LPVOID*)&ppf2)))
1352         {
1353           LPITEMIDLIST pidlCurrent;
1354           IPersistFolder2_GetCurFolder(ppf2, &pidlCurrent);
1355           IPersistFolder2_Release(ppf2);
1356           if( ! COMDLG32_PIDL_ILIsEqual(pidlCurrent, fodInfos->ShellInfos.pidlAbsCurrent))
1357           {
1358             IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser, pidlCurrent, SBSP_ABSOLUTE);
1359           }
1360           else if( nOpenAction == ONOPEN_SEARCH )
1361           {
1362             IShellView_Refresh(fodInfos->Shell.FOIShellView);
1363           }
1364           COMDLG32_SHFree(pidlCurrent);
1365         }
1366       }
1367       ret = FALSE;
1368       break;
1369     case ONOPEN_OPEN:   /* fill in the return struct and close the dialog */
1370       TRACE("ONOPEN_OPEN %s\n", lpstrPathAndFile);
1371       {
1372         /* add default extension */
1373         if (fodInfos->ofnInfos->lpstrDefExt)
1374           COMDLG32_PathAddExtensionA(lpstrPathAndFile, fodInfos->ofnInfos->lpstrDefExt);
1375
1376         /* Check that size size of the file does not exceed buffer size */
1377         if(strlen(lpstrPathAndFile) < fodInfos->ofnInfos->nMaxFile)
1378         {
1379           LPSTR lpszTemp;
1380
1381           /* fill destination buffer */
1382           strcpy(fodInfos->ofnInfos->lpstrFile, lpstrPathAndFile);
1383
1384           /* set filename offset */
1385           lpszTemp = COMDLG32_PathFindFileNameA(lpstrPathAndFile);
1386           fodInfos->ofnInfos->nFileOffset = lpszTemp - lpstrPathAndFile;
1387
1388           /* set extension offset */
1389           lpszTemp = COMDLG32_PathFindExtensionA(lpstrPathAndFile);
1390           fodInfos->ofnInfos->nFileExtension = (lpszTemp) ? lpszTemp - lpstrPathAndFile + 1 : 0;
1391
1392           /* set the lpstrFileTitle */
1393           if(fodInfos->ofnInfos->lpstrFileTitle)
1394           {
1395             LPSTR lpstrFileTitle = COMDLG32_PathFindFileNameA(lpstrPathAndFile);
1396             strncpy(fodInfos->ofnInfos->lpstrFileTitle, lpstrFileTitle, fodInfos->ofnInfos->nMaxFileTitle);
1397           }
1398
1399           FILEDLG95_Clean(hwnd);
1400           ret = EndDialog(hwnd, TRUE);
1401         }
1402         else
1403         {
1404           /* FIXME set error FNERR_BUFFERTOSMALL */
1405           FILEDLG95_Clean(hwnd);
1406           ret = EndDialog(hwnd, FALSE);
1407         }
1408         goto ret;
1409       }
1410       break;
1411   }
1412
1413 ret:
1414   if(lpsf) IShellFolder_Release(lpsf);
1415   return ret;
1416 }
1417
1418 /***********************************************************************
1419  *      FILEDLG95_SHELL_Init
1420  *
1421  * Initialisation of the shell objects
1422  */
1423 static HRESULT FILEDLG95_SHELL_Init(HWND hwnd)
1424 {
1425   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1426
1427   TRACE("\n");
1428
1429   /*
1430    * Initialisation of the FileOpenDialogInfos structure
1431    */
1432
1433   /* Shell */
1434
1435   /*ShellInfos */
1436   fodInfos->ShellInfos.hwndOwner = hwnd;
1437
1438   /* Disable multi-select if flag not set */
1439   if (!(fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT))
1440   {
1441      fodInfos->ShellInfos.folderSettings.fFlags |= FWF_SINGLESEL;
1442   }
1443   fodInfos->ShellInfos.folderSettings.fFlags |= FWF_AUTOARRANGE | FWF_ALIGNLEFT;
1444   fodInfos->ShellInfos.folderSettings.ViewMode = FVM_LIST;
1445
1446   GetWindowRect(GetDlgItem(hwnd,IDC_SHELLSTATIC),&fodInfos->ShellInfos.rectView);
1447   ScreenToClient(hwnd,(LPPOINT)&fodInfos->ShellInfos.rectView.left);
1448   ScreenToClient(hwnd,(LPPOINT)&fodInfos->ShellInfos.rectView.right);
1449
1450   /* Construct the IShellBrowser interface */
1451   fodInfos->Shell.FOIShellBrowser = IShellBrowserImpl_Construct(hwnd);
1452
1453   return NOERROR;
1454 }
1455
1456 /***********************************************************************
1457  *      FILEDLG95_SHELL_ExecuteCommand
1458  *
1459  * Change the folder option and refresh the view
1460  * If the function succeeds, the return value is nonzero.
1461  */
1462 static BOOL FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb)
1463 {
1464   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1465
1466   IContextMenu * pcm;
1467   TRACE("(0x%08x,%p)\n", hwnd, lpVerb);
1468
1469   if(SUCCEEDED(IShellView_GetItemObject(fodInfos->Shell.FOIShellView,
1470                                         SVGIO_BACKGROUND,
1471                                         &IID_IContextMenu,
1472                                         (LPVOID*)&pcm)))
1473   {
1474     CMINVOKECOMMANDINFO ci;
1475     ZeroMemory(&ci, sizeof(CMINVOKECOMMANDINFO));
1476     ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
1477     ci.lpVerb = lpVerb;
1478     ci.hwnd = hwnd;
1479
1480     IContextMenu_InvokeCommand(pcm, &ci);
1481     IContextMenu_Release(pcm);
1482   }
1483
1484   return FALSE;
1485 }
1486
1487 /***********************************************************************
1488  *      FILEDLG95_SHELL_UpFolder
1489  *
1490  * Browse to the specified object
1491  * If the function succeeds, the return value is nonzero.
1492  */
1493 static BOOL FILEDLG95_SHELL_UpFolder(HWND hwnd)
1494 {
1495   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1496
1497   TRACE("\n");
1498
1499   if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
1500                                           NULL,
1501                                           SBSP_PARENT)))
1502   {
1503     return TRUE;
1504   }
1505   return FALSE;
1506 }
1507
1508 /***********************************************************************
1509  *      FILEDLG95_SHELL_Clean
1510  *
1511  * Cleans the memory used by shell objects
1512  */
1513 static void FILEDLG95_SHELL_Clean(HWND hwnd)
1514 {
1515     FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1516
1517     TRACE("\n");
1518
1519     COMDLG32_SHFree(fodInfos->ShellInfos.pidlAbsCurrent);
1520
1521     /* clean Shell interfaces */
1522     IShellView_DestroyViewWindow(fodInfos->Shell.FOIShellView);
1523     IShellView_Release(fodInfos->Shell.FOIShellView);
1524     IShellFolder_Release(fodInfos->Shell.FOIShellFolder);
1525     IShellBrowser_Release(fodInfos->Shell.FOIShellBrowser);
1526     if (fodInfos->Shell.FOIDataObject)
1527       IDataObject_Release(fodInfos->Shell.FOIDataObject);
1528 }
1529
1530 /***********************************************************************
1531  *      FILEDLG95_FILETYPE_Init
1532  *
1533  * Initialisation of the file type combo box
1534  */
1535 static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd)
1536 {
1537   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1538
1539   TRACE("\n");
1540
1541   if(fodInfos->ofnInfos->lpstrFilter)
1542   {
1543     int nFilters = 0;   /* number of filters */
1544     LPSTR lpstrFilter;
1545     LPCSTR lpstrPos = fodInfos->ofnInfos->lpstrFilter;
1546
1547     for(;;)
1548     {
1549       /* filter is a list...  title\0ext\0......\0\0
1550        * Set the combo item text to the title and the item data
1551        *  to the ext
1552        */
1553       LPCSTR lpstrDisplay;
1554       LPSTR lpstrExt;
1555
1556       /* Get the title */
1557       if(! *lpstrPos) break;    /* end */
1558       lpstrDisplay = lpstrPos;
1559       lpstrPos += strlen(lpstrPos) + 1;
1560
1561       /* Copy the extensions */
1562       if (! *lpstrPos) return E_FAIL;   /* malformed filter */
1563       if (!(lpstrExt = (LPSTR) MemAlloc(strlen(lpstrPos)+1))) return E_FAIL;
1564       strcpy(lpstrExt,lpstrPos);
1565       lpstrPos += strlen(lpstrPos) + 1;
1566
1567       /* Add the item at the end of the combo */
1568       CBAddString(fodInfos->DlgInfos.hwndFileTypeCB, lpstrDisplay);
1569       CBSetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB, nFilters, lpstrExt);
1570       nFilters++;
1571     }
1572     /*
1573      * Set the current filter to the one specified
1574      * in the initialisation structure
1575      * FIXME: lpstrCustomFilter not handled at all
1576      */
1577
1578     /* set default filter index */
1579     if(fodInfos->ofnInfos->nFilterIndex == 0 && fodInfos->ofnInfos->lpstrCustomFilter == NULL)
1580       fodInfos->ofnInfos->nFilterIndex = 1;
1581
1582     /* First, check to make sure our index isn't out of bounds. */
1583     if ( fodInfos->ofnInfos->nFilterIndex > nFilters )
1584       fodInfos->ofnInfos->nFilterIndex = nFilters;
1585
1586     /* Set the current index selection. */
1587     CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB, fodInfos->ofnInfos->nFilterIndex-1);
1588
1589     /* Get the corresponding text string from the combo box. */
1590     lpstrFilter = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
1591                                              fodInfos->ofnInfos->nFilterIndex-1);
1592
1593     if ((INT)lpstrFilter == CB_ERR)  /* control is empty */
1594       lpstrFilter = NULL;
1595
1596     if(lpstrFilter)
1597     {
1598       CRTDLL__strlwr(lpstrFilter);      /* lowercase */
1599       fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc((strlen(lpstrFilter)+1)*2);
1600       lstrcpyAtoW(fodInfos->ShellInfos.lpstrCurrentFilter, lpstrFilter);
1601     }
1602   }
1603   return NOERROR;
1604 }
1605
1606 /***********************************************************************
1607  *      FILEDLG95_FILETYPE_OnCommand
1608  *
1609  * WM_COMMAND of the file type combo box
1610  * If the function succeeds, the return value is nonzero.
1611  */
1612 static BOOL FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode)
1613 {
1614   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1615
1616   switch(wNotifyCode)
1617   {
1618     case CBN_SELENDOK:
1619     {
1620       LPSTR lpstrFilter;
1621
1622       /* Get the current item of the filetype combo box */
1623       int iItem = CBGetCurSel(fodInfos->DlgInfos.hwndFileTypeCB);
1624
1625       /* set the current filter index - indexed from 1 */
1626       fodInfos->ofnInfos->nFilterIndex = iItem + 1;
1627
1628       /* Set the current filter with the current selection */
1629       if(fodInfos->ShellInfos.lpstrCurrentFilter)
1630          MemFree((LPVOID)fodInfos->ShellInfos.lpstrCurrentFilter);
1631
1632       lpstrFilter = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
1633                                              iItem);
1634       if((int)lpstrFilter != CB_ERR)
1635       {
1636         fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc((strlen(lpstrFilter)+1)*2);
1637         lstrcpyAtoW(fodInfos->ShellInfos.lpstrCurrentFilter,CRTDLL__strlwr(lpstrFilter));
1638         SendCustomDlgNotificationMessage(hwnd,CDN_TYPECHANGE);
1639       }
1640
1641       /* Refresh the actual view to display the included items*/
1642       IShellView_Refresh(fodInfos->Shell.FOIShellView);
1643     }
1644   }
1645   return FALSE;
1646 }
1647 /***********************************************************************
1648  *      FILEDLG95_FILETYPE_SearchExt
1649  *
1650  * searches for a extension in the filetype box
1651  */
1652 static int FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPCSTR lpstrExt)
1653 {
1654   int i, iCount = CBGetCount(hwnd);
1655
1656   TRACE("%s\n", lpstrExt);
1657
1658   if(iCount != CB_ERR)
1659   {
1660     for(i=0;i<iCount;i++)
1661     {
1662       if(!strcasecmp(lpstrExt,(LPSTR)CBGetItemDataPtr(hwnd,i)))
1663           return i;
1664     }
1665   }
1666   return -1;
1667 }
1668
1669 /***********************************************************************
1670  *      FILEDLG95_FILETYPE_Clean
1671  *
1672  * Clean the memory used by the filetype combo box
1673  */
1674 static void FILEDLG95_FILETYPE_Clean(HWND hwnd)
1675 {
1676   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1677   int iPos;
1678   int iCount = CBGetCount(fodInfos->DlgInfos.hwndFileTypeCB);
1679
1680   TRACE("\n");
1681
1682   /* Delete each string of the combo and their associated data */
1683   if(iCount != CB_ERR)
1684   {
1685     for(iPos = iCount-1;iPos>=0;iPos--)
1686     {
1687       MemFree((LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,iPos));
1688       CBDeleteString(fodInfos->DlgInfos.hwndFileTypeCB,iPos);
1689     }
1690   }
1691   /* Current filter */
1692   if(fodInfos->ShellInfos.lpstrCurrentFilter)
1693      MemFree(fodInfos->ShellInfos.lpstrCurrentFilter);
1694
1695 }
1696
1697 /***********************************************************************
1698  *      FILEDLG95_LOOKIN_Init
1699  *
1700  * Initialisation of the look in combo box
1701  */
1702 static HRESULT FILEDLG95_LOOKIN_Init(HWND hwndCombo)
1703 {
1704   IShellFolder  *psfRoot, *psfDrives;
1705   IEnumIDList   *lpeRoot, *lpeDrives;
1706   LPITEMIDLIST  pidlDrives, pidlTmp, pidlTmp1, pidlAbsTmp;
1707
1708   LookInInfos *liInfos = MemAlloc(sizeof(LookInInfos));
1709
1710   TRACE("\n");
1711
1712   liInfos->iMaxIndentation = 0;
1713
1714   SetPropA(hwndCombo, LookInInfosStr, (HANDLE) liInfos);
1715   CBSetItemHeight(hwndCombo,0,GetSystemMetrics(SM_CYSMICON));
1716
1717   /* Initialise data of Desktop folder */
1718   COMDLG32_SHGetSpecialFolderLocation(0,CSIDL_DESKTOP,&pidlTmp);
1719   FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
1720   COMDLG32_SHFree(pidlTmp);
1721
1722   COMDLG32_SHGetSpecialFolderLocation(0,CSIDL_DRIVES,&pidlDrives);
1723
1724   COMDLG32_SHGetDesktopFolder(&psfRoot);
1725
1726   if (psfRoot)
1727   {
1728     /* enumerate the contents of the desktop */
1729     if(SUCCEEDED(IShellFolder_EnumObjects(psfRoot, hwndCombo, SHCONTF_FOLDERS, &lpeRoot)))
1730     {
1731       while (S_OK == IEnumIDList_Next(lpeRoot, 1, &pidlTmp, NULL))
1732       {
1733         FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
1734
1735         /* special handling for CSIDL_DRIVES */
1736         if (COMDLG32_PIDL_ILIsEqual(pidlTmp, pidlDrives))
1737         {
1738           if(SUCCEEDED(IShellFolder_BindToObject(psfRoot, pidlTmp, NULL, &IID_IShellFolder, (LPVOID*)&psfDrives)))
1739           {
1740             /* enumerate the drives */
1741             if(SUCCEEDED(IShellFolder_EnumObjects(psfDrives, hwndCombo,SHCONTF_FOLDERS, &lpeDrives)))
1742             {
1743               while (S_OK == IEnumIDList_Next(lpeDrives, 1, &pidlTmp1, NULL))
1744               {
1745                 pidlAbsTmp = COMDLG32_PIDL_ILCombine(pidlTmp, pidlTmp1);
1746                 FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlAbsTmp,LISTEND);
1747                 COMDLG32_SHFree(pidlAbsTmp);
1748                 COMDLG32_SHFree(pidlTmp1);
1749               }
1750               IEnumIDList_Release(lpeDrives);
1751             }
1752             IShellFolder_Release(psfDrives);
1753           }
1754         }
1755         COMDLG32_SHFree(pidlTmp);
1756       }
1757       IEnumIDList_Release(lpeRoot);
1758     }
1759   }
1760
1761   IShellFolder_Release(psfRoot);
1762   COMDLG32_SHFree(pidlDrives);
1763   return NOERROR;
1764 }
1765
1766 /***********************************************************************
1767  *      FILEDLG95_LOOKIN_DrawItem
1768  *
1769  * WM_DRAWITEM message handler
1770  */
1771 static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct)
1772 {
1773   COLORREF crWin = GetSysColor(COLOR_WINDOW);
1774   COLORREF crHighLight = GetSysColor(COLOR_HIGHLIGHT);
1775   COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
1776   RECT rectText;
1777   RECT rectIcon;
1778   SHFILEINFOA sfi;
1779   HIMAGELIST ilItemImage;
1780   int iIndentation;
1781   LPSFOLDER tmpFolder;
1782
1783
1784   LookInInfos *liInfos = (LookInInfos *)GetPropA(pDIStruct->hwndItem,LookInInfosStr);
1785
1786   TRACE("\n");
1787
1788   if(pDIStruct->itemID == -1)
1789     return 0;
1790
1791   if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(pDIStruct->hwndItem,
1792                             pDIStruct->itemID)))
1793     return 0;
1794
1795
1796   if(pDIStruct->itemID == liInfos->uSelectedItem)
1797   {
1798     ilItemImage = (HIMAGELIST) COMDLG32_SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
1799                                                0,
1800                                                &sfi,
1801                                                sizeof (SHFILEINFOA),
1802                                                SHGFI_PIDL | SHGFI_SMALLICON |
1803                                                SHGFI_OPENICON | SHGFI_SYSICONINDEX    |
1804                                                SHGFI_DISPLAYNAME );
1805   }
1806   else
1807   {
1808     ilItemImage = (HIMAGELIST) COMDLG32_SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
1809                                                   0,
1810                                                   &sfi,
1811                                                   sizeof (SHFILEINFOA),
1812                                                   SHGFI_PIDL | SHGFI_SMALLICON |
1813                                                   SHGFI_SYSICONINDEX |
1814                                                   SHGFI_DISPLAYNAME);
1815   }
1816
1817   /* Is this item selected ?*/
1818   if(pDIStruct->itemState & ODS_SELECTED)
1819   {
1820     SetTextColor(pDIStruct->hDC,(0x00FFFFFF & ~(crText)));
1821     SetBkColor(pDIStruct->hDC,crHighLight);
1822     FillRect(pDIStruct->hDC,&pDIStruct->rcItem,(HBRUSH)crHighLight);
1823   }
1824   else
1825   {
1826     SetTextColor(pDIStruct->hDC,crText);
1827     SetBkColor(pDIStruct->hDC,crWin);
1828     FillRect(pDIStruct->hDC,&pDIStruct->rcItem,(HBRUSH)crWin);
1829   }
1830
1831   /* Do not indent item  if drawing in the edit of the combo*/
1832   if(pDIStruct->itemState & ODS_COMBOBOXEDIT)
1833   {
1834     iIndentation = 0;
1835     ilItemImage = (HIMAGELIST) COMDLG32_SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
1836                                                 0,
1837                                                 &sfi,
1838                                                 sizeof (SHFILEINFOA),
1839                                                 SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_OPENICON
1840                                                 | SHGFI_SYSICONINDEX | SHGFI_DISPLAYNAME  );
1841
1842   }
1843   else
1844   {
1845     iIndentation = tmpFolder->m_iIndent;
1846   }
1847   /* Draw text and icon */
1848
1849   /* Initialise the icon display area */
1850   rectIcon.left = pDIStruct->rcItem.left + ICONWIDTH/2 * iIndentation;
1851   rectIcon.top = pDIStruct->rcItem.top;
1852   rectIcon.right = rectIcon.left + ICONWIDTH;
1853   rectIcon.bottom = pDIStruct->rcItem.bottom;
1854
1855   /* Initialise the text display area */
1856   rectText.left = rectIcon.right;
1857   rectText.top = pDIStruct->rcItem.top + YTEXTOFFSET;
1858   rectText.right = pDIStruct->rcItem.right + XTEXTOFFSET;
1859   rectText.bottom = pDIStruct->rcItem.bottom;
1860
1861
1862   /* Draw the icon from the image list */
1863   COMDLG32_ImageList_Draw(ilItemImage,
1864                  sfi.iIcon,
1865                  pDIStruct->hDC,
1866                  rectIcon.left,
1867                  rectIcon.top,
1868                  ILD_TRANSPARENT );
1869
1870   /* Draw the associated text */
1871   if(sfi.szDisplayName)
1872     TextOutA(pDIStruct->hDC,rectText.left,rectText.top,sfi.szDisplayName,strlen(sfi.szDisplayName));
1873
1874
1875   return NOERROR;
1876 }
1877
1878 /***********************************************************************
1879  *      FILEDLG95_LOOKIN_OnCommand
1880  *
1881  * LookIn combo box WM_COMMAND message handler
1882  * If the function succeeds, the return value is nonzero.
1883  */
1884 static BOOL FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode)
1885 {
1886   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1887
1888   TRACE("%p\n", fodInfos);
1889
1890   switch(wNotifyCode)
1891   {
1892     case CBN_SELENDOK:
1893     {
1894       LPSFOLDER tmpFolder;
1895       int iItem;
1896
1897       iItem = CBGetCurSel(fodInfos->DlgInfos.hwndLookInCB);
1898
1899       if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,
1900                                                iItem)))
1901         return FALSE;
1902
1903
1904       if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
1905                                               tmpFolder->pidlItem,
1906                                               SBSP_ABSOLUTE)))
1907       {
1908         return TRUE;
1909       }
1910       break;
1911     }
1912
1913   }
1914   return FALSE;
1915 }
1916
1917 /***********************************************************************
1918  *      FILEDLG95_LOOKIN_AddItem
1919  *
1920  * Adds an absolute pidl item to the lookin combo box
1921  * returns the index of the inserted item
1922  */
1923 static int FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId)
1924 {
1925   LPITEMIDLIST pidlNext;
1926   SHFILEINFOA sfi;
1927   SFOLDER *tmpFolder;
1928   LookInInfos *liInfos;
1929
1930   TRACE("\n");
1931
1932   if(!pidl)
1933     return -1;
1934
1935   if(!(liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr)))
1936     return -1;
1937
1938   tmpFolder = MemAlloc(sizeof(SFOLDER));
1939   tmpFolder->m_iIndent = 0;
1940
1941   /* Calculate the indentation of the item in the lookin*/
1942   pidlNext = pidl;
1943   while( (pidlNext=COMDLG32_PIDL_ILGetNext(pidlNext)) )
1944   {
1945     tmpFolder->m_iIndent++;
1946   }
1947
1948   tmpFolder->pidlItem = COMDLG32_PIDL_ILClone(pidl); /* FIXME: memory leak*/
1949
1950   if(tmpFolder->m_iIndent > liInfos->iMaxIndentation)
1951     liInfos->iMaxIndentation = tmpFolder->m_iIndent;
1952
1953   sfi.dwAttributes = SFGAO_FILESYSANCESTOR | SFGAO_FILESYSTEM;
1954   COMDLG32_SHGetFileInfoA((LPSTR)pidl,
1955                   0,
1956                   &sfi,
1957                   sizeof(sfi),
1958                   SHGFI_DISPLAYNAME | SHGFI_SYSICONINDEX
1959                   | SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_ATTRIBUTES | SHGFI_ATTR_SPECIFIED);
1960
1961
1962   if((sfi.dwAttributes & SFGAO_FILESYSANCESTOR) || (sfi.dwAttributes & SFGAO_FILESYSTEM))
1963   {
1964     int iItemID;
1965
1966     /* Add the item at the end of the list */
1967     if(iInsertId < 0)
1968     {
1969       iItemID = CBAddString(hwnd,sfi.szDisplayName);
1970     }
1971     /* Insert the item at the iInsertId position*/
1972     else
1973     {
1974       iItemID = CBInsertString(hwnd,sfi.szDisplayName,iInsertId);
1975     }
1976
1977     CBSetItemDataPtr(hwnd,iItemID,tmpFolder);
1978     return iItemID;
1979   }
1980
1981   MemFree( tmpFolder );
1982   return -1;
1983
1984 }
1985
1986 /***********************************************************************
1987  *      FILEDLG95_LOOKIN_InsertItemAfterParent
1988  *
1989  * Insert an item below its parent
1990  */
1991 static int FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl)
1992 {
1993
1994   LPITEMIDLIST pidlParent = GetParentPidl(pidl);
1995   int iParentPos;
1996
1997   TRACE("\n");
1998
1999   iParentPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidlParent,SEARCH_PIDL);
2000
2001   if(iParentPos < 0)
2002   {
2003     iParentPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidlParent);
2004   }
2005
2006   /* Free pidlParent memory */
2007   COMDLG32_SHFree((LPVOID)pidlParent);
2008
2009   return FILEDLG95_LOOKIN_AddItem(hwnd,pidl,iParentPos + 1);
2010 }
2011
2012 /***********************************************************************
2013  *      FILEDLG95_LOOKIN_SelectItem
2014  *
2015  * Adds an absolute pidl item to the lookin combo box
2016  * returns the index of the inserted item
2017  */
2018 int FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl)
2019 {
2020   int iItemPos;
2021   LookInInfos *liInfos;
2022
2023   TRACE("\n");
2024
2025   iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidl,SEARCH_PIDL);
2026
2027   liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr);
2028
2029   if(iItemPos < 0)
2030   {
2031     while(FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd) > -1);
2032     iItemPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidl);
2033   }
2034
2035   else
2036   {
2037     SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
2038     while(liInfos->iMaxIndentation > tmpFolder->m_iIndent)
2039     {
2040       int iRemovedItem;
2041
2042       if(-1 == (iRemovedItem = FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd)))
2043         break;
2044       if(iRemovedItem < iItemPos)
2045         iItemPos--;
2046     }
2047   }
2048
2049   CBSetCurSel(hwnd,iItemPos);
2050   liInfos->uSelectedItem = iItemPos;
2051
2052   return 0;
2053
2054 }
2055
2056 /***********************************************************************
2057  *      FILEDLG95_LOOKIN_RemoveMostExpandedItem
2058  *
2059  * Remove the item with an expansion level over iExpansionLevel
2060  */
2061 static int FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd)
2062 {
2063   int iItemPos;
2064
2065   LookInInfos *liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr);
2066
2067   TRACE("\n");
2068
2069   if(liInfos->iMaxIndentation <= 2)
2070     return -1;
2071
2072   if((iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)liInfos->iMaxIndentation,SEARCH_EXP)) >=0)
2073   {
2074     SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
2075     COMDLG32_SHFree(tmpFolder->pidlItem);
2076     MemFree(tmpFolder);
2077     CBDeleteString(hwnd,iItemPos);
2078     liInfos->iMaxIndentation--;
2079
2080     return iItemPos;
2081   }
2082
2083   return -1;
2084 }
2085
2086 /***********************************************************************
2087  *      FILEDLG95_LOOKIN_SearchItem
2088  *
2089  * Search for pidl in the lookin combo box
2090  * returns the index of the found item
2091  */
2092 static int FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod)
2093 {
2094   int i = 0;
2095   int iCount = CBGetCount(hwnd);
2096
2097   TRACE("\n");
2098
2099   if (iCount != CB_ERR)
2100   {
2101     for(;i<iCount;i++)
2102     {
2103       LPSFOLDER tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,i);
2104
2105       if(iSearchMethod == SEARCH_PIDL && COMDLG32_PIDL_ILIsEqual((LPITEMIDLIST)searchArg,tmpFolder->pidlItem))
2106         return i;
2107       if(iSearchMethod == SEARCH_EXP && tmpFolder->m_iIndent == (int)searchArg)
2108         return i;
2109     }
2110   }
2111
2112   return -1;
2113 }
2114
2115 /***********************************************************************
2116  *      FILEDLG95_LOOKIN_Clean
2117  *
2118  * Clean the memory used by the lookin combo box
2119  */
2120 static void FILEDLG95_LOOKIN_Clean(HWND hwnd)
2121 {
2122     FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2123     int iPos;
2124     int iCount = CBGetCount(fodInfos->DlgInfos.hwndLookInCB);
2125
2126     TRACE("\n");
2127
2128     /* Delete each string of the combo and their associated data */
2129     if (iCount != CB_ERR)
2130     {
2131       for(iPos = iCount-1;iPos>=0;iPos--)
2132       {
2133         SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,iPos);
2134         COMDLG32_SHFree(tmpFolder->pidlItem);
2135         MemFree(tmpFolder);
2136         CBDeleteString(fodInfos->DlgInfos.hwndLookInCB,iPos);
2137       }
2138     }
2139
2140     /* LookInInfos structure */
2141     RemovePropA(fodInfos->DlgInfos.hwndLookInCB,LookInInfosStr);
2142
2143 }
2144 /***********************************************************************
2145  * FILEDLG95_FILENAME_FillFromSelection
2146  *
2147  * fills the edit box from the cached DataObject
2148  */
2149 void FILEDLG95_FILENAME_FillFromSelection (HWND hwnd)
2150 {
2151     FileOpenDlgInfos *fodInfos;
2152     LPITEMIDLIST      pidl;
2153     UINT              nFiles = 0, nFileToOpen, nFileSelected, nLength = 0;
2154     char              lpstrTemp[MAX_PATH];
2155     LPSTR             lpstrAllFile = NULL, lpstrCurrFile = NULL;
2156
2157     TRACE("\n");
2158     fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2159
2160     /* Count how many files we have */
2161     nFileSelected = GetNumSelected( fodInfos->Shell.FOIDataObject );
2162
2163     /* calculate the string length, count files */
2164     if (nFileSelected >= 1)
2165     {
2166       nLength += 3;     /* first and last quotes, trailing \0 */
2167       for ( nFileToOpen = 0; nFileToOpen < nFileSelected; nFileToOpen++ )
2168       {
2169         pidl = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, nFileToOpen+1 );
2170
2171         if (pidl)
2172         {
2173           /* get the total length of the selected file names*/
2174           lpstrTemp[0] = '\0';
2175           GetName( fodInfos->Shell.FOIShellFolder, pidl, SHGDN_INFOLDER, lpstrTemp );
2176
2177           if ( ! IsPidlFolder(fodInfos->Shell.FOIShellFolder, pidl) ) /* Ignore folders */
2178           {
2179             nLength += lstrlenA( lpstrTemp ) + 3;
2180             nFiles++;
2181           }
2182           COMDLG32_SHFree( pidl );
2183         }
2184       }
2185     }
2186
2187     /* allocate the buffer */
2188     if (nFiles <= 1) nLength = MAX_PATH;
2189     lpstrAllFile = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nLength);
2190     lpstrAllFile[0] = '\0';
2191
2192     /* Generate the string for the edit control */
2193     if(nFiles >= 1)
2194     {
2195       lpstrCurrFile = lpstrAllFile;
2196       for ( nFileToOpen = 0; nFileToOpen < nFileSelected; nFileToOpen++ )
2197       {
2198         pidl = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, nFileToOpen+1 );
2199
2200         if (pidl)
2201         {
2202           /* get the file name */
2203           lpstrTemp[0] = '\0';
2204           GetName( fodInfos->Shell.FOIShellFolder, pidl, SHGDN_INFOLDER, lpstrTemp );
2205
2206           if (! IsPidlFolder(fodInfos->Shell.FOIShellFolder, pidl)) /* Ignore folders */
2207           {
2208             if ( nFiles > 1)
2209             {
2210               *lpstrCurrFile++ =  '\"';
2211               lstrcpyA( lpstrCurrFile, lpstrTemp );
2212               lpstrCurrFile += lstrlenA( lpstrTemp );
2213               lstrcpyA( lpstrCurrFile, "\" " );
2214               lpstrCurrFile += 2;
2215             }
2216             else
2217             {
2218               lstrcpyA( lpstrAllFile, lpstrTemp );
2219             }
2220           }
2221           COMDLG32_SHFree( (LPVOID) pidl );
2222         }
2223       }
2224     }
2225
2226     SetWindowTextA( fodInfos->DlgInfos.hwndFileName, lpstrAllFile );
2227     HeapFree(GetProcessHeap(),0, lpstrAllFile );
2228 }
2229
2230
2231 /* copied from shell32 to avoid linking to it */
2232 static HRESULT COMDLG32_StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
2233 {
2234         switch (src->uType)
2235         {
2236           case STRRET_WSTR:
2237             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
2238             COMDLG32_SHFree(src->u.pOleStr);
2239             break;
2240
2241           case STRRET_CSTRA:
2242             lstrcpynA((LPSTR)dest, src->u.cStr, len);
2243             break;
2244
2245           case STRRET_OFFSETA:
2246             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
2247             break;
2248
2249           default:
2250             FIXME("unknown type!\n");
2251             if (len)
2252             {
2253               *(LPSTR)dest = '\0';
2254             }
2255             return(FALSE);
2256         }
2257         return S_OK;
2258 }
2259
2260 /***********************************************************************
2261  * FILEDLG95_FILENAME_GetFileNames
2262  *
2263  * copys the filenames to a 0-delimited string
2264  */
2265 int FILEDLG95_FILENAME_GetFileNames (HWND hwnd, LPSTR * lpstrFileList, UINT * sizeUsed)
2266 {
2267         FileOpenDlgInfos *fodInfos  = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2268         UINT nStrCharCount = 0; /* index in src buffer */
2269         UINT nFileIndex = 0;    /* index in dest buffer */
2270         UINT nFileCount = 0;    /* number of files */
2271         UINT nStrLen = 0;       /* length of string in edit control */
2272         LPSTR lpstrEdit;        /* buffer for string from edit control */
2273
2274         TRACE("\n");
2275
2276         /* get the filenames from the edit control */
2277         nStrLen = SendMessageA(fodInfos->DlgInfos.hwndFileName, WM_GETTEXTLENGTH, 0, 0);
2278         lpstrEdit = MemAlloc(nStrLen+1);
2279         GetDlgItemTextA(hwnd, IDC_FILENAME, lpstrEdit, nStrLen+1);
2280
2281         TRACE("nStrLen=%u str=%s\n", nStrLen, lpstrEdit);
2282
2283         *lpstrFileList = MemAlloc(nStrLen);
2284         *sizeUsed = 0;
2285
2286         /* build 0-delimited file list from filenames*/
2287         while ( nStrCharCount <= nStrLen )
2288         {
2289           if ( lpstrEdit[nStrCharCount]=='"' )
2290           {
2291             nStrCharCount++;
2292             while ((lpstrEdit[nStrCharCount]!='"') && (nStrCharCount <= nStrLen))
2293             {
2294               (*lpstrFileList)[nFileIndex++] = lpstrEdit[nStrCharCount];
2295               (*sizeUsed)++;
2296               nStrCharCount++;
2297             }
2298             (*lpstrFileList)[nFileIndex++] = '\0';
2299             (*sizeUsed)++;
2300             nFileCount++;
2301           }
2302           nStrCharCount++;
2303         }
2304
2305         /* single, unquoted string */
2306         if ((nStrLen > 0) && (*sizeUsed == 0) )
2307         {
2308           strcpy(*lpstrFileList, lpstrEdit);
2309           nFileIndex = strlen(lpstrEdit) + 1;
2310           (*sizeUsed) = nFileIndex;
2311           nFileCount = 1;
2312         }
2313
2314         /* trailing \0 */
2315         (*lpstrFileList)[nFileIndex] = '\0';
2316         (*sizeUsed)++;
2317
2318         MemFree(lpstrEdit);
2319         return nFileCount;
2320  }
2321
2322 #define SETDefFormatEtc(fe,cf,med) \
2323 { \
2324     (fe).cfFormat = cf;\
2325     (fe).dwAspect = DVASPECT_CONTENT; \
2326     (fe).ptd =NULL;\
2327     (fe).tymed = med;\
2328     (fe).lindex = -1;\
2329 };
2330
2331 /*
2332  * DATAOBJECT Helper functions
2333  */
2334
2335 /***********************************************************************
2336  * COMCTL32_ReleaseStgMedium
2337  *
2338  * like ReleaseStgMedium from ole32
2339  */
2340 static void COMCTL32_ReleaseStgMedium (STGMEDIUM medium)
2341 {
2342       if(medium.pUnkForRelease)
2343       {
2344         IUnknown_Release(medium.pUnkForRelease);
2345       }
2346       else
2347       {
2348         GlobalUnlock(medium.u.hGlobal);
2349         GlobalFree(medium.u.hGlobal);
2350       }
2351 }
2352
2353 /***********************************************************************
2354  *          GetPidlFromDataObject
2355  *
2356  * Return pidl(s) by number from the cached DataObject
2357  *
2358  * nPidlIndex=0 gets the fully qualified root path
2359  */
2360 LPITEMIDLIST GetPidlFromDataObject ( IDataObject *doSelected, UINT nPidlIndex)
2361 {
2362
2363     STGMEDIUM medium;
2364     FORMATETC formatetc;
2365     LPITEMIDLIST pidl = NULL;
2366
2367     TRACE("sv=%p index=%u\n", doSelected, nPidlIndex);
2368
2369     /* Set the FORMATETC structure*/
2370     SETDefFormatEtc(formatetc, RegisterClipboardFormatA(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
2371
2372     /* Get the pidls from IDataObject */
2373     if(SUCCEEDED(IDataObject_GetData(doSelected,&formatetc,&medium)))
2374     {
2375       LPIDA cida = GlobalLock(medium.u.hGlobal);
2376       if(nPidlIndex <= cida->cidl)
2377       {
2378         pidl = COMDLG32_PIDL_ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[nPidlIndex]]));
2379       }
2380       COMCTL32_ReleaseStgMedium(medium);
2381     }
2382     return pidl;
2383 }
2384
2385 /***********************************************************************
2386  *          GetNumSelected
2387  *
2388  * Return the number of selected items in the DataObject.
2389  *
2390 */
2391 UINT GetNumSelected( IDataObject *doSelected )
2392 {
2393     UINT retVal = 0;
2394     STGMEDIUM medium;
2395     FORMATETC formatetc;
2396
2397     TRACE("sv=%p\n", doSelected);
2398
2399     if (!doSelected) return 0;
2400
2401     /* Set the FORMATETC structure*/
2402     SETDefFormatEtc(formatetc, RegisterClipboardFormatA(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
2403
2404     /* Get the pidls from IDataObject */
2405     if(SUCCEEDED(IDataObject_GetData(doSelected,&formatetc,&medium)))
2406     {
2407       LPIDA cida = GlobalLock(medium.u.hGlobal);
2408       retVal = cida->cidl;
2409       COMCTL32_ReleaseStgMedium(medium);
2410       return retVal;
2411     }
2412     return 0;
2413 }
2414
2415 /*
2416  * TOOLS
2417  */
2418
2419 /***********************************************************************
2420  *      GetName
2421  *
2422  * Get the pidl's display name (relative to folder) and
2423  * put it in lpstrFileName.
2424  *
2425  * Return NOERROR on success,
2426  * E_FAIL otherwise
2427  */
2428
2429 HRESULT GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPSTR lpstrFileName)
2430 {
2431   STRRET str;
2432   HRESULT hRes;
2433
2434   TRACE("sf=%p pidl=%p\n", lpsf, pidl);
2435
2436   if(!lpsf)
2437   {
2438     HRESULT hRes;
2439     COMDLG32_SHGetDesktopFolder(&lpsf);
2440     hRes = GetName(lpsf,pidl,dwFlags,lpstrFileName);
2441     IShellFolder_Release(lpsf);
2442     return hRes;
2443   }
2444
2445   /* Get the display name of the pidl relative to the folder */
2446   if (SUCCEEDED(hRes = IShellFolder_GetDisplayNameOf(lpsf, pidl, dwFlags, &str)))
2447   {
2448       return COMDLG32_StrRetToStrNA(lpstrFileName, MAX_PATH, &str, pidl);
2449   }
2450   return E_FAIL;
2451 }
2452
2453 /***********************************************************************
2454  *      GetShellFolderFromPidl
2455  *
2456  * pidlRel is the item pidl relative
2457  * Return the IShellFolder of the absolute pidl
2458  */
2459 IShellFolder *GetShellFolderFromPidl(LPITEMIDLIST pidlAbs)
2460 {
2461   IShellFolder *psf = NULL,*psfParent;
2462
2463   TRACE("%p\n", pidlAbs);
2464
2465   if(SUCCEEDED(COMDLG32_SHGetDesktopFolder(&psfParent)))
2466   {
2467     psf = psfParent;
2468     if(pidlAbs && pidlAbs->mkid.cb)
2469     {
2470       if(SUCCEEDED(IShellFolder_BindToObject(psfParent, pidlAbs, NULL, &IID_IShellFolder, (LPVOID*)&psf)))
2471       {
2472         IShellFolder_Release(psfParent);
2473         return psf;
2474       }
2475     }
2476     /* return the desktop */
2477     return psfParent;
2478   }
2479   return NULL;
2480 }
2481
2482 /***********************************************************************
2483  *      GetParentPidl
2484  *
2485  * Return the LPITEMIDLIST to the parent of the pidl in the list
2486  */
2487 LPITEMIDLIST GetParentPidl(LPITEMIDLIST pidl)
2488 {
2489   LPITEMIDLIST pidlParent;
2490
2491   TRACE("%p\n", pidl);
2492
2493   pidlParent = COMDLG32_PIDL_ILClone(pidl);
2494   COMDLG32_PIDL_ILRemoveLastID(pidlParent);
2495
2496   return pidlParent;
2497 }
2498
2499 /***********************************************************************
2500  *      GetPidlFromName
2501  *
2502  * returns the pidl of the file name relative to folder
2503  * NULL if an error occured
2504  */
2505 LPITEMIDLIST GetPidlFromName(IShellFolder *lpsf,LPCSTR lpcstrFileName)
2506 {
2507   LPITEMIDLIST pidl;
2508   ULONG ulEaten;
2509   WCHAR lpwstrDirName[MAX_PATH];
2510
2511   TRACE("sf=%p file=%s\n", lpsf, lpcstrFileName);
2512
2513   if(!lpcstrFileName) return NULL;
2514
2515   MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,lpcstrFileName,-1,(LPWSTR)lpwstrDirName,MAX_PATH);
2516
2517   if(!lpsf)
2518   {
2519     COMDLG32_SHGetDesktopFolder(&lpsf);
2520     pidl = GetPidlFromName(lpsf, lpcstrFileName);
2521     IShellFolder_Release(lpsf);
2522   }
2523   else
2524   {
2525     IShellFolder_ParseDisplayName(lpsf, 0, NULL, (LPWSTR)lpwstrDirName, &ulEaten, &pidl, NULL);
2526   }
2527   return pidl;
2528 }
2529
2530 /*
2531 */
2532 BOOL IsPidlFolder (LPSHELLFOLDER psf, LPITEMIDLIST pidl)
2533 {
2534         ULONG uAttr  = SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
2535         HRESULT ret;
2536
2537         TRACE("%p, %p\n", psf, pidl);
2538
2539         ret = IShellFolder_GetAttributesOf( psf, 1, &pidl, &uAttr );
2540
2541         TRACE("-- 0x%08lx 0x%08lx\n", uAttr, ret);
2542         /* see documentation shell 4.1*/
2543         return uAttr & (SFGAO_FOLDER | SFGAO_HASSUBFOLDER);
2544 }
2545
2546 /***********************************************************************
2547  *      BrowseSelectedFolder
2548  */
2549 static BOOL BrowseSelectedFolder(HWND hwnd)
2550 {
2551   BOOL bBrowseSelFolder = FALSE;
2552   FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2553
2554   TRACE("\n");
2555
2556   if (GetNumSelected(fodInfos->Shell.FOIDataObject) == 1)
2557   {
2558       LPITEMIDLIST pidlSelection;
2559
2560       /* get the file selected */
2561       pidlSelection  = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, 1);
2562       if (IsPidlFolder (fodInfos->Shell.FOIShellFolder, pidlSelection))
2563       {
2564           if ( FAILED( IShellBrowser_BrowseObject( fodInfos->Shell.FOIShellBrowser,
2565                          pidlSelection, SBSP_RELATIVE ) ) )
2566           {
2567                MessageBoxA( hwnd, "Path does not exist", fodInfos->ofnInfos->lpstrTitle,
2568                       MB_OK | MB_ICONEXCLAMATION );
2569           }
2570
2571          bBrowseSelFolder = TRUE;
2572       }
2573       COMDLG32_SHFree( pidlSelection );
2574   }
2575
2576   return bBrowseSelFolder;
2577 }
2578
2579 /*
2580  * Memory allocation methods */
2581 static void *MemAlloc(UINT size)
2582 {
2583     return HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size);
2584 }
2585
2586 static void MemFree(void *mem)
2587 {
2588     if(mem)
2589     {
2590         HeapFree(GetProcessHeap(),0,mem);
2591     }
2592 }
2593