git.oblomov.eu Git - wine/blob - programs/winefile/winefile.c

   1 /*
   2  * Winefile
   3  *
   4  * Copyright 2000, 2003, 2004, 2005 Martin Fuchs
   5  * Copyright 2006 Jason Green
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #ifdef __WINE__
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 /* for unix filesystem function calls */
  27 #include <sys/stat.h>
  28 #include <sys/types.h>
  29 #include <dirent.h>
  30 #endif
  31
  32 #define COBJMACROS
  33
  34 #include "winefile.h"
  35 #include "resource.h"
  36 #include "wine/unicode.h"
  37
  38 #ifndef _MAX_PATH
  39 #define _MAX_DRIVE          3
  40 #define _MAX_FNAME          256
  41 #define _MAX_DIR            _MAX_FNAME
  42 #define _MAX_EXT            _MAX_FNAME
  43 #define _MAX_PATH           260
  44 #endif
  45
  46 #ifdef NONAMELESSUNION
  47 #define UNION_MEMBER(x) DUMMYUNIONNAME.x
  48 #else
  49 #define UNION_MEMBER(x) x
  50 #endif
  51
  52 #define DEFAULT_SPLIT_POS       300
  53
  54 static const WCHAR registry_key[] = { 'S','o','f','t','w','a','r','e','\\',
  55                                       'W','i','n','e','\\',
  56                                       'W','i','n','e','F','i','l','e','\0'};
  57 static const WCHAR reg_start_x[] = { 's','t','a','r','t','X','\0'};
  58 static const WCHAR reg_start_y[] = { 's','t','a','r','t','Y','\0'};
  59 static const WCHAR reg_width[] = { 'w','i','d','t','h','\0'};
  60 static const WCHAR reg_height[] = { 'h','e','i','g','h','t','\0'};
  61 static const WCHAR reg_logfont[] = { 'l','o','g','f','o','n','t','\0'};
  62
  63 enum ENTRY_TYPE {
  64         ET_WINDOWS,
  65         ET_UNIX,
  66         ET_SHELL
  67 };
  68
  69 typedef struct _Entry {
  70         struct _Entry*  next;
  71         struct _Entry*  down;
  72         struct _Entry*  up;
  73
  74         BOOL                    expanded;
  75         BOOL                    scanned;
  76         int                             level;
  77
  78         WIN32_FIND_DATAW        data;
  79
  80         BY_HANDLE_FILE_INFORMATION bhfi;
  81         BOOL                    bhfi_valid;
  82         enum ENTRY_TYPE etype;
  83         LPITEMIDLIST    pidl;
  84         IShellFolder*   folder;
  85         HICON                   hicon;
  86 } Entry;
  87
  88 typedef struct {
  89         Entry   entry;
  90         WCHAR   path[MAX_PATH];
  91         WCHAR   volname[_MAX_FNAME];
  92         WCHAR   fs[_MAX_DIR];
  93         DWORD   drive_type;
  94         DWORD   fs_flags;
  95 } Root;
  96
  97 enum COLUMN_FLAGS {
  98         COL_SIZE                = 0x01,
  99         COL_DATE                = 0x02,
 100         COL_TIME                = 0x04,
 101         COL_ATTRIBUTES  = 0x08,
 102         COL_DOSNAMES    = 0x10,
 103         COL_INDEX               = 0x20,
 104         COL_LINKS               = 0x40,
 105         COL_ALL = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_DOSNAMES|COL_INDEX|COL_LINKS
 106 };
 107
 108 typedef enum {
 109         SORT_NAME,
 110         SORT_EXT,
 111         SORT_SIZE,
 112         SORT_DATE
 113 } SORT_ORDER;
 114
 115 typedef struct {
 116         HWND    hwnd;
 117         HWND    hwndHeader;
 118
 119 #define COLUMNS 10
 120         int             widths[COLUMNS];
 121         int             positions[COLUMNS+1];
 122
 123         BOOL    treePane;
 124         int             visible_cols;
 125         Entry*  root;
 126         Entry*  cur;
 127 } Pane;
 128
 129 typedef struct {
 130         HWND    hwnd;
 131         Pane    left;
 132         Pane    right;
 133         int             focus_pane;             /* 0: left  1: right */
 134         WINDOWPLACEMENT pos;
 135         int             split_pos;
 136         BOOL    header_wdths_ok;
 137
 138         WCHAR   path[MAX_PATH];
 139         WCHAR   filter_pattern[MAX_PATH];
 140         int             filter_flags;
 141         Root    root;
 142
 143         SORT_ORDER sortOrder;
 144 } ChildWnd;
 145
 146
 147
 148 static void read_directory(Entry* dir, LPCWSTR path, SORT_ORDER sortOrder, HWND hwnd);
 149 static void set_curdir(ChildWnd* child, Entry* entry, int idx, HWND hwnd);
 150 static void refresh_child(ChildWnd* child);
 151 static void refresh_drives(void);
 152 static void get_path(Entry* dir, PWSTR path);
 153 static void format_date(const FILETIME* ft, WCHAR* buffer, int visible_cols);
 154
 155 static LRESULT CALLBACK FrameWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
 156 static LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
 157 static LRESULT CALLBACK TreeWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
 158
 159
 160 /* globals */
 161 WINEFILE_GLOBALS Globals;
 162
 163 static int last_split;
 164
 165 /* some common string constants */
 166 static const WCHAR sEmpty[] = {'\0'};
 167 static const WCHAR sSpace[] = {' ', '\0'};
 168 static const WCHAR sNumFmt[] = {'%','d','\0'};
 169 static const WCHAR sQMarks[] = {'?','?','?','\0'};
 170
 171 /* window class names */
 172 static const WCHAR sWINEFILEFRAME[] = {'W','F','S','_','F','r','a','m','e','\0'};
 173 static const WCHAR sWINEFILETREE[] = {'W','F','S','_','T','r','e','e','\0'};
 174
 175 static void format_longlong(LPWSTR ret, ULONGLONG val)
 176 {
 177     WCHAR buffer[65], *p = &buffer[64];
 178
 179     *p = 0;
 180     do {
 181         *(--p) = '0' + val % 10;
 182         val /= 10;
 183     } while (val);
 184     lstrcpyW( ret, p );
 185 }
 186
 187
 188 /* load resource string */
 189 static LPWSTR load_string(LPWSTR buffer, DWORD size, UINT id)
 190 {
 191         LoadStringW(Globals.hInstance, id, buffer, size);
 192         return buffer;
 193 }
 194
 195 #define RS(b, i) load_string(b, sizeof(b)/sizeof(b[0]), i)
 196
 197
 198 /* display error message for the specified WIN32 error code */
 199 static void display_error(HWND hwnd, DWORD error)
 200 {
 201         WCHAR b1[BUFFER_LEN], b2[BUFFER_LEN];
 202         PWSTR msg;
 203
 204         if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 205                 0, error, MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), (PWSTR)&msg, 0, NULL))
 206                 MessageBoxW(hwnd, msg, RS(b2,IDS_WINEFILE), MB_OK);
 207         else
 208                 MessageBoxW(hwnd, RS(b1,IDS_ERROR), RS(b2,IDS_WINEFILE), MB_OK);
 209
 210         LocalFree(msg);
 211 }
 212
 213
 214 /* display network error message using WNetGetLastErrorW() */
 215 static void display_network_error(HWND hwnd)
 216 {
 217         WCHAR msg[BUFFER_LEN], provider[BUFFER_LEN], b2[BUFFER_LEN];
 218         DWORD error;
 219
 220         if (WNetGetLastErrorW(&error, msg, BUFFER_LEN, provider, BUFFER_LEN) == NO_ERROR)
 221                 MessageBoxW(hwnd, msg, RS(b2,IDS_WINEFILE), MB_OK);
 222 }
 223
 224 static inline BOOL get_check(HWND hwnd, INT id)
 225 {
 226         return BST_CHECKED&SendMessageW(GetDlgItem(hwnd, id), BM_GETSTATE, 0, 0);
 227 }
 228
 229 static inline INT set_check(HWND hwnd, INT id, BOOL on)
 230 {
 231         return SendMessageW(GetDlgItem(hwnd, id), BM_SETCHECK, on?BST_CHECKED:BST_UNCHECKED, 0);
 232 }
 233
 234 static inline void choose_font(HWND hwnd)
 235 {
 236         WCHAR dlg_name[BUFFER_LEN], dlg_info[BUFFER_LEN];
 237         CHOOSEFONTW chFont;
 238         LOGFONTW lFont;
 239
 240         HDC hdc = GetDC(hwnd);
 241
 242         GetObjectW(Globals.hfont, sizeof(LOGFONTW), &lFont);
 243
 244         chFont.lStructSize = sizeof(CHOOSEFONTW);
 245         chFont.hwndOwner = hwnd;
 246         chFont.hDC = NULL;
 247         chFont.lpLogFont = &lFont;
 248         chFont.Flags = CF_SCREENFONTS | CF_FORCEFONTEXIST | CF_LIMITSIZE | CF_NOSCRIPTSEL | CF_INITTOLOGFONTSTRUCT;
 249         chFont.rgbColors = RGB(0,0,0);
 250         chFont.lCustData = 0;
 251         chFont.lpfnHook = NULL;
 252         chFont.lpTemplateName = NULL;
 253         chFont.hInstance = Globals.hInstance;
 254         chFont.lpszStyle = NULL;
 255         chFont.nFontType = SIMULATED_FONTTYPE;
 256         chFont.nSizeMin = 0;
 257         chFont.nSizeMax = 24;
 258
 259         if (ChooseFontW(&chFont)) {
 260                 HWND childWnd;
 261                 HFONT hFontOld;
 262
 263                 DeleteObject(Globals.hfont);
 264                 Globals.hfont = CreateFontIndirectW(&lFont);
 265                 hFontOld = SelectObject(hdc, Globals.hfont);
 266                 GetTextExtentPoint32W(hdc, sSpace, 1, &Globals.spaceSize);
 267
 268                 /* change font in all open child windows */
 269                 for(childWnd=GetWindow(Globals.hmdiclient,GW_CHILD); childWnd; childWnd=GetNextWindow(childWnd,GW_HWNDNEXT)) {
 270                         ChildWnd* child = (ChildWnd*) GetWindowLongPtrW(childWnd, GWLP_USERDATA);
 271                         SendMessageW(child->left.hwnd, WM_SETFONT, (WPARAM)Globals.hfont, TRUE);
 272                         SendMessageW(child->right.hwnd, WM_SETFONT, (WPARAM)Globals.hfont, TRUE);
 273                         SendMessageW(child->left.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));
 274                         SendMessageW(child->right.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));
 275                         InvalidateRect(child->left.hwnd, NULL, TRUE);
 276                         InvalidateRect(child->right.hwnd, NULL, TRUE);
 277                 }
 278
 279                 SelectObject(hdc, hFontOld);
 280         }
 281         else if (CommDlgExtendedError()) {
 282                 LoadStringW(Globals.hInstance, IDS_FONT_SEL_DLG_NAME, dlg_name, BUFFER_LEN);
 283                 LoadStringW(Globals.hInstance, IDS_FONT_SEL_ERROR, dlg_info, BUFFER_LEN);
 284                 MessageBoxW(hwnd, dlg_info, dlg_name, MB_OK);
 285         }
 286
 287         ReleaseDC(hwnd, hdc);
 288 }
 289
 290
 291 /* allocate and initialise a directory entry */
 292 static Entry* alloc_entry(void)
 293 {
 294         Entry* entry = HeapAlloc(GetProcessHeap(), 0, sizeof(Entry));
 295
 296         entry->pidl = NULL;
 297         entry->folder = NULL;
 298         entry->hicon = 0;
 299
 300         return entry;
 301 }
 302
 303 /* free a directory entry */
 304 static void free_entry(Entry* entry)
 305 {
 306         if (entry->hicon && entry->hicon!=(HICON)-1)
 307                 DestroyIcon(entry->hicon);
 308
 309         if (entry->folder && entry->folder!=Globals.iDesktop)
 310                 IShellFolder_Release(entry->folder);
 311
 312         if (entry->pidl)
 313                 IMalloc_Free(Globals.iMalloc, entry->pidl);
 314
 315         HeapFree(GetProcessHeap(), 0, entry);
 316 }
 317
 318 /* recursively free all child entries */
 319 static void free_entries(Entry* dir)
 320 {
 321         Entry *entry, *next=dir->down;
 322
 323         if (next) {
 324                 dir->down = 0;
 325
 326                 do {
 327                         entry = next;
 328                         next = entry->next;
 329
 330                         free_entries(entry);
 331                         free_entry(entry);
 332                 } while(next);
 333         }
 334 }
 335
 336
 337 static void read_directory_win(Entry* dir, LPCWSTR path)
 338 {
 339         Entry* first_entry = NULL;
 340         Entry* last = NULL;
 341         Entry* entry;
 342
 343         int level = dir->level + 1;
 344         WIN32_FIND_DATAW w32fd;
 345         HANDLE hFind;
 346         HANDLE hFile;
 347
 348         WCHAR buffer[MAX_PATH], *p;
 349         for(p=buffer; *path; )
 350                 *p++ = *path++;
 351
 352         *p++ = '\\';
 353         p[0] = '*';
 354         p[1] = '\0';
 355
 356         hFind = FindFirstFileW(buffer, &w32fd);
 357
 358         if (hFind != INVALID_HANDLE_VALUE) {
 359                 do {
 360                         entry = alloc_entry();
 361
 362                         if (!first_entry)
 363                                 first_entry = entry;
 364
 365                         if (last)
 366                                 last->next = entry;
 367
 368                         memcpy(&entry->data, &w32fd, sizeof(WIN32_FIND_DATAW));
 369                         entry->down = NULL;
 370                         entry->up = dir;
 371                         entry->expanded = FALSE;
 372                         entry->scanned = FALSE;
 373                         entry->level = level;
 374                         entry->etype = ET_WINDOWS;
 375                         entry->bhfi_valid = FALSE;
 376
 377                         lstrcpyW(p, entry->data.cFileName);
 378
 379                         hFile = CreateFileW(buffer, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
 380                                                                 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
 381
 382                         if (hFile != INVALID_HANDLE_VALUE) {
 383                                 if (GetFileInformationByHandle(hFile, &entry->bhfi))
 384                                         entry->bhfi_valid = TRUE;
 385
 386                                 CloseHandle(hFile);
 387                         }
 388
 389                         last = entry;
 390                 } while(FindNextFileW(hFind, &w32fd));
 391
 392                 if (last)
 393                         last->next = NULL;
 394
 395                 FindClose(hFind);
 396         }
 397
 398         dir->down = first_entry;
 399         dir->scanned = TRUE;
 400 }
 401
 402
 403 static Entry* find_entry_win(Entry* dir, LPCWSTR name)
 404 {
 405         Entry* entry;
 406
 407         for(entry=dir->down; entry; entry=entry->next) {
 408                 LPCWSTR p = name;
 409                 LPCWSTR q = entry->data.cFileName;
 410
 411                 do {
 412                         if (!*p || *p == '\\' || *p == '/')
 413                                 return entry;
 414                 } while(tolower(*p++) == tolower(*q++));
 415
 416                 p = name;
 417                 q = entry->data.cAlternateFileName;
 418
 419                 do {
 420                         if (!*p || *p == '\\' || *p == '/')
 421                                 return entry;
 422                 } while(tolower(*p++) == tolower(*q++));
 423         }
 424
 425         return 0;
 426 }
 427
 428
 429 static Entry* read_tree_win(Root* root, LPCWSTR path, SORT_ORDER sortOrder, HWND hwnd)
 430 {
 431         WCHAR buffer[MAX_PATH];
 432         Entry* entry = &root->entry;
 433         LPCWSTR s = path;
 434         PWSTR d = buffer;
 435
 436         HCURSOR old_cursor = SetCursor(LoadCursorW(0, (LPCWSTR)IDC_WAIT));
 437
 438         entry->etype = ET_WINDOWS;
 439         while(entry) {
 440                 while(*s && *s != '\\' && *s != '/')
 441                         *d++ = *s++;
 442
 443                 while(*s == '\\' || *s == '/')
 444                         s++;
 445
 446                 *d++ = '\\';
 447                 *d = '\0';
 448
 449                 read_directory(entry, buffer, sortOrder, hwnd);
 450
 451                 if (entry->down)
 452                         entry->expanded = TRUE;
 453
 454                 if (!*s)
 455                         break;
 456
 457                 entry = find_entry_win(entry, s);
 458         }
 459
 460         SetCursor(old_cursor);
 461
 462         return entry;
 463 }
 464
 465
 466 #ifdef __WINE__
 467
 468 static BOOL time_to_filetime(time_t t, FILETIME* ftime)
 469 {
 470         struct tm* tm = gmtime(&t);
 471         SYSTEMTIME stime;
 472
 473         if (!tm)
 474                 return FALSE;
 475
 476         stime.wYear = tm->tm_year+1900;
 477         stime.wMonth = tm->tm_mon+1;
 478         /*      stime.wDayOfWeek */
 479         stime.wDay = tm->tm_mday;
 480         stime.wHour = tm->tm_hour;
 481         stime.wMinute = tm->tm_min;
 482         stime.wSecond = tm->tm_sec;
 483         stime.wMilliseconds = 0;
 484
 485         return SystemTimeToFileTime(&stime, ftime);
 486 }
 487
 488 static void read_directory_unix(Entry* dir, LPCWSTR path)
 489 {
 490         Entry* first_entry = NULL;
 491         Entry* last = NULL;
 492         Entry* entry;
 493         DIR* pdir;
 494
 495         int level = dir->level + 1;
 496         char cpath[MAX_PATH];
 497
 498         WideCharToMultiByte(CP_UNIXCP, 0, path, -1, cpath, MAX_PATH, NULL, NULL);
 499         pdir = opendir(cpath);
 500
 501         if (pdir) {
 502                 struct stat st;
 503                 struct dirent* ent;
 504                 char buffer[MAX_PATH], *p;
 505                 const char* s;
 506
 507                 for(p=buffer,s=cpath; *s; )
 508                         *p++ = *s++;
 509
 510                 if (p==buffer || p[-1]!='/')
 511                         *p++ = '/';
 512
 513                 while((ent=readdir(pdir))) {
 514                         entry = alloc_entry();
 515
 516                         if (!first_entry)
 517                                 first_entry = entry;
 518
 519                         if (last)
 520                                 last->next = entry;
 521
 522                         entry->etype = ET_UNIX;
 523
 524                         strcpy(p, ent->d_name);
 525                         MultiByteToWideChar(CP_UNIXCP, 0, p, -1, entry->data.cFileName, MAX_PATH);
 526
 527                         if (!stat(buffer, &st)) {
 528                                 entry->data.dwFileAttributes = p[0]=='.'? FILE_ATTRIBUTE_HIDDEN: 0;
 529
 530                                 if (S_ISDIR(st.st_mode))
 531                                         entry->data.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
 532
 533                                 entry->data.nFileSizeLow = st.st_size & 0xFFFFFFFF;
 534                                 entry->data.nFileSizeHigh = st.st_size >> 32;
 535
 536                                 memset(&entry->data.ftCreationTime, 0, sizeof(FILETIME));
 537                                 time_to_filetime(st.st_atime, &entry->data.ftLastAccessTime);
 538                                 time_to_filetime(st.st_mtime, &entry->data.ftLastWriteTime);
 539
 540                                 entry->bhfi.nFileIndexLow = ent->d_ino;
 541                                 entry->bhfi.nFileIndexHigh = 0;
 542
 543                                 entry->bhfi.nNumberOfLinks = st.st_nlink;
 544
 545                                 entry->bhfi_valid = TRUE;
 546                         } else {
 547                                 entry->data.nFileSizeLow = 0;
 548                                 entry->data.nFileSizeHigh = 0;
 549                                 entry->bhfi_valid = FALSE;
 550                         }
 551
 552                         entry->down = NULL;
 553                         entry->up = dir;
 554                         entry->expanded = FALSE;
 555                         entry->scanned = FALSE;
 556                         entry->level = level;
 557
 558                         last = entry;
 559                 }
 560
 561                 if (last)
 562                         last->next = NULL;
 563
 564                 closedir(pdir);
 565         }
 566
 567         dir->down = first_entry;
 568         dir->scanned = TRUE;
 569 }
 570
 571 static Entry* find_entry_unix(Entry* dir, LPCWSTR name)
 572 {
 573         Entry* entry;
 574
 575         for(entry=dir->down; entry; entry=entry->next) {
 576                 LPCWSTR p = name;
 577                 LPCWSTR q = entry->data.cFileName;
 578
 579                 do {
 580                         if (!*p || *p == '/')
 581                                 return entry;
 582                 } while(*p++ == *q++);
 583         }
 584
 585         return 0;
 586 }
 587
 588 static Entry* read_tree_unix(Root* root, LPCWSTR path, SORT_ORDER sortOrder, HWND hwnd)
 589 {
 590         WCHAR buffer[MAX_PATH];
 591         Entry* entry = &root->entry;
 592         LPCWSTR s = path;
 593         PWSTR d = buffer;
 594
 595         HCURSOR old_cursor = SetCursor(LoadCursorW(0, (LPCWSTR)IDC_WAIT));
 596
 597         entry->etype = ET_UNIX;
 598
 599         while(entry) {
 600                 while(*s && *s != '/')
 601                         *d++ = *s++;
 602
 603                 while(*s == '/')
 604                         s++;
 605
 606                 *d++ = '/';
 607                 *d = '\0';
 608
 609                 read_directory(entry, buffer, sortOrder, hwnd);
 610
 611                 if (entry->down)
 612                         entry->expanded = TRUE;
 613
 614                 if (!*s)
 615                         break;
 616
 617                 entry = find_entry_unix(entry, s);
 618         }
 619
 620         SetCursor(old_cursor);
 621
 622         return entry;
 623 }
 624
 625 #endif /* __WINE__ */
 626
 627 static void free_strret(STRRET* str)
 628 {
 629         if (str->uType == STRRET_WSTR)
 630                 IMalloc_Free(Globals.iMalloc, str->UNION_MEMBER(pOleStr));
 631 }
 632
 633 static LPWSTR wcscpyn(LPWSTR dest, LPCWSTR source, size_t count)
 634 {
 635  LPCWSTR s;
 636  LPWSTR d = dest;
 637
 638  for(s=source; count&&(*d++=*s++); )
 639   count--;
 640
 641  return dest;
 642 }
 643
 644 static void get_strretW(STRRET* str, const SHITEMID* shiid, LPWSTR buffer, int len)
 645 {
 646  switch(str->uType) {
 647   case STRRET_WSTR:
 648         wcscpyn(buffer, str->UNION_MEMBER(pOleStr), len);
 649         break;
 650
 651   case STRRET_OFFSET:
 652         MultiByteToWideChar(CP_ACP, 0, (LPCSTR)shiid+str->UNION_MEMBER(uOffset), -1, buffer, len);
 653         break;
 654
 655   case STRRET_CSTR:
 656         MultiByteToWideChar(CP_ACP, 0, str->UNION_MEMBER(cStr), -1, buffer, len);
 657  }
 658 }
 659
 660
 661 static HRESULT name_from_pidl(IShellFolder* folder, LPITEMIDLIST pidl, LPWSTR buffer, int len, SHGDNF flags)
 662 {
 663         STRRET str;
 664
 665         HRESULT hr = IShellFolder_GetDisplayNameOf(folder, pidl, flags, &str);
 666
 667         if (SUCCEEDED(hr)) {
 668                 get_strretW(&str, &pidl->mkid, buffer, len);
 669                 free_strret(&str);
 670         } else
 671                 buffer[0] = '\0';
 672
 673         return hr;
 674 }
 675
 676
 677 static HRESULT path_from_pidlW(IShellFolder* folder, LPITEMIDLIST pidl, LPWSTR buffer, int len)
 678 {
 679         STRRET str;
 680
 681          /* SHGDN_FORPARSING: get full path of id list */
 682         HRESULT hr = IShellFolder_GetDisplayNameOf(folder, pidl, SHGDN_FORPARSING, &str);
 683
 684         if (SUCCEEDED(hr)) {
 685                 get_strretW(&str, &pidl->mkid, buffer, len);
 686                 free_strret(&str);
 687         } else
 688                 buffer[0] = '\0';
 689
 690         return hr;
 691 }
 692
 693
 694  /* create an item id list from a file system path */
 695
 696 static LPITEMIDLIST get_path_pidl(LPWSTR path, HWND hwnd)
 697 {
 698         LPITEMIDLIST pidl;
 699         HRESULT hr;
 700         ULONG len;
 701         LPWSTR buffer = path;
 702
 703         hr = IShellFolder_ParseDisplayName(Globals.iDesktop, hwnd, NULL, buffer, &len, &pidl, NULL);
 704         if (FAILED(hr))
 705                 return NULL;
 706
 707         return pidl;
 708 }
 709
 710
 711  /* convert an item id list from relative to absolute (=relative to the desktop) format */
 712
 713 static LPITEMIDLIST get_to_absolute_pidl(Entry* entry, HWND hwnd)
 714 {
 715         if (entry->up && entry->up->etype==ET_SHELL) {
 716                 LPITEMIDLIST idl = NULL;
 717
 718                 while (entry->up) {
 719                         idl = ILCombine(ILClone(entry->pidl), idl);
 720                         entry = entry->up;
 721                 }
 722
 723                 return idl;
 724         } else if (entry->etype == ET_WINDOWS) {
 725                 WCHAR path[MAX_PATH];
 726
 727                 get_path(entry, path);
 728
 729                 return get_path_pidl(path, hwnd);
 730         } else if (entry->pidl)
 731                 return ILClone(entry->pidl);
 732
 733         return NULL;
 734 }
 735
 736
 737 static HICON extract_icon(IShellFolder* folder, LPCITEMIDLIST pidl)
 738 {
 739         IExtractIconW* pExtract;
 740
 741         if (SUCCEEDED(IShellFolder_GetUIObjectOf(folder, 0, 1, (LPCITEMIDLIST*)&pidl, &IID_IExtractIconW, 0, (LPVOID*)&pExtract))) {
 742                 WCHAR path[_MAX_PATH];
 743                 unsigned flags;
 744                 HICON hicon;
 745                 int idx;
 746
 747                 if (SUCCEEDED(IExtractIconW_GetIconLocation(pExtract, GIL_FORSHELL, path, _MAX_PATH, &idx, &flags))) {
 748                         if (!(flags & GIL_NOTFILENAME)) {
 749                                 if (idx == -1)
 750                                         idx = 0;        /* special case for some control panel applications */
 751
 752                                 if ((int)ExtractIconExW(path, idx, 0, &hicon, 1) > 0)
 753                                         flags &= ~GIL_DONTCACHE;
 754                         } else {
 755                                 HICON hIconLarge = 0;
 756
 757                                 HRESULT hr = IExtractIconW_Extract(pExtract, path, idx, &hIconLarge, &hicon, MAKELONG(0/*GetSystemMetrics(SM_CXICON)*/,GetSystemMetrics(SM_CXSMICON)));
 758
 759                                 if (SUCCEEDED(hr))
 760                                         DestroyIcon(hIconLarge);
 761                         }
 762
 763                         return hicon;
 764                 }
 765         }
 766
 767         return 0;
 768 }
 769
 770
 771 static Entry* find_entry_shell(Entry* dir, LPCITEMIDLIST pidl)
 772 {
 773         Entry* entry;
 774
 775         for(entry=dir->down; entry; entry=entry->next) {
 776                 if (entry->pidl->mkid.cb == pidl->mkid.cb &&
 777                         !memcmp(entry->pidl, pidl, entry->pidl->mkid.cb))
 778                         return entry;
 779         }
 780
 781         return 0;
 782 }
 783
 784 static Entry* read_tree_shell(Root* root, LPITEMIDLIST pidl, SORT_ORDER sortOrder, HWND hwnd)
 785 {
 786         Entry* entry = &root->entry;
 787         Entry* next;
 788         LPITEMIDLIST next_pidl = pidl;
 789         IShellFolder* folder;
 790         IShellFolder* child = NULL;
 791         HRESULT hr;
 792
 793         HCURSOR old_cursor = SetCursor(LoadCursorW(0, (LPCWSTR)IDC_WAIT));
 794
 795         entry->etype = ET_SHELL;
 796         folder = Globals.iDesktop;
 797
 798         while(entry) {
 799                 entry->pidl = next_pidl;
 800                 entry->folder = folder;
 801
 802                 if (!pidl->mkid.cb)
 803                         break;
 804
 805                  /* copy first element of item idlist */
 806                 next_pidl = IMalloc_Alloc(Globals.iMalloc, pidl->mkid.cb+sizeof(USHORT));
 807                 memcpy(next_pidl, pidl, pidl->mkid.cb);
 808                 ((LPITEMIDLIST)((LPBYTE)next_pidl+pidl->mkid.cb))->mkid.cb = 0;
 809
 810                 hr = IShellFolder_BindToObject(folder, next_pidl, 0, &IID_IShellFolder, (void**)&child);
 811                 if (FAILED(hr))
 812                         break;
 813
 814                 read_directory(entry, NULL, sortOrder, hwnd);
 815
 816                 if (entry->down)
 817                         entry->expanded = TRUE;
 818
 819                 next = find_entry_shell(entry, next_pidl);
 820                 if (!next)
 821                         break;
 822
 823                 folder = child;
 824                 entry = next;
 825
 826                  /* go to next element */
 827                 pidl = (LPITEMIDLIST) ((LPBYTE)pidl+pidl->mkid.cb);
 828         }
 829
 830         SetCursor(old_cursor);
 831
 832         return entry;
 833 }
 834
 835
 836 static void fill_w32fdata_shell(IShellFolder* folder, LPCITEMIDLIST pidl, SFGAOF attribs, WIN32_FIND_DATAW* w32fdata)
 837 {
 838         if (!(attribs & SFGAO_FILESYSTEM) ||
 839                         FAILED(SHGetDataFromIDListW(folder, pidl, SHGDFIL_FINDDATA, w32fdata, sizeof(WIN32_FIND_DATAW)))) {
 840                 WIN32_FILE_ATTRIBUTE_DATA fad;
 841                 IDataObject* pDataObj;
 842
 843                 STGMEDIUM medium = {0, {0}, 0};
 844                 FORMATETC fmt = {Globals.cfStrFName, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
 845
 846                 HRESULT hr = IShellFolder_GetUIObjectOf(folder, 0, 1, &pidl, &IID_IDataObject, 0, (LPVOID*)&pDataObj);
 847
 848                 if (SUCCEEDED(hr)) {
 849                         hr = IDataObject_GetData(pDataObj, &fmt, &medium);
 850
 851                         IDataObject_Release(pDataObj);
 852
 853                         if (SUCCEEDED(hr)) {
 854                                 LPCWSTR path = GlobalLock(medium.UNION_MEMBER(hGlobal));
 855                                 UINT sem_org = SetErrorMode(SEM_FAILCRITICALERRORS);
 856
 857                                 if (GetFileAttributesExW(path, GetFileExInfoStandard, &fad)) {
 858                                         w32fdata->dwFileAttributes = fad.dwFileAttributes;
 859                                         w32fdata->ftCreationTime = fad.ftCreationTime;
 860                                         w32fdata->ftLastAccessTime = fad.ftLastAccessTime;
 861                                         w32fdata->ftLastWriteTime = fad.ftLastWriteTime;
 862
 863                                         if (!(fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 864                                                 w32fdata->nFileSizeLow = fad.nFileSizeLow;
 865                                                 w32fdata->nFileSizeHigh = fad.nFileSizeHigh;
 866                                         }
 867                                 }
 868
 869                                 SetErrorMode(sem_org);
 870
 871                                 GlobalUnlock(medium.UNION_MEMBER(hGlobal));
 872                                 GlobalFree(medium.UNION_MEMBER(hGlobal));
 873                         }
 874                 }
 875         }
 876
 877         if (attribs & (SFGAO_FOLDER|SFGAO_HASSUBFOLDER))
 878                 w32fdata->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
 879
 880         if (attribs & SFGAO_READONLY)
 881                 w32fdata->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
 882
 883         if (attribs & SFGAO_COMPRESSED)
 884                 w32fdata->dwFileAttributes |= FILE_ATTRIBUTE_COMPRESSED;
 885 }
 886
 887
 888 static void read_directory_shell(Entry* dir, HWND hwnd)
 889 {
 890         IShellFolder* folder = dir->folder;
 891         int level = dir->level + 1;
 892         HRESULT hr;
 893
 894         IShellFolder* child;
 895         IEnumIDList* idlist;
 896
 897         Entry* first_entry = NULL;
 898         Entry* last = NULL;
 899         Entry* entry;
 900
 901         if (!folder)
 902                 return;
 903
 904         hr = IShellFolder_EnumObjects(folder, hwnd, SHCONTF_FOLDERS|SHCONTF_NONFOLDERS|SHCONTF_INCLUDEHIDDEN|SHCONTF_SHAREABLE|SHCONTF_STORAGE, &idlist);
 905
 906         if (SUCCEEDED(hr)) {
 907                 for(;;) {
 908 #define FETCH_ITEM_COUNT        32
 909                         LPITEMIDLIST pidls[FETCH_ITEM_COUNT];
 910                         SFGAOF attribs;
 911                         ULONG cnt = 0;
 912                         ULONG n;
 913
 914                         memset(pidls, 0, sizeof(pidls));
 915
 916                         hr = IEnumIDList_Next(idlist, FETCH_ITEM_COUNT, pidls, &cnt);
 917                         if (FAILED(hr))
 918                                 break;
 919
 920                         if (hr == S_FALSE)
 921                                 break;
 922
 923                         for(n=0; n<cnt; ++n) {
 924                                 entry = alloc_entry();
 925
 926                                 if (!first_entry)
 927                                         first_entry = entry;
 928
 929                                 if (last)
 930                                         last->next = entry;
 931
 932                                 memset(&entry->data, 0, sizeof(WIN32_FIND_DATAW));
 933                                 entry->bhfi_valid = FALSE;
 934
 935                                 attribs = ~SFGAO_FILESYSTEM;    /*SFGAO_HASSUBFOLDER|SFGAO_FOLDER; SFGAO_FILESYSTEM sorgt dafür, daß "My Documents" anstatt von "Martin's Documents" angezeigt wird */
 936
 937                                 hr = IShellFolder_GetAttributesOf(folder, 1, (LPCITEMIDLIST*)&pidls[n], &attribs);
 938
 939                                 if (SUCCEEDED(hr)) {
 940                                         if (attribs != (SFGAOF)~SFGAO_FILESYSTEM) {
 941                                                 fill_w32fdata_shell(folder, pidls[n], attribs, &entry->data);
 942
 943                                                 entry->bhfi_valid = TRUE;
 944                                         } else
 945                                                 attribs = 0;
 946                                 } else
 947                                         attribs = 0;
 948
 949                                 entry->pidl = pidls[n];
 950
 951                                 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
 952                                         hr = IShellFolder_BindToObject(folder, pidls[n], 0, &IID_IShellFolder, (void**)&child);
 953
 954                                         if (SUCCEEDED(hr))
 955                                                 entry->folder = child;
 956                                         else
 957                                                 entry->folder = NULL;
 958                                 }
 959                                 else
 960                                         entry->folder = NULL;
 961
 962                                 if (!entry->data.cFileName[0])
 963                                         /*hr = */name_from_pidl(folder, pidls[n], entry->data.cFileName, MAX_PATH, /*SHGDN_INFOLDER*/0x2000/*0x2000=SHGDN_INCLUDE_NONFILESYS*/);
 964
 965                                  /* get display icons for files and virtual objects */
 966                                 if (!(entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
 967                                         !(attribs & SFGAO_FILESYSTEM)) {
 968                                         entry->hicon = extract_icon(folder, pidls[n]);
 969
 970                                         if (!entry->hicon)
 971                                                 entry->hicon = (HICON)-1;       /* don't try again later */
 972                                 }
 973
 974                                 entry->down = NULL;
 975                                 entry->up = dir;
 976                                 entry->expanded = FALSE;
 977                                 entry->scanned = FALSE;
 978                                 entry->level = level;
 979
 980                                 entry->etype = ET_SHELL;
 981                                 entry->bhfi_valid = FALSE;
 982
 983                                 last = entry;
 984                         }
 985                 }
 986
 987                 IEnumIDList_Release(idlist);
 988         }
 989
 990         if (last)
 991                 last->next = NULL;
 992
 993         dir->down = first_entry;
 994         dir->scanned = TRUE;
 995 }
 996
 997 /* sort order for different directory/file types */
 998 enum TYPE_ORDER {
 999         TO_DIR = 0,
1000         TO_DOT = 1,
1001         TO_DOTDOT = 2,
1002         TO_OTHER_DIR = 3,
1003         TO_FILE = 4
1004 };
1005
1006 /* distinguish between ".", ".." and any other directory names */
1007 static int TypeOrderFromDirname(LPCWSTR name)
1008 {
1009         if (name[0] == '.') {
1010                 if (name[1] == '\0')
1011                         return TO_DOT;  /* "." */
1012
1013                 if (name[1]=='.' && name[2]=='\0')
1014                         return TO_DOTDOT;       /* ".." */
1015         }
1016
1017         return TO_OTHER_DIR;    /* anything else */
1018 }
1019
1020 /* directories first... */
1021 static int compareType(const WIN32_FIND_DATAW* fd1, const WIN32_FIND_DATAW* fd2)
1022 {
1023         int order1 = fd1->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY? TO_DIR: TO_FILE;
1024         int order2 = fd2->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY? TO_DIR: TO_FILE;
1025
1026         /* Handle "." and ".." as special case and move them at the very first beginning. */
1027         if (order1==TO_DIR && order2==TO_DIR) {
1028                 order1 = TypeOrderFromDirname(fd1->cFileName);
1029                 order2 = TypeOrderFromDirname(fd2->cFileName);
1030         }
1031
1032         return order2==order1? 0: order1<order2? -1: 1;
1033 }
1034
1035
1036 static int compareName(const void* arg1, const void* arg2)
1037 {
1038         const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
1039         const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;
1040
1041         int cmp = compareType(fd1, fd2);
1042         if (cmp)
1043                 return cmp;
1044
1045         return lstrcmpiW(fd1->cFileName, fd2->cFileName);
1046 }
1047
1048 static int compareExt(const void* arg1, const void* arg2)
1049 {
1050         const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
1051         const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;
1052         const WCHAR *name1, *name2, *ext1, *ext2;
1053
1054         int cmp = compareType(fd1, fd2);
1055         if (cmp)
1056                 return cmp;
1057
1058         name1 = fd1->cFileName;
1059         name2 = fd2->cFileName;
1060
1061         ext1 = strrchrW(name1, '.');
1062         ext2 = strrchrW(name2, '.');
1063
1064         if (ext1)
1065                 ext1++;
1066         else
1067                 ext1 = sEmpty;
1068
1069         if (ext2)
1070                 ext2++;
1071         else
1072                 ext2 = sEmpty;
1073
1074         cmp = lstrcmpiW(ext1, ext2);
1075         if (cmp)
1076                 return cmp;
1077
1078         return lstrcmpiW(name1, name2);
1079 }
1080
1081 static int compareSize(const void* arg1, const void* arg2)
1082 {
1083         const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
1084         const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;
1085
1086         int cmp = compareType(fd1, fd2);
1087         if (cmp)
1088                 return cmp;
1089
1090         cmp = fd2->nFileSizeHigh - fd1->nFileSizeHigh;
1091
1092         if (cmp < 0)
1093                 return -1;
1094         else if (cmp > 0)
1095                 return 1;
1096
1097         cmp = fd2->nFileSizeLow - fd1->nFileSizeLow;
1098
1099         return cmp<0? -1: cmp>0? 1: 0;
1100 }
1101
1102 static int compareDate(const void* arg1, const void* arg2)
1103 {
1104         const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
1105         const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;
1106
1107         int cmp = compareType(fd1, fd2);
1108         if (cmp)
1109                 return cmp;
1110
1111         return CompareFileTime(&fd2->ftLastWriteTime, &fd1->ftLastWriteTime);
1112 }
1113
1114
1115 static int (*sortFunctions[])(const void* arg1, const void* arg2) = {
1116         compareName,    /* SORT_NAME */
1117         compareExt,             /* SORT_EXT */
1118         compareSize,    /* SORT_SIZE */
1119         compareDate             /* SORT_DATE */
1120 };
1121
1122
1123 static void SortDirectory(Entry* dir, SORT_ORDER sortOrder)
1124 {
1125         Entry* entry;
1126         Entry** array, **p;
1127         int len;
1128
1129         len = 0;
1130         for(entry=dir->down; entry; entry=entry->next)
1131                 len++;
1132
1133         if (len) {
1134                 array = HeapAlloc(GetProcessHeap(), 0, len*sizeof(Entry*));
1135
1136                 p = array;
1137                 for(entry=dir->down; entry; entry=entry->next)
1138                         *p++ = entry;
1139
1140                 /* call qsort with the appropriate compare function */
1141                 qsort(array, len, sizeof(array[0]), sortFunctions[sortOrder]);
1142
1143                 dir->down = array[0];
1144
1145                 for(p=array; --len; p++)
1146                         p[0]->next = p[1];
1147
1148                 (*p)->next = 0;
1149
1150                 HeapFree(GetProcessHeap(), 0, array);
1151         }
1152 }
1153
1154
1155 static void read_directory(Entry* dir, LPCWSTR path, SORT_ORDER sortOrder, HWND hwnd)
1156 {
1157         WCHAR buffer[MAX_PATH];
1158         Entry* entry;
1159         LPCWSTR s;
1160         PWSTR d;
1161
1162         if (dir->etype == ET_SHELL)
1163         {
1164                 read_directory_shell(dir, hwnd);
1165
1166                 if (Globals.prescan_node) {
1167                         s = path;
1168                         d = buffer;
1169
1170                         while(*s)
1171                                 *d++ = *s++;
1172
1173                         *d++ = '\\';
1174
1175                         for(entry=dir->down; entry; entry=entry->next)
1176                                 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1177                                         read_directory_shell(entry, hwnd);
1178                                         SortDirectory(entry, sortOrder);
1179                                 }
1180                 }
1181         }
1182         else
1183 #ifdef __WINE__
1184         if (dir->etype == ET_UNIX)
1185         {
1186                 read_directory_unix(dir, path);
1187
1188                 if (Globals.prescan_node) {
1189                         s = path;
1190                         d = buffer;
1191
1192                         while(*s)
1193                                 *d++ = *s++;
1194
1195                         *d++ = '/';
1196
1197                         for(entry=dir->down; entry; entry=entry->next)
1198                                 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1199                                         lstrcpyW(d, entry->data.cFileName);
1200                                         read_directory_unix(entry, buffer);
1201                                         SortDirectory(entry, sortOrder);
1202                                 }
1203                 }
1204         }
1205         else
1206 #endif
1207         {
1208                 read_directory_win(dir, path);
1209
1210                 if (Globals.prescan_node) {
1211                         s = path;
1212                         d = buffer;
1213
1214                         while(*s)
1215                                 *d++ = *s++;
1216
1217                         *d++ = '\\';
1218
1219                         for(entry=dir->down; entry; entry=entry->next)
1220                                 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1221                                         lstrcpyW(d, entry->data.cFileName);
1222                                         read_directory_win(entry, buffer);
1223                                         SortDirectory(entry, sortOrder);
1224                                 }
1225                 }
1226         }
1227
1228         SortDirectory(dir, sortOrder);
1229 }
1230
1231
1232 static Entry* read_tree(Root* root, LPCWSTR path, LPITEMIDLIST pidl, LPWSTR drv, SORT_ORDER sortOrder, HWND hwnd)
1233 {
1234 #ifdef __WINE__
1235         static const WCHAR sSlash[] = {'/', '\0'};
1236 #endif
1237         static const WCHAR sBackslash[] = {'\\', '\0'};
1238
1239         if (pidl)
1240         {
1241                  /* read shell namespace tree */
1242                 root->drive_type = DRIVE_UNKNOWN;
1243                 drv[0] = '\\';
1244                 drv[1] = '\0';
1245                 load_string(root->volname, sizeof(root->volname)/sizeof(root->volname[0]), IDS_DESKTOP);
1246                 root->fs_flags = 0;
1247                 load_string(root->fs, sizeof(root->fs)/sizeof(root->fs[0]), IDS_SHELL);
1248
1249                 return read_tree_shell(root, pidl, sortOrder, hwnd);
1250         }
1251         else
1252 #ifdef __WINE__
1253         if (*path == '/')
1254         {
1255                 /* read unix file system tree */
1256                 root->drive_type = GetDriveTypeW(path);
1257
1258                 lstrcatW(drv, sSlash);
1259                 load_string(root->volname, sizeof(root->volname)/sizeof(root->volname[0]), IDS_ROOT_FS);
1260                 root->fs_flags = 0;
1261                 load_string(root->fs, sizeof(root->fs)/sizeof(root->fs[0]), IDS_UNIXFS);
1262
1263                 lstrcpyW(root->path, sSlash);
1264
1265                 return read_tree_unix(root, path, sortOrder, hwnd);
1266         }
1267 #endif
1268
1269          /* read WIN32 file system tree */
1270        root->drive_type = GetDriveTypeW(path);
1271
1272         lstrcatW(drv, sBackslash);
1273         GetVolumeInformationW(drv, root->volname, _MAX_FNAME, 0, 0, &root->fs_flags, root->fs, _MAX_DIR);
1274
1275         lstrcpyW(root->path, drv);
1276
1277         return read_tree_win(root, path, sortOrder, hwnd);
1278 }
1279
1280
1281 /* flags to filter different file types */
1282 enum TYPE_FILTER {
1283         TF_DIRECTORIES  = 0x01,
1284         TF_PROGRAMS             = 0x02,
1285         TF_DOCUMENTS    = 0x04,
1286         TF_OTHERS               = 0x08,
1287         TF_HIDDEN               = 0x10,
1288         TF_ALL                  = 0x1F
1289 };
1290
1291
1292 static ChildWnd* alloc_child_window(LPCWSTR path, LPITEMIDLIST pidl, HWND hwnd)
1293 {
1294         WCHAR drv[_MAX_DRIVE+1], dir[_MAX_DIR], name[_MAX_FNAME], ext[_MAX_EXT];
1295         WCHAR dir_path[MAX_PATH];
1296         static const WCHAR sAsterics[] = {'*', '\0'};
1297         static const WCHAR sTitleFmt[] = {'%','s',' ','-',' ','%','s','\0'};
1298
1299         ChildWnd* child = HeapAlloc(GetProcessHeap(), 0, sizeof(ChildWnd));
1300         Root* root = &child->root;
1301         Entry* entry;
1302
1303         memset(child, 0, sizeof(ChildWnd));
1304
1305         child->left.treePane = TRUE;
1306         child->left.visible_cols = 0;
1307
1308         child->right.treePane = FALSE;
1309         child->right.visible_cols = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_INDEX|COL_LINKS;
1310
1311         child->pos.length = sizeof(WINDOWPLACEMENT);
1312         child->pos.flags = 0;
1313         child->pos.showCmd = SW_SHOWNORMAL;
1314         child->pos.rcNormalPosition.left = CW_USEDEFAULT;
1315         child->pos.rcNormalPosition.top = CW_USEDEFAULT;
1316         child->pos.rcNormalPosition.right = CW_USEDEFAULT;
1317         child->pos.rcNormalPosition.bottom = CW_USEDEFAULT;
1318
1319         child->focus_pane = 0;
1320         child->split_pos = DEFAULT_SPLIT_POS;
1321         child->sortOrder = SORT_NAME;
1322         child->header_wdths_ok = FALSE;
1323
1324         if (path)
1325         {
1326                 lstrcpyW(child->path, path);
1327
1328                 _wsplitpath(path, drv, dir, name, ext);
1329         }
1330
1331         lstrcpyW(child->filter_pattern, sAsterics);
1332         child->filter_flags = TF_ALL;
1333
1334         root->entry.level = 0;
1335
1336         lstrcpyW(dir_path, drv);
1337         lstrcatW(dir_path, dir);
1338         entry = read_tree(root, dir_path, pidl, drv, child->sortOrder, hwnd);
1339
1340         if (root->entry.etype == ET_SHELL)
1341                 load_string(root->entry.data.cFileName, sizeof(root->entry.data.cFileName)/sizeof(root->entry.data.cFileName[0]), IDS_DESKTOP);
1342         else
1343                 wsprintfW(root->entry.data.cFileName, sTitleFmt, drv, root->fs);
1344
1345         root->entry.data.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
1346
1347         child->left.root = &root->entry;
1348         child->right.root = NULL;
1349
1350         set_curdir(child, entry, 0, hwnd);
1351
1352         return child;
1353 }
1354
1355
1356 /* free all memory associated with a child window */
1357 static void free_child_window(ChildWnd* child)
1358 {
1359         free_entries(&child->root.entry);
1360         HeapFree(GetProcessHeap(), 0, child);
1361 }
1362
1363
1364 /* get full path of specified directory entry */
1365 static void get_path(Entry* dir, PWSTR path)
1366 {
1367         Entry* entry;
1368         int len = 0;
1369         int level = 0;
1370
1371         if (dir->etype == ET_SHELL)
1372         {
1373                 SFGAOF attribs;
1374                 HRESULT hr = S_OK;
1375
1376                 path[0] = '\0';
1377
1378                 attribs = 0;
1379
1380                 if (dir->folder)
1381                         hr = IShellFolder_GetAttributesOf(dir->folder, 1, (LPCITEMIDLIST*)&dir->pidl, &attribs);
1382
1383                 if (SUCCEEDED(hr) && (attribs&SFGAO_FILESYSTEM)) {
1384                         IShellFolder* parent = dir->up? dir->up->folder: Globals.iDesktop;
1385
1386                         hr = path_from_pidlW(parent, dir->pidl, path, MAX_PATH);
1387                 }
1388         }
1389         else
1390         {
1391                 for(entry=dir; entry; level++) {
1392                         LPCWSTR name;
1393                         int l;
1394
1395                         {
1396                                 LPCWSTR s;
1397                                 name = entry->data.cFileName;
1398                                 s = name;
1399
1400                                 for(l=0; *s && *s != '/' && *s != '\\'; s++)
1401                                         l++;
1402                         }
1403
1404                         if (entry->up) {
1405                                 if (l > 0) {
1406                                         memmove(path+l+1, path, len*sizeof(WCHAR));
1407                                         memcpy(path+1, name, l*sizeof(WCHAR));
1408                                         len += l+1;
1409
1410                                         if (entry->etype == ET_UNIX)
1411                                                 path[0] = '/';
1412                                         else
1413                                                 path[0] = '\\';
1414                                 }
1415
1416                                 entry = entry->up;
1417                         } else {
1418                                 memmove(path+l, path, len*sizeof(WCHAR));
1419                                 memcpy(path, name, l*sizeof(WCHAR));
1420                                 len += l;
1421                                 break;
1422                         }
1423                 }
1424
1425                 if (!level) {
1426                         if (entry->etype == ET_UNIX)
1427                                 path[len++] = '/';
1428                         else
1429                                 path[len++] = '\\';
1430                 }
1431
1432                 path[len] = '\0';
1433         }
1434 }
1435
1436 static windowOptions load_registry_settings(void)
1437 {
1438         DWORD size;
1439         DWORD type;
1440         HKEY hKey;
1441         windowOptions opts;
1442         LOGFONTW logfont;
1443
1444         RegOpenKeyExW( HKEY_CURRENT_USER, registry_key,
1445                        0, KEY_QUERY_VALUE, &hKey );
1446
1447         size = sizeof(DWORD);
1448
1449         if( RegQueryValueExW( hKey, reg_start_x, NULL, &type,
1450                               (LPBYTE) &opts.start_x, &size ) != ERROR_SUCCESS )
1451                 opts.start_x = CW_USEDEFAULT;
1452
1453         if( RegQueryValueExW( hKey, reg_start_y, NULL, &type,
1454                               (LPBYTE) &opts.start_y, &size ) != ERROR_SUCCESS )
1455                 opts.start_y = CW_USEDEFAULT;
1456
1457         if( RegQueryValueExW( hKey, reg_width, NULL, &type,
1458                               (LPBYTE) &opts.width, &size ) != ERROR_SUCCESS )
1459                 opts.width = CW_USEDEFAULT;
1460
1461         if( RegQueryValueExW( hKey, reg_height, NULL, &type,
1462                               (LPBYTE) &opts.height, &size ) != ERROR_SUCCESS )
1463                 opts.height = CW_USEDEFAULT;
1464         size=sizeof(logfont);
1465         if( RegQueryValueExW( hKey, reg_logfont, NULL, &type,
1466                               (LPBYTE) &logfont, &size ) != ERROR_SUCCESS )
1467                 GetObjectW(GetStockObject(DEFAULT_GUI_FONT),sizeof(logfont),&logfont);
1468
1469         RegCloseKey( hKey );
1470
1471         Globals.hfont = CreateFontIndirectW(&logfont);
1472         return opts;
1473 }
1474
1475 static void save_registry_settings(void)
1476 {
1477         WINDOWINFO wi;
1478         HKEY hKey;
1479         INT width, height;
1480         LOGFONTW logfont;
1481
1482         wi.cbSize = sizeof( WINDOWINFO );
1483         GetWindowInfo(Globals.hMainWnd, &wi);
1484         width = wi.rcWindow.right - wi.rcWindow.left;
1485         height = wi.rcWindow.bottom - wi.rcWindow.top;
1486
1487         if ( RegOpenKeyExW( HKEY_CURRENT_USER, registry_key,
1488                             0, KEY_SET_VALUE, &hKey ) != ERROR_SUCCESS )
1489         {
1490                 /* Unable to save registry settings - try to create key */
1491                 if ( RegCreateKeyExW( HKEY_CURRENT_USER, registry_key,
1492                                       0, NULL, REG_OPTION_NON_VOLATILE,
1493                                       KEY_SET_VALUE, NULL, &hKey, NULL ) != ERROR_SUCCESS )
1494                 {
1495                         /* FIXME: Cannot create key */
1496                         return;
1497                 }
1498         }
1499         /* Save all of the settings */
1500         RegSetValueExW( hKey, reg_start_x, 0, REG_DWORD,
1501                         (LPBYTE) &wi.rcWindow.left, sizeof(DWORD) );
1502         RegSetValueExW( hKey, reg_start_y, 0, REG_DWORD,
1503                         (LPBYTE) &wi.rcWindow.top, sizeof(DWORD) );
1504         RegSetValueExW( hKey, reg_width, 0, REG_DWORD,
1505                         (LPBYTE) &width, sizeof(DWORD) );
1506         RegSetValueExW( hKey, reg_height, 0, REG_DWORD,
1507                         (LPBYTE) &height, sizeof(DWORD) );
1508         GetObjectW(Globals.hfont, sizeof(logfont), &logfont);
1509         RegSetValueExW( hKey, reg_logfont, 0, REG_BINARY,
1510                         (LPBYTE)&logfont, sizeof(LOGFONTW) );
1511
1512         /* TODO: Save more settings here (List vs. Detailed View, etc.) */
1513         RegCloseKey( hKey );
1514 }
1515
1516 static void resize_frame_rect(HWND hwnd, PRECT prect)
1517 {
1518         int new_top;
1519         RECT rt;
1520
1521         if (IsWindowVisible(Globals.htoolbar)) {
1522                 SendMessageW(Globals.htoolbar, WM_SIZE, 0, 0);
1523                 GetClientRect(Globals.htoolbar, &rt);
1524                 prect->top = rt.bottom+3;
1525                 prect->bottom -= rt.bottom+3;
1526         }
1527
1528         if (IsWindowVisible(Globals.hdrivebar)) {
1529                 SendMessageW(Globals.hdrivebar, WM_SIZE, 0, 0);
1530                 GetClientRect(Globals.hdrivebar, &rt);
1531                 new_top = --prect->top + rt.bottom+3;
1532                 MoveWindow(Globals.hdrivebar, 0, prect->top, rt.right, new_top, TRUE);
1533                 prect->top = new_top;
1534                 prect->bottom -= rt.bottom+2;
1535         }
1536
1537         if (IsWindowVisible(Globals.hstatusbar)) {
1538                 int parts[] = {300, 500};
1539
1540                 SendMessageW(Globals.hstatusbar, WM_SIZE, 0, 0);
1541                 SendMessageW(Globals.hstatusbar, SB_SETPARTS, 2, (LPARAM)&parts);
1542                 GetClientRect(Globals.hstatusbar, &rt);
1543                 prect->bottom -= rt.bottom;
1544         }
1545
1546         MoveWindow(Globals.hmdiclient, prect->left-1,prect->top-1,prect->right+2,prect->bottom+1, TRUE);
1547 }
1548
1549 static void resize_frame(HWND hwnd, int cx, int cy)
1550 {
1551         RECT rect;
1552
1553         rect.left   = 0;
1554         rect.top    = 0;
1555         rect.right  = cx;
1556         rect.bottom = cy;
1557
1558         resize_frame_rect(hwnd, &rect);
1559 }
1560
1561 static void resize_frame_client(HWND hwnd)
1562 {
1563         RECT rect;
1564
1565         GetClientRect(hwnd, &rect);
1566
1567         resize_frame_rect(hwnd, &rect);
1568 }
1569
1570
1571 static HHOOK hcbthook;
1572 static ChildWnd* newchild = NULL;
1573
1574 static LRESULT CALLBACK CBTProc(int code, WPARAM wparam, LPARAM lparam)
1575 {
1576         if (code==HCBT_CREATEWND && newchild) {
1577                 ChildWnd* child = newchild;
1578                 newchild = NULL;
1579
1580                 child->hwnd = (HWND) wparam;
1581                 SetWindowLongPtrW(child->hwnd, GWLP_USERDATA, (LPARAM)child);
1582         }
1583
1584         return CallNextHookEx(hcbthook, code, wparam, lparam);
1585 }
1586
1587 static HWND create_child_window(ChildWnd* child)
1588 {
1589         MDICREATESTRUCTW mcs;
1590         int idx;
1591
1592         mcs.szClass = sWINEFILETREE;
1593         mcs.szTitle = child->path;
1594         mcs.hOwner  = Globals.hInstance;
1595         mcs.x       = child->pos.rcNormalPosition.left;
1596         mcs.y       = child->pos.rcNormalPosition.top;
1597         mcs.cx      = child->pos.rcNormalPosition.right-child->pos.rcNormalPosition.left;
1598         mcs.cy      = child->pos.rcNormalPosition.bottom-child->pos.rcNormalPosition.top;
1599         mcs.style   = 0;
1600         mcs.lParam  = 0;
1601
1602         hcbthook = SetWindowsHookExW(WH_CBT, CBTProc, 0, GetCurrentThreadId());
1603
1604         newchild = child;
1605         child->hwnd = (HWND)SendMessageW(Globals.hmdiclient, WM_MDICREATE, 0, (LPARAM)&mcs);
1606         if (!child->hwnd) {
1607                 UnhookWindowsHookEx(hcbthook);
1608                 return 0;
1609         }
1610
1611         UnhookWindowsHookEx(hcbthook);
1612
1613         SendMessageW(child->left.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));
1614         SendMessageW(child->right.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));
1615
1616         idx = SendMessageW(child->left.hwnd, LB_FINDSTRING, 0, (LPARAM)child->left.cur);
1617         SendMessageW(child->left.hwnd, LB_SETCURSEL, idx, 0);
1618
1619         return child->hwnd;
1620 }
1621
1622 #define RFF_NODEFAULT           0x02    /* No default item selected. */
1623
1624 static void WineFile_OnRun( HWND hwnd )
1625 {
1626         static const WCHAR shell32_dll[] = {'S','H','E','L','L','3','2','.','D','L','L',0};
1627         void (WINAPI *pRunFileDlgAW )(HWND, HICON, LPWSTR, LPWSTR, LPWSTR, DWORD);
1628         HMODULE hshell = GetModuleHandleW( shell32_dll );
1629
1630         pRunFileDlgAW = (void*)GetProcAddress(hshell, (LPCSTR)61);
1631         if (pRunFileDlgAW) pRunFileDlgAW( hwnd, 0, NULL, NULL, NULL, RFF_NODEFAULT);
1632 }
1633
1634 static INT_PTR CALLBACK DestinationDlgProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
1635 {
1636         WCHAR b1[BUFFER_LEN], b2[BUFFER_LEN];
1637
1638         switch(nmsg) {
1639                 case WM_INITDIALOG:
1640                         SetWindowLongPtrW(hwnd, GWLP_USERDATA, lparam);
1641                         SetWindowTextW(GetDlgItem(hwnd, 201), (LPCWSTR)lparam);
1642                         return 1;
1643
1644                 case WM_COMMAND: {
1645                         int id = (int)wparam;
1646
1647                         switch(id) {
1648                           case IDOK: {
1649                                 LPWSTR dest = (LPWSTR)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
1650                                 GetWindowTextW(GetDlgItem(hwnd, 201), dest, MAX_PATH);
1651                                 EndDialog(hwnd, id);
1652                                 break;}
1653
1654                           case IDCANCEL:
1655                                 EndDialog(hwnd, id);
1656                                 break;
1657
1658                           case 254:
1659                                 MessageBoxW(hwnd, RS(b1,IDS_NO_IMPL), RS(b2,IDS_WINEFILE), MB_OK);
1660                                 break;
1661                         }
1662
1663                         return 1;
1664                 }
1665         }
1666
1667         return 0;
1668 }
1669
1670
1671 struct FilterDialog {
1672         WCHAR   pattern[MAX_PATH];
1673         int             flags;
1674 };
1675
1676 static INT_PTR CALLBACK FilterDialogDlgProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
1677 {
1678         static struct FilterDialog* dlg;
1679
1680         switch(nmsg) {
1681                 case WM_INITDIALOG:
1682                         dlg = (struct FilterDialog*) lparam;
1683                         SetWindowTextW(GetDlgItem(hwnd, IDC_VIEW_PATTERN), dlg->pattern);
1684                         set_check(hwnd, IDC_VIEW_TYPE_DIRECTORIES, dlg->flags&TF_DIRECTORIES);
1685                         set_check(hwnd, IDC_VIEW_TYPE_PROGRAMS, dlg->flags&TF_PROGRAMS);
1686                         set_check(hwnd, IDC_VIEW_TYPE_DOCUMENTS, dlg->flags&TF_DOCUMENTS);
1687                         set_check(hwnd, IDC_VIEW_TYPE_OTHERS, dlg->flags&TF_OTHERS);
1688                         set_check(hwnd, IDC_VIEW_TYPE_HIDDEN, dlg->flags&TF_HIDDEN);
1689                         return 1;
1690
1691                 case WM_COMMAND: {
1692                         int id = (int)wparam;
1693
1694                         if (id == IDOK) {
1695                                 int flags = 0;
1696
1697                                 GetWindowTextW(GetDlgItem(hwnd, IDC_VIEW_PATTERN), dlg->pattern, MAX_PATH);
1698
1699                                 flags |= get_check(hwnd, IDC_VIEW_TYPE_DIRECTORIES) ? TF_DIRECTORIES : 0;
1700                                 flags |= get_check(hwnd, IDC_VIEW_TYPE_PROGRAMS) ? TF_PROGRAMS : 0;
1701                                 flags |= get_check(hwnd, IDC_VIEW_TYPE_DOCUMENTS) ? TF_DOCUMENTS : 0;
1702                                 flags |= get_check(hwnd, IDC_VIEW_TYPE_OTHERS) ? TF_OTHERS : 0;
1703                                 flags |= get_check(hwnd, IDC_VIEW_TYPE_HIDDEN) ? TF_HIDDEN : 0;
1704
1705                                 dlg->flags = flags;
1706
1707                                 EndDialog(hwnd, id);
1708                         } else if (id == IDCANCEL)
1709                                 EndDialog(hwnd, id);
1710
1711                         return 1;}
1712         }
1713
1714         return 0;
1715 }
1716
1717
1718 struct PropertiesDialog {
1719         WCHAR   path[MAX_PATH];
1720         Entry   entry;
1721         void*   pVersionData;
1722 };
1723
1724 /* Structure used to store enumerated languages and code pages. */
1725 struct LANGANDCODEPAGE {
1726         WORD wLanguage;
1727         WORD wCodePage;
1728 } *lpTranslate;
1729
1730 static LPCSTR InfoStrings[] = {
1731         "Comments",
1732         "CompanyName",
1733         "FileDescription",
1734         "FileVersion",
1735         "InternalName",
1736         "LegalCopyright",
1737         "LegalTrademarks",
1738         "OriginalFilename",
1739         "PrivateBuild",
1740         "ProductName",
1741         "ProductVersion",
1742         "SpecialBuild",
1743         NULL
1744 };
1745
1746 static void PropDlg_DisplayValue(HWND hlbox, HWND hedit)
1747 {
1748         int idx = SendMessageW(hlbox, LB_GETCURSEL, 0, 0);
1749
1750         if (idx != LB_ERR) {
1751                 LPCWSTR pValue = (LPCWSTR)SendMessageW(hlbox, LB_GETITEMDATA, idx, 0);
1752
1753                 if (pValue)
1754                         SetWindowTextW(hedit, pValue);
1755         }
1756 }
1757
1758 static void CheckForFileInfo(struct PropertiesDialog* dlg, HWND hwnd, LPCWSTR strFilename)
1759 {
1760         static WCHAR sBackSlash[] = {'\\','\0'};
1761         static WCHAR sTranslation[] = {'\\','V','a','r','F','i','l','e','I','n','f','o','\\','T','r','a','n','s','l','a','t','i','o','n','\0'};
1762         static WCHAR sStringFileInfo[] = {'\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o','\\',
1763                                                                                 '%','0','4','x','%','0','4','x','\\','%','s','\0'};
1764         static WCHAR sFmt[] = {'%','d','.','%','d','.','%','d','.','%','d','\0'};
1765         DWORD dwVersionDataLen = GetFileVersionInfoSizeW(strFilename, NULL);
1766
1767         if (dwVersionDataLen) {
1768                 dlg->pVersionData = HeapAlloc(GetProcessHeap(), 0, dwVersionDataLen);
1769
1770                 if (GetFileVersionInfoW(strFilename, 0, dwVersionDataLen, dlg->pVersionData)) {
1771                         LPVOID pVal;
1772                         UINT nValLen;
1773
1774                         if (VerQueryValueW(dlg->pVersionData, sBackSlash, &pVal, &nValLen)) {
1775                                 if (nValLen == sizeof(VS_FIXEDFILEINFO)) {
1776                                         VS_FIXEDFILEINFO* pFixedFileInfo = (VS_FIXEDFILEINFO*)pVal;
1777                                         WCHAR buffer[BUFFER_LEN];
1778
1779                                         sprintfW(buffer, sFmt,
1780                                                  HIWORD(pFixedFileInfo->dwFileVersionMS), LOWORD(pFixedFileInfo->dwFileVersionMS),
1781                                                  HIWORD(pFixedFileInfo->dwFileVersionLS), LOWORD(pFixedFileInfo->dwFileVersionLS));
1782
1783                                         SetDlgItemTextW(hwnd, IDC_STATIC_PROP_VERSION, buffer);
1784                                 }
1785                         }
1786
1787                         /* Read the list of languages and code pages. */
1788                         if (VerQueryValueW(dlg->pVersionData, sTranslation, &pVal, &nValLen)) {
1789                                 struct LANGANDCODEPAGE* pTranslate = (struct LANGANDCODEPAGE*)pVal;
1790                                 struct LANGANDCODEPAGE* pEnd = (struct LANGANDCODEPAGE*)((LPBYTE)pVal+nValLen);
1791
1792                                 HWND hlbox = GetDlgItem(hwnd, IDC_LIST_PROP_VERSION_TYPES);
1793
1794                                 /* Read the file description for each language and code page. */
1795                                 for(; pTranslate<pEnd; ++pTranslate) {
1796                                         LPCSTR* p;
1797
1798                                         for(p=InfoStrings; *p; ++p) {
1799                                                 WCHAR subblock[200];
1800                                                 WCHAR infoStr[100];
1801                                                 LPCWSTR pTxt;
1802                                                 UINT nValLen;
1803
1804                                                 LPCSTR pInfoString = *p;
1805                                                 MultiByteToWideChar(CP_ACP, 0, pInfoString, -1, infoStr, 100);
1806                                                 wsprintfW(subblock, sStringFileInfo, pTranslate->wLanguage, pTranslate->wCodePage, infoStr);
1807
1808                                                 /* Retrieve file description for language and code page */
1809                                                 if (VerQueryValueW(dlg->pVersionData, subblock, (PVOID)&pTxt, &nValLen)) {
1810                                                         int idx = SendMessageW(hlbox, LB_ADDSTRING, 0L, (LPARAM)infoStr);
1811                                                         SendMessageW(hlbox, LB_SETITEMDATA, idx, (LPARAM)pTxt);
1812                                                 }
1813                                         }
1814                                 }
1815
1816                                 SendMessageW(hlbox, LB_SETCURSEL, 0, 0);
1817
1818                                 PropDlg_DisplayValue(hlbox, GetDlgItem(hwnd,IDC_LIST_PROP_VERSION_VALUES));
1819                         }
1820                 }
1821         }
1822 }
1823
1824 static INT_PTR CALLBACK PropertiesDialogDlgProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
1825 {
1826         static struct PropertiesDialog* dlg;
1827
1828         switch(nmsg) {
1829                 case WM_INITDIALOG: {
1830                         static const WCHAR sByteFmt[] = {'%','s',' ','B','y','t','e','s','\0'};
1831                         WCHAR b1[BUFFER_LEN], b2[BUFFER_LEN];
1832                         LPWIN32_FIND_DATAW pWFD;
1833
1834                         dlg = (struct PropertiesDialog*) lparam;
1835                         pWFD = (LPWIN32_FIND_DATAW)&dlg->entry.data;
1836
1837                         GetWindowTextW(hwnd, b1, MAX_PATH);
1838                         wsprintfW(b2, b1, pWFD->cFileName);
1839                         SetWindowTextW(hwnd, b2);
1840
1841                         format_date(&pWFD->ftLastWriteTime, b1, COL_DATE|COL_TIME);
1842                         SetWindowTextW(GetDlgItem(hwnd, IDC_STATIC_PROP_LASTCHANGE), b1);
1843
1844                         format_longlong( b1, ((ULONGLONG)pWFD->nFileSizeHigh << 32) | pWFD->nFileSizeLow );
1845                         wsprintfW(b2, sByteFmt, b1);
1846                         SetWindowTextW(GetDlgItem(hwnd, IDC_STATIC_PROP_SIZE), b2);
1847
1848                         SetWindowTextW(GetDlgItem(hwnd, IDC_STATIC_PROP_FILENAME), pWFD->cFileName);
1849                         SetWindowTextW(GetDlgItem(hwnd, IDC_STATIC_PROP_PATH), dlg->path);
1850
1851                         set_check(hwnd, IDC_CHECK_READONLY, pWFD->dwFileAttributes&FILE_ATTRIBUTE_READONLY);
1852                         set_check(hwnd, IDC_CHECK_ARCHIVE, pWFD->dwFileAttributes&FILE_ATTRIBUTE_ARCHIVE);
1853                         set_check(hwnd, IDC_CHECK_COMPRESSED, pWFD->dwFileAttributes&FILE_ATTRIBUTE_COMPRESSED);
1854                         set_check(hwnd, IDC_CHECK_HIDDEN, pWFD->dwFileAttributes&FILE_ATTRIBUTE_HIDDEN);
1855                         set_check(hwnd, IDC_CHECK_SYSTEM, pWFD->dwFileAttributes&FILE_ATTRIBUTE_SYSTEM);
1856
1857                         CheckForFileInfo(dlg, hwnd, dlg->path);
1858                         return 1;}
1859
1860                 case WM_COMMAND: {
1861                         int id = (int)wparam;
1862
1863                         switch(HIWORD(wparam)) {
1864                           case LBN_SELCHANGE: {
1865                                 HWND hlbox = GetDlgItem(hwnd, IDC_LIST_PROP_VERSION_TYPES);
1866                                 PropDlg_DisplayValue(hlbox, GetDlgItem(hwnd,IDC_LIST_PROP_VERSION_VALUES));
1867                                 break;
1868                           }
1869
1870                           case BN_CLICKED:
1871                                 if (id==IDOK || id==IDCANCEL)
1872                                         EndDialog(hwnd, id);
1873                         }
1874
1875                         return 1;}
1876
1877                 case WM_NCDESTROY:
1878                         HeapFree(GetProcessHeap(), 0, dlg->pVersionData);
1879                         dlg->pVersionData = NULL;
1880                         break;
1881         }
1882
1883         return 0;
1884 }
1885
1886 static void show_properties_dlg(Entry* entry, HWND hwnd)
1887 {
1888         struct PropertiesDialog dlg;
1889
1890         memset(&dlg, 0, sizeof(struct PropertiesDialog));
1891         get_path(entry, dlg.path);
1892         memcpy(&dlg.entry, entry, sizeof(Entry));
1893
1894         DialogBoxParamW(Globals.hInstance, MAKEINTRESOURCEW(IDD_DIALOG_PROPERTIES), hwnd, PropertiesDialogDlgProc, (LPARAM)&dlg);
1895 }
1896
1897 static struct FullScreenParameters {
1898         BOOL    mode;
1899         RECT    orgPos;
1900         BOOL    wasZoomed;
1901 } g_fullscreen = {
1902     FALSE,      /* mode */
1903         {0, 0, 0, 0},
1904         FALSE
1905 };
1906
1907 static void frame_get_clientspace(HWND hwnd, PRECT prect)
1908 {
1909         RECT rt;
1910
1911         if (!IsIconic(hwnd))
1912                 GetClientRect(hwnd, prect);
1913         else {
1914                 WINDOWPLACEMENT wp;
1915
1916                 GetWindowPlacement(hwnd, &wp);
1917
1918                 prect->left = prect->top = 0;
1919                 prect->right = wp.rcNormalPosition.right-wp.rcNormalPosition.left-
1920                                                 2*(GetSystemMetrics(SM_CXSIZEFRAME)+GetSystemMetrics(SM_CXEDGE));
1921                 prect->bottom = wp.rcNormalPosition.bottom-wp.rcNormalPosition.top-
1922                                                 2*(GetSystemMetrics(SM_CYSIZEFRAME)+GetSystemMetrics(SM_CYEDGE))-
1923                                                 GetSystemMetrics(SM_CYCAPTION)-GetSystemMetrics(SM_CYMENUSIZE);
1924         }
1925
1926         if (IsWindowVisible(Globals.htoolbar)) {
1927                 GetClientRect(Globals.htoolbar, &rt);
1928                 prect->top += rt.bottom+2;
1929         }
1930
1931         if (IsWindowVisible(Globals.hdrivebar)) {
1932                 GetClientRect(Globals.hdrivebar, &rt);
1933                 prect->top += rt.bottom+2;
1934         }
1935
1936         if (IsWindowVisible(Globals.hstatusbar)) {
1937                 GetClientRect(Globals.hstatusbar, &rt);
1938                 prect->bottom -= rt.bottom;
1939         }
1940 }
1941
1942 static BOOL toggle_fullscreen(HWND hwnd)
1943 {
1944         RECT rt;
1945
1946         if ((g_fullscreen.mode=!g_fullscreen.mode)) {
1947                 GetWindowRect(hwnd, &g_fullscreen.orgPos);
1948                 g_fullscreen.wasZoomed = IsZoomed(hwnd);
1949
1950                 Frame_CalcFrameClient(hwnd, &rt);
1951                 MapWindowPoints( hwnd, 0, (POINT *)&rt, 2 );
1952
1953                 rt.left = g_fullscreen.orgPos.left-rt.left;
1954                 rt.top = g_fullscreen.orgPos.top-rt.top;
1955                 rt.right = GetSystemMetrics(SM_CXSCREEN)+g_fullscreen.orgPos.right-rt.right;
1956                 rt.bottom = GetSystemMetrics(SM_CYSCREEN)+g_fullscreen.orgPos.bottom-rt.bottom;
1957
1958                 MoveWindow(hwnd, rt.left, rt.top, rt.right-rt.left, rt.bottom-rt.top, TRUE);
1959         } else {
1960                 MoveWindow(hwnd, g_fullscreen.orgPos.left, g_fullscreen.orgPos.top,
1961                                                         g_fullscreen.orgPos.right-g_fullscreen.orgPos.left,
1962                                                         g_fullscreen.orgPos.bottom-g_fullscreen.orgPos.top, TRUE);
1963
1964                 if (g_fullscreen.wasZoomed)
1965                         ShowWindow(hwnd, WS_MAXIMIZE);
1966         }
1967
1968         return g_fullscreen.mode;
1969 }
1970
1971 static void fullscreen_move(HWND hwnd)
1972 {
1973         RECT rt, pos;
1974         GetWindowRect(hwnd, &pos);
1975
1976         Frame_CalcFrameClient(hwnd, &rt);
1977         MapWindowPoints( hwnd, 0, (POINT *)&rt, 2 );
1978
1979         rt.left = pos.left-rt.left;
1980         rt.top = pos.top-rt.top;
1981         rt.right = GetSystemMetrics(SM_CXSCREEN)+pos.right-rt.right;
1982         rt.bottom = GetSystemMetrics(SM_CYSCREEN)+pos.bottom-rt.bottom;
1983
1984         MoveWindow(hwnd, rt.left, rt.top, rt.right-rt.left, rt.bottom-rt.top, TRUE);
1985 }
1986
1987 static void toggle_child(HWND hwnd, UINT cmd, HWND hchild)
1988 {
1989         BOOL vis = IsWindowVisible(hchild);
1990
1991         CheckMenuItem(Globals.hMenuOptions, cmd, vis?MF_BYCOMMAND:MF_BYCOMMAND|MF_CHECKED);
1992
1993         ShowWindow(hchild, vis?SW_HIDE:SW_SHOW);
1994
1995         if (g_fullscreen.mode)
1996                 fullscreen_move(hwnd);
1997
1998         resize_frame_client(hwnd);
1999 }
2000
2001 static BOOL activate_drive_window(LPCWSTR path)
2002 {
2003         WCHAR drv1[_MAX_DRIVE], drv2[_MAX_DRIVE];
2004         HWND child_wnd;
2005
2006         _wsplitpath(path, drv1, 0, 0, 0);
2007
2008         /* search for a already open window for the same drive */
2009         for(child_wnd=GetNextWindow(Globals.hmdiclient,GW_CHILD); child_wnd; child_wnd=GetNextWindow(child_wnd, GW_HWNDNEXT)) {
2010                 ChildWnd* child = (ChildWnd*)GetWindowLongPtrW(child_wnd, GWLP_USERDATA);
2011
2012                 if (child) {
2013                         _wsplitpath(child->root.path, drv2, 0, 0, 0);
2014
2015                         if (!lstrcmpiW(drv2, drv1)) {
2016                                 SendMessageW(Globals.hmdiclient, WM_MDIACTIVATE, (WPARAM)child_wnd, 0);
2017
2018                                 if (IsIconic(child_wnd))
2019                                         ShowWindow(child_wnd, SW_SHOWNORMAL);
2020
2021                                 return TRUE;
2022                         }
2023                 }
2024         }
2025
2026         return FALSE;
2027 }
2028
2029 static BOOL activate_fs_window(LPCWSTR filesys)
2030 {
2031         HWND child_wnd;
2032
2033         /* search for a already open window of the given file system name */
2034         for(child_wnd=GetNextWindow(Globals.hmdiclient,GW_CHILD); child_wnd; child_wnd=GetNextWindow(child_wnd, GW_HWNDNEXT)) {
2035                 ChildWnd* child = (ChildWnd*) GetWindowLongPtrW(child_wnd, GWLP_USERDATA);
2036
2037                 if (child) {
2038                         if (!lstrcmpiW(child->root.fs, filesys)) {
2039                                 SendMessageW(Globals.hmdiclient, WM_MDIACTIVATE, (WPARAM)child_wnd, 0);
2040
2041                                 if (IsIconic(child_wnd))
2042                                         ShowWindow(child_wnd, SW_SHOWNORMAL);
2043
2044                                 return TRUE;
2045                         }
2046                 }
2047         }
2048
2049         return FALSE;
2050 }
2051
2052 static LRESULT CALLBACK FrameWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
2053 {
2054         WCHAR b1[BUFFER_LEN], b2[BUFFER_LEN];
2055
2056         switch(nmsg) {
2057                 case WM_CLOSE:
2058                         if (Globals.saveSettings)
2059                                 save_registry_settings();
2060
2061                         DestroyWindow(hwnd);
2062
2063                          /* clear handle variables */
2064                         Globals.hMenuFrame = 0;
2065                         Globals.hMenuView = 0;
2066                         Globals.hMenuOptions = 0;
2067                         Globals.hMainWnd = 0;
2068                         Globals.hmdiclient = 0;
2069                         Globals.hdrivebar = 0;
2070                         break;
2071
2072                 case WM_DESTROY:
2073                         PostQuitMessage(0);
2074                         break;
2075
2076                 case WM_INITMENUPOPUP: {
2077                         HWND hwndClient = (HWND)SendMessageW(Globals.hmdiclient, WM_MDIGETACTIVE, 0, 0);
2078
2079                         if (!SendMessageW(hwndClient, WM_INITMENUPOPUP, wparam, lparam))
2080                                 return 0;
2081                         break;}
2082
2083                 case WM_COMMAND: {
2084                         UINT cmd = LOWORD(wparam);
2085                         HWND hwndClient = (HWND)SendMessageW(Globals.hmdiclient, WM_MDIGETACTIVE, 0, 0);
2086
2087                         if (SendMessageW(hwndClient, WM_DISPATCH_COMMAND, wparam, lparam))
2088                                 break;
2089
2090                         if (cmd>=ID_DRIVE_FIRST && cmd<=ID_DRIVE_FIRST+0xFF) {
2091                                 WCHAR drv[_MAX_DRIVE], path[MAX_PATH];
2092                                 ChildWnd* child;
2093                                 LPCWSTR root = Globals.drives;
2094                                 int i;
2095
2096                                 for(i=cmd-ID_DRIVE_FIRST; i--; root++)
2097                                         while(*root)
2098                                                 root++;
2099
2100                                 if (activate_drive_window(root))
2101                                         return 0;
2102
2103                                 _wsplitpath(root, drv, 0, 0, 0);
2104
2105                                 if (!SetCurrentDirectoryW(drv)) {
2106                                         display_error(hwnd, GetLastError());
2107                                         return 0;
2108                                 }
2109
2110                                 GetCurrentDirectoryW(MAX_PATH, path); /*TODO: store last directory per drive */
2111                                 child = alloc_child_window(path, NULL, hwnd);
2112
2113                                 if (!create_child_window(child))
2114                                         HeapFree(GetProcessHeap(), 0, child);
2115                         } else switch(cmd) {
2116                                 case ID_FILE_EXIT:
2117                                         SendMessageW(hwnd, WM_CLOSE, 0, 0);
2118                                         break;
2119
2120                                 case ID_WINDOW_NEW: {
2121                                         WCHAR path[MAX_PATH];
2122                                         ChildWnd* child;
2123
2124                                         GetCurrentDirectoryW(MAX_PATH, path);
2125                                         child = alloc_child_window(path, NULL, hwnd);
2126
2127                                         if (!create_child_window(child))
2128                                                 HeapFree(GetProcessHeap(), 0, child);
2129                                         break;}
2130
2131                                 case ID_REFRESH:
2132                                         refresh_drives();
2133                                         break;
2134
2135                                 case ID_WINDOW_CASCADE:
2136                                         SendMessageW(Globals.hmdiclient, WM_MDICASCADE, 0, 0);
2137                                         break;
2138
2139                                 case ID_WINDOW_TILE_HORZ:
2140                                         SendMessageW(Globals.hmdiclient, WM_MDITILE, MDITILE_HORIZONTAL, 0);
2141                                         break;
2142
2143                                 case ID_WINDOW_TILE_VERT:
2144                                         SendMessageW(Globals.hmdiclient, WM_MDITILE, MDITILE_VERTICAL, 0);
2145                                         break;
2146
2147                                 case ID_WINDOW_ARRANGE:
2148                                         SendMessageW(Globals.hmdiclient, WM_MDIICONARRANGE, 0, 0);
2149                                         break;
2150
2151                                 case ID_SELECT_FONT:
2152                                         choose_font(hwnd);
2153                                         break;
2154
2155                                 case ID_VIEW_TOOL_BAR:
2156                                         toggle_child(hwnd, cmd, Globals.htoolbar);
2157                                         break;
2158
2159                                 case ID_VIEW_DRIVE_BAR:
2160                                         toggle_child(hwnd, cmd, Globals.hdrivebar);
2161                                         break;
2162
2163                                 case ID_VIEW_STATUSBAR:
2164                                         toggle_child(hwnd, cmd, Globals.hstatusbar);
2165                                         break;
2166
2167                                 case ID_VIEW_SAVESETTINGS:
2168                                         Globals.saveSettings = !Globals.saveSettings;
2169                                         CheckMenuItem(Globals.hMenuOptions, ID_VIEW_SAVESETTINGS,
2170                                                       Globals.saveSettings ? MF_CHECKED : MF_UNCHECKED );
2171                                         break;
2172
2173                                 case ID_RUN:
2174                                         WineFile_OnRun( hwnd );
2175                                         break;
2176
2177                                 case ID_CONNECT_NETWORK_DRIVE: {
2178                                         DWORD ret = WNetConnectionDialog(hwnd, RESOURCETYPE_DISK);
2179                                         if (ret == NO_ERROR)
2180                                                 refresh_drives();
2181                                         else if (ret != (DWORD)-1) {
2182                                                 if (ret == ERROR_EXTENDED_ERROR)
2183                                                         display_network_error(hwnd);
2184                                                 else
2185                                                         display_error(hwnd, ret);
2186                                         }
2187                                         break;}
2188
2189                                 case ID_DISCONNECT_NETWORK_DRIVE: {
2190                                         DWORD ret = WNetDisconnectDialog(hwnd, RESOURCETYPE_DISK);
2191                                         if (ret == NO_ERROR)
2192                                                 refresh_drives();
2193                                         else if (ret != (DWORD)-1) {
2194                                                 if (ret == ERROR_EXTENDED_ERROR)
2195                                                         display_network_error(hwnd);
2196                                                 else
2197                                                         display_error(hwnd, ret);
2198                                         }
2199                                         break;}
2200
2201                                 case ID_HELP:
2202                                         WinHelpW(hwnd, RS(b1,IDS_WINEFILE), HELP_INDEX, 0);
2203                                         break;
2204
2205                                 case ID_VIEW_FULLSCREEN:
2206                                         CheckMenuItem(Globals.hMenuOptions, cmd, toggle_fullscreen(hwnd)?MF_CHECKED:0);
2207                                         break;
2208
2209 #ifdef __WINE__
2210                                 case ID_DRIVE_UNIX_FS: {
2211                                         WCHAR path[MAX_PATH];
2212                                         char cpath[MAX_PATH];
2213                                         ChildWnd* child;
2214
2215                                         if (activate_fs_window(RS(b1,IDS_UNIXFS)))
2216                                                 break;
2217
2218                                         getcwd(cpath, MAX_PATH);
2219                                         MultiByteToWideChar(CP_UNIXCP, 0, cpath, -1, path, MAX_PATH);
2220                                         child = alloc_child_window(path, NULL, hwnd);
2221
2222                                         if (!create_child_window(child))
2223                                                 HeapFree(GetProcessHeap(), 0, child);
2224                                         break;}
2225 #endif
2226                                 case ID_DRIVE_SHELL_NS: {
2227                                         WCHAR path[MAX_PATH];
2228                                         ChildWnd* child;
2229
2230                                         if (activate_fs_window(RS(b1,IDS_SHELL)))
2231                                                 break;
2232
2233                                         GetCurrentDirectoryW(MAX_PATH, path);
2234                                         child = alloc_child_window(path, get_path_pidl(path,hwnd), hwnd);
2235
2236                                         if (!create_child_window(child))
2237                                                 HeapFree(GetProcessHeap(), 0, child);
2238                                         break;}
2239
2240                                 /*TODO: There are even more menu items! */
2241
2242                                 case ID_ABOUT:
2243                                         ShellAboutW(hwnd, RS(b1,IDS_WINEFILE), NULL,
2244                                                    LoadImageW( Globals.hInstance, MAKEINTRESOURCEW(IDI_WINEFILE),
2245                                                               IMAGE_ICON, 48, 48, LR_SHARED ));
2246                                         break;
2247
2248                                 default:
2249                                         /*TODO: if (wParam >= PM_FIRST_LANGUAGE && wParam <= PM_LAST_LANGUAGE)
2250                                                 STRING_SelectLanguageByNumber(wParam - PM_FIRST_LANGUAGE);
2251                                         else */if ((cmd<IDW_FIRST_CHILD || cmd>=IDW_FIRST_CHILD+0x100) &&
2252                                                 (cmd<SC_SIZE || cmd>SC_RESTORE))
2253                                                 MessageBoxW(hwnd, RS(b2,IDS_NO_IMPL), RS(b1,IDS_WINEFILE), MB_OK);
2254
2255                                         return DefFrameProcW(hwnd, Globals.hmdiclient, nmsg, wparam, lparam);
2256                         }
2257                         break;}
2258
2259                 case WM_SIZE:
2260                         resize_frame(hwnd, LOWORD(lparam), HIWORD(lparam));
2261                         break;  /* do not pass message to DefFrameProcW */
2262
2263                 case WM_DEVICECHANGE:
2264                         SendMessageW(hwnd, WM_COMMAND, MAKELONG(ID_REFRESH,0), 0);
2265                         break;
2266
2267                 case WM_GETMINMAXINFO: {
2268                         LPMINMAXINFO lpmmi = (LPMINMAXINFO)lparam;
2269
2270                         lpmmi->ptMaxTrackSize.x <<= 1;/*2*GetSystemMetrics(SM_CXSCREEN) / SM_CXVIRTUALSCREEN */
2271                         lpmmi->ptMaxTrackSize.y <<= 1;/*2*GetSystemMetrics(SM_CYSCREEN) / SM_CYVIRTUALSCREEN */
2272                         break;}
2273
2274                 case FRM_CALC_CLIENT:
2275                         frame_get_clientspace(hwnd, (PRECT)lparam);
2276                         return TRUE;
2277
2278                 default:
2279                         return DefFrameProcW(hwnd, Globals.hmdiclient, nmsg, wparam, lparam);
2280         }
2281
2282         return 0;
2283 }
2284
2285
2286 static WCHAR g_pos_names[COLUMNS][20] = {
2287         {'\0'}  /* symbol */
2288 };
2289
2290 static const int g_pos_align[] = {
2291         0,
2292         HDF_LEFT,       /* Name */
2293         HDF_RIGHT,      /* Size */
2294         HDF_LEFT,       /* CDate */
2295         HDF_LEFT,       /* ADate */
2296         HDF_LEFT,       /* MDate */
2297         HDF_LEFT,       /* Index */
2298         HDF_CENTER,     /* Links */
2299         HDF_CENTER,     /* Attributes */
2300         HDF_LEFT        /* Security */
2301 };
2302
2303 static void resize_tree(ChildWnd* child, int cx, int cy)
2304 {
2305         HDWP hdwp = BeginDeferWindowPos(4);
2306         RECT rt;
2307         WINDOWPOS wp;
2308         HD_LAYOUT hdl;
2309
2310         rt.left   = 0;
2311         rt.top    = 0;
2312         rt.right  = cx;
2313         rt.bottom = cy;
2314
2315         cx = child->split_pos + SPLIT_WIDTH/2;
2316         hdl.prc   = &rt;
2317         hdl.pwpos = &wp;
2318
2319         SendMessageW(child->left.hwndHeader, HDM_LAYOUT, 0, (LPARAM)&hdl);
2320
2321         DeferWindowPos(hdwp, child->left.hwndHeader, wp.hwndInsertAfter,
2322                        wp.x-1, wp.y, child->split_pos-SPLIT_WIDTH/2+1, wp.cy, wp.flags);
2323         DeferWindowPos(hdwp, child->right.hwndHeader, wp.hwndInsertAfter,
2324                        rt.left+cx+1, wp.y, wp.cx-cx+2, wp.cy, wp.flags);
2325         DeferWindowPos(hdwp, child->left.hwnd, 0, rt.left, rt.top, child->split_pos-SPLIT_WIDTH/2-rt.left, rt.bottom-rt.top, SWP_NOZORDER|SWP_NOACTIVATE);
2326         DeferWindowPos(hdwp, child->right.hwnd, 0, rt.left+cx+1, rt.top, rt.right-cx, rt.bottom-rt.top, SWP_NOZORDER|SWP_NOACTIVATE);
2327
2328         EndDeferWindowPos(hdwp);
2329 }
2330
2331 static HWND create_header(HWND parent, Pane* pane, UINT id)
2332 {
2333         HDITEMW hdi;
2334         int idx;
2335
2336         HWND hwnd = CreateWindowW(WC_HEADERW, 0, WS_CHILD|WS_VISIBLE|HDS_HORZ|HDS_FULLDRAG/*TODO: |HDS_BUTTONS + sort orders*/,
2337                                  0, 0, 0, 0, parent, (HMENU)ULongToHandle(id), Globals.hInstance, 0);
2338         if (!hwnd)
2339                 return 0;
2340
2341         SendMessageW(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), FALSE);
2342
2343         hdi.mask = HDI_TEXT|HDI_WIDTH|HDI_FORMAT;
2344
2345         for(idx=0; idx<COLUMNS; idx++) {
2346                 hdi.pszText = g_pos_names[idx];
2347                 hdi.fmt = HDF_STRING | g_pos_align[idx];
2348                 hdi.cxy = pane->widths[idx];
2349                 SendMessageW(hwnd, HDM_INSERTITEMW, idx, (LPARAM)&hdi);
2350         }
2351
2352         return hwnd;
2353 }
2354
2355 static void init_output(HWND hwnd)
2356 {
2357         static const WCHAR s1000[] = {'1','0','0','0','\0'};
2358         WCHAR b[16];
2359         HFONT old_font;
2360         HDC hdc = GetDC(hwnd);
2361
2362         if (GetNumberFormatW(LOCALE_USER_DEFAULT, 0, s1000, 0, b, 16) > 4)
2363                 Globals.num_sep = b[1];
2364         else
2365                 Globals.num_sep = '.';
2366
2367         old_font = SelectObject(hdc, Globals.hfont);
2368         GetTextExtentPoint32W(hdc, sSpace, 1, &Globals.spaceSize);
2369         SelectObject(hdc, old_font);
2370         ReleaseDC(hwnd, hdc);
2371 }
2372
2373 static void draw_item(Pane* pane, LPDRAWITEMSTRUCT dis, Entry* entry, int calcWidthCol);
2374
2375
2376 /* calculate preferred width for all visible columns */
2377
2378 static BOOL calc_widths(Pane* pane, BOOL anyway)
2379 {
2380         int col, x, cx, spc=3*Globals.spaceSize.cx;
2381         int entries = SendMessageW(pane->hwnd, LB_GETCOUNT, 0, 0);
2382         int orgWidths[COLUMNS];
2383         int orgPositions[COLUMNS+1];
2384         HFONT hfontOld;
2385         HDC hdc;
2386         int cnt;
2387
2388         if (!anyway) {
2389                 memcpy(orgWidths, pane->widths, sizeof(orgWidths));
2390                 memcpy(orgPositions, pane->positions, sizeof(orgPositions));
2391         }
2392
2393         for(col=0; col<COLUMNS; col++)
2394                 pane->widths[col] = 0;
2395
2396         hdc = GetDC(pane->hwnd);
2397         hfontOld = SelectObject(hdc, Globals.hfont);
2398
2399         for(cnt=0; cnt<entries; cnt++) {
2400                 Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, cnt, 0);
2401
2402                 DRAWITEMSTRUCT dis;
2403
2404                 dis.CtlType               = 0;
2405                 dis.CtlID                 = 0;
2406                 dis.itemID                = 0;
2407                 dis.itemAction    = 0;
2408                 dis.itemState     = 0;
2409                 dis.hwndItem      = pane->hwnd;
2410                 dis.hDC                   = hdc;
2411                 dis.rcItem.left   = 0;
2412                 dis.rcItem.top    = 0;
2413                 dis.rcItem.right  = 0;
2414                 dis.rcItem.bottom = 0;
2415                 /*dis.itemData    = 0; */
2416
2417                 draw_item(pane, &dis, entry, COLUMNS);
2418         }
2419
2420         SelectObject(hdc, hfontOld);
2421         ReleaseDC(pane->hwnd, hdc);
2422
2423         x = 0;
2424         for(col=0; col<COLUMNS; col++) {
2425                 pane->positions[col] = x;
2426                 cx = pane->widths[col];
2427
2428                 if (cx) {
2429                         cx += spc;
2430
2431                         if (cx < IMAGE_WIDTH)
2432                                 cx = IMAGE_WIDTH;
2433
2434                         pane->widths[col] = cx;
2435                 }
2436
2437                 x += cx;
2438         }
2439
2440         pane->positions[COLUMNS] = x;
2441
2442         SendMessageW(pane->hwnd, LB_SETHORIZONTALEXTENT, x, 0);
2443
2444         /* no change? */
2445         if (!anyway && !memcmp(orgWidths, pane->widths, sizeof(orgWidths)))
2446                 return FALSE;
2447
2448         /* don't move, if only collapsing an entry */
2449         if (!anyway && pane->widths[0]<orgWidths[0] &&
2450                 !memcmp(orgWidths+1, pane->widths+1, sizeof(orgWidths)-sizeof(int))) {
2451                 pane->widths[0] = orgWidths[0];
2452                 memcpy(pane->positions, orgPositions, sizeof(orgPositions));
2453
2454                 return FALSE;
2455         }
2456
2457         InvalidateRect(pane->hwnd, 0, TRUE);
2458
2459         return TRUE;
2460 }
2461
2462 /* calculate one preferred column width */
2463 static void calc_single_width(Pane* pane, int col)
2464 {
2465         HFONT hfontOld;
2466         int x, cx;
2467         int entries = SendMessageW(pane->hwnd, LB_GETCOUNT, 0, 0);
2468         int cnt;
2469         HDC hdc;
2470
2471         pane->widths[col] = 0;
2472
2473         hdc = GetDC(pane->hwnd);
2474         hfontOld = SelectObject(hdc, Globals.hfont);
2475
2476         for(cnt=0; cnt<entries; cnt++) {
2477                 Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, cnt, 0);
2478                 DRAWITEMSTRUCT dis;
2479
2480                 dis.CtlType               = 0;
2481                 dis.CtlID                 = 0;
2482                 dis.itemID                = 0;
2483                 dis.itemAction    = 0;
2484                 dis.itemState     = 0;
2485                 dis.hwndItem      = pane->hwnd;
2486                 dis.hDC                   = hdc;
2487                 dis.rcItem.left   = 0;
2488                 dis.rcItem.top    = 0;
2489                 dis.rcItem.right  = 0;
2490                 dis.rcItem.bottom = 0;
2491                 /*dis.itemData    = 0; */
2492
2493                 draw_item(pane, &dis, entry, col);
2494         }
2495
2496         SelectObject(hdc, hfontOld);
2497         ReleaseDC(pane->hwnd, hdc);
2498
2499         cx = pane->widths[col];
2500
2501         if (cx) {
2502                 cx += 3*Globals.spaceSize.cx;
2503
2504                 if (cx < IMAGE_WIDTH)
2505                         cx = IMAGE_WIDTH;
2506         }
2507
2508         pane->widths[col] = cx;
2509
2510         x = pane->positions[col] + cx;
2511
2512         for(; col<COLUMNS-1; ) {
2513                 pane->positions[++col] = x;
2514                 x += pane->widths[col];
2515         }
2516
2517         SendMessageW(pane->hwnd, LB_SETHORIZONTALEXTENT, x, 0);
2518 }
2519
2520 static BOOL pattern_match(LPCWSTR str, LPCWSTR pattern)
2521 {
2522         for( ; *str&&*pattern; str++,pattern++) {
2523                 if (*pattern == '*') {
2524                         do pattern++;
2525                         while(*pattern == '*');
2526
2527                         if (!*pattern)
2528                                 return TRUE;
2529
2530                         for(; *str; str++)
2531                                 if (*str==*pattern && pattern_match(str, pattern))
2532                                         return TRUE;
2533
2534                         return FALSE;
2535                 }
2536                 else if (*str!=*pattern && *pattern!='?')
2537                         return FALSE;
2538         }
2539
2540         if (*str || *pattern)
2541                 if (*pattern!='*' || pattern[1]!='\0')
2542                         return FALSE;
2543
2544         return TRUE;
2545 }
2546
2547 static BOOL pattern_imatch(LPCWSTR str, LPCWSTR pattern)
2548 {
2549         WCHAR b1[BUFFER_LEN], b2[BUFFER_LEN];
2550
2551         lstrcpyW(b1, str);
2552         lstrcpyW(b2, pattern);
2553         CharUpperW(b1);
2554         CharUpperW(b2);
2555
2556         return pattern_match(b1, b2);
2557 }
2558
2559
2560 enum FILE_TYPE {
2561         FT_OTHER                = 0,
2562         FT_EXECUTABLE   = 1,
2563         FT_DOCUMENT             = 2
2564 };
2565
2566 static enum FILE_TYPE get_file_type(LPCWSTR filename);
2567
2568
2569 /* insert listbox entries after index idx */
2570
2571 static int insert_entries(Pane* pane, Entry* dir, LPCWSTR pattern, int filter_flags, int idx)
2572 {
2573         Entry* entry = dir;
2574
2575         if (!entry)
2576                 return idx;
2577
2578         ShowWindow(pane->hwnd, SW_HIDE);
2579
2580         for(; entry; entry=entry->next) {
2581                 if (pane->treePane && !(entry->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
2582                         continue;
2583
2584                 if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
2585                         /* don't display entries "." and ".." in the left pane */
2586                         if (pane->treePane && entry->data.cFileName[0] == '.')
2587                                 if (entry->data.cFileName[1] == '\0' ||
2588                                     (entry->data.cFileName[1] == '.' &&
2589                                     entry->data.cFileName[2] == '\0'))
2590                                         continue;
2591
2592                         /* filter directories in right pane */
2593                         if (!pane->treePane && !(filter_flags&TF_DIRECTORIES))
2594                                 continue;
2595                 }
2596
2597                 /* filter using the file name pattern */
2598                 if (pattern)
2599                         if (!pattern_imatch(entry->data.cFileName, pattern))
2600                                 continue;
2601
2602                 /* filter system and hidden files */
2603                 if (!(filter_flags&TF_HIDDEN) && (entry->data.dwFileAttributes&(FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM)))
2604                         continue;
2605
2606                 /* filter looking at the file type */
2607                 if ((filter_flags&(TF_PROGRAMS|TF_DOCUMENTS|TF_OTHERS)) != (TF_PROGRAMS|TF_DOCUMENTS|TF_OTHERS))
2608                         switch(get_file_type(entry->data.cFileName)) {
2609                           case FT_EXECUTABLE:
2610                                 if (!(filter_flags & TF_PROGRAMS))
2611                                         continue;
2612                                 break;
2613
2614                           case FT_DOCUMENT:
2615                                 if (!(filter_flags & TF_DOCUMENTS))
2616                                         continue;
2617                                 break;
2618
2619                           default: /* TF_OTHERS */
2620                                 if (!(filter_flags & TF_OTHERS))
2621                                         continue;
2622                         }
2623
2624                 if (idx != -1)
2625                         idx++;
2626
2627                 SendMessageW(pane->hwnd, LB_INSERTSTRING, idx, (LPARAM)entry);
2628
2629                 if (pane->treePane && entry->expanded)
2630                         idx = insert_entries(pane, entry->down, pattern, filter_flags, idx);
2631         }
2632
2633         ShowWindow(pane->hwnd, SW_SHOW);
2634
2635         return idx;
2636 }
2637
2638
2639 static void format_bytes(LPWSTR buffer, LONGLONG bytes)
2640 {
2641         static const WCHAR sFmtSmall[]  = {'%', 'u', 0};
2642         static const WCHAR sFmtBig[] = {'%', '.', '1', 'f', ' ', '%', 's', '\0'};
2643
2644         if (bytes < 1024)
2645                 sprintfW(buffer, sFmtSmall, (DWORD)bytes);
2646         else
2647         {
2648                 WCHAR unit[64];
2649                 UINT resid;
2650                 float fBytes;
2651                 if (bytes >= 1073741824)        /* 1 GB */
2652                 {
2653                         fBytes = ((float)bytes)/1073741824.f+.5f;
2654                         resid = IDS_UNIT_GB;
2655                 }
2656                 else if (bytes >= 1048576)      /* 1 MB */
2657                 {
2658                         fBytes = ((float)bytes)/1048576.f+.5f;
2659                         resid = IDS_UNIT_MB;
2660                 }
2661                 else if (bytes >= 1024)         /* 1 kB */
2662                 {
2663                         fBytes = ((float)bytes)/1024.f+.5f;
2664                         resid = IDS_UNIT_KB;
2665                 }
2666                 LoadStringW(Globals.hInstance, resid, unit, sizeof(unit)/sizeof(*unit));
2667                 sprintfW(buffer, sFmtBig, fBytes, unit);
2668         }
2669 }
2670
2671 static void set_space_status(void)
2672 {
2673         ULARGE_INTEGER ulFreeBytesToCaller, ulTotalBytes, ulFreeBytes;
2674         WCHAR fmt[64], b1[64], b2[64], buffer[BUFFER_LEN];
2675
2676         if (GetDiskFreeSpaceExW(NULL, &ulFreeBytesToCaller, &ulTotalBytes, &ulFreeBytes)) {
2677                 DWORD_PTR args[2];
2678                 format_bytes(b1, ulFreeBytesToCaller.QuadPart);
2679                 format_bytes(b2, ulTotalBytes.QuadPart);
2680                 args[0] = (DWORD_PTR)b1;
2681                 args[1] = (DWORD_PTR)b2;
2682                 FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
2683                                RS(fmt,IDS_FREE_SPACE_FMT), 0, 0, buffer,
2684                                sizeof(buffer)/sizeof(*buffer), (__ms_va_list*)args);
2685         } else
2686                 lstrcpyW(buffer, sQMarks);
2687
2688         SendMessageW(Globals.hstatusbar, SB_SETTEXTW, 0, (LPARAM)buffer);
2689 }
2690
2691
2692 static WNDPROC g_orgTreeWndProc;
2693
2694 static void create_tree_window(HWND parent, Pane* pane, UINT id, UINT id_header, LPCWSTR pattern, int filter_flags)
2695 {
2696         static const WCHAR sListBox[] = {'L','i','s','t','B','o','x','\0'};
2697
2698         static int s_init = 0;
2699         Entry* entry = pane->root;
2700
2701         pane->hwnd = CreateWindowW(sListBox, sEmpty, WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|
2702                                   LBS_DISABLENOSCROLL|LBS_NOINTEGRALHEIGHT|LBS_OWNERDRAWFIXED|LBS_NOTIFY,
2703                                   0, 0, 0, 0, parent, (HMENU)ULongToHandle(id), Globals.hInstance, 0);
2704
2705         SetWindowLongPtrW(pane->hwnd, GWLP_USERDATA, (LPARAM)pane);
2706         g_orgTreeWndProc = (WNDPROC)SetWindowLongPtrW(pane->hwnd, GWLP_WNDPROC, (LPARAM)TreeWndProc);
2707
2708         SendMessageW(pane->hwnd, WM_SETFONT, (WPARAM)Globals.hfont, FALSE);
2709
2710         /* insert entries into listbox */
2711         if (entry)
2712                 insert_entries(pane, entry, pattern, filter_flags, -1);
2713
2714         /* calculate column widths */
2715         if (!s_init) {
2716                 s_init = 1;
2717                 init_output(pane->hwnd);
2718         }
2719
2720         calc_widths(pane, TRUE);
2721
2722         pane->hwndHeader = create_header(parent, pane, id_header);
2723 }
2724
2725
2726 static void InitChildWindow(ChildWnd* child)
2727 {
2728         create_tree_window(child->hwnd, &child->left, IDW_TREE_LEFT, IDW_HEADER_LEFT, NULL, TF_ALL);
2729         create_tree_window(child->hwnd, &child->right, IDW_TREE_RIGHT, IDW_HEADER_RIGHT, child->filter_pattern, child->filter_flags);
2730 }
2731
2732
2733 static void format_date(const FILETIME* ft, WCHAR* buffer, int visible_cols)
2734 {
2735         SYSTEMTIME systime;
2736         FILETIME lft;
2737         int len = 0;
2738
2739         *buffer = '\0';
2740
2741         if (!ft->dwLowDateTime && !ft->dwHighDateTime)
2742                 return;
2743
2744         if (!FileTimeToLocalFileTime(ft, &lft))
2745                 {err: lstrcpyW(buffer,sQMarks); return;}
2746
2747         if (!FileTimeToSystemTime(&lft, &systime))
2748                 goto err;
2749
2750         if (visible_cols & COL_DATE) {
2751                 len = GetDateFormatW(LOCALE_USER_DEFAULT, 0, &systime, 0, buffer, BUFFER_LEN);
2752                 if (!len)
2753                         goto err;
2754         }
2755
2756         if (visible_cols & COL_TIME) {
2757                 if (len)
2758                         buffer[len-1] = ' ';
2759
2760                 buffer[len++] = ' ';
2761
2762                 if (!GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &systime, 0, buffer+len, BUFFER_LEN-len))
2763                         buffer[len] = '\0';
2764         }
2765 }
2766
2767
2768 static void calc_width(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
2769 {
2770         RECT rt = {0, 0, 0, 0};
2771
2772         DrawTextW(dis->hDC, str, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_NOPREFIX);
2773
2774         if (rt.right > pane->widths[col])
2775                 pane->widths[col] = rt.right;
2776 }
2777
2778 static void calc_tabbed_width(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
2779 {
2780         RECT rt = {0, 0, 0, 0};
2781
2782         DrawTextW(dis->hDC, str, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_EXPANDTABS|DT_TABSTOP|(2<<8));
2783         /*FIXME rt (0,0) ??? */
2784
2785         if (rt.right > pane->widths[col])
2786                 pane->widths[col] = rt.right;
2787 }
2788
2789
2790 static void output_text(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str, DWORD flags)
2791 {
2792         int x = dis->rcItem.left;
2793         RECT rt;
2794
2795         rt.left   = x+pane->positions[col]+Globals.spaceSize.cx;
2796         rt.top    = dis->rcItem.top;
2797         rt.right  = x+pane->positions[col+1]-Globals.spaceSize.cx;
2798         rt.bottom = dis->rcItem.bottom;
2799
2800         DrawTextW(dis->hDC, str, -1, &rt, DT_SINGLELINE|DT_NOPREFIX|flags);
2801 }
2802
2803 static void output_tabbed_text(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
2804 {
2805         int x = dis->rcItem.left;
2806         RECT rt;
2807
2808         rt.left   = x+pane->positions[col]+Globals.spaceSize.cx;
2809         rt.top    = dis->rcItem.top;
2810         rt.right  = x+pane->positions[col+1]-Globals.spaceSize.cx;
2811         rt.bottom = dis->rcItem.bottom;
2812
2813         DrawTextW(dis->hDC, str, -1, &rt, DT_SINGLELINE|DT_EXPANDTABS|DT_TABSTOP|(2<<8));
2814 }
2815
2816 static void output_number(Pane* pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
2817 {
2818         int x = dis->rcItem.left;
2819         RECT rt;
2820         LPCWSTR s = str;
2821         WCHAR b[128];
2822         LPWSTR d = b;
2823         int pos;
2824
2825         rt.left   = x+pane->positions[col]+Globals.spaceSize.cx;
2826         rt.top    = dis->rcItem.top;
2827         rt.right  = x+pane->positions[col+1]-Globals.spaceSize.cx;
2828         rt.bottom = dis->rcItem.bottom;
2829
2830         if (*s)
2831                 *d++ = *s++;
2832
2833         /* insert number separator characters */
2834         pos = lstrlenW(s) % 3;
2835
2836         while(*s)
2837                 if (pos--)
2838                         *d++ = *s++;
2839                 else {
2840                         *d++ = Globals.num_sep;
2841                         pos = 3;
2842                 }
2843
2844         DrawTextW(dis->hDC, b, d-b, &rt, DT_RIGHT|DT_SINGLELINE|DT_NOPREFIX|DT_END_ELLIPSIS);
2845 }
2846
2847
2848 static BOOL is_exe_file(LPCWSTR ext)
2849 {
2850         static const WCHAR executable_extensions[][4] = {
2851                 {'C','O','M','\0'},
2852                 {'E','X','E','\0'},
2853                 {'B','A','T','\0'},
2854                 {'C','M','D','\0'},
2855                 {'C','M','M','\0'},
2856                 {'B','T','M','\0'},
2857                 {'A','W','K','\0'},
2858                 {'\0'}
2859         };
2860
2861         WCHAR ext_buffer[_MAX_EXT];
2862         const WCHAR (*p)[4];
2863         LPCWSTR s;
2864         LPWSTR d;
2865
2866         for(s=ext+1,d=ext_buffer; (*d=tolower(*s)); s++)
2867                 d++;
2868
2869         for(p=executable_extensions; (*p)[0]; p++)
2870                 if (!lstrcmpiW(ext_buffer, *p))
2871                         return TRUE;
2872
2873         return FALSE;
2874 }
2875
2876 static BOOL is_registered_type(LPCWSTR ext)
2877 {
2878         /* check if there exists a classname for this file extension in the registry */
2879         if (!RegQueryValueW(HKEY_CLASSES_ROOT, ext, NULL, NULL))
2880                 return TRUE;
2881
2882         return FALSE;
2883 }
2884
2885 static enum FILE_TYPE get_file_type(LPCWSTR filename)
2886 {
2887         LPCWSTR ext = strrchrW(filename, '.');
2888         if (!ext)
2889                 ext = sEmpty;
2890
2891         if (is_exe_file(ext))
2892                 return FT_EXECUTABLE;
2893         else if (is_registered_type(ext))
2894                 return FT_DOCUMENT;
2895         else
2896                 return FT_OTHER;
2897 }
2898
2899
2900 static void draw_item(Pane* pane, LPDRAWITEMSTRUCT dis, Entry* entry, int calcWidthCol)
2901 {
2902         WCHAR buffer[BUFFER_LEN];
2903         DWORD attrs;
2904         int visible_cols = pane->visible_cols;
2905         COLORREF bkcolor, textcolor;
2906         RECT focusRect = dis->rcItem;
2907         HBRUSH hbrush;
2908         enum IMAGE img;
2909         int img_pos, cx;
2910         int col = 0;
2911
2912         if (entry) {
2913                 attrs = entry->data.dwFileAttributes;
2914
2915                 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
2916                         if (entry->data.cFileName[0] == '.' && entry->data.cFileName[1] == '.'
2917                                         && entry->data.cFileName[2] == '\0')
2918                                 img = IMG_FOLDER_UP;
2919                         else if (entry->data.cFileName[0] == '.' && entry->data.cFileName[1] == '\0')
2920                                 img = IMG_FOLDER_CUR;
2921                         else if (pane->treePane && (dis->itemState&ODS_FOCUS))
2922                                 img = IMG_OPEN_FOLDER;
2923                         else
2924                                 img = IMG_FOLDER;
2925                 } else {
2926                         switch(get_file_type(entry->data.cFileName)) {
2927                           case FT_EXECUTABLE:   img = IMG_EXECUTABLE;   break;
2928                           case FT_DOCUMENT:             img = IMG_DOCUMENT;             break;
2929                           default:                              img = IMG_FILE;
2930                         }
2931                 }
2932         } else {
2933                 attrs = 0;
2934                 img = IMG_NONE;
2935         }
2936
2937         if (pane->treePane) {
2938                 if (entry) {
2939                         img_pos = dis->rcItem.left + entry->level*(IMAGE_WIDTH+TREE_LINE_DX);
2940
2941                         if (calcWidthCol == -1) {
2942                                 int x;
2943                                 int y = dis->rcItem.top + IMAGE_HEIGHT/2;
2944                                 Entry* up;
2945                                 RECT rt_clip;
2946                                 HRGN hrgn_org = CreateRectRgn(0, 0, 0, 0);
2947                                 HRGN hrgn;
2948
2949                                 rt_clip.left   = dis->rcItem.left;
2950                                 rt_clip.top    = dis->rcItem.top;
2951                                 rt_clip.right  = dis->rcItem.left+pane->widths[col];
2952                                 rt_clip.bottom = dis->rcItem.bottom;
2953
2954                                 hrgn = CreateRectRgnIndirect(&rt_clip);
2955
2956                                 if (!GetClipRgn(dis->hDC, hrgn_org)) {
2957                                         DeleteObject(hrgn_org);
2958                                         hrgn_org = 0;
2959                                 }
2960
2961                                 ExtSelectClipRgn(dis->hDC, hrgn, RGN_AND);
2962                                 DeleteObject(hrgn);
2963
2964                                 if ((up=entry->up) != NULL) {
2965                                         MoveToEx(dis->hDC, img_pos-IMAGE_WIDTH/2, y, 0);
2966                                         LineTo(dis->hDC, img_pos-2, y);
2967
2968                                         x = img_pos - IMAGE_WIDTH/2;
2969
2970                                         do {
2971                                                 x -= IMAGE_WIDTH+TREE_LINE_DX;
2972
2973                                                 if (up->next
2974                                                         && (up->next->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2975                                                         ) {
2976                                                         MoveToEx(dis->hDC, x, dis->rcItem.top, 0);
2977                                                         LineTo(dis->hDC, x, dis->rcItem.bottom);
2978                                                 }
2979                                         } while((up=up->up) != NULL);
2980                                 }
2981
2982                                 x = img_pos - IMAGE_WIDTH/2;
2983
2984                                 MoveToEx(dis->hDC, x, dis->rcItem.top, 0);
2985                                 LineTo(dis->hDC, x, y);
2986
2987                                 if (entry->next
2988                                         && (entry->next->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
2989                                         LineTo(dis->hDC, x, dis->rcItem.bottom);
2990
2991                                 SelectClipRgn(dis->hDC, hrgn_org);
2992                                 if (hrgn_org) DeleteObject(hrgn_org);
2993                         } else if (calcWidthCol==col || calcWidthCol==COLUMNS) {
2994                                 int right = img_pos + IMAGE_WIDTH - TREE_LINE_DX;
2995
2996                                 if (right > pane->widths[col])
2997                                         pane->widths[col] = right;
2998                         }
2999                 } else  {
3000                         img_pos = dis->rcItem.left;
3001                 }
3002         } else {
3003                 img_pos = dis->rcItem.left;
3004
3005                 if (calcWidthCol==col || calcWidthCol==COLUMNS)
3006                         pane->widths[col] = IMAGE_WIDTH;
3007         }
3008
3009         if (calcWidthCol == -1) {
3010                 focusRect.left = img_pos -2;
3011
3012                 if (attrs & FILE_ATTRIBUTE_COMPRESSED)
3013                         textcolor = COLOR_COMPRESSED;
3014                 else
3015                         textcolor = RGB(0,0,0);
3016
3017                 if (dis->itemState & ODS_FOCUS) {
3018                         textcolor = RGB(255,255,255);
3019                         bkcolor = COLOR_SELECTION;
3020                 } else {
3021                         bkcolor = RGB(255,255,255);
3022                 }
3023
3024                 hbrush = CreateSolidBrush(bkcolor);
3025                 FillRect(dis->hDC, &focusRect, hbrush);
3026                 DeleteObject(hbrush);
3027
3028                 SetBkMode(dis->hDC, TRANSPARENT);
3029                 SetTextColor(dis->hDC, textcolor);
3030
3031                 cx = pane->widths[col];
3032
3033                 if (cx && img!=IMG_NONE) {
3034                         if (cx > IMAGE_WIDTH)
3035                                 cx = IMAGE_WIDTH;
3036
3037                         if (entry->hicon && entry->hicon!=(HICON)-1)
3038                                 DrawIconEx(dis->hDC, img_pos, dis->rcItem.top, entry->hicon, cx, GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
3039                         else
3040                                 ImageList_DrawEx(Globals.himl, img, dis->hDC,
3041                                                                  img_pos, dis->rcItem.top, cx,
3042                                                                  IMAGE_HEIGHT, bkcolor, CLR_DEFAULT, ILD_NORMAL);
3043                 }
3044         }
3045
3046         if (!entry)
3047                 return;
3048
3049         col++;
3050
3051         /* output file name */
3052         if (calcWidthCol == -1)
3053                 output_text(pane, dis, col, entry->data.cFileName, 0);
3054         else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3055                 calc_width(pane, dis, col, entry->data.cFileName);
3056
3057         col++;
3058
3059         /* display file size */
3060         if (visible_cols & COL_SIZE) {
3061                 format_longlong( buffer, ((ULONGLONG)entry->data.nFileSizeHigh << 32) | entry->data.nFileSizeLow );
3062
3063                 if (calcWidthCol == -1)
3064                         output_number(pane, dis, col, buffer);
3065                 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3066                         calc_width(pane, dis, col, buffer);/*TODO: not ever time enough */
3067
3068                 col++;
3069         }
3070
3071         /* display file date */
3072         if (visible_cols & (COL_DATE|COL_TIME)) {
3073                 format_date(&entry->data.ftCreationTime, buffer, visible_cols);
3074                 if (calcWidthCol == -1)
3075                         output_text(pane, dis, col, buffer, 0);
3076                 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3077                         calc_width(pane, dis, col, buffer);
3078                 col++;
3079
3080                 format_date(&entry->data.ftLastAccessTime, buffer, visible_cols);
3081                 if (calcWidthCol == -1)
3082                         output_text(pane, dis, col, buffer, 0);
3083                 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3084                         calc_width(pane, dis, col, buffer);
3085                 col++;
3086
3087                 format_date(&entry->data.ftLastWriteTime, buffer, visible_cols);
3088                 if (calcWidthCol == -1)
3089                         output_text(pane, dis, col, buffer, 0);
3090                 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3091                         calc_width(pane, dis, col, buffer);
3092                 col++;
3093         }
3094
3095         if (entry->bhfi_valid) {
3096                 if (visible_cols & COL_INDEX) {
3097                         static const WCHAR fmtlow[] = {'%','X',0};
3098                         static const WCHAR fmthigh[] = {'%','X','%','0','8','X',0};
3099
3100                         if (entry->bhfi.nFileIndexHigh)
3101                             wsprintfW(buffer, fmthigh,
3102                                      entry->bhfi.nFileIndexHigh, entry->bhfi.nFileIndexLow );
3103                         else
3104                             wsprintfW(buffer, fmtlow, entry->bhfi.nFileIndexLow );
3105
3106                         if (calcWidthCol == -1)
3107                                 output_text(pane, dis, col, buffer, DT_RIGHT);
3108                         else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3109                                 calc_width(pane, dis, col, buffer);
3110
3111                         col++;
3112                 }
3113
3114                 if (visible_cols & COL_LINKS) {
3115                         wsprintfW(buffer, sNumFmt, entry->bhfi.nNumberOfLinks);
3116
3117                         if (calcWidthCol == -1)
3118                                 output_text(pane, dis, col, buffer, DT_CENTER);
3119                         else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3120                                 calc_width(pane, dis, col, buffer);
3121
3122                         col++;
3123                 }
3124         } else
3125                 col += 2;
3126
3127         /* show file attributes */
3128         if (visible_cols & COL_ATTRIBUTES) {
3129                 static const WCHAR s11Tabs[] = {' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\0'};
3130                 lstrcpyW(buffer, s11Tabs);
3131
3132                 if (attrs & FILE_ATTRIBUTE_NORMAL)                                      buffer[ 0] = 'N';
3133                 else {
3134                         if (attrs & FILE_ATTRIBUTE_READONLY)                    buffer[ 2] = 'R';
3135                         if (attrs & FILE_ATTRIBUTE_HIDDEN)                              buffer[ 4] = 'H';
3136                         if (attrs & FILE_ATTRIBUTE_SYSTEM)                              buffer[ 6] = 'S';
3137                         if (attrs & FILE_ATTRIBUTE_ARCHIVE)                             buffer[ 8] = 'A';
3138                         if (attrs & FILE_ATTRIBUTE_COMPRESSED)                  buffer[10] = 'C';
3139                         if (attrs & FILE_ATTRIBUTE_DIRECTORY)                   buffer[12] = 'D';
3140                         if (attrs & FILE_ATTRIBUTE_ENCRYPTED)                   buffer[14] = 'E';
3141                         if (attrs & FILE_ATTRIBUTE_TEMPORARY)                   buffer[16] = 'T';
3142                         if (attrs & FILE_ATTRIBUTE_SPARSE_FILE)                 buffer[18] = 'P';
3143                         if (attrs & FILE_ATTRIBUTE_REPARSE_POINT)               buffer[20] = 'Q';
3144                         if (attrs & FILE_ATTRIBUTE_OFFLINE)                             buffer[22] = 'O';
3145                         if (attrs & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) buffer[24] = 'X';
3146                 }
3147
3148                 if (calcWidthCol == -1)
3149                         output_tabbed_text(pane, dis, col, buffer);
3150                 else if (calcWidthCol==col || calcWidthCol==COLUMNS)
3151                         calc_tabbed_width(pane, dis, col, buffer);
3152
3153                 col++;
3154         }
3155 }
3156
3157 static void set_header(Pane* pane)
3158 {
3159         HDITEMW item;
3160         int scroll_pos = GetScrollPos(pane->hwnd, SB_HORZ);
3161         int i=0, x=0;
3162
3163         item.mask = HDI_WIDTH;
3164         item.cxy = 0;
3165
3166         for(; (i < COLUMNS) && (x+pane->widths[i] < scroll_pos); i++) {
3167                 x += pane->widths[i];
3168                 SendMessageW(pane->hwndHeader, HDM_SETITEMW, i, (LPARAM)&item);
3169         }
3170
3171         if (i < COLUMNS) {
3172                 x += pane->widths[i];
3173                 item.cxy = x - scroll_pos;
3174                 SendMessageW(pane->hwndHeader, HDM_SETITEMW, i++, (LPARAM)&item);
3175
3176                 for(; i < COLUMNS; i++) {
3177                         item.cxy = pane->widths[i];
3178                         x += pane->widths[i];
3179                         SendMessageW(pane->hwndHeader, HDM_SETITEMW, i, (LPARAM)&item);
3180                 }
3181         }
3182 }
3183
3184 static LRESULT pane_notify(Pane* pane, NMHDR* pnmh)
3185 {
3186         switch(pnmh->code) {
3187                 case HDN_ITEMCHANGEDW: {
3188                         LPNMHEADERW phdn = (LPNMHEADERW)pnmh;
3189                         int idx = phdn->iItem;
3190                         int dx = phdn->pitem->cxy - pane->widths[idx];
3191                         int i;
3192
3193                         RECT clnt;
3194                         GetClientRect(pane->hwnd, &clnt);
3195
3196                         pane->widths[idx] += dx;
3197
3198                         for(i=idx; ++i<=COLUMNS; )
3199                                 pane->positions[i] += dx;
3200
3201                         {
3202                                 int scroll_pos = GetScrollPos(pane->hwnd, SB_HORZ);
3203                                 RECT rt_scr;
3204                                 RECT rt_clip;
3205
3206                                 rt_scr.left   = pane->positions[idx+1]-scroll_pos;
3207                                 rt_scr.top    = 0;
3208                                 rt_scr.right  = clnt.right;
3209                                 rt_scr.bottom = clnt.bottom;
3210
3211                                 rt_clip.left   = pane->positions[idx]-scroll_pos;
3212                                 rt_clip.top    = 0;
3213                                 rt_clip.right  = clnt.right;
3214                                 rt_clip.bottom = clnt.bottom;
3215
3216                                 if (rt_scr.left < 0) rt_scr.left = 0;
3217                                 if (rt_clip.left < 0) rt_clip.left = 0;
3218
3219                                 ScrollWindowEx(pane->hwnd, dx, 0, &rt_scr, &rt_clip, 0, 0, SW_INVALIDATE);
3220
3221                                 rt_clip.right = pane->positions[idx+1];
3222                                 RedrawWindow(pane->hwnd, &rt_clip, 0, RDW_INVALIDATE|RDW_UPDATENOW);
3223
3224                                 if (pnmh->code == HDN_ENDTRACKW) {
3225                                         SendMessageW(pane->hwnd, LB_SETHORIZONTALEXTENT, pane->positions[COLUMNS], 0);
3226
3227                                         if (GetScrollPos(pane->hwnd, SB_HORZ) != scroll_pos)
3228                                                 set_header(pane);
3229                                 }
3230                         }
3231
3232                         return FALSE;
3233                 }
3234
3235                 case HDN_DIVIDERDBLCLICKW: {
3236                         LPNMHEADERW phdn = (LPNMHEADERW)pnmh;
3237                         HDITEMW item;
3238
3239                         calc_single_width(pane, phdn->iItem);
3240                         item.mask = HDI_WIDTH;
3241                         item.cxy = pane->widths[phdn->iItem];
3242
3243                         SendMessageW(pane->hwndHeader, HDM_SETITEMW, phdn->iItem, (LPARAM)&item);
3244                         InvalidateRect(pane->hwnd, 0, TRUE);
3245                         break;}
3246         }
3247
3248         return 0;
3249 }
3250
3251 static void scan_entry(ChildWnd* child, Entry* entry, int idx, HWND hwnd)
3252 {
3253         WCHAR path[MAX_PATH];
3254         HCURSOR old_cursor = SetCursor(LoadCursorW(0, (LPCWSTR)IDC_WAIT));
3255
3256         /* delete sub entries in left pane */
3257         for(;;) {
3258                 LRESULT res = SendMessageW(child->left.hwnd, LB_GETITEMDATA, idx+1, 0);
3259                 Entry* sub = (Entry*) res;
3260
3261                 if (res==LB_ERR || !sub || sub->level<=entry->level)
3262                         break;
3263
3264                 SendMessageW(child->left.hwnd, LB_DELETESTRING, idx+1, 0);
3265         }
3266
3267         /* empty right pane */
3268         SendMessageW(child->right.hwnd, LB_RESETCONTENT, 0, 0);
3269
3270         /* release memory */
3271         free_entries(entry);
3272
3273         /* read contents from disk */
3274         if (entry->etype == ET_SHELL)
3275         {
3276                 read_directory(entry, NULL, child->sortOrder, hwnd);
3277         }
3278         else
3279         {
3280                 get_path(entry, path);
3281                 read_directory(entry, path, child->sortOrder, hwnd);
3282         }
3283
3284         /* insert found entries in right pane */
3285         insert_entries(&child->right, entry->down, child->filter_pattern, child->filter_flags, -1);
3286         calc_widths(&child->right, FALSE);
3287         set_header(&child->right);
3288
3289         child->header_wdths_ok = FALSE;
3290
3291         SetCursor(old_cursor);
3292 }
3293
3294
3295 /* expand a directory entry */
3296
3297 static BOOL expand_entry(ChildWnd* child, Entry* dir)
3298 {
3299         int idx;
3300         Entry* p;
3301
3302         if (!dir || dir->expanded || !dir->down)
3303                 return FALSE;
3304
3305         p = dir->down;
3306
3307         if (p->data.cFileName[0]=='.' && p->data.cFileName[1]=='\0' && p->next) {
3308                 p = p->next;
3309
3310                 if (p->data.cFileName[0]=='.' && p->data.cFileName[1]=='.' &&
3311                                 p->data.cFileName[2]=='\0' && p->next)
3312                         p = p->next;
3313         }
3314
3315         /* no subdirectories ? */
3316         if (!(p->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
3317                 return FALSE;
3318
3319         idx = SendMessageW(child->left.hwnd, LB_FINDSTRING, 0, (LPARAM)dir);
3320
3321         dir->expanded = TRUE;
3322
3323         /* insert entries in left pane */
3324         insert_entries(&child->left, p, NULL, TF_ALL, idx);
3325
3326         if (!child->header_wdths_ok) {
3327                 if (calc_widths(&child->left, FALSE)) {
3328                         set_header(&child->left);
3329
3330                         child->header_wdths_ok = TRUE;
3331                 }
3332         }
3333
3334         return TRUE;
3335 }
3336
3337
3338 static void collapse_entry(Pane* pane, Entry* dir)
3339 {
3340         int idx;
3341
3342         if (!dir) return;
3343         idx = SendMessageW(pane->hwnd, LB_FINDSTRING, 0, (LPARAM)dir);
3344
3345         ShowWindow(pane->hwnd, SW_HIDE);
3346
3347         /* hide sub entries */
3348         for(;;) {
3349                 LRESULT res = SendMessageW(pane->hwnd, LB_GETITEMDATA, idx+1, 0);
3350                 Entry* sub = (Entry*) res;
3351
3352                 if (res==LB_ERR || !sub || sub->level<=dir->level)
3353                         break;
3354
3355                 SendMessageW(pane->hwnd, LB_DELETESTRING, idx+1, 0);
3356         }
3357
3358         dir->expanded = FALSE;
3359
3360         ShowWindow(pane->hwnd, SW_SHOW);
3361 }
3362
3363
3364 static void refresh_right_pane(ChildWnd* child)
3365 {
3366         SendMessageW(child->right.hwnd, LB_RESETCONTENT, 0, 0);
3367         insert_entries(&child->right, child->right.root, child->filter_pattern, child->filter_flags, -1);
3368         calc_widths(&child->right, FALSE);
3369
3370         set_header(&child->right);
3371 }
3372
3373 static void set_curdir(ChildWnd* child, Entry* entry, int idx, HWND hwnd)
3374 {
3375         WCHAR path[MAX_PATH];
3376
3377         if (!entry)
3378                 return;
3379
3380         path[0] = '\0';
3381
3382         child->left.cur = entry;
3383
3384         child->right.root = entry->down? entry->down: entry;
3385         child->right.cur = entry;
3386
3387         if (!entry->scanned)
3388                 scan_entry(child, entry, idx, hwnd);
3389         else
3390                 refresh_right_pane(child);
3391
3392         get_path(entry, path);
3393         lstrcpyW(child->path, path);
3394
3395         if (child->hwnd)        /* only change window title, if the window already exists */
3396                 SetWindowTextW(child->hwnd, path);
3397
3398         if (path[0])
3399                 if (SetCurrentDirectoryW(path))
3400                         set_space_status();
3401 }
3402
3403
3404 static void refresh_child(ChildWnd* child)
3405 {
3406         WCHAR path[MAX_PATH], drv[_MAX_DRIVE+1];
3407         Entry* entry;
3408         int idx;
3409
3410         get_path(child->left.cur, path);
3411         _wsplitpath(path, drv, NULL, NULL, NULL);
3412
3413         child->right.root = NULL;
3414
3415         scan_entry(child, &child->root.entry, 0, child->hwnd);
3416
3417         if (child->root.entry.etype == ET_SHELL)
3418         {
3419                 LPITEMIDLIST local_pidl = get_path_pidl(path,child->hwnd);
3420                 if (local_pidl)
3421                         entry = read_tree(&child->root, NULL, local_pidl , drv, child->sortOrder, child->hwnd);
3422                 else
3423                         entry = NULL;
3424         }
3425         else
3426                 entry = read_tree(&child->root, path, NULL, drv, child->sortOrder, child->hwnd);
3427
3428         if (!entry)
3429                 entry = &child->root.entry;
3430
3431         insert_entries(&child->left, child->root.entry.down, NULL, TF_ALL, 0);
3432
3433         set_curdir(child, entry, 0, child->hwnd);
3434
3435         idx = SendMessageW(child->left.hwnd, LB_FINDSTRING, 0, (LPARAM)child->left.cur);
3436         SendMessageW(child->left.hwnd, LB_SETCURSEL, idx, 0);
3437 }
3438
3439
3440 static void create_drive_bar(void)
3441 {
3442         TBBUTTON drivebarBtn = {0, 0, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0};
3443         WCHAR b1[BUFFER_LEN];
3444         int btn = 1;
3445         PWSTR p;
3446
3447         GetLogicalDriveStringsW(BUFFER_LEN, Globals.drives);
3448
3449         Globals.hdrivebar = CreateToolbarEx(Globals.hMainWnd, WS_CHILD|WS_VISIBLE|CCS_NOMOVEY|TBSTYLE_LIST,
3450                                 IDW_DRIVEBAR, 2, Globals.hInstance, IDB_DRIVEBAR, &drivebarBtn,
3451                                 0, 16, 13, 16, 13, sizeof(TBBUTTON));
3452
3453 #ifdef __WINE__
3454         /* insert unix file system button */
3455         b1[0] = '/';
3456         b1[1] = '\0';
3457         b1[2] = '\0';
3458         SendMessageW(Globals.hdrivebar, TB_ADDSTRINGW, 0, (LPARAM)b1);
3459
3460         drivebarBtn.idCommand = ID_DRIVE_UNIX_FS;
3461         SendMessageW(Globals.hdrivebar, TB_INSERTBUTTONW, btn++, (LPARAM)&drivebarBtn);
3462         drivebarBtn.iString++;
3463 #endif
3464         /* insert shell namespace button */
3465         load_string(b1, sizeof(b1)/sizeof(b1[0]), IDS_SHELL);
3466         b1[lstrlenW(b1)+1] = '\0';
3467         SendMessageW(Globals.hdrivebar, TB_ADDSTRINGW, 0, (LPARAM)b1);
3468
3469         drivebarBtn.idCommand = ID_DRIVE_SHELL_NS;
3470         SendMessageW(Globals.hdrivebar, TB_INSERTBUTTONW, btn++, (LPARAM)&drivebarBtn);
3471         drivebarBtn.iString++;
3472
3473         /* register windows drive root strings */
3474         SendMessageW(Globals.hdrivebar, TB_ADDSTRINGW, 0, (LPARAM)Globals.drives);
3475
3476         drivebarBtn.idCommand = ID_DRIVE_FIRST;
3477
3478         for(p=Globals.drives; *p; ) {
3479                 switch(GetDriveTypeW(p)) {
3480                         case DRIVE_REMOVABLE:   drivebarBtn.iBitmap = 1;        break;
3481                         case DRIVE_CDROM:               drivebarBtn.iBitmap = 3;        break;
3482                         case DRIVE_REMOTE:              drivebarBtn.iBitmap = 4;        break;
3483                         case DRIVE_RAMDISK:             drivebarBtn.iBitmap = 5;        break;
3484                         default:/*DRIVE_FIXED*/ drivebarBtn.iBitmap = 2;
3485                 }
3486
3487                 SendMessageW(Globals.hdrivebar, TB_INSERTBUTTONW, btn++, (LPARAM)&drivebarBtn);
3488                 drivebarBtn.idCommand++;
3489                 drivebarBtn.iString++;
3490
3491                 while(*p++);
3492         }
3493 }
3494
3495 static void refresh_drives(void)
3496 {
3497         RECT rect;
3498
3499         /* destroy drive bar */
3500         DestroyWindow(Globals.hdrivebar);
3501         Globals.hdrivebar = 0;
3502
3503         /* re-create drive bar */
3504         create_drive_bar();
3505
3506         /* update window layout */
3507         GetClientRect(Globals.hMainWnd, &rect);
3508         SendMessageW(Globals.hMainWnd, WM_SIZE, 0, MAKELONG(rect.right, rect.bottom));
3509 }
3510
3511
3512 static BOOL launch_file(HWND hwnd, LPCWSTR cmd, UINT nCmdShow)
3513 {
3514         HINSTANCE hinst = ShellExecuteW(hwnd, NULL/*operation*/, cmd, NULL/*parameters*/, NULL/*dir*/, nCmdShow);
3515
3516         if (PtrToUlong(hinst) <= 32) {
3517                 display_error(hwnd, GetLastError());
3518                 return FALSE;
3519         }
3520
3521         return TRUE;
3522 }
3523
3524
3525 static BOOL launch_entry(Entry* entry, HWND hwnd, UINT nCmdShow)
3526 {
3527         WCHAR cmd[MAX_PATH];
3528
3529         if (entry->etype == ET_SHELL) {
3530                 BOOL ret = TRUE;
3531
3532                 SHELLEXECUTEINFOW shexinfo;
3533
3534                 shexinfo.cbSize = sizeof(SHELLEXECUTEINFOW);
3535                 shexinfo.fMask = SEE_MASK_IDLIST;
3536                 shexinfo.hwnd = hwnd;
3537                 shexinfo.lpVerb = NULL;
3538                 shexinfo.lpFile = NULL;
3539                 shexinfo.lpParameters = NULL;
3540                 shexinfo.lpDirectory = NULL;
3541                 shexinfo.nShow = nCmdShow;
3542                 shexinfo.lpIDList = get_to_absolute_pidl(entry, hwnd);
3543
3544                 if (!ShellExecuteExW(&shexinfo)) {
3545                         display_error(hwnd, GetLastError());
3546                         ret = FALSE;
3547                 }
3548
3549                 if (shexinfo.lpIDList != entry->pidl)
3550                         IMalloc_Free(Globals.iMalloc, shexinfo.lpIDList);
3551
3552                 return ret;
3553         }
3554
3555         get_path(entry, cmd);
3556
3557          /* start program, open document... */
3558         return launch_file(hwnd, cmd, nCmdShow);
3559 }
3560
3561
3562 static void activate_entry(ChildWnd* child, Pane* pane, HWND hwnd)
3563 {
3564         Entry* entry = pane->cur;
3565
3566         if (!entry)
3567                 return;
3568
3569         if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
3570                 int scanned_old = entry->scanned;
3571
3572                 if (!scanned_old)
3573                 {
3574                         int idx = SendMessageW(child->left.hwnd, LB_GETCURSEL, 0, 0);
3575                         scan_entry(child, entry, idx, hwnd);
3576                 }
3577
3578                 if (entry->data.cFileName[0]=='.' && entry->data.cFileName[1]=='\0')
3579                         return;
3580
3581                 if (entry->data.cFileName[0]=='.' && entry->data.cFileName[1]=='.' && entry->data.cFileName[2]=='\0') {
3582                         entry = child->left.cur->up;
3583                         collapse_entry(&child->left, entry);
3584                         goto focus_entry;
3585                 } else if (entry->expanded)
3586                         collapse_entry(pane, child->left.cur);
3587                 else {
3588                         expand_entry(child, child->left.cur);
3589
3590                         if (!pane->treePane) focus_entry: {
3591                                 int idxstart = SendMessageW(child->left.hwnd, LB_GETCURSEL, 0, 0);
3592                                 int idx = SendMessageW(child->left.hwnd, LB_FINDSTRING, idxstart, (LPARAM)entry);
3593                                 SendMessageW(child->left.hwnd, LB_SETCURSEL, idx, 0);
3594                                 set_curdir(child, entry, idx, hwnd);
3595                         }
3596                 }
3597
3598                 if (!scanned_old) {
3599                         calc_widths(pane, FALSE);
3600
3601                         set_header(pane);
3602                 }
3603         } else {
3604                 if (GetKeyState(VK_MENU) < 0)
3605                         show_properties_dlg(entry, child->hwnd);
3606                 else
3607                         launch_entry(entry, child->hwnd, SW_SHOWNORMAL);
3608         }
3609 }
3610
3611
3612 static BOOL pane_command(Pane* pane, UINT cmd)
3613 {
3614         switch(cmd) {
3615                 case ID_VIEW_NAME:
3616                         if (pane->visible_cols) {
3617                                 pane->visible_cols = 0;
3618                                 calc_widths(pane, TRUE);
3619                                 set_header(pane);
3620                                 InvalidateRect(pane->hwnd, 0, TRUE);
3621                                 CheckMenuItem(Globals.hMenuView, ID_VIEW_NAME, MF_BYCOMMAND|MF_CHECKED);
3622                                 CheckMenuItem(Globals.hMenuView, ID_VIEW_ALL_ATTRIBUTES, MF_BYCOMMAND);
3623                         }
3624                         break;
3625
3626                 case ID_VIEW_ALL_ATTRIBUTES:
3627                         if (pane->visible_cols != COL_ALL) {
3628                                 pane->visible_cols = COL_ALL;
3629                                 calc_widths(pane, TRUE);
3630                                 set_header(pane);
3631                                 InvalidateRect(pane->hwnd, 0, TRUE);
3632                                 CheckMenuItem(Globals.hMenuView, ID_VIEW_NAME, MF_BYCOMMAND);
3633                                 CheckMenuItem(Globals.hMenuView, ID_VIEW_ALL_ATTRIBUTES, MF_BYCOMMAND|MF_CHECKED);
3634                         }
3635                         break;
3636
3637                 case ID_PREFERRED_SIZES: {
3638                         calc_widths(pane, TRUE);
3639                         set_header(pane);
3640                         InvalidateRect(pane->hwnd, 0, TRUE);
3641                         break;}
3642
3643                         /* TODO: more command ids... */
3644
3645                 default:
3646                         return FALSE;
3647         }
3648
3649         return TRUE;
3650 }
3651
3652
3653 static void set_sort_order(ChildWnd* child, SORT_ORDER sortOrder)
3654 {
3655         if (child->sortOrder != sortOrder) {
3656                 child->sortOrder = sortOrder;
3657                 refresh_child(child);
3658         }
3659 }
3660
3661 static void update_view_menu(ChildWnd* child)
3662 {
3663         CheckMenuItem(Globals.hMenuView, ID_VIEW_SORT_NAME, child->sortOrder==SORT_NAME? MF_CHECKED: MF_UNCHECKED);
3664         CheckMenuItem(Globals.hMenuView, ID_VIEW_SORT_TYPE, child->sortOrder==SORT_EXT? MF_CHECKED: MF_UNCHECKED);
3665         CheckMenuItem(Globals.hMenuView, ID_VIEW_SORT_SIZE, child->sortOrder==SORT_SIZE? MF_CHECKED: MF_UNCHECKED);
3666         CheckMenuItem(Globals.hMenuView, ID_VIEW_SORT_DATE, child->sortOrder==SORT_DATE? MF_CHECKED: MF_UNCHECKED);
3667 }
3668
3669
3670 static BOOL is_directory(LPCWSTR target)
3671 {
3672         /*TODO correctly handle UNIX paths */
3673         DWORD target_attr = GetFileAttributesW(target);
3674
3675         if (target_attr == INVALID_FILE_ATTRIBUTES)
3676                 return FALSE;
3677
3678         return (target_attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
3679 }
3680
3681 static BOOL prompt_target(Pane* pane, LPWSTR source, LPWSTR target)
3682 {
3683         WCHAR path[MAX_PATH];
3684         int len;
3685
3686         get_path(pane->cur, path);
3687
3688         if (DialogBoxParamW(Globals.hInstance, MAKEINTRESOURCEW(IDD_SELECT_DESTINATION), pane->hwnd, DestinationDlgProc, (LPARAM)path) != IDOK)
3689                 return FALSE;
3690
3691         get_path(pane->cur, source);
3692
3693         /* convert relative targets to absolute paths */
3694         if (path[0]!='/' && path[1]!=':') {
3695                 get_path(pane->cur->up, target);
3696                 len = lstrlenW(target);
3697
3698                 if (target[len-1]!='\\' && target[len-1]!='/')
3699                         target[len++] = '/';
3700
3701                 lstrcpyW(target+len, path);
3702         } else
3703                 lstrcpyW(target, path);
3704
3705         /* If the target already exists as directory, create a new target below this. */
3706         if (is_directory(path)) {
3707                 WCHAR fname[_MAX_FNAME], ext[_MAX_EXT];
3708                 static const WCHAR sAppend[] = {'%','s','/','%','s','%','s','\0'};
3709
3710                 _wsplitpath(source, NULL, NULL, fname, ext);
3711
3712                 wsprintfW(target, sAppend, path, fname, ext);
3713         }
3714
3715         return TRUE;
3716 }
3717
3718
3719 static IContextMenu2* s_pctxmenu2 = NULL;
3720 static IContextMenu3* s_pctxmenu3 = NULL;
3721
3722 static void CtxMenu_reset(void)
3723 {
3724         s_pctxmenu2 = NULL;
3725         s_pctxmenu3 = NULL;
3726 }
3727
3728 static IContextMenu* CtxMenu_query_interfaces(IContextMenu* pcm1)
3729 {
3730         IContextMenu* pcm = NULL;
3731
3732         CtxMenu_reset();
3733
3734         if (IContextMenu_QueryInterface(pcm1, &IID_IContextMenu3, (void**)&pcm) == NOERROR)
3735                 s_pctxmenu3 = (LPCONTEXTMENU3)pcm;
3736         else if (IContextMenu_QueryInterface(pcm1, &IID_IContextMenu2, (void**)&pcm) == NOERROR)
3737                 s_pctxmenu2 = (LPCONTEXTMENU2)pcm;
3738
3739         if (pcm) {
3740                 IContextMenu_Release(pcm1);
3741                 return pcm;
3742         } else
3743                 return pcm1;
3744 }
3745
3746 static BOOL CtxMenu_HandleMenuMsg(UINT nmsg, WPARAM wparam, LPARAM lparam)
3747 {
3748         if (s_pctxmenu3) {
3749                 if (SUCCEEDED(IContextMenu3_HandleMenuMsg(s_pctxmenu3, nmsg, wparam, lparam)))
3750                         return TRUE;
3751         }
3752
3753         if (s_pctxmenu2)
3754                 if (SUCCEEDED(IContextMenu2_HandleMenuMsg(s_pctxmenu2, nmsg, wparam, lparam)))
3755                         return TRUE;
3756
3757         return FALSE;
3758 }
3759
3760 static HRESULT ShellFolderContextMenu(IShellFolder* shell_folder, HWND hwndParent, int cidl, LPCITEMIDLIST* apidl, int x, int y)
3761 {
3762         IContextMenu* pcm;
3763         BOOL executed = FALSE;
3764
3765         HRESULT hr = IShellFolder_GetUIObjectOf(shell_folder, hwndParent, cidl, apidl, &IID_IContextMenu, NULL, (LPVOID*)&pcm);
3766
3767         if (SUCCEEDED(hr)) {
3768                 HMENU hmenu = CreatePopupMenu();
3769
3770                 pcm = CtxMenu_query_interfaces(pcm);
3771
3772                 if (hmenu) {
3773                         hr = IContextMenu_QueryContextMenu(pcm, hmenu, 0, FCIDM_SHVIEWFIRST, FCIDM_SHVIEWLAST, CMF_NORMAL);
3774
3775                         if (SUCCEEDED(hr)) {
3776                                 UINT idCmd = TrackPopupMenu(hmenu, TPM_LEFTALIGN|TPM_RETURNCMD|TPM_RIGHTBUTTON, x, y, 0, hwndParent, NULL);
3777
3778                                 CtxMenu_reset();
3779
3780                                 if (idCmd) {
3781                                   CMINVOKECOMMANDINFO cmi;
3782
3783                                   cmi.cbSize = sizeof(CMINVOKECOMMANDINFO);
3784                                   cmi.fMask = 0;
3785                                   cmi.hwnd = hwndParent;
3786                                   cmi.lpVerb = (LPCSTR)(INT_PTR)(idCmd - FCIDM_SHVIEWFIRST);
3787                                   cmi.lpParameters = NULL;
3788                                   cmi.lpDirectory = NULL;
3789                                   cmi.nShow = SW_SHOWNORMAL;
3790                                   cmi.dwHotKey = 0;
3791                                   cmi.hIcon = 0;
3792
3793                                   hr = IContextMenu_InvokeCommand(pcm, &cmi);
3794                                         executed = TRUE;
3795                                 }
3796                         } else
3797                                 CtxMenu_reset();
3798                 }
3799
3800                 IContextMenu_Release(pcm);
3801         }
3802
3803         return FAILED(hr)? hr: executed? S_OK: S_FALSE;
3804 }
3805
3806 static LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
3807 {
3808         ChildWnd* child = (ChildWnd*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
3809         ASSERT(child);
3810
3811         switch(nmsg) {
3812                 case WM_DRAWITEM: {
3813                         LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT)lparam;
3814                         Entry* entry = (Entry*) dis->itemData;
3815
3816                         if (dis->CtlID == IDW_TREE_LEFT)
3817                                 draw_item(&child->left, dis, entry, -1);
3818                         else if (dis->CtlID == IDW_TREE_RIGHT)
3819                                 draw_item(&child->right, dis, entry, -1);
3820                         else
3821                                 goto draw_menu_item;
3822
3823                         return TRUE;}
3824
3825                 case WM_CREATE:
3826                         InitChildWindow(child);
3827                         break;
3828
3829                 case WM_NCDESTROY:
3830                         free_child_window(child);
3831                         SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0);
3832                         break;
3833
3834                 case WM_PAINT: {
3835                         PAINTSTRUCT ps;
3836                         HBRUSH lastBrush;
3837                         RECT rt;
3838                         GetClientRect(hwnd, &rt);
3839                         BeginPaint(hwnd, &ps);
3840                         rt.left = child->split_pos-SPLIT_WIDTH/2;
3841                         rt.right = child->split_pos+SPLIT_WIDTH/2+1;
3842                         lastBrush = SelectObject(ps.hdc, GetStockObject(COLOR_SPLITBAR));
3843                         Rectangle(ps.hdc, rt.left, rt.top-1, rt.right, rt.bottom+1);
3844                         SelectObject(ps.hdc, lastBrush);
3845                         EndPaint(hwnd, &ps);
3846                         break;}
3847
3848                 case WM_SETCURSOR:
3849                         if (LOWORD(lparam) == HTCLIENT) {
3850                                 POINT pt;
3851                                 GetCursorPos(&pt);
3852                                 ScreenToClient(hwnd, &pt);
3853
3854                                 if (pt.x>=child->split_pos-SPLIT_WIDTH/2 && pt.x<child->split_pos+SPLIT_WIDTH/2+1) {
3855                                         SetCursor(LoadCursorW(0, (LPCWSTR)IDC_SIZEWE));
3856                                         return TRUE;
3857                                 }
3858                         }
3859                         goto def;
3860
3861                 case WM_LBUTTONDOWN: {
3862                         RECT rt;
3863                         int x = (short)LOWORD(lparam);
3864
3865                         GetClientRect(hwnd, &rt);
3866
3867                         if (x>=child->split_pos-SPLIT_WIDTH/2 && x<child->split_pos+SPLIT_WIDTH/2+1) {
3868                                 last_split = child->split_pos;
3869                                 SetCapture(hwnd);
3870                         }
3871
3872                         break;}
3873
3874                 case WM_LBUTTONUP:
3875                         if (GetCapture() == hwnd)
3876                                 ReleaseCapture();
3877                         break;
3878
3879                 case WM_KEYDOWN:
3880                         if (wparam == VK_ESCAPE)
3881                                 if (GetCapture() == hwnd) {
3882                                         RECT rt;
3883                                         child->split_pos = last_split;
3884                                         GetClientRect(hwnd, &rt);
3885                                         resize_tree(child, rt.right, rt.bottom);
3886                                         last_split = -1;
3887                                         ReleaseCapture();
3888                                         SetCursor(LoadCursorW(0, (LPCWSTR)IDC_ARROW));
3889                                 }
3890                         break;
3891
3892                 case WM_MOUSEMOVE:
3893                         if (GetCapture() == hwnd) {
3894                                 RECT rt;
3895                                 int x = (short)LOWORD(lparam);
3896
3897                                 GetClientRect(hwnd, &rt);
3898
3899                                 if (x>=0 && x<rt.right) {
3900                                         child->split_pos = x;
3901                                         resize_tree(child, rt.right, rt.bottom);
3902                                         rt.left = x-SPLIT_WIDTH/2;
3903                                         rt.right = x+SPLIT_WIDTH/2+1;
3904                                         InvalidateRect(hwnd, &rt, FALSE);
3905                                         UpdateWindow(child->left.hwnd);
3906                                         UpdateWindow(hwnd);
3907                                         UpdateWindow(child->right.hwnd);
3908                                 }
3909                         }
3910                         break;
3911
3912                 case WM_GETMINMAXINFO:
3913                         DefMDIChildProcW(hwnd, nmsg, wparam, lparam);
3914
3915                         {LPMINMAXINFO lpmmi = (LPMINMAXINFO)lparam;
3916
3917                         lpmmi->ptMaxTrackSize.x <<= 1;/*2*GetSystemMetrics(SM_CXSCREEN) / SM_CXVIRTUALSCREEN */
3918                         lpmmi->ptMaxTrackSize.y <<= 1;/*2*GetSystemMetrics(SM_CYSCREEN) / SM_CYVIRTUALSCREEN */
3919                         break;}
3920
3921                 case WM_SETFOCUS:
3922                         if (SetCurrentDirectoryW(child->path))
3923                                 set_space_status();
3924                         SetFocus(child->focus_pane? child->right.hwnd: child->left.hwnd);
3925                         break;
3926
3927                 case WM_DISPATCH_COMMAND: {
3928                         Pane* pane = GetFocus()==child->left.hwnd? &child->left: &child->right;
3929
3930                         switch(LOWORD(wparam)) {
3931                                 case ID_WINDOW_NEW: {
3932                                         ChildWnd* new_child = alloc_child_window(child->path, NULL, hwnd);
3933
3934                                         if (!create_child_window(new_child))
3935                                                 HeapFree(GetProcessHeap(), 0, new_child);
3936
3937                                         break;}
3938
3939                                 case ID_REFRESH:
3940                                         refresh_drives();
3941                                         refresh_child(child);
3942                                         break;
3943
3944                                 case ID_ACTIVATE:
3945                                         activate_entry(child, pane, hwnd);
3946                                         break;
3947
3948                                 case ID_FILE_MOVE: {
3949                                         WCHAR source[BUFFER_LEN], target[BUFFER_LEN];
3950
3951                                         if (prompt_target(pane, source, target)) {
3952                                                 SHFILEOPSTRUCTW shfo = {hwnd, FO_MOVE, source, target};
3953
3954                                                 source[lstrlenW(source)+1] = '\0';
3955                                                 target[lstrlenW(target)+1] = '\0';
3956
3957                                                 if (!SHFileOperationW(&shfo))
3958                                                         refresh_child(child);
3959                                         }
3960                                         break;}
3961
3962                                 case ID_FILE_COPY: {
3963                                         WCHAR source[BUFFER_LEN], target[BUFFER_LEN];
3964
3965                                         if (prompt_target(pane, source, target)) {
3966                                                 SHFILEOPSTRUCTW shfo = {hwnd, FO_COPY, source, target};
3967
3968                                                 source[lstrlenW(source)+1] = '\0';
3969                                                 target[lstrlenW(target)+1] = '\0';
3970
3971                                                 if (!SHFileOperationW(&shfo))
3972                                                         refresh_child(child);
3973                                         }
3974                                         break;}
3975
3976                                 case ID_FILE_DELETE: {
3977                                         WCHAR path[BUFFER_LEN];
3978                                         SHFILEOPSTRUCTW shfo = {hwnd, FO_DELETE, path, NULL, FOF_ALLOWUNDO};
3979
3980                                         get_path(pane->cur, path);
3981
3982                                         path[lstrlenW(path)+1] = '\0';
3983
3984                                         if (!SHFileOperationW(&shfo))
3985                                                 refresh_child(child);
3986                                         break;}
3987
3988                                 case ID_VIEW_SORT_NAME:
3989                                         set_sort_order(child, SORT_NAME);
3990                                         break;
3991
3992                                 case ID_VIEW_SORT_TYPE:
3993                                         set_sort_order(child, SORT_EXT);
3994                                         break;
3995
3996                                 case ID_VIEW_SORT_SIZE:
3997                                         set_sort_order(child, SORT_SIZE);
3998                                         break;
3999
4000                                 case ID_VIEW_SORT_DATE:
4001                                         set_sort_order(child, SORT_DATE);
4002                                         break;
4003
4004                                 case ID_VIEW_FILTER: {
4005                                         struct FilterDialog dlg;
4006
4007                                         memset(&dlg, 0, sizeof(struct FilterDialog));
4008                                         lstrcpyW(dlg.pattern, child->filter_pattern);
4009                                         dlg.flags = child->filter_flags;
4010
4011                                         if (DialogBoxParamW(Globals.hInstance, MAKEINTRESOURCEW(IDD_DIALOG_VIEW_TYPE), hwnd, FilterDialogDlgProc, (LPARAM)&dlg) == IDOK) {
4012                                                 lstrcpyW(child->filter_pattern, dlg.pattern);
4013                                                 child->filter_flags = dlg.flags;
4014                                                 refresh_right_pane(child);
4015                                         }
4016                                         break;}
4017
4018                                 case ID_VIEW_SPLIT: {
4019                                         last_split = child->split_pos;
4020                                         SetCapture(hwnd);
4021                                         break;}
4022
4023                                 case ID_EDIT_PROPERTIES:
4024                                         show_properties_dlg(pane->cur, child->hwnd);
4025                                         break;
4026
4027                                 default:
4028                                         return pane_command(pane, LOWORD(wparam));
4029                         }
4030
4031                         return TRUE;}
4032
4033                 case WM_COMMAND: {
4034                         Pane* pane = GetFocus()==child->left.hwnd? &child->left: &child->right;
4035
4036                         switch(HIWORD(wparam)) {
4037                                 case LBN_SELCHANGE: {
4038                                         int idx = SendMessageW(pane->hwnd, LB_GETCURSEL, 0, 0);
4039                                         Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, idx, 0);
4040
4041                                         if (pane == &child->left)
4042                                                 set_curdir(child, entry, idx, hwnd);
4043                                         else
4044                                                 pane->cur = entry;
4045                                         break;}
4046
4047                                 case LBN_DBLCLK:
4048                                         activate_entry(child, pane, hwnd);
4049                                         break;
4050                         }
4051                         break;}
4052
4053                 case WM_NOTIFY: {
4054                         NMHDR* pnmh = (NMHDR*) lparam;
4055                         return pane_notify(pnmh->idFrom==IDW_HEADER_LEFT? &child->left: &child->right, pnmh);}
4056
4057                 case WM_CONTEXTMENU: {
4058                         POINT pt, pt_clnt;
4059                         Pane* pane;
4060                         int idx;
4061
4062                          /* first select the current item in the listbox */
4063                         HWND hpanel = (HWND) wparam;
4064                         pt_clnt.x = pt.x = (short)LOWORD(lparam);
4065                         pt_clnt.y = pt.y = (short)HIWORD(lparam);
4066                         ScreenToClient(hpanel, &pt_clnt);
4067                         SendMessageW(hpanel, WM_LBUTTONDOWN, 0, MAKELONG(pt_clnt.x, pt_clnt.y));
4068                         SendMessageW(hpanel, WM_LBUTTONUP, 0, MAKELONG(pt_clnt.x, pt_clnt.y));
4069
4070                          /* now create the popup menu using shell namespace and IContextMenu */
4071                         pane = GetFocus()==child->left.hwnd? &child->left: &child->right;
4072                         idx = SendMessageW(pane->hwnd, LB_GETCURSEL, 0, 0);
4073
4074                         if (idx != -1) {
4075                                 Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, idx, 0);
4076
4077                                 LPITEMIDLIST pidl_abs = get_to_absolute_pidl(entry, hwnd);
4078
4079                                 if (pidl_abs) {
4080                                         IShellFolder* parentFolder;
4081                                         LPCITEMIDLIST pidlLast;
4082
4083                                          /* get and use the parent folder to display correct context menu in all cases */
4084                                         if (SUCCEEDED(SHBindToParent(pidl_abs, &IID_IShellFolder, (LPVOID*)&parentFolder, &pidlLast))) {
4085                                                 if (ShellFolderContextMenu(parentFolder, hwnd, 1, &pidlLast, pt.x, pt.y) == S_OK)
4086                                                         refresh_child(child);
4087
4088                                                 IShellFolder_Release(parentFolder);
4089                                         }
4090
4091                                         IMalloc_Free(Globals.iMalloc, pidl_abs);
4092                                 }
4093                         }
4094                         break;}
4095
4096                   case WM_MEASUREITEM:
4097                   draw_menu_item:
4098                         if (!wparam)    /* Is the message menu-related? */
4099                                 if (CtxMenu_HandleMenuMsg(nmsg, wparam, lparam))
4100                                         return TRUE;
4101
4102                         break;
4103
4104                   case WM_INITMENUPOPUP:
4105                         if (CtxMenu_HandleMenuMsg(nmsg, wparam, lparam))
4106                                 return 0;
4107
4108                         update_view_menu(child);
4109                         break;
4110
4111                   case WM_MENUCHAR:     /* only supported by IContextMenu3 */
4112                    if (s_pctxmenu3) {
4113                            LRESULT lResult = 0;
4114
4115                            IContextMenu3_HandleMenuMsg2(s_pctxmenu3, nmsg, wparam, lparam, &lResult);
4116
4117                            return lResult;
4118                    }
4119
4120                    break;
4121
4122                 case WM_SIZE:
4123                         if (wparam != SIZE_MINIMIZED)
4124                                 resize_tree(child, LOWORD(lparam), HIWORD(lparam));
4125                         /* fall through */
4126
4127                 default: def:
4128                         return DefMDIChildProcW(hwnd, nmsg, wparam, lparam);
4129         }
4130
4131         return 0;
4132 }
4133
4134
4135 static LRESULT CALLBACK TreeWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
4136 {
4137         ChildWnd* child = (ChildWnd*)GetWindowLongPtrW(GetParent(hwnd), GWLP_USERDATA);
4138         Pane* pane = (Pane*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
4139         ASSERT(child);
4140
4141         switch(nmsg) {
4142                 case WM_HSCROLL:
4143                         set_header(pane);
4144                         break;
4145
4146                 case WM_SETFOCUS:
4147                         child->focus_pane = pane==&child->right? 1: 0;
4148                         SendMessageW(hwnd, LB_SETSEL, TRUE, 1);
4149                         /*TODO: check menu items */
4150                         break;
4151
4152                 case WM_KEYDOWN:
4153                         if (wparam == VK_TAB) {
4154                                 /*TODO: SetFocus(Globals.hdrivebar) */
4155                                 SetFocus(child->focus_pane? child->left.hwnd: child->right.hwnd);
4156                         }
4157         }
4158
4159         return CallWindowProcW(g_orgTreeWndProc, hwnd, nmsg, wparam, lparam);
4160 }
4161
4162
4163 static void InitInstance(HINSTANCE hinstance)
4164 {
4165         static const WCHAR sFont[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
4166
4167         WNDCLASSEXW wcFrame;
4168         WNDCLASSW wcChild;
4169         int col;
4170
4171         INITCOMMONCONTROLSEX icc = {
4172                 sizeof(INITCOMMONCONTROLSEX),
4173                 ICC_BAR_CLASSES
4174         };
4175
4176         HDC hdc = GetDC(0);
4177
4178         setlocale(LC_COLLATE, "");      /* set collating rules to local settings for compareName */
4179
4180         InitCommonControlsEx(&icc);
4181
4182
4183         /* register frame window class */
4184
4185         wcFrame.cbSize        = sizeof(WNDCLASSEXW);
4186         wcFrame.style         = 0;
4187         wcFrame.lpfnWndProc   = FrameWndProc;
4188         wcFrame.cbClsExtra    = 0;
4189         wcFrame.cbWndExtra    = 0;
4190         wcFrame.hInstance     = hinstance;
4191         wcFrame.hIcon         = LoadIconW(hinstance, MAKEINTRESOURCEW(IDI_WINEFILE));
4192         wcFrame.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
4193         wcFrame.hbrBackground = 0;
4194         wcFrame.lpszMenuName  = 0;
4195         wcFrame.lpszClassName = sWINEFILEFRAME;
4196         wcFrame.hIconSm       = LoadImageW(hinstance, MAKEINTRESOURCEW(IDI_WINEFILE), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED);
4197
4198         Globals.hframeClass = RegisterClassExW(&wcFrame);
4199
4200
4201         /* register tree windows class */
4202
4203         wcChild.style         = CS_CLASSDC|CS_DBLCLKS|CS_VREDRAW;
4204         wcChild.lpfnWndProc   = ChildWndProc;
4205         wcChild.cbClsExtra    = 0;
4206         wcChild.cbWndExtra    = 0;
4207         wcChild.hInstance     = hinstance;
4208         wcChild.hIcon         = 0;
4209         wcChild.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
4210         wcChild.hbrBackground = 0;
4211         wcChild.lpszMenuName  = 0;
4212         wcChild.lpszClassName = sWINEFILETREE;
4213
4214         RegisterClassW(&wcChild);
4215
4216
4217         Globals.haccel = LoadAcceleratorsW(hinstance, MAKEINTRESOURCEW(IDA_WINEFILE));
4218
4219         Globals.hfont = CreateFontW(-MulDiv(8,GetDeviceCaps(hdc,LOGPIXELSY),72), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, sFont);
4220
4221         ReleaseDC(0, hdc);
4222
4223         Globals.hInstance = hinstance;
4224
4225         CoInitialize(NULL);
4226         CoGetMalloc(MEMCTX_TASK, &Globals.iMalloc);
4227         SHGetDesktopFolder(&Globals.iDesktop);
4228         Globals.cfStrFName = RegisterClipboardFormatW(CFSTR_FILENAMEW);
4229
4230         /* load column strings */
4231         col = 1;
4232
4233         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_NAME);
4234         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_SIZE);
4235         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_CDATE);
4236         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_ADATE);
4237         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_MDATE);
4238         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_IDX);
4239         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_LINKS);
4240         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_ATTR);
4241         load_string(g_pos_names[col++], sizeof(g_pos_names[col])/sizeof(g_pos_names[col][0]), IDS_COL_SEC);
4242 }
4243
4244
4245 static BOOL show_frame(HWND hwndParent, int cmdshow, LPCWSTR path)
4246 {
4247         static const WCHAR sMDICLIENT[] = {'M','D','I','C','L','I','E','N','T','\0'};
4248
4249         WCHAR buffer[MAX_PATH], b1[BUFFER_LEN];
4250         ChildWnd* child;
4251         HMENU hMenuFrame, hMenuWindow;
4252         windowOptions opts;
4253
4254         CLIENTCREATESTRUCT ccs;
4255
4256         if (Globals.hMainWnd)
4257                 return TRUE;
4258
4259         opts = load_registry_settings();
4260         hMenuFrame = LoadMenuW(Globals.hInstance, MAKEINTRESOURCEW(IDM_WINEFILE));
4261         hMenuWindow = GetSubMenu(hMenuFrame, GetMenuItemCount(hMenuFrame)-2);
4262
4263         Globals.hMenuFrame = hMenuFrame;
4264         Globals.hMenuView = GetSubMenu(hMenuFrame, 2);
4265         Globals.hMenuOptions = GetSubMenu(hMenuFrame, 3);
4266
4267         ccs.hWindowMenu  = hMenuWindow;
4268         ccs.idFirstChild = IDW_FIRST_CHILD;
4269
4270
4271         /* create main window */
4272         Globals.hMainWnd = CreateWindowExW(0, MAKEINTRESOURCEW(Globals.hframeClass), RS(b1,IDS_WINEFILE), WS_OVERLAPPEDWINDOW,
4273                                         opts.start_x, opts.start_y, opts.width, opts.height,
4274                                         hwndParent, Globals.hMenuFrame, Globals.hInstance, 0/*lpParam*/);
4275
4276
4277         Globals.hmdiclient = CreateWindowExW(0, sMDICLIENT, NULL,
4278                                         WS_CHILD|WS_CLIPCHILDREN|WS_VSCROLL|WS_HSCROLL|WS_VISIBLE|WS_BORDER,
4279                                         0, 0, 0, 0,
4280                                         Globals.hMainWnd, 0, Globals.hInstance, &ccs);
4281
4282         CheckMenuItem(Globals.hMenuOptions, ID_VIEW_DRIVE_BAR, MF_BYCOMMAND|MF_CHECKED);
4283         CheckMenuItem(Globals.hMenuOptions, ID_VIEW_SAVESETTINGS, MF_BYCOMMAND);
4284
4285         create_drive_bar();
4286
4287         {
4288                 TBBUTTON toolbarBtns[] = {
4289                         {0, 0, 0, BTNS_SEP, {0, 0}, 0, 0},
4290                         {0, ID_WINDOW_NEW, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
4291                         {1, ID_WINDOW_CASCADE, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
4292                         {2, ID_WINDOW_TILE_HORZ, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
4293                         {3, ID_WINDOW_TILE_VERT, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
4294                 };
4295
4296                 Globals.htoolbar = CreateToolbarEx(Globals.hMainWnd, WS_CHILD|WS_VISIBLE,
4297                         IDW_TOOLBAR, 2, Globals.hInstance, IDB_TOOLBAR, toolbarBtns,
4298                         sizeof(toolbarBtns)/sizeof(TBBUTTON), 16, 15, 16, 15, sizeof(TBBUTTON));
4299                 CheckMenuItem(Globals.hMenuOptions, ID_VIEW_TOOL_BAR, MF_BYCOMMAND|MF_CHECKED);
4300         }
4301
4302         Globals.hstatusbar = CreateStatusWindowW(WS_CHILD|WS_VISIBLE, 0, Globals.hMainWnd, IDW_STATUSBAR);
4303         CheckMenuItem(Globals.hMenuOptions, ID_VIEW_STATUSBAR, MF_BYCOMMAND|MF_CHECKED);
4304
4305         /*TODO: read paths from registry */
4306
4307         if (!path || !*path) {
4308                 GetCurrentDirectoryW(MAX_PATH, buffer);
4309                 path = buffer;
4310         }
4311
4312         ShowWindow(Globals.hMainWnd, cmdshow);
4313
4314 #ifndef __WINE__
4315          /* Shell Namespace as default: */
4316         child = alloc_child_window(path, get_path_pidl(path,Globals.hMainWnd), Globals.hMainWnd);
4317 #else
4318         child = alloc_child_window(path, NULL, Globals.hMainWnd);
4319 #endif
4320
4321         child->pos.showCmd = SW_SHOWMAXIMIZED;
4322         child->pos.rcNormalPosition.left = 0;
4323         child->pos.rcNormalPosition.top = 0;
4324         child->pos.rcNormalPosition.right = 320;
4325         child->pos.rcNormalPosition.bottom = 280;
4326
4327         if (!create_child_window(child)) {
4328                 HeapFree(GetProcessHeap(), 0, child);
4329                 return FALSE;
4330         }
4331
4332         SetWindowPlacement(child->hwnd, &child->pos);
4333
4334         Globals.himl = ImageList_LoadImageW(Globals.hInstance, MAKEINTRESOURCEW(IDB_IMAGES), 16, 0, RGB(0,255,0), IMAGE_BITMAP, 0);
4335
4336         Globals.prescan_node = FALSE;
4337
4338         UpdateWindow(Globals.hMainWnd);
4339
4340         if (child->hwnd && path && path[0])
4341         {
4342                 int index,count;
4343                 WCHAR drv[_MAX_DRIVE+1], dir[_MAX_DIR], name[_MAX_FNAME], ext[_MAX_EXT];
4344                 WCHAR fullname[_MAX_FNAME+_MAX_EXT+1];
4345
4346                 memset(name,0,sizeof(name));
4347                 memset(name,0,sizeof(ext));
4348                 _wsplitpath(path, drv, dir, name, ext);
4349                 if (name[0])
4350                 {
4351                         count = SendMessageW(child->right.hwnd, LB_GETCOUNT, 0, 0);
4352                         lstrcpyW(fullname,name);
4353                         lstrcatW(fullname,ext);
4354
4355                         for (index = 0; index < count; index ++)
4356                         {
4357                                 Entry* entry = (Entry*)SendMessageW(child->right.hwnd, LB_GETITEMDATA, index, 0);
4358                                 if (lstrcmpW(entry->data.cFileName,fullname)==0 ||
4359                                                 lstrcmpW(entry->data.cAlternateFileName,fullname)==0)
4360                                 {
4361                                         SendMessageW(child->right.hwnd, LB_SETCURSEL, index, 0);
4362                                         SetFocus(child->right.hwnd);
4363                                         break;
4364                                 }
4365                         }
4366                 }
4367         }
4368         return TRUE;
4369 }
4370
4371 static void ExitInstance(void)
4372 {
4373         IShellFolder_Release(Globals.iDesktop);
4374         IMalloc_Release(Globals.iMalloc);
4375         CoUninitialize();
4376
4377         DeleteObject(Globals.hfont);
4378         ImageList_Destroy(Globals.himl);
4379 }
4380
4381 int APIENTRY wWinMain(HINSTANCE hinstance, HINSTANCE previnstance, LPWSTR cmdline, int cmdshow)
4382 {
4383         MSG msg;
4384
4385         InitInstance(hinstance);
4386
4387         if( !show_frame(0, cmdshow, cmdline) )
4388         {
4389                 ExitInstance();
4390                 return 1;
4391         }
4392
4393         while(GetMessageW(&msg, 0, 0, 0)) {
4394                 if (Globals.hmdiclient && TranslateMDISysAccel(Globals.hmdiclient, &msg))
4395                         continue;
4396
4397                 if (Globals.hMainWnd && TranslateAcceleratorW(Globals.hMainWnd, Globals.haccel, &msg))
4398                         continue;
4399
4400                 TranslateMessage(&msg);
4401                 DispatchMessageW(&msg);
4402         }
4403
4404         ExitInstance();
4405
4406         return msg.wParam;
4407 }